Xcode “Build and Archive” na linha de comando

O Xcode 3.2 fornece um novo recurso incrível no menu Build, "Build and Archive", que gera um arquivo .ipa adequado para distribuição Ad Hoc. Você também pode abrir o Organizer, vá para "Aplicativos arquivados" e "Enviar aplicativo para o iTunesConnect".

Existe uma maneira de usar "Compilar e arquivar" na linha de comando (como parte de um script de compilação)? Eu diria que isso xcodebuildestaria envolvido de alguma forma, mas a manpágina parece não dizer nada sobre isso.

ATUALIZAÇÃO Michael Grinich solicitou esclarecimentos; aqui está o que exatamente você não pode fazer com a criação de linhas de comando, recursos que você SOMENTE pode fazer com o Organizador do Xcode depois de "Criar e arquivar".

1. Você pode clicar em "Compartilhar aplicativo ..." para compartilhar seu IPA com testadores beta. Como Guillaume aponta abaixo, devido a alguma mágica do Xcode, esse arquivo IPA não requer um arquivo .mobileprovision distribuído separadamente que os testadores beta precisam instalar; isso é mágico. Nenhum script de linha de comando pode fazer isso. Por exemplo, o script da Arrix (enviado em 1º de maio) não atende a esse requisito.
2. Mais importante, depois de testar uma versão beta, você pode clicar em "Enviar aplicativo ao iTunes Connect" para enviar a mesma versão EXATA para a Apple, a mesma versão binária que você testou, sem reconstruí-la. Isso é impossível na linha de comando, porque assinar o aplicativo faz parte do processo de compilação; você pode assinar bits para o teste beta ad hoc OU pode assiná-los para envio à App Store, mas não ambos. Nenhum IPA criado na linha de comando pode ser testado em beta nos telefones e depois enviado diretamente à Apple.

Eu adoraria que alguém aparecesse e me provasse errado: esses dois recursos funcionam muito bem na interface gráfica do Xcode e não podem ser replicados a partir da linha de comando.

Eu descobri como automatizar o processo de compilação e arquivamento a partir da linha de comando. Acabei de escrever um artigo explicando como você pode conseguir isso.

O comando que você precisa usar é 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}"

Você encontrará todos os detalhes no artigo . Se você tiver alguma dúvida, não hesite em perguntar.

Com o Xcode 4.2, você pode usar o sinalizador -scheme para fazer isso:

xcodebuild -scheme <SchemeName> archive

Após este comando, o arquivo será exibido no Xcode Organizer.

Atualizando minha resposta com o Xcode 9 e o Swift

Arquivo

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

Exportação IPA ( observe a opção de exportação )

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

Para quem não conhece o exportOptions.plist, https://blog.bitrise.io/new-export-options-plist-in-xcode-9

Aqueles que estavam usando isso para o projeto de construção em ferramentas de CI / CD como teamcity / jenkins, certifique-se de usar o xcode certo instalado no agente de construção para arquivar e exportar.

Você pode usar uma das 2 opções abaixo para isso.

1. Use o caminho completo para xcodebuild,

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

2. Use xcode-select,

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

Abaixo está a minha resposta antiga

Aqui está o script da linha de comandos para criar exemplo de arquivo morto e IPA. Eu tenho um projeto iPhone xcode, localizado na pasta Desktop / MyiOSApp.

Execute os seguintes comandos, um por um:

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"

Isso foi testado com o Xcode 5 e está funcionando bem para mim.

Eu tenho usado meu próprio script de construção para gerar o pacote ipa para distribuição 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

O script também incrementa o número da versão. Você pode remover essa parte se não for necessário. Espero que ajude.

A xcodebuildferramenta pode criar e exportar produtos de arquivamento com o sinalizador -exportArchive (a partir do Xcode 5). A etapa de exportação anteriormente só era possível através da interface do usuário do Xcode Organizer.

Primeiro arquive seu aplicativo:

xcodebuild -scheme <scheme name> archive

Dado $ARCHIVE_PATH(o caminho para o arquivo .xcarchive ), exporte o aplicativo do arquivo morto com um dos seguintes:

Arquivo .ipa do iOS :

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

Arquivo .app do Mac :

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

Em ambos os comandos dos -exportProvisioningProfile e -exportSigningIdentity argumentos são opcionais. man xcodebuildpara detalhes sobre a semântica. Nesses exemplos, o perfil de provisionamento para a versão do iOS especificou um perfil de provisionamento de distribuição AdHoc, e a identidade de assinatura do aplicativo para Mac especificou um ID de desenvolvedor para exportação como um aplicativo de terceiros (ou seja, não distribuído pela Mac App Store).

Desenvolvemos um aplicativo para iPad com o XCode 4.2.1 e queríamos integrar a compilação à nossa integração contínua (Jenkins) para distribuição OTA. Aqui está a solução que eu criei:

# 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

Depois, Jenkins carrega os arquivos ipa, plist e html em nosso servidor da web.

Este é o modelo 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>

Para configurar isso, você deve importar o certificado de distribuição e o perfil de provisionamento para o conjunto de chaves do usuário designado.

Eu achei algumas das outras respostas aqui difíceis de seguir. Este artigo fez se por mim. Alguns caminhos podem precisar ser absolutos, conforme mencionado nas outras respostas.

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

Na verdade, você PODE renunciar uma compilação, assim como o XCode, para poder testar e enviar o mesmo binário. Por exemplo, no meu script (semelhante aos acima), eu construo minha versão de lançamento assinada como AdHoc, depois arquivo como IPA para teste, em seguida, renuncio ao meu certificado de distribuição e crio um arquivo zip, que é o que envio para Maçã. A linha relevante é:

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

Para o Xcode 7 , você tem uma solução muito mais simples. O único trabalho extra é que você precisa criar um arquivo plist de configuração para exportar o arquivo morto.

(Comparado ao Xcode 6, nos resultados de xcrun xcodebuild -help, -exportFormate as -exportProvisioningProfileopções não são mais mencionadas; o primeiro é excluído e o segundo é substituído por-exportOptionsPlist .)

Etapa 1 , altere o diretório para a pasta, incluindo o arquivo .xcodeproject ou .xcworkspace.

cd MyProjectFolder

Etapa 2 , use o Xcode ou /usr/libexec/PlistBuddy exportOptions.plistpara criar um arquivo plist de opções de exportação. A propósito, xcrun xcodebuild -helpdirá quais chaves você deve inserir no arquivo plist.

Etapa 3 , crie o arquivo .xcarchive (pasta, de fato) da seguinte maneira (a compilação / diretório será criada automaticamente pelo Xcode agora),

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

Etapa 4 , exporte como arquivo .ipa como este, diferente do Xcode6

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

Agora, você obtém um arquivo ipa no diretório build /. Basta enviá-lo para a Apple App Store.

A propósito, o arquivo ipa criado pelo Xcode 7 é muito maior que o Xcode 6.

Eu dei uma breve descrição das etapas a seguir e dos parâmetros a serem transmitidos ao gerar um ipa usando o terrminal abaixo:

1. Vá para a pasta que contém o arquivo MyApp.xcodeproject no terminal

2. Ao usar o comando abaixo, você obterá todos os destinos do aplicativo

   /usr/bin/xcodebuild -list 

3. Após a execução do comando acima, você obterá uma lista de destinos dos quais você deve selecionar um destino específico que precisa gerar .ipa

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

4. O comando acima cria o projeto e cria um arquivo .app. O caminho para localizar o arquivo .app é ./build/Release-iphoneos/MyApp.app

5. Depois que o Build for bem-sucedido, execute o seguinte comando para gerar .ipa do aplicativo usando o Nome do desenvolvedor e o Perfil de provisionamento usando a sintaxe abaixo:

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

Explicação de cada parâmetro na sintaxe acima:

${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 será gerado no diretório de saída selecionado " $ {OUTDIR} "

Xcode 8:

Formato IPA:

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

Exporta o arquivo MyMobileApp.xcarchive como um arquivo IPA para o caminho MyMobileApp.ipa usando o perfil de fornecimento MyMobileApp Distribution Profile.

Formato da APP:

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

Exporta o arquivo MyMacApp.xcarchive como um arquivo PKG para o caminho MyMacApp.pkg usando a identidade de assinatura de cátion do aplicativo de aplicativo Application ID do desenvolvedor Application: My Team. A identidade de assinatura do instalador ID do desenvolvedor Instalador: Minha equipe é implicitamente usada para assinar o pacote exportado.

Página de manual do Xcodebuild

Vá para a pasta onde está a raiz do seu projeto e:

xcodebuild -project projectname -activetarget -activeconfiguration archive

Indo um passo adiante, fazendo o upload para o iTunesConnect via linha de comando com o Xcode 7 ! (Supondo que você esteja começando com um .ipaque tenha sido assinado com o perfil de liberação e a identidade de assinatura corretos.)

Digite altoola interface da CLI para o Application Loader ( docs, página 38). Escondida na estrutura do Xcode.app, está uma função útil para nos enviar diretamente para o ItunesConnect.

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

Basta executar o $ altool --upload-app -f file -u username [-p password]upload do seu recém-cunhado .ipadireto para a Apple. A senha é opcional e solicitará se você a deixar de fora do comando.

Se houver algum problema com o aplicativo durante a etapa de verificação, o console os imprimirá.

Você provavelmente terá que exportar o caminho para altoolse não quiser salvar sua localização.

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

É isso aí! Basta acessar o iTunesConnect.com e selecionar sua nova versão para teste com testflight.

Nota final: Se você receber um erro dizendo Exception while launching iTunesTransporter: Transporter not found at path: /usr/local/itms/bin/iTMSTransporter. You should reinstall the application, pode seguir a sugestão desta resposta do SO para executar um link simbólico no local correto:

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

Melhorando a resposta de Vincent, escrevi um script para fazer isso: xcodearchive
Permite arquivar (gerar um ipa) seu projeto através da linha de comando. Pense nisso como a irmã do xcodebuildcomando, mas para arquivar.

O código está disponível no github: http://github.com/gcerquant/xcodearchive

Uma opção do script é ativar o arquivamento dos símbolos dSYM em um arquivo com registro de data e hora. Não há desculpa para não manter mais os símbolos e não ser capaz de simbolizar o log de falhas que você poderá receber posteriormente.

Como criar um projeto iOS com o 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

O que é o ExportOptions.plist?

ExportOptions.plist é necessário no Xcode. Permite especificar algumas opções ao criar um arquivo ipa. Você pode selecionar as opções em uma interface amigável ao usar o Xcode para arquivar seu aplicativo.

Importante : O método para liberação e desenvolvimento é diferente no ExportOptions.plist

AppStore:

exportOptions_release ~ method = loja de aplicativos

Desenvolvimento

exportOptions_dev ~ method = development

Experimente o xctool, é um substituto do xcodebuild da Apple que facilita a criação e o teste de produtos iOS e Mac. É especialmente útil para integração contínua. Possui alguns recursos extras:

1. Executa os mesmos testes que o Xcode.app.
2. Saída estruturada dos resultados de compilação e teste.
3. Saída de cor ANSI amigável ao ser humano.

No.3 é extremamente útil. Não sei se alguém pode ler a saída do console do xcodebuild, não sei, geralmente isso me dava uma linha com mais de 5000 caracteres. Ainda mais difícil de ler do que um trabalho de tese.

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

se você usar a próxima ferramenta: https://github.com/nomad/shenzhen

então esta tarefa é muito fácil:

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

Após atualizar para o Xcode 8, descobri que o ipa corporativo gera por

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

O comando não pode ser iniciado devido a algum problema de assinatura. O log indica que "aviso: PackageApplication está obsoleto, use xcodebuild -exportArchive lugar.

Então mudei para xcodebuild -exportArchivee tudo voltou ao normal.

Você quer dizer as opções de validar / compartilhar / enviar? Eu acho que esses são específicos para o Xcode e não são adequados para uma ferramenta de criação de linha de comando.

Com alguma esperteza, aposto que você poderia criar um script para fazer isso por você. Parece que eles estão armazenados apenas em~/Library/MobileDevice/Archived Applications/ com um UUDI e uma lista. Não posso imaginar que seria tão difícil fazer a engenharia reversa do validador também.

O processo que eu estou interessado em automatizar está enviando builds para beta testers. (Como o envio da App Store acontece com pouca frequência, não me importo de fazê-lo manualmente, principalmente porque geralmente preciso adicionar um novo texto de descrição.) Ao fazer um pseudo Build + Archive usando a CLI do Xcode, posso acionar compilações automáticas a cada confirmação de código, crie arquivos IPA com perfis de provisionamento incorporados e envie por e-mail aos testadores.