Xcode "Build and Archive" desde la línea de comandos

Xcode 3.2 proporciona una nueva característica impresionante en el menú Generar, "Generar y archivar" que genera un archivo .ipa adecuado para la distribución Ad Hoc. También puede abrir el Organizador, ir a "Aplicaciones archivadas" y "Enviar solicitud a iTunesConnect".

¿Hay alguna manera de usar "Build and Archive" desde la línea de comandos (como parte de un script de compilación)? Supongo que xcodebuildestaría involucrado de alguna manera, pero la manpágina no parece decir nada sobre esto.

ACTUALIZACIÓN Michael Grinich solicitó una aclaración; esto es exactamente lo que no puede hacer con las compilaciones de línea de comandos, características que SOLO puede hacer con el Organizador de Xcode después de "Construir y Archivar".

1. Puede hacer clic en "Compartir aplicación ..." para compartir su IPA con beta testers. Como Guillaume señala a continuación, debido a la magia de Xcode, este archivo IPA no requiere un archivo .mobileprovision distribuido por separado que los probadores beta deben instalar; Eso es mágico. Ningún script de línea de comandos puede hacerlo. Por ejemplo, el script de Arrix (enviado el 1 de mayo) no cumple con ese requisito.
2. Más importante aún, después de que haya probado beta una compilación, puede hacer clic en "Enviar aplicación a iTunes Connect" para enviar esa misma compilación EXACTAMENTE a Apple, el binario que probó, sin reconstruirla. Eso es imposible desde la línea de comandos, porque firmar la aplicación es parte del proceso de compilación; puede firmar bits para la prueba beta Ad Hoc O puede firmarlos para enviarlos a la App Store, pero no ambos. Ningún IPA integrado en la línea de comandos puede probarse en versión beta en teléfonos y luego enviarse directamente a Apple.

Me encantaría que alguien viniera y demuestre que estoy equivocado: ambas características funcionan muy bien en la GUI de Xcode y no se pueden replicar desde la línea de comandos.

Encontré cómo automatizar el proceso de compilación y archivo desde la línea de comando, acabo de escribir un artículo de blog explicando cómo puedes lograrlo.

El comando que debes usar es 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}"

Encontrarás todos los detalles en el artículo . Si tiene alguna pregunta, no dude en preguntar.

Con Xcode 4.2 puede usar el indicador -scheme para hacer esto:

xcodebuild -scheme <SchemeName> archive

Después de este comando, el Archivo aparecerá en el Xcode Organizer.

Actualizando mi respuesta con Xcode 9 y Swift

Archivo

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

Exportación IPA ( tenga en cuenta la opción de exportación plist )

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

Para aquellos que no conocen exportOptions.plist, https://blog.bitrise.io/new-export-options-plist-in-xcode-9

Aquellos que estaban usando esto para construir proyectos en herramientas de CI / CD como teamcity / jenkins, asegúrese de estar usando el xcode correcto instalado en el agente de compilación para archivar y exportar.

Puede usar cualquiera de las siguientes 2 opciones para esto.

1. Use la ruta completa 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

Abajo está mi vieja respuesta

Aquí hay un script de línea de comando para crear un archivo y un ejemplo de IPA. Tengo un proyecto de iPhone xcode, que se encuentra en la carpeta Desktop / MyiOSApp.

Ejecute los siguientes comandos uno por 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"

Esto se ha probado con Xcode 5 y funciona bien para mí.

He estado usando mi propio script de compilación para generar el paquete ipa para la distribución 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

El script también incrementa el número de versión. Puede eliminar esa parte si no es necesaria. Espero eso ayude.

La xcodebuildherramienta puede compilar y exportar productos de archivo con el indicador -exportArchive (a partir de Xcode 5). Anteriormente, el paso de exportación solo era posible a través de la interfaz de usuario de Xcode Organizer.

Primero archiva tu aplicación:

xcodebuild -scheme <scheme name> archive

Dada $ARCHIVE_PATH(la ruta al archivo .xcarchive ), exporte la aplicación desde el archivo con uno de los siguientes:

Archivo .ipa de iOS :

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

Archivo .app de Mac :

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

En ambos comandos, los argumentos -exportProvisioningProfile y -exportSigningIdentity son opcionales. man xcodebuildpara detalles sobre la semántica. En estos ejemplos, el perfil de aprovisionamiento para la compilación de iOS especificaba un perfil de aprovisionamiento de distribución AdHoc, y la identidad de firma para la aplicación Mac especificaba un ID de desarrollador para exportarlo como una aplicación de terceros (es decir, no distribuido a través de Mac App Store).

Desarrollamos una aplicación para iPad con XCode 4.2.1 y queríamos integrar la compilación en nuestra integración continua (Jenkins) para la distribución de OTA. Aquí está la solución que se me ocurrió:

# 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

Luego, Jenkins carga los archivos ipa, plist y html en nuestro servidor web.

Esta es la plantilla de 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 esto, debe importar el certificado de distribución y el perfil de aprovisionamiento en el llavero del usuario designado.

Encontré algunas de las otras respuestas aquí difíciles de poner en marcha. Este artículo lo hizo para mí. Algunos caminos pueden necesitar ser absolutos, como se menciona en las otras respuestas.

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

PUEDE realmente renunciar a una compilación, tal como lo hace XCode, para que pueda probar y enviar el mismo binario. Por ejemplo, en mi script (similar a los anteriores) construyo mi versión de lanzamiento firmada como una compilación AdHoc, luego la archivo como IPA para probar, luego renuncio con mi certificado de distribución y creo un archivo zip, que es lo que envío a Manzana. La línea relevante es:

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

Para Xcode 7 , tiene una solución mucho más simple. El único trabajo adicional es que debe crear un archivo plist de configuración para exportar el archivo.

(En comparación con Xcode 6, en los resultados de xcrun xcodebuild -help, -exportFormaty las -exportProvisioningProfileopciones ya no se mencionan; la primera se elimina y la segunda se reemplaza por -exportOptionsPlist).

Paso 1 , cambie el directorio a la carpeta incluyendo .xcodeproject o .xcworkspace file.

cd MyProjectFolder

Paso 2 , usa Xcode o /usr/libexec/PlistBuddy exportOptions.plistpara crear opciones de exportación de archivos plist. Por cierto, xcrun xcodebuild -helple dirá qué claves debe insertar en el archivo plist.

Paso 3 , cree el archivo .xcarchive (carpeta, de hecho) de la siguiente manera (la compilación / directorio será creado automáticamente por Xcode en este momento),

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

Paso 4 , exporte como un archivo .ipa como este, que difiere de Xcode6

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

Ahora, obtienes un archivo ipa en el directorio build /. Simplemente envíelo a la App Store de Apple.

Por cierto, el archivo ipa creado por Xcode 7 es mucho más grande que Xcode 6.

He dado una breve descripción de los pasos a seguir y los parámetros que se deben pasar al generar un ipa usando terrminal a continuación:

1. Vaya a la carpeta que contiene el archivo MyApp.xcodeproject en la terminal

2. Al usar el comando que se proporciona a continuación, obtendrá todos los objetivos de la aplicación

   /usr/bin/xcodebuild -list 

3. Después de ejecutar el comando anterior, obtendrá una lista de objetivos de los cuales debe seleccionar un objetivo específico que necesita generar .ipa

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

4. El comando anterior crea el proyecto y crea un archivo .app. La ruta para ubicar el archivo .app es ./build/Release-iphoneos/MyApp.app

5. Después de que Build tenga éxito, ejecute el siguiente comando para generar .ipa de la aplicación usando el Nombre del desarrollador y el Perfil de aprovisionamiento usando la sintaxis a continuación:

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

Explicación de cada parámetro en la sintaxis anterior:

${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 se generará en el directorio de salida seleccionado " $ {OUTDIR} "

Xcode 8:

Formato de IPA:

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

Exporta el archivo MyMobileApp.xcarchive como un archivo IPA a la ruta MyMobileApp.ipa utilizando el perfil de aprovisionamiento MyMobileApp Distribution Profile.

Formato de la APLICACIÓN:

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

Exporta el archivo MyMacApp.xcarchive como un archivo PKG a la ruta MyMacApp.pkg utilizando la aplicación de aplicación identidad de firma de cationes ID de desarrollador Aplicación: Mi equipo. La identidad de firma del instalador. ID del desarrollador Instalador: Mi equipo se usa implícitamente para firmar el paquete exportado.

Página de manual de Xcodebuild

Vaya a la carpeta donde está la raíz de su proyecto y:

xcodebuild -project projectname -activetarget -activeconfiguration archive

¡Avanza un paso más y sube a iTunesConnect a través de la línea de comandos con Xcode 7 ! (Suponiendo que está comenzando con un .ipaque se ha firmado con el perfil de lanzamiento y la identidad de firma correctos).

Ingrese altool, la interfaz CLI para Application Loader ( docs, página 38). Oculto en la estructura de Xcode.app, es una función útil que nos permite subir directamente a ItunesConnect.

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

Simplemente ejecute $ altool --upload-app -f file -u username [-p password]para cargar su recién acuñado .ipadirectamente a Apple. La contraseña es opcional y se la solicitará si la deja fuera del comando.

Si hay algún problema con la aplicación durante el paso de verificación, la consola los imprimirá.

Es probable que tenga que exportar la ruta a altoolsi no desea guardar su ubicación.

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

¡Eso es! Simplemente inicie sesión en iTunesConnect.com y seleccione su nueva compilación para probar con testflight.

Nota final: si recibe un mensaje de error Exception while launching iTunesTransporter: Transporter not found at path: /usr/local/itms/bin/iTMSTransporter. You should reinstall the application, puede seguir la sugerencia de esta respuesta SO , para ejecutar un enlace simbólico a la ubicación correcta:

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

Mejorando la respuesta de Vincent, escribí un script para hacerlo: le xcodearchive
permite archivar (generar un ipa) su proyecto a través de la línea de comando. Piense en ello como la hermana del xcodebuildcomando, pero para archivar.

El código está disponible en github: http://github.com/gcerquant/xcodearchive

Una opción del script es habilitar el archivado de los símbolos dSYM en un archivo con marca de tiempo. No hay excusa para no mantener más los símbolos y no ser capaz de simbolizar el registro de bloqueo que pueda recibir más tarde.

¿Cómo construir un proyecto 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

¿Qué es ExportOptions.plist?

ExportOptions.plist es obligatorio en Xcode. Le permite especificar algunas opciones cuando crea un archivo ipa. Puede seleccionar las opciones en una interfaz de usuario amigable cuando usa Xcode para archivar su aplicación.

Importante : El método de lanzamiento y desarrollo es diferente en ExportOptions.plist

AppStore:

exportOptions_release ~ method = app-store

Desarrollo

exportOptions_dev ~ method = development

pruebe xctool, es un reemplazo para xcodebuild de Apple que hace que sea más fácil construir y probar productos iOS y Mac. Es especialmente útil para la integración continua. Tiene algunas características adicionales:

1. Ejecuta las mismas pruebas que Xcode.app.
2. Salida estructurada de resultados de compilación y prueba.
3. Salida de color ANSI amigable para los humanos.

No.3 es extremadamente útil. No sé si alguien puede leer la salida de consola de xcodebuild, no puedo, por lo general, me dio una línea con más de 5000 caracteres. Aún más difícil de leer que un trabajo de tesis.

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

si usa la siguiente herramienta: https://github.com/nomad/shenzhen

entonces esta tarea es muy 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}"

fuente

Después de actualizar a Xcode 8, descubrí que la ipa empresarial se genera 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}" 

El comando no se puede iniciar debido a algún problema de firma. El registro indica que "advertencia: PackageApplication está en desuso, use xcodebuild -exportArchiveen su lugar.

Así que me cambio xcodebuild -exportArchivey todo volvió a la normalidad.

¿Te refieres a las opciones de validación / compartir / enviar? Creo que son específicos de Xcode y no son adecuados para una herramienta de construcción de línea de comandos.

Con algo de inteligencia, apuesto a que podrías hacer un guión que lo haga por ti. Parece que solo están almacenados ~/Library/MobileDevice/Archived Applications/con un UUDI y un plist. No puedo imaginar que sea tan difícil hacer ingeniería inversa en el validador tampoco.

El proceso que estoy interesado en automatizar es enviar compilaciones a probadores beta. (Dado que el envío de la App Store ocurre con poca frecuencia, no me importa hacerlo manualmente, especialmente porque a menudo necesito agregar un nuevo texto descriptivo). Al hacer un pseudo Build + Archive usando la CLI de Xcode, puedo activar compilaciones automáticas de cada confirmación de código, cree archivos IPA con perfiles de aprovisionamiento integrados y envíelos por correo electrónico a los evaluadores.