An App Store senden Probleme: Nicht unterstützte Architektur x86

Ich versuche also, die Shopify-API zu verwenden. Wenn ich die App archiviere und validiere, gibt es keine Probleme, aber wenn ich sie an den App Store sende, gibt es die folgenden Probleme.

1. FEHLER ITMS-90087: "Nicht unterstützte Architektur. Ihre ausführbare Datei enthält nicht unterstützte Architektur '[x86_64, i386]'."
2. FEHLER ITMS-90209: "Ungültige Segmentausrichtung. Die App-Binärdatei unter SJAPP.app/Frameworks/Buy.framework/Buy weist keine ordnungsgemäße Segmentausrichtung auf. Versuchen Sie, die App mit der neuesten Xcode-Version neu zu erstellen." (Ich verwende bereits die neueste Version.)
3. FEHLER ITMS-90125: "Die Binärdatei ist ungültig. Die Verschlüsselungsinformationen im Ladebefehl LC_ENCRYPTION_INFO fehlen oder sind ungültig, oder die Binärdatei ist bereits verschlüsselt. Diese Binärdatei scheint nicht mit Apples Linker erstellt worden zu sein."
4. WARNUNG ITMS-90080: "Die ausführbare Nutzlast /..../ Buy.framework ist keine positionsunabhängige ausführbare Datei. Stellen Sie sicher, dass Ihre Build-Einstellungen so konfiguriert sind, dass ausführbare PIE-Dateien erstellt werden."

Das Problem ist, dass das Buy-Framework einen Build sowohl für den Simulator (x86_64) als auch für die tatsächlichen Geräte (ARM) enthält.

Natürlich dürfen Sie keine Binärdatei für eine nicht unterstützte Architektur an den App Store senden. Daher besteht die Lösung darin, die nicht benötigten Architekturen "manuell" aus der endgültigen Binärdatei zu entfernen, bevor Sie sie senden.

Daniel Kennett hat eine nette Lösung gefunden und stellt dieses Skript zur Verfügung, um es der Build-Phase hinzuzufügen:

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

Ich habe es benutzt und es hat perfekt funktioniert.

BEARBEITEN: Stellen Sie sicher, dass Sie sich das von Varrry veröffentlichte modifizierte Skript ansehen, da dieses einige kleinere Probleme aufweist.

Die Antwort von pAkY88 funktioniert, aber ich hatte das gleiche Problem wie Mario A Guzman in https://stackoverflow.com/a/35240555/5272316 : Sobald wir nicht verwendete Architekturen abgeschnitten haben, können wir kein Skript mehr ausführen, da es versucht, es zu entfernen Keine vorhandenen Slices, da xcode Binärdateien nicht jedes Mal neu einbettet. Die Idee war - entfernen Sie einfach i386- und x86_64-Slices, wenn Sie für das Archiv erstellen, also habe ich das Skript geändert:

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

Dieses Skript entfernt einfach i386- und x86_64-Slices aus der Fat-Binärdatei (falls vorhanden), wenn sie nicht für den Simulator ausgeführt werden (dh der Zielordner entspricht nicht "Debug-iphonesimulator").

Entschuldigung, ich bin nicht mit Shell-Skripten vertraut, daher könnte jemand sie eleganter schreiben. Aber es funktioniert)

Wenn Sie Karthago verwenden , kann dieses Problem auftreten, da das Projekt wie folgt lautet:

• Fehlende carthage copy-frameworksBuild-Phase.
• Oder die Erstellungsphase enthält nicht alle Frameworks (unvollständige Liste).

Diese Aktion filtert Frameworks nach einer Liste gültiger Architekturen (Code) .

Einrichten der Erstellungsphase für Copy-Frameworks

Aus dem Karthago-Gebäude für iOS Schritte :

Klicken Sie auf der Registerkarte "Build Phases" Ihrer Anwendungsziele auf das Symbol "+" und wählen Sie "New Run Script Phase". Erstellen Sie ein Ausführungsskript, in dem Sie Ihre Shell angeben (z. B. bin / sh), und fügen Sie dem Skriptbereich unter der Shell den folgenden Inhalt hinzu:

/usr/local/bin/carthage copy-frameworks

und fügen Sie die Pfade zu den Frameworks hinzu, die Sie unter "Eingabedateien" verwenden möchten, z.

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

Dieses Skript umgeht einen App Store-Übermittlungsfehler, der durch universelle Binärdateien ausgelöst wird, und stellt sicher, dass die erforderlichen bitcodebezogenen Dateien und dSYMs bei der Archivierung kopiert werden.

Ich habe den Fehler ITMS-90080 behoben, indem ich ein Framework (das ausgezeichnete SVProgressHUD) aus dem Abschnitt "Eingebettete Binärdateien" (Xcode-Ziel -> Registerkarte "Allgemein") entfernt habe.

Wenn Sie verwenden, Carthagestellen Sie sicher, dass Ihr Embed Frameworks Build Stepvor dem istCarthage copy-frameworks

In einigen ungewöhnlichen Fällen (Beispiel: Lottie-iOS-Framework):

• Sie haben es einfach wie gewohnt in "Link Library".

• Allerdings müssen Sie auch explizit hinzufügen in „Embed Frameworks“ (obwohl das scheint sinnlos, da es perfekt funktioniert , wenn Sie es nur in „Embed Frameworks“ haben),

• und setzen Sie es in Copy-Frameworks

• und stellen Sie sicher, dass Copy-Frameworks nach "Embed Frameworks" steht.

Entfernen Sie [x86_64, i386] mithilfe des folgenden Schritts aus dem Framework. [x86_64, i386] wird für den Simulator verwendet.

1. Öffnen Terminal

2. Öffnen Sie Ihren Projekt-Drag-Pfad des jeweiligen Frameworks zum Terminal

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

3. Legen Sie Ihren Framework-Namen im folgenden Befehl fest und führen Sie ihn aus

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

4. Öffnen Sie nun Ihr Projekt erneut, Bereinigen, Erstellen und Ausführen und Archiv erstellen ...

Ich werde hier meine 2 Cent hinzufügen (auf eine weniger beängstigende Weise :-). Ich habe eine ganze Reihe von Fat Libraries von Anbietern gefunden, die (aus irgendeinem Grund) nicht normal funktionieren, indem sie dem Frameworksvon Apple dokumentierten Verzeichnis hinzugefügt werden . Die einzige Möglichkeit, sie zum Laufen zu bringen, besteht darin, .framekworkrechts in das Projektverzeichnis zu ziehen und das Embedded Frameworksund Link Binary with Librariesmanuell in den Build-Einstellungen zu verknüpfen . Dies scheint jedoch ohne Probleme funktioniert zu haben, da sie bei jeder Fat Library mit den externen Simulator-Architekturen i386 und x86_64zusammen mit den armArchitekturen geliefert werden.

Eine schnelle Möglichkeit, die Architekturen in der Fettbibliothek zu überprüfen, ist

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

Welches sollte eine Ausgabe so etwas spucken

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

Dies bestätigt, dass Sie vor dem Hochladen von iTunesConnect Archival das Fett (nämlich i386& x86_64) aus Ihrem Framework "entfernen" müssen, wodurch diese Architekturen nicht zulässig sind (da sie für iOS nicht unterstützt werden).

Jetzt bieten alle Antworten (oder zumindest einige der Antworten) hier diese wunderbaren Ausführungsskripte, von denen ich sicher bin, dass sie wirklich gut funktionieren, aber nur, wenn sich Ihr Framework im FrameworksVerzeichnis befindet. Wenn Sie kein Shell-Skript-Junkie sind, funktionieren diese Skripte ohne Änderungen nicht für das oben erläuterte Szenario. Es gibt jedoch eine sehr einfache Möglichkeit, die i386& x86_64Architekturen aus dem Framework zu entfernen.

1. Öffnen Sie das Terminal im Verzeichnis Ihres Projekts.

2. Wechseln Sie direkt in das .framekwork, wie

   cd YourProjectDir/YourProject/YourLibrary.framework

3. Führen Sie die Befehlsreihe wie unten gezeigt aus.

$ 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

Ein paar Dinge, die hier zu beachten sind - lipo -removemüssen einmal ausgeführt werden, damit jede Architektur entfernt wird. lipoÄndert die Eingabedatei nicht, es wird nur eine Datei erstellt, sodass Sie sie lipo -removeeinmal für x86_64und ausführen müssen i386. Die obigen Befehle tun dies einfach, indem Sie zuerst die ausführbare Datei umbenennen und schließlich die gewünschten Bögen entfernen und dann die verbleibenden Dateien bereinigen. Und das war's, jetzt sollte beim Hochladen der Application Loader-Archivierung auf iTunesConnect ein grünes Häkchen angezeigt werden.

Zu beachtende Dinge : Die oben genannten Schritte sollten nur während des Produktionsaufbaus ausgeführt werden, da .frameworkdie Simulatorarchitekturen entfernt werden und Builds auf Simulatoren nicht mehr funktionieren (was erwartet wird). In einer Entwicklungsumgebung sollte es nicht erforderlich sein, die Architekturen aus der .frameworkDatei zu entfernen, da Sie sowohl auf dem Simulator als auch auf einem physischen Gerät testen möchten. Wenn sich Ihre Fettbibliothek im FrameworksOrdner des Projekts befindet, sehen Sie sich bitte die akzeptierte Antwort an.

Ich hatte das gleiche Problem, selbst nachdem ich das Skript hinzugefügt und das Framework einige Male aktualisiert hatte.

Stellen Sie sicher, dass in xCode das Skript am Ende nach der Einbettung hinzugefügt wird. Ich glaube, ich habe das Skript versehentlich vor das eingebettete Framework verschoben.

Hinweis: Ich habe xCode 9.1

Aktualisiert für Xcode 10.1. Die folgende Lösung hat bei mir funktioniert:

Sie müssen nur das Framework aus den eingebetteten Binärdateien entfernen und es einfach zu den verknüpften Frameworks und Bibliotheken hinzufügen.

Siehe folgenden Screenshot;

Vielen Dank an alle oben genannten Antworten. Hier ist ein Skript, das mit Swift 4.2 und 5 arbeitet . Ersetzen Sie die Zeichenfolge Your_Framework_Name durch den ursprünglichen Namen Ihres Frameworks.

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

Dieses Problem wurde für mich behoben, indem das Ausführungsskript aus der Antwort von pAky88 geringfügig geändert und nach dem Einbetten von Frameworks ausgeführt wurde. Deaktivieren Sie außerdem das Kontrollkästchen "Skript nur bei Installation ausführen".

/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

Ich habe die Architekturen i386 und x64_86 aus den Build-Einstellungen - Gültige Architekturen - Release entfernt, und alles hat einwandfrei funktioniert.

Das einzige Problem wäre nun, dass Sie einen RELEASE- Build nicht zu Testzwecken auf einem SIMULATOR ausführen können . Aber so einfach Sie die Bögen entfernt haben, können Sie sie wieder hinzufügen, wenn Sie möchten.

Die einfache Lösung, die für mich funktioniert hat, war

1- Entfernen Sie das Framework aus eingebetteten Frameworks.

2- Fügen Sie das Framework als verknüpftes Framework hinzu

getan!

Dieser Fehler (ITMS-90240) kann auch durch eine statische (.a) Bibliothek verursacht werden. Hier ist ein Skript, um die überschüssigen Architekturen zu entfernen. Fügen Sie dies in Xcode zu Ziel> BuildPhases> Klicken Sie auf das + und wählen Sie Skript ausführen. Fügen Sie dies dann in das Skriptfeld ein.

Das Skript sucht nach .a-Dateien, prüft, ob es eine fehlerhafte Architektur enthält, und erstellt dann eine neue .a-Datei ohne diese Architektur.

Für 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

Für 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

Ich hatte das gleiche Problem. Auch nach dem Hinzufügen des angegebenen Run-Skripts funktionierte es nicht. Es war ein Xcode-Problem. Ich habe die Xcode-Version 9.0 verwendet, aber die neueste Version war 9.2.

Also habe ich den neuesten Xcode (9.2) installiert und es hat funktioniert.

Ihr Framework enthält sowohl Code ARMals auch x86Code, mit dem Sie ihn auf einem Gerät oder im Simulator verwenden können. Wenn Sie Ihre App an den App Store senden möchten, führen Sie das folgende Skript aus, um den inaktiven Code aus der Binärdatei zu entfernen.

1.Wählen Sie Ihr Ziel im Projektnavigator aus und klicken Sie oben im Projekteditor auf Phasen erstellen.

2.Wählen Sie im Menü Editor die Option Build-Phase hinzufügen und dann Run-Skript-Build-Phase hinzufügen (oder klicken Sie auf die Schaltfläche + in der oberen linken Ecke des Editors für Build-Phasen).

3. Erweitern Sie das Offenlegungsdreieck neben der neuen Build-Erstellungsphase, die gerade hinzugefügt wurde. Fügen Sie im Skripteditorfeld Folgendes ein: bash

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

Hier ist ein Skript, mit dem ich speziell nur die Architektur eines Frameworks aus der ausführbaren Datei entfernt habe.

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

Fügen Sie dieses Skript zu Ihren Projekten "Build Phases" Ihres Projektziels hinzu. Aktivieren Sie unbedingt das Kontrollkästchen: "Skript nur bei der Installation ausführen"