Prześlij do App Store: nieobsługiwana architektura x86

Próbuję więc użyć interfejsu API Shopify. Gdy zarchiwizuję aplikację i zweryfikuję ją, nie będzie żadnych problemów, ale kiedy prześlę ją do sklepu z aplikacjami, otrzymam następujące problemy.

1. BŁĄD ITMS-90087: „Nieobsługiwana architektura. Plik wykonywalny zawiera nieobsługiwaną architekturę„ [x86_64, i386] ”.”
2. BŁĄD ITMS-90209: „Nieprawidłowe wyrównanie segmentów. Aplikacja Binary w SJAPP.app/Frameworks/Buy.framework/Buy nie ma odpowiedniego wyrównania segmentów. Spróbuj odbudować aplikację z najnowszą wersją Xcode.” (Korzystam już z najnowszej wersji).
3. BŁĄD ITMS-90125: „Plik binarny jest nieprawidłowy. Brakuje informacji o szyfrowaniu w poleceniu ładowania LC_ENCRYPTION_INFO lub jest on nieprawidłowy lub plik binarny jest już zaszyfrowany. Wygląda na to, że ten plik binarny nie został utworzony za pomocą narzędzia Apple Linker.”
4. OSTRZEŻENIE ITMS-90080: „Ładunek wykonywalny /..../ Buy.framework nie jest plikiem wykonywalnym niezależnym od pozycji. Upewnij się, że ustawienia kompilacji ur są skonfigurowane do tworzenia plików wykonywalnych PIE”.

Problem polega na tym, że struktura Buy zawiera kompilację zarówno dla symulatora (x86_64), jak i rzeczywistych urządzeń (ARM).

Oczywiście nie można przesyłać do App Store pliku binarnego dla nieobsługiwanej architektury, więc rozwiązaniem jest „ręczne” usunięcie niepotrzebnych architektur z ostatecznego pliku binarnego przed przesłaniem go.

Daniel Kennett wymyślił fajne rozwiązanie i udostępnia ten skrypt, aby dodać go do fazy kompilacji:

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

Użyłem go i działało idealnie.

EDYCJA: upewnij się, że spojrzałeś na zmodyfikowany skrypt opublikowany przez Varrry, ponieważ ten ma kilka drobnych problemów.

Odpowiedź udzielona przez pAkY88 działa, ale napotkałem ten sam problem, co Mario A Guzman w https://stackoverflow.com/a/35240555/5272316 : po odcięciu nieużywanej architektury nie możemy już uruchomić skryptu, ponieważ próbuje on usunąć nieistniejące wycinki, ponieważ xcode nie za każdym razem ponownie osadza pliki binarne. Pomysł był taki: po prostu usuń plasterki i386 i x86_64 podczas budowania archiwum, więc zmodyfikowałem skrypt:

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

Ten skrypt po prostu usuwa plastry i386 i x86_64 z grubego pliku binarnego (jeśli istnieją), jeśli nie są uruchomione dla symulatora (co oznacza, że ​​folder docelowy nie jest podobny do „Debug-iphonesimulator”).

Niestety, nie znam skryptów powłoki, więc być może ktoś mógłby napisać to w bardziej elegancki sposób. Ale to działa)

Jeśli używasz Kartaginy , możesz napotkać ten problem, ponieważ projekt to:

• Brak carthage copy-frameworksfazy kompilacji.
• Lub faza kompilacji nie obejmuje wszystkich ram (niekompletna lista).

Ta akcja filtruje ramy do listy poprawnych architektur (kodu) .

Konfigurowanie fazy kompilacji struktur kopiowania

Z budynku Kartaginy na iOS :

Na karcie ustawień „Fazy kompilacji” celu aplikacji kliknij ikonę „+” i wybierz opcję „Nowa faza skryptu uruchamiania”. Utwórz skrypt uruchamiający, w którym określisz swoją powłokę (np. Bin / sh), dodaj następującą zawartość do obszaru skryptu pod powłoką:

/usr/local/bin/carthage copy-frameworks

i dodaj ścieżki do ram, których chcesz użyć w „Plikach wejściowych”, np .:

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

Ten skrypt działa wokół błędu przesyłania App Store wywołanego przez uniwersalne pliki binarne i zapewnia, że ​​niezbędne pliki związane z kodem bitowym i dSYM są kopiowane podczas archiwizacji.

Rozwiązałem błąd ITMS-90080, usuwając platformę (doskonałe SVProgressHUD) z sekcji Osadzone pliki binarne (cel Xcode -> karta Ogólne).

Jeśli używasz, Carthageupewnij się, że Embed Frameworks Build Stepjest przedCarthage copy-frameworks

W niektórych nietypowych przypadkach (przykład: framework Lottie-iOS):

• będziesz go mieć jak zwykle w „Link Library”.

• Jednak trzeba też wyraźnie dodać go w „Wstaw Ram” (mimo, że wydaje się bezcelowe, ponieważ działa idealnie, gdy masz go tylko w „Embed Ram”)

• i umieść to w ramach kopiowania

• i upewnij się, że kopiowanie ram jest po „Embed Frameworks”

Usuń [x86_64, i386] ze struktury, wykonując poniższy krok. [x86_64, i386] jest używany w symulatorze.

1. otwarty Terminal

2. otwórz ścieżkę przeciągania projektu odpowiedniej struktury do terminala

   przykład: cd /Users/MAC/Desktop/MyProject/Alamofire.framework

3. ustaw nazwę frameworku w poniższym poleceniu i uruchom

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

4. Teraz ponownie otwórz projekt, wyczyść, zbuduj i uruchom oraz utwórz archiwum ...

Dodam tutaj moje 2 centy (w mniej przerażający sposób :-). Zetknąłem się z wieloma grubymi bibliotekami od dostawców, które (z jakiegoś powodu) nie działają normalnie, dodając je do Frameworkskatalogu udokumentowanego przez Apple. Jedynym sposobem, w jaki udało nam się sprawić, by działały, jest przeciągnięcie w .framekworkprawo do katalogu projektu i połączenie Embedded Frameworksi Link Binary with Librariesręcznie w Ustawieniach kompilacji. Wydaje się, że działało to bez żadnych problemów, ponieważ w każdej grubej bibliotece są one dostarczane z zewnętrznymi architekturami symulatorów i386 i x86_64wraz z armarchitekturami.

Szybkim sposobem na sprawdzenie architektury biblioteki tłuszczu jest

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

Co powinno wypluć dane wyjściowe coś takiego

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

Potwierdza to, że będziesz musiał „przyciąć gruby” (a mianowicie i386& x86_64) ze swojego środowiska przed przesłaniem archiwum iTunesConnect, co nie pozwala na te architektury (ponieważ nie są obsługiwane dla iOS).

Teraz wszystkie odpowiedzi (lub przynajmniej niektóre z tych odpowiedzi) dostarczają tych wspaniałych skryptów Run, które na pewno działają naprawdę dobrze, ale tylko wtedy, gdy Twój Framework znajduje się w Frameworkskatalogu. Teraz, chyba że jesteś ćpunem w skryptach powłoki, te skrypty bez modyfikacji nie będą działać w scenariuszu, który wyjaśnię powyżej. Istnieje jednak bardzo prosty sposób na pozbycie się architektury i386i x86_64architektur z frameworka.

1. Otwórz terminal w katalogu swojego projektu.

2. Zmień katalog bezpośrednio w .framekwork, jak

   cd YourProjectDir/YourProject/YourLibrary.framework

3. Uruchom serię poleceń, jak pokazano poniżej-

$ 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

Należy zwrócić uwagę na kilka rzeczy - lipo -removenależy to zrobić raz dla każdej architektury do usunięcia. liponie modyfikuje pliku wejściowego, tworzy tylko plik, więc musisz lipo -removeraz uruchomić dla x86_64i i386. Powyższe polecenia po prostu robią to, najpierw zmieniając nazwę pliku wykonywalnego, a następnie usuwając pożądane archiwa, a następnie usuwając pozostałe pliki. I to jest to, powinieneś teraz zobaczyć zielony znacznik wyboru w przesyłaniu archiwum modułu ładującego aplikacje do iTunesConnect.

Należy pamiętać : powyższe kroki należy wykonać tylko podczas kompilacji produkcyjnej, ponieważ .frameworkzostaną one usunięte z architektur symulatora, kompilacje na symulatorach przestaną działać (co jest oczekiwane). W środowisku programistycznym nie powinno być potrzeby usuwania architektur z .frameworkpliku, ponieważ chcesz mieć możliwość testowania zarówno na Symulatorze, jak i na urządzeniu fizycznym. Jeśli Twoja gruba biblioteka znajduje się w Frameworksfolderze w projekcie, spójrz na zaakceptowaną odpowiedź.

Miałem ten sam problem, nawet po kilkakrotnym dodaniu skryptu i aktualizacji frameworka.

Upewnij się, że w xCode skrypt jest dodawany na końcu, po osadzeniu. Myślę, że przypadkowo przesunąłem skrypt przed osadzoną platformą.

Uwaga: Mam xCode 9.1

Zaktualizowany dla Xcode 10.1. Poniższe rozwiązanie działało dla mnie:

Musisz tylko usunąć framework z osadzonych plików binarnych i po prostu dodać go do Linked Frameworks and Libraries.

Zobacz zrzut ekranu poniżej;

Dzięki wszystkim powyższym odpowiedziom. Oto skrypt działający z szybkimi wersjami 4.2 i 5 . Zastąp ciąg Your_Framework_Name oryginalną nazwą twojego 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

Ten problem został dla mnie rozwiązany poprzez nieznaczną modyfikację skryptu uruchamiania z odpowiedzi pAky88 i wykonanie po osadzeniu frameworków. Należy również odznaczyć pole „Uruchom skrypt tylko podczas instalacji”.

/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

Usunąłem architektury i386 i x64_86 z Ustawień kompilacji - Prawidłowe architektury - wydanie i wszystko działało dobrze.

Teraz jedynym problemem byłoby to, że nie można uruchomić kompilacji RELEASE do celów testowych na symulatorze . Ale tak łatwo, jak usunąłeś archiwa, możesz je dodać z powrotem, jeśli chcesz.

proste rozwiązanie, które dla mnie zadziałało, to

1- usuń ramę z osadzonych ram.

2- dodać ramę jako ramę połączoną

Gotowe!

Ten błąd (ITMS-90240) może być również spowodowany przez bibliotekę statyczną (.a). Oto skrypt usuwający nadmiar architektury. W Xcode dodaj to do Target> BuildPhases> Kliknij + i wybierz Uruchom skrypt. Następnie wklej to w pole skryptu.

Skrypt wyszukuje pliki .a, sprawdza, czy zawiera szkodliwą architekturę, a następnie tworzy nowy plik .a bez tej architektury.

W systemie 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

Na 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

Miałem ten sam problem. Nawet to nie działało po dodaniu danego skryptu uruchamiania. To był problem związany z Xcode. Korzystałem z Xcode w wersji 9.0, ale najnowsza wersja to 9.2.

Więc zainstalowałem najnowszy Xcode (9.2) i zadziałało.

Twój framework zawiera zarówno kod, jak ARMi x86kod, co pozwala używać go na urządzeniu lub w symulatorze. Jeśli zamierzasz przesłać aplikację do App Store, uruchom następujący skrypt, aby usunąć nieaktywny kod z pliku binarnego.

1. Wybierz cel w Nawigatorze projektu i kliknij Fazy budowania u góry edytora projektu.

2. Z menu Edytor wybierz polecenie Dodaj fazę kompilacji, a następnie Dodaj fazę kompilacji skryptu uruchamiania (lub kliknij przycisk + w lewym górnym rogu edytora faz budowania).

3.Rozwiń trójkąt ujawnienia obok nowej fazy kompilacji Run Script, która właśnie została dodana. W polu edytora skryptów wklej następujące: bash

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

Oto skrypt, którego użyłem do specyficznego usunięcia tylko jednej architektury frameworka z pliku wykonywalnego.

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

Dodaj ten skrypt do swoich projektów „Fazy kompilacji” celu projektu. Pamiętaj, aby zaznaczyć pole: „Uruchom skrypt tylko podczas instalacji”