Xcode "Build and Archive" dalla riga di comando

Xcode 3.2 offre una nuova fantastica funzionalità nel menu Build, "Build and Archive" che genera un file .ipa adatto alla distribuzione ad hoc. Puoi anche aprire Organizer, andare su "Applicazioni archiviate" e "Invia domanda a iTunesConnect".

C'è un modo per usare "Build and Archive" dalla riga di comando (come parte di uno script di build)? Suppongo che xcodebuildsarebbe coinvolto in qualche modo, ma la manpagina non sembra dire nulla al riguardo.

AGGIORNAMENTO Michael Grinich ha chiesto chiarimenti; ecco cosa non puoi fare esattamente con le build da riga di comando, funzionalità che puoi fare SOLO con l'Organizer di Xcode dopo aver "Build and Archive".

1. Puoi fare clic su "Condividi applicazione ..." per condividere il tuo IPA con i beta tester. Come sottolinea Guillaume di seguito, a causa della magia di Xcode, questo file IPA non richiede un file .mobileprovision distribuito separatamente che i beta tester devono installare; è magico. Nessuno script da riga di comando può farlo. Ad esempio, lo script di Arrix (inviato il 1 maggio) non soddisfa tale requisito.
2. Ancora più importante, dopo aver beta testato una build, puoi fare clic su "Invia applicazione a iTunes Connect" per inviare la stessa build EXACT ad Apple, proprio il binario che hai testato, senza ricostruirla. È impossibile dalla riga di comando, perché la firma dell'app fa parte del processo di compilazione; puoi firmare i bit per il beta test Ad Hoc O puoi firmarli per l'invio all'App Store, ma non entrambi. Nessun IPA basato sulla riga di comando può essere beta testato sui telefoni e quindi inviato direttamente ad Apple.

Mi piacerebbe che qualcuno arrivasse e mi dimostrasse che mi sbagliavo: entrambe queste funzionalità funzionano alla grande nella GUI di Xcode e non possono essere replicate dalla riga di comando.

Ho scoperto come automatizzare il processo di compilazione e archiviazione dalla riga di comando, ho appena scritto un articolo sul blog che spiega come farlo.

Il comando che devi usare è 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}"

Troverai tutti i dettagli nell'articolo . Se avete domande, non esitate a chiedere.

Con Xcode 4.2 puoi usare il flag -scheme per fare questo:

xcodebuild -scheme <SchemeName> archive

Dopo questo comando, l'archivio verrà visualizzato in Xcode Organizer.

Aggiornamento della mia risposta con Xcode 9 e Swift

Archivio

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

Esportazione IPA ( notare la lista delle opzioni di esportazione )

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

Per coloro che non conoscono exportOptions.plist, https://blog.bitrise.io/new-export-options-plist-in-xcode-9

Coloro che lo utilizzavano per realizzare progetti in strumenti CI / CD come teamcity / jenkins, assicurarsi di utilizzare il codice x corretto installato nell'agente di compilazione sia per l'archiviazione che per l'esportazione.

È possibile utilizzare una delle 2 opzioni seguenti per questo.

1. Usa il percorso completo di xcodebuild,

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

2. Usa xcode-select,

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

Di seguito è la mia vecchia risposta

Ecco lo script da riga di comando per la creazione di un archivio e un esempio di IPA. Ho un progetto xcode per iPhone, che si trova nella cartella Desktop / MyiOSApp.

Eseguire i seguenti comandi uno per uno:

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"

Questo è testato con Xcode 5 e funziona bene per me.

Ho usato il mio script di build per generare il pacchetto ipa per la distribuzione 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

Lo script incrementa anche il numero di versione. Puoi rimuovere quella parte se non è necessaria. Spero che sia d'aiuto.

Lo xcodebuildstrumento può creare ed esportare prodotti di archivio con il flag -exportArchive (a partire da Xcode 5). Il passaggio di esportazione era precedentemente possibile solo tramite l'interfaccia utente di Xcode Organizer.

Prima archivia la tua app:

xcodebuild -scheme <scheme name> archive

Dato $ARCHIVE_PATH(il percorso del file .xcarchive ), esporta l'app dall'archivio con uno dei seguenti:

File .ipa iOS :

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

File .app per Mac :

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

In entrambi i comandi gli argomenti -exportProvisioningProfile e -exportSigningIdentity sono facoltativi. man xcodebuildper dettagli sulla semantica. In questi esempi, il profilo di provisioning per la build di iOS ha specificato un profilo di provisioning di distribuzione AdHoc e l'identità di firma per l'app Mac ha specificato un ID sviluppatore per l'esportazione come applicazione di terze parti (ovvero non distribuita tramite Mac App Store).

Abbiamo sviluppato un'app per iPad con XCode 4.2.1 e volevamo integrare la build nella nostra integrazione continua (Jenkins) per la distribuzione OTA. Ecco la soluzione che mi è venuta in mente:

# 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

Quindi Jenkins carica i file ipa, plist e html sul nostro server web.

Questo è il modello 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>

Per configurarlo, devi importare il certificato di distribuzione e il profilo di provisioning nel portachiavi dell'utente designato.

Ho trovato alcune delle altre risposte qui difficili da ottenere. Questo articolo ha fatto se per me. Potrebbe essere necessario che alcuni percorsi siano assoluti, come indicato nelle altre risposte.

Il comando:

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"

Puoi effettivamente dimettere una build, proprio come fa XCode, in modo da poter testare e spedire lo stesso binario. Ad esempio nel mio script (simile a quelli sopra) creo la mia versione di rilascio firmata come build AdHoc, quindi l'archivo come IPA per il test, quindi mi dimetto con il mio certificato di distribuzione e creo un file zip, che è ciò a cui invio Mela. La linea pertinente è:

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

Per Xcode 7 , hai una soluzione molto più semplice. L'unico lavoro extra è che devi creare un file di configurazione per esportare l'archivio.

(Rispetto a Xcode 6, nei risultati di xcrun xcodebuild -help, -exportFormate -exportProvisioningProfilele opzioni non sono menzionati più; il primo è cancellato, e quest'ultimo viene sostituite da -exportOptionsPlist.)

Passaggio 1 , modifica la directory nella cartella incluso il file .xcodeproject o .xcworkspace.

cd MyProjectFolder

Passaggio 2 , utilizzare Xcode o /usr/libexec/PlistBuddy exportOptions.plistper creare il file plist delle opzioni di esportazione. A proposito, xcrun xcodebuild -helpti dirà quali chiavi devi inserire nel file plist.

Passo 3 , crea il file .xcarchive (cartella, in effetti) come segue (build / directory verrà automaticamente creata da Xcode in questo momento),

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

Passo 4 , esporta come file .ipa in questo modo, che differisce da Xcode6

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

Ora, ottieni un file ipa nella directory build /. Basta inviarlo all'App Store di Apple.

A proposito, il file ipa creato da Xcode 7 è molto più grande di Xcode 6.

Ho fornito una breve descrizione dei passaggi da seguire e dei parametri da passare durante la generazione di un ipa usando terrminal di seguito:

1. Vai alla cartella che contiene il file MyApp.xcodeproject nel terminale

2. Usando il comando indicato di seguito otterrai tutti i target dell'applicazione

   /usr/bin/xcodebuild -list 

3. Dopo aver eseguito il comando sopra, otterrai un elenco di target di cui devi selezionare un target specifico che devi generare .ipa

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

4. Il comando precedente crea il progetto e crea un file .app. Il percorso per individuare il file .app è ./build/Release-iphoneos/MyApp.app

5. Dopo che Build ha avuto esito positivo, eseguire il comando seguente per generare .ipa dell'applicazione utilizzando Nome sviluppatore e Profilo di provisioning utilizzando la sintassi seguente:

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

Spiegazione di ciascun parametro nella sintassi sopra:

${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 verrà generato nella directory di output selezionata " $ {OUTDIR} "

Xcode 8:

Formato IPA:

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

Esporta l'archivio MyMobileApp.xcarchive come file IPA nel percorso MyMobileApp.ipa utilizzando il profilo di provisioning Profilo di distribuzione MyMobileApp.

Formato APP:

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

Esporta l'archivio MyMacApp.xcarchive come file PKG nel percorso MyMacApp.pkg utilizzando l'identità di firma cation dell'applicazione applicazione ID sviluppatore: Il mio team. Identificatore della firma dell'installer ID sviluppatore sviluppatore: il mio team viene implicitamente utilizzato per firmare il pacchetto esportato.

Pagina man di Xcodebuild

Vai alla cartella in cui si trova la radice del tuo progetto e:

xcodebuild -project projectname -activetarget -activeconfiguration archive

Andando oltre, caricando su iTunesConnect tramite riga di comando con Xcode 7 ! (Supponendo che stai iniziando con un.ipa che è stato firmato con il profilo di rilascio e l'identità della firma corretti.)

Enter altool, l'interfaccia della CLI per il Caricatore applicazioni ( docs, pagina 38). Nascosto in profondità nella struttura di Xcode.app, è una pratica funzione che ci consente di caricare direttamente su ItunesConnect.

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

Corri semplicemente $ altool --upload-app -f file -u username [-p password]per caricare il tuo nuovo coniato.ipa direttamente su Apple. La password è facoltativa e la richiederà se la si lascia fuori dal comando.

In caso di problemi con l'app durante il passaggio di verifica, la console li stamperà.

Probabilmente dovrai esportare il percorso altoolse non vuoi salvare la sua posizione.

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

Questo è tutto! Accedi a iTunesConnect.com e seleziona la tua nuova build per i test con testflight.

Nota finale: se viene visualizzato un errore Exception while launching iTunesTransporter: Transporter not found at path: /usr/local/itms/bin/iTMSTransporter. You should reinstall the application, è possibile seguire il suggerimento su questa risposta SO , per eseguire un collegamento simbolico nella posizione corretta:

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

Migliorando la risposta di Vincent, ho scritto uno script per farlo: xcodearchive
ti consente di archiviare (generare un ipa) il tuo progetto tramite la riga di comando. Pensalo come la sorella del xcodebuildcomando, ma per l'archiviazione.

Il codice è disponibile su github: http://github.com/gcerquant/xcodearchive

Un'opzione dello script è abilitare l'archiviazione dei simboli dSYM in un archivio con data e ora. Nessuna scusa per non conservare più i simboli e non essere in grado di simboleggiare il registro degli arresti anomali che potresti ricevere in seguito.

Come costruire un progetto iOS con comando?

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

Che cos'è ExportOptions.plist?

ExportOptions.plist è richiesto in Xcode. Ti consente di specificare alcune opzioni quando crei un file ipa. È possibile selezionare le opzioni in un'interfaccia utente intuitiva quando si utilizza Xcode per archiviare l'app.

Importante : il metodo di rilascio e sviluppo è diverso nell'AppStore ExportOptions.plist

:

exportOptions_release ~ method = app-store

Sviluppo

exportOptions_dev ~ method = development

prova xctool, è un sostituto di xcodebuild di Apple che semplifica la creazione e il test di prodotti iOS e Mac. È particolarmente utile per l'integrazione continua. Ha alcune funzionalità extra:

1. Esegue gli stessi test di Xcode.app.
2. Output strutturato dei risultati di build e test.
3. Uscita a colori ANSI, ecocompatibile.

No.3 è estremamente utile. Non so se qualcuno può leggere l'output della console di xcodebuild, non posso, di solito mi ha dato una riga con oltre 5000 caratteri. Ancora più difficile da leggere di un documento di tesi.

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

se usi lo strumento successivo: https://github.com/nomad/shenzhen

quindi questo compito è molto semplice:

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}"

fonte

Dopo l'aggiornamento a Xcode 8, ho scoperto che ipa enterprise genera da

/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}" 

Il comando non può essere avviato a causa di un problema di firma. Il registro indica che "avviso: PackageApplication è obsoleto, utilizzare xcodebuild -exportArchiveinvece.

Quindi passo a xcodebuild -exportArchivee tutto è tornato normale.

Intendi le opzioni di validazione / condivisione / invio? Penso che quelli siano specifici di Xcode e non adatti a uno strumento di creazione da riga di comando.

Con una certa intelligenza, scommetto che potresti creare una sceneggiatura per farlo per te. Sembra che siano appena archiviati ~/Library/MobileDevice/Archived Applications/con un UUDI e un plist. Non posso immaginare che sarebbe altrettanto difficile decodificare il validatore.

Il processo che mi interessa automatizzare è l'invio di build ai beta tester. (Dato che l'invio all'App Store avviene di rado, non mi dispiace farlo manualmente, soprattutto perché spesso ho bisogno di aggiungere un nuovo testo descrittivo.) Facendo uno pseudo Build + Archive usando l'interfaccia della riga di comando di Xcode, posso innescare build automatiche da ogni commit del codice, creare file IPA con profili di provisioning incorporati e inviarli via e-mail ai tester.