Xcode «Build and Archive» à partir de la ligne de commande

Xcode 3.2 fournit une nouvelle fonctionnalité impressionnante dans le menu Build, "Build and Archive" qui génère un fichier .ipa adapté à la distribution Ad Hoc. Vous pouvez également ouvrir l'Organiseur, aller dans "Applications archivées" et "Soumettre la demande à iTunesConnect".

Existe-t-il un moyen d'utiliser "Build and Archive" à partir de la ligne de commande (dans le cadre d'un script de build)? Je suppose que xcodebuildcela serait impliqué d'une manière ou d'une autre, mais la manpage ne semble rien dire à ce sujet.

MISE À JOUR Michael Grinich a demandé des éclaircissements; voici ce que vous ne pouvez pas faire exactement avec les builds en ligne de commande, les fonctionnalités que vous ne pouvez faire qu'avec l'Organisateur de Xcode après avoir "Build and Archive".

1. Vous pouvez cliquer sur "Partager l'application ..." pour partager votre IPA avec les bêta-testeurs. Comme le souligne Guillaume ci-dessous, en raison de la magie de Xcode, ce fichier IPA ne nécessite pas de fichier .mobileprovision distribué séparément que les bêta-testeurs doivent installer; c'est magique. Aucun script de ligne de commande ne peut le faire. Par exemple, le script d'Arrix (soumis le 1er mai) ne répond pas à cette exigence.
2. Plus important encore, après avoir testé une version bêta, vous pouvez cliquer sur «Soumettre l'application à iTunes Connect» pour soumettre cette même version EXACT à Apple, le très binaire que vous avez testé, sans la reconstruire. C'est impossible depuis la ligne de commande, car la signature de l'application fait partie du processus de génération; vous pouvez signer des bits pour les tests bêta ad hoc OU vous pouvez les signer pour les soumettre à l'App Store, mais pas les deux. Aucun IPA construit sur la ligne de commande ne peut être testé en version bêta sur les téléphones, puis soumis directement à Apple.

J'aimerais que quelqu'un vienne me prouver le contraire: ces deux fonctionnalités fonctionnent très bien dans l'interface graphique Xcode et ne peuvent pas être répliquées à partir de la ligne de commande.

J'ai trouvé comment automatiser le processus de construction et d'archivage à partir de la ligne de commande, je viens d'écrire un article de blog expliquant comment vous pouvez y parvenir.

La commande que vous devez utiliser est xcrun:

/usr/bin/xcrun -sdk iphoneos PackageApplication \
-v "${RELEASE_BUILDDIR}/${APPLICATION_NAME}.app" \
-o "${BUILD_HISTORY_DIR}/${APPLICATION_NAME}.ipa" \
--sign "${DEVELOPER_NAME}" \
--embed "${PROVISONING_PROFILE}"

Vous trouverez tous les détails dans l'article . Si vous avez des questions, n'hésitez pas à demander.

Avec Xcode 4.2, vous pouvez utiliser l'indicateur -scheme pour ce faire:

xcodebuild -scheme <SchemeName> archive

Après cette commande, l'archive apparaîtra dans l'organisateur Xcode.

Mettre à jour ma réponse avec Xcode 9 et Swift

Archiver

xcodebuild -workspace <ProjectName>/<ProjectName>.xcworkspace \
  -scheme <schemeName> clean archive -configuration release \
  -sdk iphoneos -archivePath <ProjectName>.xcarchive

Exportation IPA ( veuillez noter la liste des options d'exportation )

xcodebuild -exportArchive -archivePath  <ProjectName>.xcarchive \
  -exportOptionsPlist  <ProjectName>/exportOptions.plist \
  -exportPath  <ProjectName>.ipa

Pour ceux qui ne connaissent pas exportOptions.plist, https://blog.bitrise.io/new-export-options-plist-in-xcode-9

Ceux qui l'utilisaient pour construire un projet dans des outils CI / CD comme teamcity / jenkins, assurez-vous que vous utilisez le bon xcode installé dans l'agent de construction pour l'archivage et l'exportation.

Vous pouvez utiliser l'une des deux options ci-dessous pour cela.

1. Utilisez le chemin complet vers xcodebuild,

/Applications/Xcode 9.3.1.app/Contents/Developer/usr/bin/xcodebuild

2. Utilisez xcode-select,

xcode-select -switch /Applications/Xcode 9.3.1.app

Voici mon ancienne réponse

Voici un script de ligne de commande pour créer une archive et un exemple IPA. J'ai un projet iPhone xcode, qui se trouve dans le dossier Desktop / MyiOSApp.

Exécutez les commandes suivantes une par une:

cd /Users/username/Desktop/MyiOSApp/

xcodebuild -scheme MyiOSApp archive \
  -archivePath /Users/username/Desktop/MyiOSApp.xcarchive

xcodebuild -exportArchive -exportFormat ipa \
  -archivePath "/Users/username/Desktop/MyiOSApp.xcarchive" \
  -exportPath "/Users/username/Desktop/MyiOSApp.ipa" \
  -exportProvisioningProfile "MyCompany Distribution Profile"

Ceci est testé avec Xcode 5 et fonctionne très bien pour moi.

J'ai utilisé mon propre script de génération pour générer le package ipa pour une distribution ad hoc.

die() {
    echo "$*" >&2
    exit 1
}

appname='AppName'
config='Ad Hoc Distribution'
sdk='iphoneos3.1.3'
project_dir=$(pwd)

echo using configuration $config

echo updating version number
agvtool bump -all
fullversion="$(agvtool mvers -terse1)($(agvtool vers -terse))"
echo building version $fullversion

xcodebuild -activetarget -configuration "$config" -sdk $sdk build || die "build failed"

echo making ipa...
# packaging
cd build/"$config"-iphoneos || die "no such directory"
rm -rf Payload
rm -f "$appname".*.ipa
mkdir Payload
cp -Rp "$appname.app" Payload/
if [ -f "$project_dir"/iTunesArtwork ] ; then
    cp -f "$project_dir"/iTunesArtwork Payload/iTunesArtwork
fi

ipaname="$appname.$fullversion.$(date -u +%Y%m%d%H%M%S).ipa"
zip -r $ipaname Payload

echo finished making $ipaname

Le script incrémente également le numéro de version. Vous pouvez supprimer cette partie si elle n'est pas nécessaire. J'espère que cela aide.

L' xcodebuildoutil peut créer et exporter des produits d'archives avec l' indicateur -exportArchive (à partir de Xcode 5). L'étape d'exportation n'était auparavant possible que via l'interface utilisateur de Xcode Organizer.

Archivez d'abord votre application:

xcodebuild -scheme <scheme name> archive

Étant donné $ARCHIVE_PATH(le chemin d'accès au fichier .xcarchive ), exportez l'application à partir de l'archive avec l'un des éléments suivants:

Fichier .ipa iOS :

xcodebuild -exportArchive -exportFormat ipa -archivePath "$ARCHIVE_PATH" -exportPath "myApp.ipa" -exportProvisioningProfile "My App Provisioning profile"

Fichier .app Mac :

xcodebuild -exportArchive -exportFormat app -archivePath "$ARCHIVE_PATH" -exportPath "myApp.app" -exportSigningIdentity "Developer ID Application: My Software Company"

Dans les deux commandes, les arguments -exportProvisioningProfile et -exportSigningIdentity sont facultatifs. man xcodebuildpour plus de détails sur la sémantique. Dans ces exemples, le profil d'approvisionnement pour la version iOS a spécifié un profil d'approvisionnement pour la distribution AdHoc, et l'identité de signature pour l'application Mac a spécifié un ID développeur pour l'exportation en tant qu'application tierce (c'est-à-dire non distribué via le Mac App Store).

Nous avons développé une application iPad avec XCode 4.2.1 et voulions intégrer la version dans notre intégration continue (Jenkins) pour la distribution OTA. Voici la solution que j'ai trouvée:

# Unlock keychain
security unlock-keychain -p jenkins /Users/jenkins/Library/Keychains/login.keychain

# Build and sign app
xcodebuild -configuration Distribution clean build

# Set variables
APP_PATH="$PWD/build/Distribution-iphoneos/iPadApp.app"
VERSION=`defaults read $APP_PATH/Info CFBundleShortVersionString`
REVISION=`defaults read $APP_PATH/Info CFBundleVersion`
DATE=`date +"%Y%m%d-%H%M%S"`
ITUNES_LINK="<a href=\"itms-services:\/\/?action=download-manifest\&url=https:\/\/xxx.xxx.xxx\/iPadApp-$VERSION.$REVISION-$DATE.plist\">Download iPad2-App v$VERSION.$REVISION-$DATE<\/a>"

# Package and verify app
xcrun -sdk iphoneos PackageApplication -v build/Distribution-iphoneos/iPadApp.app -o $PWD/iPadApp-$VERSION.$REVISION-$DATE.ipa

# Create plist
cat iPadApp.plist.template | sed -e "s/\${VERSION}/$VERSION/" -e "s/\${DATE}/$DATE/" -e "s/\${REVISION}/$REVISION/" > iPadApp-$VERSION.$REVISION-$DATE.plist

# Update index.html
curl https://xxx.xxx.xxx/index.html -o index.html.$DATE
cat index.html.$DATE | sed -n '1h;1!H;${;g;s/\(<h3>Aktuelle Version<\/h3>\)\(.*\)\(<h3>&Auml;ltere Versionen<\/h3>.<ul>.<li>\)/\1\
${ITUNES_LINK}\
\3\2<\/li>\
<li>/g;p;}' | sed -e "s/\${ITUNES_LINK}/$ITUNES_LINK/" > index.html

Jenkins télécharge ensuite les fichiers ipa, plist et html sur notre serveur Web.

Voici le modèle plist:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>items</key>
    <array>
        <dict>
            <key>assets</key>
            <array>
                <dict>
                    <key>kind</key>
                    <string>software-package</string>
                    <key>url</key>
                    <string>https://xxx.xxx.xxx/iPadApp-${VERSION}.${REVISION}-${DATE}.ipa</string>
                </dict>
                <dict>
                    <key>kind</key>
                    <string>full-size-image</string>
                    <key>needs-shine</key>
                    <true/>
                    <key>url</key>
                    <string>https://xxx.xxx.xxx/iPadApp.png</string>
                </dict>
                <dict>
                    <key>kind</key>
                    <string>display-image</string>
                    <key>needs-shine</key>
                    <true/>
                    <key>url</key>
                    <string>https://xxx.xxx.xxx/iPadApp_sm.png</string>
                </dict>
            </array>
            <key>metadata</key>
            <dict>
                <key>bundle-identifier</key>
                <string>xxx.xxx.xxx.iPadApp</string>
                <key>bundle-version</key>
                <string>${VERSION}</string>
                <key>kind</key>
                <string>software</string>
                <key>subtitle</key>
                <string>iPad2-App</string>
                <key>title</key>
                <string>iPadApp</string>
            </dict>
        </dict>
    </array>
</dict>
</plist>

Pour configurer cela, vous devez importer le certificat de distribution et le profil d'approvisionnement dans le trousseau de l'utilisateur désigné.

J'ai trouvé difficile de démarrer certaines des autres réponses. Cet article l'a fait pour moi. Certains chemins peuvent devoir être absolus, comme mentionné dans les autres réponses.

La commande:

xcrun -sdk iphoneos PackageApplication \
    "/path/to/build/MyApp.app" \
    -o "output/path/to/MyApp.ipa" \
    --sign "iPhone Distribution: My Company" \
    --embed "/path/to/something.mobileprovision"

Vous POUVEZ en fait résigner une build, tout comme le fait XCode, afin de pouvoir tester et expédier le même binaire. Par exemple, dans mon script (similaire à ceux ci-dessus), je construis ma version finale signée en tant que build AdHoc, puis je l'archive en tant qu'IPA pour les tests, puis je démissionne avec mon certificat de distribution et crée un fichier zip, ce que j'envoie à Pomme. La ligne pertinente est:

codesign -f -vv -s "$DistributionIdentity" "$APPDIR"

Pour Xcode 7 , vous avez une solution beaucoup plus simple. Le seul travail supplémentaire est que vous devez créer un fichier plist de configuration pour exporter l'archive.

(Par rapport à Xcode 6, dans les résultats de xcrun xcodebuild -help, -exportFormatet les -exportProvisioningProfileoptions ne sont plus mentionnées; la première est supprimée et la seconde est remplacée par -exportOptionsPlist.)

Étape 1 , remplacez le répertoire par le dossier contenant le fichier .xcodeproject ou .xcworkspace.

cd MyProjectFolder

Étape 2 , utilisez Xcode ou /usr/libexec/PlistBuddy exportOptions.plistpour créer un fichier plist d'options d'exportation. Soit dit en passant, xcrun xcodebuild -helpvous dira quelles clés vous devez insérer dans le fichier plist.

Étape 3 , créez le fichier .xcarchive (dossier, en fait) comme suit (le répertoire build / sera automatiquement créé par Xcode en ce moment),

xcrun xcodebuild -scheme MyApp -configuration Release archive -archivePath build/MyApp.xcarchive

Étape 4 , exportez en tant que fichier .ipa comme celui-ci, qui diffère de Xcode6

xcrun xcodebuild -exportArchive -exportPath build/ -archivePath build/MyApp.xcarchive/ -exportOptionsPlist exportOptions.plist

Maintenant, vous obtenez un fichier ipa dans le répertoire build /. Envoyez-le simplement à l'App Store d'Apple.

Soit dit en passant, le fichier ipa créé par Xcode 7 est beaucoup plus volumineux que par Xcode 6.

J'ai donné une brève description des étapes à suivre et des paramètres à passer lors de la génération d'un ipa en utilisant terrminal ci-dessous:

1. Accédez au dossier qui contient le fichier MyApp.xcodeproject dans le terminal

2. En utilisant la commande donnée ci-dessous, vous obtiendrez toutes les cibles de l'application

   /usr/bin/xcodebuild -list 

3. Après l'exécution de la commande ci-dessus, vous obtiendrez une liste de cibles dont vous devez sélectionner une cible spécifique dont vous avez besoin pour générer .ipa

   /usr/bin/xcodebuild -target $TARGET -sdk iphoneos -configuration Release

4. La commande ci-dessus crée le projet et crée un fichier .app. Le chemin pour localiser le fichier .app est ./build/Release-iphoneos/MyApp.app

5. Une fois la construction réussie, exécutez la commande suivante pour générer .ipa de l'application à l'aide du nom du développeur et du profil de provisioning à l'aide de la syntaxe ci-dessous:

   /usr/bin/xcrun -sdk iphoneos PackageApplication -v “${TARGET}.app” -o “${OUTDIR}/${TARGET}.ipa” –sign “${IDENTITY}” –embed “${PROVISONING_PROFILE}”

Explication de chaque paramètre dans la syntaxe ci-dessus:

${TARGET}.app                == Target path (ex :/Users/XXXXXX/desktop/Application/build/Release-iphoneos/MyApp.app)
${OUTDIR}                    == Select the output directory(Where you want to save .ipa file)
${IDENTITY}                   == iPhone Developer: XXXXXXX (XXXXXXXXXX)(which can be obtained from Keychain access)
${PROVISONING_PROFILE}   == Path to the provisioning profile(/Users/XXXXXX/Library/MobileDevice/Provisioning Profiles/XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX.mobileprovision”)

6. ipa sera généré dans le répertoire de sortie sélectionné " $ {OUTDIR} "

Xcode 8:

Format IPA:

xcodebuild -exportArchive -exportFormat IPA -archivePath MyMobileApp.xcarchive -exportPath MyMobileApp.ipa -exportProvisioningProfile 'MyMobileApp Distribution Profile'

Exporte l'archive MyMobileApp.xcarchive en tant que fichier IPA vers le chemin MyMobileApp.ipa à l'aide du profil de provisionnement MyMobileApp Distribution Profile.

Format APP:

xcodebuild -exportArchive -exportFormat APP -archivePath MyMacApp.xcarchive -exportPath MyMacApp.pkg -exportSigningIdentity 'Developer ID Application: My Team'

Exporte l'archive MyMacApp.xcarchive sous forme de fichier PKG vers le chemin MyMacApp.pkg à l'aide de l'identité d'application signature de cation d'application Developer ID Application: My Team. Le programme d'installation qui signe l'identité Developer ID Installer: My Team est implicitement utilisé pour signer le package exporté.

Page de manuel de Xcodebuild

Accédez au dossier où se trouve la racine de votre projet et:

xcodebuild -project projectname -activetarget -activeconfiguration archive

Pour aller plus loin, télécharger sur iTunesConnect via la ligne de commande avec Xcode 7 ! (En supposant que vous commencez par un.ipa qui a été signé avec le profil de version et l'identité de signature corrects.)

Entrez altool, l'interface CLI pour le chargeur d'application ( docs, page 38). Caché profondément dans la structure de Xcode.app, est une fonction pratique pour nous permettre de télécharger directement sur ItunesConnect.

/Applications/Xcode.app/Contents/Applications/Application Loader.app/Contents/Frameworks/ITunesSoftwareService.framework/Versions/A/Support/altool

Exécutez simplement $ altool --upload-app -f file -u username [-p password]pour télécharger votre nouvellement créé.ipa directement sur Apple. Le mot de passe est facultatif et vous le demandera si vous le laissez hors de la commande.

S'il y a des problèmes avec l'application pendant l'étape de vérification, la console les imprimera.

Vous devrez probablement exporter le chemin vers altoolsi vous ne souhaitez pas enregistrer son emplacement.

export PATH=$PATH:/Applications/Xcode.app/Contents/Applications/Application\ Loader.app/Contents/Frameworks/ITunesSoftwareService.framework/Versions/A/Support/

C'est ça! Connectez-vous simplement à iTunesConnect.com et sélectionnez votre nouvelle version à tester avec testflight.

Remarque finale: Si vous obtenez une erreur indiquant Exception while launching iTunesTransporter: Transporter not found at path: /usr/local/itms/bin/iTMSTransporter. You should reinstall the application, vous pouvez suivre la suggestion de cette réponse SO , pour exécuter un lien symbolique vers l'emplacement correct:

ln -s /Applications/Xcode.app/Contents/Applications/Application\ Loader.app/Contents/itms /usr/local/itms

Pour améliorer la réponse de Vincent, j'ai écrit un script pour cela: xcodearchive
il vous permet d'archiver (générer une ipa) votre projet via la ligne de commande. Pensez-y comme la sœur de la xcodebuildcommande, mais pour l'archivage.

Le code est disponible sur github: http://github.com/gcerquant/xcodearchive

Une option du script consiste à activer l'archivage des symboles dSYM dans une archive horodatée. Aucune excuse pour ne plus conserver les symboles et ne pas pouvoir symboliser le journal des plantages que vous pourriez recevoir plus tard.

Comment construire un projet iOS avec une commande?

Clean : codebuild clean -workspace work-space-name.xcworkspace -scheme scheme-name 

&&

Archive : xcodebuild archive -workspace work-space-name.xcworkspace -scheme "scheme-name" -configuration Release -archivePath IPA-name.xcarchive 

&&

Export : xcodebuild -exportArchive -archivePath IPA-name.xcarchive -exportPath IPA-name.ipa -exportOptionsPlist exportOptions.plist

Qu'est-ce que ExportOptions.plist?

ExportOptions.plist est requis dans Xcode. Il vous permet de spécifier certaines options lorsque vous créez un fichier ipa. Vous pouvez sélectionner les options dans une interface utilisateur conviviale lorsque vous utilisez Xcode pour archiver votre application.

Important : La méthode de publication et de développement est différente dans l' AppStore ExportOptions.plist

:

exportOptions_release ~ method = app-store

Développement

exportOptions_dev ~ method = development

essayez xctool, c'est un remplacement pour xcodebuild d'Apple qui facilite la construction et le test des produits iOS et Mac. C'est particulièrement utile pour une intégration continue. Il a quelques fonctionnalités supplémentaires:

1. Exécute les mêmes tests que Xcode.app.
2. Sortie structurée des résultats de construction et de test.
3. Sortie conviviale, couleur ANSI.

Le n ° 3 est extrêmement utile. Je ne sais pas si quelqu'un peut lire la sortie de la console de xcodebuild, je ne peux pas, généralement cela m'a donné une ligne avec plus de 5000 caractères. Encore plus difficile à lire qu'un mémoire de thèse.

xctool: https://github.com/facebook/xctool

si vous utilisez l'outil suivant: https://github.com/nomad/shenzhen

alors cette tâche est très simple:

which ipa 1>/dev/null 2>&1 || echo 'no shenzhen. to install use: sudo gem install shenzhen --no-ri --no-rdoc'
ipa build --verbose --scheme "${schemeName}"

la source

Après la mise à jour vers Xcode 8, j'ai trouvé que l'IPA d'entreprise était générée par

/usr/bin/xcrun -sdk iphoneos PackageApplication -v "${RELEASE_BUILDDIR}/${APPLICATION_NAME}.app" -o "${BUILD_HISTORY_DIR}/${APPLICATION_NAME}.ipa" --sign "${DEVELOPER_NAME}" --embed "${PROVISONING_PROFILE}" 

La commande ne peut pas être lancée en raison d'un problème de signature. Le journal indique que "avertissement: PackageApplication est obsolète, utilisez à la xcodebuild -exportArchiveplace.

Je passe donc à xcodebuild -exportArchiveet tout redevient normal.

Vous voulez dire les options valider / partager / soumettre? Je pense que ceux-ci sont spécifiques à Xcode et ne conviennent pas à un outil de construction en ligne de commande.

Avec un peu d'habileté, je parie que vous pourriez faire un script pour le faire pour vous. On dirait qu'ils sont juste stockés dans~/Library/MobileDevice/Archived Applications/ avec un UUDI et un plist. Je ne peux pas imaginer qu'il serait aussi difficile de faire de l'ingénierie inverse du validateur.

Le processus qui m'intéresse d'automatiser est d'envoyer des versions aux bêta-testeurs. (Étant donné que la soumission sur l'App Store se produit rarement, cela ne me dérange pas de le faire manuellement, d'autant plus que j'ai souvent besoin d'ajouter un nouveau texte de description.) En faisant une pseudo Build + Archive à l'aide de la CLI de Xcode, je peux déclencher des builds automatiques à partir de chaque validation de code, créez des fichiers IPA avec des profils de provisionnement intégrés et envoyez-les par e-mail aux testeurs.