Enviar a problemas de la Tienda de aplicaciones: Arquitectura no compatible x86

Así que estoy tratando de usar la API shopify. Cuando archivo la aplicación y la valida, no hay problemas, pero cuando la envío a la tienda de aplicaciones me da los siguientes problemas.

  1. ERROR ITMS-90087: “Arquitectura no compatible. Su ejecutable contiene architecture no compatible ‘[x86_64, i386]’.”
  2. ERROR ITMS-90209: “Alineación de segmento inválida. El binario de la aplicación en SJAPP.app/Frameworks/Buy.framework/Buy no tiene una alineación de segmento adecuada. Intente reconstruir la aplicación con la última versión de xcode“. (Ya estoy usando la última versión).
  3. ERROR ITMS-90125: “El binario no es válido. La información de cifrado en el comando de carga LC_ENCRYPTION_INFO falta o no es válida, o el binario ya está encriptado. Este binario no parece haberse creado con el Enlazador de Apple”.
  4. ADVERTENCIA ITMS-90080: “El cuadro Ejecutable Payload /…./ Buy. No es un ejecutable independiente de la posición. Asegúrese de que la configuración de comstackción de ur esté configurada para crear ejecutables PIE”.

El problema es que Buy Framework contiene una comstackción tanto para el simulador (x86_64) como para los dispositivos reales (ARM).

Por supuesto, no está permitido enviar a la tienda de aplicaciones un binario para una architecture no compatible, por lo que la solución es eliminar “manualmente” las architectures innecesarias del binario final antes de enviarlas.

Daniel Kennett propuso una buena solución y proporciona esta secuencia de comandos para agregar a la fase de comstackción:

APP_PATH="${TARGET_BUILD_DIR}/${WRAPPER_NAME}" # This script loops through the frameworks embedded in the application and # removes unused architectures. find "$APP_PATH" -name '*.framework' -type d | while read -r FRAMEWORK do FRAMEWORK_EXECUTABLE_NAME=$(defaults read "$FRAMEWORK/Info.plist" CFBundleExecutable) FRAMEWORK_EXECUTABLE_PATH="$FRAMEWORK/$FRAMEWORK_EXECUTABLE_NAME" echo "Executable is $FRAMEWORK_EXECUTABLE_PATH" EXTRACTED_ARCHS=() for ARCH in $ARCHS do echo "Extracting $ARCH from $FRAMEWORK_EXECUTABLE_NAME" lipo -extract "$ARCH" "$FRAMEWORK_EXECUTABLE_PATH" -o "$FRAMEWORK_EXECUTABLE_PATH-$ARCH" EXTRACTED_ARCHS+=("$FRAMEWORK_EXECUTABLE_PATH-$ARCH") done echo "Merging extracted architectures: ${ARCHS}" lipo -o "$FRAMEWORK_EXECUTABLE_PATH-merged" -create "${EXTRACTED_ARCHS[@]}" rm "${EXTRACTED_ARCHS[@]}" echo "Replacing original executable with thinned version" rm "$FRAMEWORK_EXECUTABLE_PATH" mv "$FRAMEWORK_EXECUTABLE_PATH-merged" "$FRAMEWORK_EXECUTABLE_PATH" done 

Lo usé y funcionó perfectamente.

EDITAR: asegúrese de mirar el script modificado publicado por Varrry, ya que este tiene algunos problemas menores.

La respuesta dada por pAkY88 funciona, pero me enfrenté al mismo problema que Mario A Guzman en https://stackoverflow.com/a/35240555/5272316 : una vez que cortamos las architectures no utilizadas no podemos ejecutar el script más ya que intenta eliminar no segmentos existentes, porque xcode no vuelve a incrustar binario todo el tiempo. Idea fue: simplemente elimine las divisiones i386 y x86_64 cuando compile para el archivo, así que modifiqué el script:

 echo "Target architectures: $ARCHS" APP_PATH="${TARGET_BUILD_DIR}/${WRAPPER_NAME}" find "$APP_PATH" -name '*.framework' -type d | while read -r FRAMEWORK do FRAMEWORK_EXECUTABLE_NAME=$(defaults read "$FRAMEWORK/Info.plist" CFBundleExecutable) FRAMEWORK_EXECUTABLE_PATH="$FRAMEWORK/$FRAMEWORK_EXECUTABLE_NAME" echo "Executable is $FRAMEWORK_EXECUTABLE_PATH" echo $(lipo -info "$FRAMEWORK_EXECUTABLE_PATH") FRAMEWORK_TMP_PATH="$FRAMEWORK_EXECUTABLE_PATH-tmp" # remove simulator's archs if location is not simulator's directory case "${TARGET_BUILD_DIR}" in *"iphonesimulator") echo "No need to remove archs" ;; *) if $(lipo "$FRAMEWORK_EXECUTABLE_PATH" -verify_arch "i386") ; then lipo -output "$FRAMEWORK_TMP_PATH" -remove "i386" "$FRAMEWORK_EXECUTABLE_PATH" echo "i386 architecture removed" rm "$FRAMEWORK_EXECUTABLE_PATH" mv "$FRAMEWORK_TMP_PATH" "$FRAMEWORK_EXECUTABLE_PATH" fi if $(lipo "$FRAMEWORK_EXECUTABLE_PATH" -verify_arch "x86_64") ; then lipo -output "$FRAMEWORK_TMP_PATH" -remove "x86_64" "$FRAMEWORK_EXECUTABLE_PATH" echo "x86_64 architecture removed" rm "$FRAMEWORK_EXECUTABLE_PATH" mv "$FRAMEWORK_TMP_PATH" "$FRAMEWORK_EXECUTABLE_PATH" fi ;; esac echo "Completed for executable $FRAMEWORK_EXECUTABLE_PATH" echo $(lipo -info "$FRAMEWORK_EXECUTABLE_PATH") done 

Esta secuencia de comandos simplemente elimina las divisiones i386 y x86_64 del binario grueso (si existen) si no se está ejecutando para el simulador (eso significa que la carpeta de destino no es como “Debug-iphonesimulator”).

Lo siento, no estoy familiarizado con los guiones del intérprete de comandos, por lo que es posible que alguien pueda escribirlo de manera más elegante. Pero funciona)

Si está utilizando Cartago , puede experimentar este problema porque el proyecto es:

  • Falta la fase de comstackción de carthage copy-frameworks .
  • O la fase de construcción no incluye todos los marcos (lista incompleta).

Esta acción filtra los marcos a una lista de architectures válidas (código) .

Configurar la fase de comstackción copy-frameworks

Desde el edificio de Carthage para los pasos de iOS :

En la pestaña de configuración “Crear fases” de los objectives de la aplicación, haga clic en el ícono “+” y seleccione “Nueva fase de secuencia de ejecución”. Cree un script de ejecución en el que especifique su shell (por ejemplo: bin / sh), agregue los siguientes contenidos al área de scripts debajo del shell:

/usr/local/bin/carthage copy-frameworks

y agregue las rutas a los marcos que desea usar en “Archivos de entrada”, por ejemplo:

$(SRCROOT)/Carthage/Build/iOS/Box.framework $(SRCROOT)/Carthage/Build/iOS/Result.framework $(SRCROOT)/Carthage/Build/iOS/ReactiveCocoa.framework

Esta secuencia de comandos funciona en torno a un error de envío de App Store desencadenado por binarios universales y garantiza que los archivos relacionados con el código de bits necesarios y los dSYM se copien al archivar.

Resolví el error ITMS-90080 al eliminar un marco (el excelente SVProgressHUD) de la sección Binarios incrustados (destino Xcode -> pestaña General).

enter image description here

Si está utilizando Carthage asegúrese de que el Build Step Embed Frameworks esté antes de los copy-frameworks Carthage copy-frameworks


En algunos casos inusuales (ejemplo: marco Lottie-iOS):

  • lo tendrá simplemente en “Link Library” como de costumbre.

  • Sin embargo , también debe agregarlo explícitamente en “Embed Frameworks” (aunque parezca inútil, ya que funciona perfectamente cuando lo tiene solo en “Embed Frameworks”),

  • y ponerlo en copy-frameworks

  • y asegúrese de copiar-frameworks después de “Embed Frameworks”

Tuve el mismo problema incluso después de agregar el guión y actualizar el marco varias veces.

Asegúrese de que en xCode el script se agregue al final, después de la inserción. Creo que moví accidentalmente el script antes del marco incrustado.

enter image description here

Nota: Tengo xCode 9.1

Agregaré mis 2 centavos aquí (de una manera menos atemorizante :-). Me he encontrado con un buen número de bibliotecas pesadas de Vendedores que (por alguna razón) no funcionan de la manera normal al agregarlas al directorio de Frameworks tal como lo documenta Apple. La única forma en que hemos podido hacer que funcionen es tirando de .framekwork directamente en el directorio del proyecto y vinculando Embedded Frameworks y Link Binary with Libraries manualmente en Build Settings. Esto parece haber funcionado sin ningún problema, sin embargo, como con cualquier biblioteca adictiva, vienen con las extrañas Arquitecturas Simulator i386 y x86_64 junto con las architectures de los arm .

Una forma rápida de verificar las architectures en la biblioteca de grasa es

 $ cd 'Project_dir/Project' $ lipo -info 'YourLibrary.framework/YourLibExec` 

Lo cual debería escupir un resultado como este

 Architectures in the fat file: YourLibrary.framework/YourLibExec are: i386 x86_64 armv7 arm64 

Esto confirma que tendrá que “recortar la grasa” (es decir, i386 y x86_64 ) de su marco antes de la carga de iTunesConnect Archival, que no permite estas architectures (ya que no son compatibles con iOS).

Ahora, todas las respuestas (o al menos algunas de las respuestas) anteriores proporcionan estos maravillosos Scripts de ejecución que, estoy seguro, funcionan muy bien, pero solo si su Framework reside en el directorio de Frameworks . Ahora, a menos que seas un adicto al script de shell, esos scripts sin modificaciones no funcionarán para el escenario que explico arriba. Sin embargo, hay una manera muy simple de deshacerse de las architectures i386 y x86_64 del marco.

  1. Abra la terminal en el directorio de su proyecto.
  2. Cambie el directorio directamente en .framekwork , como

    cd YourProjectDir/YourProject/YourLibrary.framework

  3. Ejecute la serie de comandos como se muestra a continuación-

    $ mv YourLibrary YourLibrary_all_archs

    $ lipo -remove x86_64 YourLibrary_all_archs -o YourLibrary_some_archs

    $ lipo -remove i386 YourLibrary_some_archs -o YourLibrary

    $ rm YourLibrary_all_archs YourLibrary_some_archs

Algunas cosas para tener en cuenta aquí: lipo -remove tiene que hacerse una vez para cada architecture para eliminar. lipo no modifica el archivo de entrada, solo produce un archivo, por lo que debe ejecutar lipo -remove una vez para x86_64 e i386 . Los comandos anteriores simplemente lo hacen cambiando primero el nombre del ejecutable y luego eliminando los archivos archivados deseados, y luego limpiando los archivos restantes. Y eso es todo, ahora debería ver una marca de verificación verde en la carga del archivo de Application Loader en iTunes Connect.

Cosas a tener en cuenta : los pasos anteriores solo deberían realizarse durante la creación de la producción, ya que el .framework se eliminará de las architectures del simulador, las construcciones en los simuladores dejarán de funcionar (lo que se espera). En el entorno de desarrollo, no debería ser necesario quitar las architectures del archivo .framework , ya que desea poder probar tanto en el simulador como en un dispositivo físico. Si su biblioteca gorda reside en la carpeta de Frameworks en el proyecto, entonces mire la respuesta aceptada.

Eliminé las architectures i386 y x64_86 de Configuraciones de comstackción – Arquitecturas válidas – Liberar, y todo funcionó bien.

enter image description here

Ahora, el único problema sería que no puede ejecutar una comstackción RELEASE para fines de prueba en un SIMULADOR . Pero tan fácilmente como quitó los arcos, puede agregarlos nuevamente si lo desea.

Este problema se resolvió para mí modificando ligeramente el script de ejecución de la respuesta de pAky88 y la ejecución después de incorporar marcos. También asegúrese de desmarcar la casilla “Ejecutar script solo al instalar”.

 /usr/local/bin/carthage copy-frameworks #!/usr/bin/env bash APP_PATH="${TARGET_BUILD_DIR}/${WRAPPER_NAME}" # This script loops through the frameworks embedded in the application and # removes unused architectures. find "$APP_PATH" -name '*.framework' -type d | while read -r FRAMEWORK do FRAMEWORK_EXECUTABLE_NAME=$(defaults read "$FRAMEWORK/Info.plist" CFBundleExecutable) FRAMEWORK_EXECUTABLE_PATH="$FRAMEWORK/$FRAMEWORK_EXECUTABLE_NAME" if [ ! -f "${FRAMEWORK_EXECUTABLE_PATH}" ]; then continue fi if xcrun lipo -info "${FRAMEWORK_EXECUTABLE_PATH}" | grep --silent "Non-fat"; then echo "Framework non-fat, skipping: $FRAMEWORK_EXECUTABLE_NAME" continue fi echo "Thinning framework $FRAMEWORK_EXECUTABLE_NAME" EXTRACTED_ARCHS=() for ARCH in $ARCHS do echo "Extracting $ARCH from $FRAMEWORK_EXECUTABLE_NAME" xcrun lipo -extract "$ARCH" "$FRAMEWORK_EXECUTABLE_PATH" -o "$FRAMEWORK_EXECUTABLE_PATH-$ARCH" EXTRACTED_ARCHS+=("$FRAMEWORK_EXECUTABLE_PATH-$ARCH") done echo "Merging extracted architectures: ${ARCHS}" xcrun lipo -o "$FRAMEWORK_EXECUTABLE_PATH-merged" -create "${EXTRACTED_ARCHS[@]}" rm "${EXTRACTED_ARCHS[@]}" echo "Replacing original executable with thinned version" rm "$FRAMEWORK_EXECUTABLE_PATH" mv "$FRAMEWORK_EXECUTABLE_PATH-merged" "$FRAMEWORK_EXECUTABLE_PATH" done 

Este error (ITMS-90240) también puede ser causado por una biblioteca estática (.a). Aquí hay una secuencia de comandos para eliminar las architectures en exceso. En Xcode, agregue esto a Target> BuildPhases> Haga clic en + y seleccione Run Script. A continuación, pegue esto en el cuadro de secuencia de comandos.

El script busca archivos .a, comprueba si contiene una architecture ofensiva y, si lo hace, crea un nuevo archivo .a sin esa architecture.

Para macOS:

 APP_PATH="${TARGET_BUILD_DIR}/${WRAPPER_NAME}" STRIPARCHS="armv7 armv7s arm64" for t in $STRIPARCHS do if find "$APP_PATH" -name '*.a' -exec lipo -info {} \; | grep $t ; then find "$APP_PATH" -name '*.a' -exec lipo -remove $t {} -output {}2 \; -exec rm {} \; -exec mv {}2 {} \; ; fi done exit 0 

Para iOS:

 APP_PATH="${TARGET_BUILD_DIR}/${WRAPPER_NAME}" STRIPARCHS="x86_64 i386" for t in $STRIPARCHS do if find "$APP_PATH" -name '*.a' -exec lipo -info {} \; | grep $t ; then find "$APP_PATH" -name '*.a' -exec lipo -remove $t {} -output {}2 \; -exec rm {} \; -exec mv {}2 {} \; ; fi done exit 0 

Su marco contiene códigos tanto ARM como x86 , lo que le permite usarlo en un dispositivo o en el simulador. Si tiene la intención de enviar su aplicación a App Store, ejecute la siguiente secuencia de comandos para quitar el código inactivo del binario.

1. Seleccione su objective en el Navegador de proyectos y haga clic en Crear fases en la parte superior del editor del proyecto.

2.Desde el menú Editor, seleccione Agregar fase de comstackción, luego Agregar fase de comstackción de secuencia de ejecución (o haga clic en el botón + en la esquina superior izquierda del editor Crear fases).

3. Amplíe el triángulo de revelación al lado de la nueva fase de comstackción Ejecutar Script que acaba de agregar. En el cuadro del editor de scripts, pegue lo siguiente: bash

$ {BUILT_PRODUCTS_DIR} / $ {FRAMEWORKS_FOLDER_PATH} / “YourframeworkName.framework” /strip-frameworks.sh

Tuve el mismo problema. Incluso no funcionaba después de agregar la secuencia de comandos de ejecución. Fue un problema relacionado con Xcode. Estaba usando la versión 9.0 de Xcode pero la última versión era 9.2.

Así que instalé el último Xcode (9.2) y funcionó.

Quite [x86_64, i386] del marco utilizando el paso siguiente. [x86_64, i386] se usa para el simulador.

  1. Terminal abierto

  2. abra su ruta de arrastre del proyecto de la estructura respectiva a la Terminal

    ejemplo: cd /Users/MAC/Desktop/MyProject/Alamofire.framework

  3. establece tu nombre de Framework en el siguiente comando y ejecuta

lipo -remove i386 Alamofire -o Alamofire && lipo -remove x86_64 Alamofire -o Alamofire

  1. Ahora abra su proyecto nuevamente, Limpiar, comstackr y ejecutar y crear archivo …

la solución simple que funcionó para mí fue

1- eliminar el marco de los marcos incrustados.

2- agregar el marco como un marco vinculado

¡hecho!