Soumettre aux problèmes de l'App Store: architecture non prise en charge x86

J'essaie donc d'utiliser l'API Shopify. Lorsque j'archive l'application et la valide, il n'y a aucun problème, mais lorsque je la soumets à l'App Store, cela me pose les problèmes suivants.

1. ERREUR ITMS-90087: "Architecture non prise en charge. Votre exécutable contient une architecture non prise en charge '[x86_64, i386]'."
2. ERREUR ITMS-90209: "Alignement de segment non valide. Le binaire d'application sur SJAPP.app/Frameworks/Buy.framework/Buy n'a pas un alignement de segment approprié. Essayez de reconstruire l'application avec la dernière version de Xcode." (J'utilise déjà la dernière version.)
3. ERREUR ITMS-90125: "Le binaire n'est pas valide. Les informations de cryptage dans la commande de chargement LC_ENCRYPTION_INFO sont manquantes ou non valides, ou le binaire est déjà crypté. Ce binaire ne semble pas avoir été construit avec l'éditeur de liens d'Apple."
4. AVERTISSEMENT ITMS-90080: "La charge utile exécutable /..../ Buy.framework n'est pas un exécutable indépendant de la position. Veuillez vous assurer que vos paramètres de construction sont configurés pour créer des exécutables PIE."

Le problème est que le framework Buy contient une version pour le simulateur (x86_64) et les périphériques réels (ARM).

Bien sûr, vous n'êtes pas autorisé à soumettre à l'App Store un binaire pour une architecture non prise en charge, donc la solution consiste à supprimer "manuellement" les architectures inutiles du binaire final, avant de le soumettre.

Daniel Kennett a trouvé une bonne solution et fournit ce script à ajouter à la phase de construction:

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

Je l'ai utilisé et cela a parfaitement fonctionné.

EDIT: assurez-vous de regarder le script modifié publié par Varrry, car celui-ci a quelques problèmes mineurs.

La réponse donnée par pAkY88 fonctionne, mais j'ai rencontré le même problème que Mario A Guzman dans https://stackoverflow.com/a/35240555/5272316 : une fois que nous avons coupé les architectures inutilisées, nous ne pouvons plus exécuter le script car il essaie de supprimer pas de tranches existantes, car xcode ne réintègre pas le binaire à chaque fois. L'idée était - il suffit de supprimer les tranches i386 et x86_64 lors de la construction pour l'archivage, j'ai donc modifié le 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

Ce script supprime simplement les tranches i386 et x86_64 du gros binaire (si elles existent) s'il ne fonctionne pas pour le simulateur (cela signifie que le dossier de destination n'est pas comme "Debug-iphonesimulator").

Désolé, je ne connais pas les scripts shell, donc peut-être que quelqu'un pourrait l'écrire de manière plus élégante. Mais ça marche)

Si vous utilisez Carthage, vous pouvez rencontrer ce problème car le projet est:

• Manque la carthage copy-frameworksphase de construction.
• Ou la phase de construction n'inclut pas tous les frameworks (liste incomplète).

Cette action filtre les frameworks en une liste d'architectures valides (code) .

Configuration de la phase de construction des frameworks de copie

Depuis le bâtiment Carthage pour les étapes iOS :

Dans l'onglet des paramètres «Build Phases» de vos cibles d'application, cliquez sur l'icône «+» et choisissez «New Run Script Phase». Créez un script d'exécution dans lequel vous spécifiez votre shell (ex: bin / sh), ajoutez le contenu suivant à la zone de script sous le shell:

/usr/local/bin/carthage copy-frameworks

et ajoutez les chemins d'accès aux cadres que vous souhaitez utiliser sous «Fichiers d'entrée», par exemple:

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

Ce script contourne un bogue de soumission sur l'App Store déclenché par des binaires universels et garantit que les fichiers liés au code bit et les dSYM nécessaires sont copiés lors de l'archivage.

J'ai résolu l'erreur ITMS-90080 en supprimant un cadre (l'excellent SVProgressHUD) de la section Embedded Binaries (cible Xcode -> onglet Général).

Si vous utilisez CarthageAssurez - vous que votre Embed Frameworks Build Stepest avant laCarthage copy-frameworks

Dans certains cas inhabituels (exemple: framework Lottie-iOS):

• vous l'aurez simplement dans "Link Library" comme d'habitude.

• Cependant, vous devez également l'ajouter explicitement dans "Embed Frameworks" (même si cela semble inutile, car cela fonctionne parfaitement lorsque vous ne l'avez que dans "Embed Frameworks"),

• et le mettre dans des cadres de copie

• et assurez-vous que les cadres de copie se trouvent après "Intégrer les cadres"

Supprimez [x86_64, i386] du cadre en utilisant l'étape ci-dessous. [x86_64, i386] est utilisé pour le simulateur.

1. Ouvert Terminal

2. ouvrez le chemin de glisser de votre projet de framework respectif vers Terminal

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

3. définissez votre nom Framework dans la commande ci-dessous et exécutez

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

4. Maintenant, ouvrez à nouveau votre projet, nettoyer, construire et exécuter et créer des archives ...

Je vais ajouter mes 2 cents ici (de manière moins effrayante :-). J'ai rencontré un certain nombre de bibliothèques grasses de fournisseurs qui (pour une raison quelconque) ne fonctionnent pas de la manière habituelle en les ajoutant au Frameworksrépertoire tel que documenté par Apple. La seule façon dont nous avons pu les faire fonctionner est en tirant vers la .framekworkdroite dans le répertoire du projet et en liant le Embedded Frameworkset Link Binary with Librariesmanuellement dans les paramètres de construction. Cela semble avoir fonctionné sans aucun problème, cependant, comme avec n'importe quelle bibliothèque de graisse, ils sont livrés avec les architectures de simulateur étrangères i386 et x86_64avec les armarchitectures.

Un moyen rapide de vérifier les architectures de la bibliothèque de graisses est

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

Qui devrait cracher une sortie quelque chose comme ça

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

Cela confirme que vous aurez besoin de "couper la graisse" (à savoir i386& x86_64) de votre cadre avant le téléchargement iTunesConnect Archival, ce qui ne permet pas ces architectures (car elles ne sont pas prises en charge pour iOS).

Maintenant, toutes les réponses (ou au moins certaines des réponses) ici fournissent ces merveilleux scripts d'exécution qui, j'en suis sûr, fonctionnent très bien, mais seulement si votre Framework réside dans le Frameworksrépertoire. Maintenant, à moins que vous ne soyez un drogué de script shell, ces scripts sans modifications ne fonctionneront pas pour le scénario que j'explique ci-dessus. Cependant, il existe un moyen très simple de se débarrasser des architectures i386& x86_64du framework.

1. Ouvrez le terminal dans le répertoire de votre projet.

2. Changez le répertoire directement dans le .framekwork, comme

   cd YourProjectDir/YourProject/YourLibrary.framework

3. Exécutez la série de commandes comme indiqué ci-dessous -

$ 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

Quelques points à noter ici - lipo -removedoivent être effectués une fois pour chaque architecture à supprimer. lipone modifie pas le fichier d'entrée, il ne produit qu'un fichier, vous devez donc exécuter lipo -removeune fois pour x86_64et i386. Les commandes ci-dessus le font simplement en renommant d'abord l'exécutable, puis en supprimant éventuellement les arches souhaitées, puis en nettoyant les fichiers restants. Et c'est tout, vous devriez maintenant voir une coche verte dans le téléchargement d'archivage Application Loader vers iTunesConnect.

Choses à garder à l'esprit : Les étapes ci-dessus ne doivent être effectuées que pendant la construction de la production, car .frameworkelles seront supprimées des architectures du simulateur, les constructions sur les simulateurs cesseront de fonctionner (ce qui est prévu). Dans un environnement de développement, il ne devrait pas être nécessaire de supprimer les architectures du .frameworkfichier, car vous voulez pouvoir tester à la fois sur le simulateur et sur un périphérique physique. Si votre bibliothèque de matières grasses réside dans le Frameworksdossier du projet, veuillez consulter la réponse acceptée.

J'ai eu le même problème même après avoir ajouté le script et mis à jour le framework plusieurs fois.

Assurez-vous que dans xCode le script est ajouté à la fin, après l'incorporation. Je pense que j'ai accidentellement déplacé le script avant le cadre intégré.

Remarque: j'ai xCode 9.1

Mis à jour pour Xcode 10.1, la solution ci-dessous a fonctionné pour moi:

Il vous suffit de supprimer le cadre des fichiers binaires intégrés et de simplement l'ajouter aux cadres et bibliothèques liés.

Référez-vous à la capture d'écran ci-dessous;

Merci à toutes les réponses ci-dessus. Voici un script fonctionnant avec swift 4.2 et 5 . Remplacez la chaîne Your_Framework_Name par le nom d'origine de votre Framework.

APP_PATH="${TARGET_BUILD_DIR}/${WRAPPER_NAME}"
FRAMEWORK_NAME="Your_Framework_Name.framework"
# Check if Framework is present.
FRAMEWORK_LOCATION=$(find "$APP_PATH" -name "$FRAMEWORK_NAME" -type d)
if [ -z $FRAMEWORK_LOCATION ]; then
echo "Couldn't find Your_Framework_Name.framework in $APP_PATH. Make sure 'Embed Frameworks' build phase is listed before the 'Strip Unused Architectures' build phase."
exit 1
fi
# This script strips unused architectures
find "$APP_PATH" -name "$FRAMEWORK_NAME" -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

Ce problème a été résolu pour moi en modifiant légèrement le script d'exécution à partir de la réponse de pAky88 et en l'exécutant après l'intégration des frameworks. Veillez également à décocher la case "Exécuter le script uniquement lors de l'installation".

/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

J'ai supprimé les architectures i386 et x64_86 des paramètres de construction - Architectures valides - Version, et tout a bien fonctionné.

Maintenant, le seul problème serait que vous ne pouvez pas exécuter une version RELEASE à des fins de test sur un SIMULATEUR . Mais aussi facilement que vous avez supprimé les arches, vous pouvez les rajouter si vous le souhaitez.

la solution simple qui a fonctionné pour moi était

1- supprimer le framework des frameworks embarqués.

2- ajouter le cadre en tant que cadre lié

terminé!

Cette erreur (ITMS-90240) peut également être provoquée par une bibliothèque statique (.a). voici un script pour dépouiller les architectures en excès. Dans Xcode, ajoutez ceci à Target> BuildPhases> Cliquez sur le + et sélectionnez Run Script. Collez-le ensuite dans la boîte de script.

Le script recherche les fichiers .a, vérifie s'il contient une architecture incriminée, puis s'il crée un nouveau fichier .a sans cette architecture.

Pour 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

Pour 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

J'avais le même problème. Même cela ne fonctionnait pas après l'ajout du script d'exécution donné. C'était un problème lié à Xcode. J'utilisais la version 9.0 de Xcode mais la dernière version était 9.2.

J'ai donc installé le dernier Xcode (9.2) et cela a fonctionné.

Votre framework contient à la fois ARMet du x86code, ce qui vous permet de l'utiliser sur un appareil ou dans le simulateur. Si vous avez l'intention de soumettre votre application à l'App Store, exécutez le script suivant pour supprimer le code inactif du binaire.

1.Sélectionnez votre cible dans le Navigateur du projet et cliquez sur Générer des phases en haut de l'éditeur de projet.

2.Dans le menu Éditeur, sélectionnez Ajouter une phase de construction, puis Ajouter une phase de génération de script d'exécution (ou cliquez sur le bouton + dans le coin supérieur gauche de l'éditeur de phases de construction).

3.Agrandir le triangle de divulgation à côté de la nouvelle phase de génération de script d'exécution qui vient d'être ajoutée. Dans la zone de l'éditeur de script, collez ce qui suit: bash

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

Voici un script que j'ai utilisé pour supprimer spécifiquement l'architecture d'un seul framework du fichier exécutable.

# Remove unused Framework architecture from "YourApp" framework.

FRAMEWORK_EXECUTABLE_PATH="${TARGET_BUILD_DIR}/${WRAPPER_NAME}/Frameworks/YourApp.framework/YourApp"

echo "$FRAMEWORK_EXECUTABLE_PATH"

cp "$FRAMEWORK_EXECUTABLE_PATH" "${FRAMEWORK_EXECUTABLE_PATH}_X86_64"

echo "Executing following command to remove x86_64 arch from YourApp framework executable"
echo "lipo -remove x86_64 \"$FRAMEWORK_EXECUTABLE_PATH\" -o \"${FRAMEWORK_EXECUTABLE_PATH}_X86_64\""

lipo -remove x86_64 "${FRAMEWORK_EXECUTABLE_PATH}_X86_64" -o "$FRAMEWORK_EXECUTABLE_PATH"

rm "${FRAMEWORK_EXECUTABLE_PATH}_X86_64"

Ajoutez ce script à vos projets "Build Phases" de votre projet cible. Assurez-vous de cocher la case: "Exécuter le script uniquement lors de l'installation"