Problemi di invio ad App Store: architettura x86 non supportata

Quindi sto cercando di utilizzare l'API di Shopify. Quando archivio l'app e la convalido, non ci sono problemi, ma quando la invio all'app store, mi dà i seguenti problemi.

1. ERRORE ITMS-90087: "Architettura non supportata. L'eseguibile contiene un'architettura non supportata" [x86_64, i386] "."
2. ERRORE ITMS-90209: "Allineamento del segmento non valido. L'app Binary su SJAPP.app/Frameworks/Buy.framework/Buy non ha un allineamento del segmento corretto. Prova a ricostruire l'app con l'ultima versione di Xcode." (Sto già utilizzando l'ultima versione.)
3. ERRORE ITMS-90125: "Il binario non è valido. Le informazioni di crittografia nel comando di caricamento LC_ENCRYPTION_INFO mancano o non sono valide, oppure il binario è già crittografato. Questo binario non sembra essere stato creato con il Linker di Apple."
4. AVVISO ITMS-90080: "Il Payload eseguibile /..../ Buy.framework non è un eseguibile indipendente dalla posizione. Assicurati che le tue impostazioni di build siano configurate per creare eseguibili PIE."

Il problema è che il framework Buy contiene una build sia per il simulatore (x86_64) che per i dispositivi effettivi (ARM).

Ovviamente non è consentito inviare all'App Store un binario per un'architettura non supportata, quindi la soluzione è rimuovere "manualmente" le architetture non necessarie dal binario finale, prima di inviarlo.

Daniel Kennett ha trovato una bella soluzione e fornisce questo script da aggiungere alla fase di costruzione:

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

L'ho usato e ha funzionato perfettamente.

EDIT: assicurati di guardare lo script modificato pubblicato da Varrry, poiché questo presenta alcuni problemi minori.

La risposta data da pAkY88 funziona, ma ho affrontato lo stesso problema di Mario A Guzman in https://stackoverflow.com/a/35240555/5272316 : una volta tagliate le architetture inutilizzate non possiamo più eseguire lo script poiché tenta di rimuovere slice non esistenti, perché xcode non reincorpora il binario ogni volta. L'idea era: rimuovere le sezioni i386 e x86_64 durante la creazione per l'archivio, quindi ho modificato lo 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

Questo script rimuove semplicemente le slice i386 e x86_64 dal fat binary (se esistono) se in esecuzione non per il simulatore (ciò significa che la cartella di destinazione non è come "Debug-iphonesimulator").

Mi dispiace, non ho familiarità con gli script di shell, quindi qualcuno potrebbe scriverlo in modo più elegante. Ma funziona)

Se stai usando Carthage, potresti riscontrare questo problema perché il progetto è:

• Manca la carthage copy-frameworksfase di costruzione.
• Oppure la fase di compilazione non include tutti i framework (elenco incompleto).

Questa azione filtra i framework in un elenco di architetture valide (codice) .

Impostazione della fase di compilazione dei framework di copia

Dall'edificio Carthage per i passaggi iOS :

Nella scheda delle impostazioni "Build Phases" delle destinazioni dell'applicazione, fare clic sull'icona "+" e scegliere "New Run Script Phase". Crea un Esegui script in cui specifichi la tua shell (es: bin / sh), aggiungi i seguenti contenuti all'area dello script sotto la shell:

/usr/local/bin/carthage copy-frameworks

e aggiungi i percorsi ai framework che desideri utilizzare in "File di input", ad esempio:

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

Questo script aggira un bug di invio di App Store attivato da binari universali e garantisce che i file relativi ai bitcode e i dSYM necessari vengano copiati durante l'archiviazione.

Ho risolto l'errore ITMS-90080 rimuovendo un framework (l'eccellente SVProgressHUD) dalla sezione Binari incorporati (destinazione Xcode -> scheda Generale).

Se stai usando, Carthageassicurati che Embed Frameworks Build Stepsia prima del fileCarthage copy-frameworks

In alcuni casi insoliti (esempio: framework Lottie-iOS):

• lo avrai semplicemente in "Link Library" come al solito.

• Tuttavia devi anche aggiungerlo esplicitamente in "Embed Frameworks" (anche se sembra inutile, dato che funziona perfettamente quando lo hai solo in "Embed Frameworks"),

• e metterlo in copy-framework

• e assicurati che il copy-framework sia dopo "Embed Frameworks"

Rimuovere [x86_64, i386] dal framework utilizzando il passaggio seguente. [x86_64, i386] è utilizzato per il simulatore.

1. Aperto Terminal

2. apri il percorso di trascinamento del progetto del rispettivo framework su Terminal

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

3. imposta il nome del tuo Framework nel comando sottostante ed esegui

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

4. Ora apri di nuovo il tuo progetto, pulisci, compila ed esegui e crea archivio ...

Aggiungerò qui i miei 2 centesimi (in un modo meno spaventoso :-). Ho riscontrato un bel numero di librerie pesanti di fornitori che (per qualche motivo) non funzionano normalmente aggiungendole alla Frameworksdirectory come documentato da Apple. L'unico modo in cui siamo stati in grado di farli funzionare è tirando il .framekworkdiritto nella directory del progetto e collegando manualmente Embedded Frameworkse Link Binary with Librariesin Impostazioni build. Questo sembra aver funzionato senza problemi, tuttavia, poiché con qualsiasi libreria grassa vengono fornite con le architetture del simulatore estranee i386 e x86_64insieme alle armarchitetture.

Un modo rapido per controllare le architetture sulla libreria fat è

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

Che dovrebbe produrre un risultato simile a questo

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

Questo conferma che dovrai "tagliare il grasso" (cioè i386& x86_64) dal tuo framework prima del caricamento di iTunesConnect Archival, che non consente queste architetture (poiché non sono supportate per iOS).

Ora, tutte le risposte (o almeno alcune delle risposte) qui forniscono questi meravigliosi script di esecuzione che sono sicuro funzionano molto bene, ma solo se il tuo Framework risiede nella Frameworksdirectory. Ora, a meno che tu non sia un drogato di script di shell, quegli script senza modifiche, non funzioneranno per lo scenario che ho spiegato sopra. Tuttavia, esiste un modo molto semplice per sbarazzarsi delle architetture i386& x86_64dal framework.

1. Apri il terminale nella directory del tuo progetto.

2. Cambia directory direttamente nel file .framekwork, like

   cd YourProjectDir/YourProject/YourLibrary.framework

3. Esegui la serie di comandi come mostrato di seguito-

$ 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

Alcune cose da notare qui: lipo -removedevono essere fatte una volta per ogni architettura da rimuovere. liponon modifica il file di input, produce solo un file quindi devi eseguire lipo -removeuna volta per x86_64e i386. I comandi sopra lo fanno semplicemente rinominando l'eseguibile e poi alla fine rimuovendo gli archi desiderati, quindi ripulendo i file rimasti. E questo è tutto, ora dovresti vedere un segno di spunta verde nel caricamento dell'archivio caricatore applicazioni su iTunesConnect.

Cose da tenere a mente : i passaggi precedenti devono essere eseguiti solo durante la build di produzione, poiché .frameworkverranno rimosse le architetture del simulatore, le build sui simulatori smetteranno di funzionare (cosa prevista). Nell'ambiente di sviluppo, non dovrebbe essere necessario rimuovere le architetture dal .frameworkfile poiché si desidera essere in grado di testare sia sul simulatore che su un dispositivo fisico. Se la tua libreria fat risiede nella Frameworkscartella del progetto, guarda la risposta accettata.

Ho avuto lo stesso problema anche dopo aver aggiunto lo script e aggiornato il framework alcune volte.

Assicurati che in xCode lo script sia aggiunto alla fine, dopo l'incorporamento. Penso di aver spostato accidentalmente lo script prima del framework incorporato.

Nota: ho xCode 9.1

Grazie a tutte le risposte di cui sopra. Ecco uno script che funziona con swift 4.2 e 5 . Sostituisci la stringa Your_Framework_Name con il nome originale del tuo 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

Aggiornato per Xcode 10.1, la soluzione sotto ha funzionato per me:

Devi solo rimuovere il framework dai binari incorporati e aggiungerlo ai framework e alle librerie collegati.

Fare riferimento alla schermata sottostante;

Ho rimosso le architetture i386 e x64_86 da Build Settings - Valid Architectures - Release, e tutto ha funzionato perfettamente.

Ora l'unico problema sarebbe che non puoi eseguire una build RELEASE a scopo di test su un SIMULATORE . Ma con la stessa facilità con cui hai rimosso gli archi, puoi aggiungerli di nuovo se lo desideri.

Questo problema è stato risolto per me modificando leggermente lo script di esecuzione dalla risposta di pAky88 ed eseguendolo dopo aver incorporato i framework. Assicurati anche di deselezionare la casella "Esegui script solo durante l'installazione".

/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

la soluzione semplice che ha funzionato per me è stata

1- rimuovere il framework dai framework incorporati.

2- aggiungi il framework come framework collegato

fatto!

Questo errore (ITMS-90240) può anche essere causato da una libreria statica (.a). ecco un copione per spogliare le architetture in eccesso. In Xcode aggiungilo a Target> BuildPhases> Fai clic su + e seleziona Esegui script. Quindi incollalo nella casella dello script.

Lo script cerca i file .a, controlla se contiene un'architettura offensiva, quindi, se lo fa, crea un nuovo file .a senza quell'architettura.

Per 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

Per 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

Ho avuto lo stesso problema. Anche se non funzionava dopo aver aggiunto il dato Run Script. Era un problema relativo a Xcode. Stavo usando la versione 9.0 di Xcode ma l'ultima era la 9.2.

Quindi ho installato l'ultimo Xcode (9.2) e ha funzionato.

Il tuo quadro contiene sia ARMe x86codice, che consente di utilizzare su un dispositivo o nel simulatore. Se intendi inviare la tua app all'App Store, esegui lo script seguente per rimuovere il codice inattivo dal binario.

1.Seleziona il tuo target nel Navigatore progetto e fai clic su Build Phases nella parte superiore dell'editor del progetto.

2.Dal menu Editor, selezionare Add Build Phase, quindi Add Run Script Build Phase (o fare clic sul pulsante + nell'angolo superiore sinistro dell'editor Build Phases).

3. Espandere il triangolo di apertura accanto alla nuova fase di compilazione Esegui script appena aggiunta. Nella casella dell'editor di script, incolla quanto segue: bash

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

Ecco uno script che ho usato per rimuovere in modo specifico l'architettura di un solo framework dal file eseguibile.

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

Aggiungi questo script ai tuoi progetti "Build Phases" del target del tuo progetto. Assicurati di selezionare la casella: "Esegui script solo durante l'installazione"