Problemas de envio para a App Store: arquitetura não suportada x86

Então, eu estou tentando usar a API do Shopify. Quando arquivo o aplicativo e o valido, não há problemas, mas quando o envio à loja de aplicativos, ele apresenta os seguintes problemas.

1. ERRO ITMS-90087: "Arquitetura não suportada. Seu executável contém arquitetura não suportada '[x86_64, i386]'."
2. ERRO ITMS-90209: "Alinhamento de segmento inválido. O binário do aplicativo em SJAPP.app/Frameworks/Buy.framework/Buy não possui alinhamento de segmento adequado. Tente reconstruir o aplicativo com a versão mais recente do Xcode." (Eu já estou usando a versão mais recente.)
3. ERRO ITMS-90125: "O binário é inválido. As informações de criptografia no comando de carregamento LC_ENCRYPTION_INFO estão ausentes ou são inválidas ou o binário já está criptografado. Este binário não parece ter sido construído com o Linker da Apple."
4. AVISO ITMS-90080: "A Carga útil executável /..../ Buy.framework não é um executável independente da posição. Verifique se as configurações de criação estão definidas para criar executáveis ​​PIE."

O problema é que a estrutura Buy contém uma compilação para o simulador (x86_64) e os dispositivos reais (ARM).

Obviamente, você não tem permissão para enviar à App Store um binário para uma arquitetura não suportada; portanto, a solução é "manualmente" remover as arquiteturas desnecessárias do binário final antes de enviá-lo.

Daniel Kennett apresentou uma boa solução e fornece este script para adicionar à fase de construção:

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

Eu usei e funcionou perfeitamente.

EDIT: verifique o script modificado publicado por Varrry, pois esse possui alguns problemas menores.

Resposta dada por pAkY88 funciona, mas eu enfrentei o mesmo problema que Mario A Guzman em https://stackoverflow.com/a/35240555/5272316 : uma vez que cortamos arquiteturas não utilizadas, não podemos mais executar scripts, pois ele tenta remover fatias não existentes, porque o xcode não reimplementa o binário todas as vezes. A idéia era - basta remover as fatias i386 e x86_64 ao criar para arquivamento, então modifiquei o 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

Esse script simplesmente remove as fatias i386 e x86_64 do binário gordo (se elas existirem) se não estiver sendo executado no simulador (isso significa que a pasta de destino não é como "Debug-iphonesimulator").

Desculpe, eu não estou familiarizado com scripts de shell, então pode ser que alguém possa escrever de maneira mais elegante. Mas funciona)

Se você estiver usando Cartago , poderá enfrentar esse problema porque o projeto é:

• Faltando a carthage copy-frameworksfase de construção.
• Ou a fase de construção não inclui todas as estruturas (lista incompleta).

Esta ação filtra estruturas para uma lista de arquiteturas válidas (código) .

Configurando a Fase de Construção de Cópias-Estruturas

No edifício Carthage para etapas do iOS :

Na guia de configurações "Criar fases" do seu aplicativo, clique no ícone "+" e escolha "Nova fase de script de execução". Crie um script de execução no qual você especifique seu shell (ex: bin / sh), adicione o seguinte conteúdo à área de script abaixo do shell:

/usr/local/bin/carthage copy-frameworks

e adicione os caminhos às estruturas que você deseja usar em "Arquivos de entrada", por exemplo:

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

Esse script soluciona um bug de envio da App Store acionado por binários universais e garante que os arquivos e dSYMs relacionados ao código de bit necessários sejam copiados durante o arquivamento.

Resolvi o erro ITMS-90080 removendo uma estrutura (o excelente SVProgressHUD) da seção Binários incorporados (destino do Xcode -> guia Geral).

Se você estiver usando, Carthageverifique se Embed Frameworks Build Stepestá antes doCarthage copy-frameworks

Em alguns casos incomuns (exemplo: estrutura Lottie-iOS):

• você o encontrará simplesmente em "Link Library", como de costume.

• No entanto, você também deve adicioná-lo explicitamente no "Embed Frameworks" (mesmo que isso pareça inútil, pois funciona perfeitamente quando você o possui apenas no "Embed Frameworks"),

• e colocá-lo em frameworks de cópia

• e garantir que as cópias-estruturas estejam após "Incorporar estruturas"

Remova [x86_64, i386] da estrutura usando a etapa abaixo. [x86_64, i386] é usado para o simulador.

1. Abrir Terminal

2. abra o caminho de arrasto do projeto da respectiva estrutura para o Terminal

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

3. defina seu nome do Framework no comando abaixo e execute

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

4. Agora abra seu projeto novamente, Limpar, Compilar e Executar e Criar Arquivo ...

Vou adicionar meus 2 centavos aqui (de uma maneira menos assustadora :-). Encontrei várias bibliotecas gordas de fornecedores que (por algum motivo) não funcionam da maneira normal adicionando-as ao Frameworksdiretório conforme documentado pela Apple. A única maneira que temos sido capazes de fazê-los trabalho é puxando a .framekworkdireita para o diretório do projeto e que liga a Embedded Frameworkse Link Binary with Librariesmanualmente em configurações de compilação. Isso parece ter funcionado sem problemas, no entanto, como em qualquer biblioteca gorda, eles vêm com as Simulator Architectures estranhas i386 e x86_64com as armarquiteturas.

Uma maneira rápida de verificar as arquiteturas na biblioteca de gorduras é

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

Que deve cuspir uma saída algo como isto

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

Isso confirma que você precisará "aparar a gordura" (ou seja, i386& x86_64) da sua estrutura antes do upload do iTunesConnect Archival, o que não permite essas arquiteturas (pois não são compatíveis com o iOS).

Agora, todas as respostas (ou pelo menos algumas das respostas) aqui fornecem esses maravilhosos Scripts de Execução que, com certeza, funcionam muito bem, mas apenas se o seu Framework residir no Frameworksdiretório Agora, a menos que você seja um viciado em scripts de shell, esses scripts sem modificações não funcionarão para o cenário que explico acima. No entanto, existe uma maneira muito simples de se livrar das arquiteturas i386e x86_64do framework.

1. Abra o terminal no diretório do seu projeto.

2. Mude o diretório diretamente para .framekwork, como

   cd YourProjectDir/YourProject/YourLibrary.framework

3. Execute a série de comandos conforme mostrado abaixo:

$ 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

Algumas coisas a serem observadas aqui - lipo -removeprecisam ser feitas uma vez para cada arquitetura remover. liponão modifica o arquivo de entrada, apenas produz um arquivo, portanto, é necessário executar lipo -removeuma vez para x86_64e i386. Os comandos acima estão simplesmente fazendo isso renomeando o executável e, em seguida, removendo os arcos desejados e, em seguida, limpando os arquivos restantes. E é isso, agora você deve ver uma marca de seleção verde no upload do Application Loader Archival para o iTunesConnect.

Pontos a serem lembrados : As etapas acima devem ser feitas apenas durante a construção da produção, uma vez .frameworkque serão retiradas as arquiteturas do simulador, as construções nos simuladores deixarão de funcionar (o que é esperado). No ambiente de desenvolvimento, não há necessidade de retirar as arquiteturas do .frameworkarquivo, pois você deseja testar no Simulador e em um dispositivo físico. Se sua biblioteca de gorduras reside na Frameworkspasta do projeto, observe a resposta aceita.

Eu tive o mesmo problema, mesmo depois de adicionar o script e atualizar a estrutura algumas vezes.

Certifique-se de que no xCode o script seja adicionado no final, após a incorporação. Eu acho que mudei acidentalmente o script antes da estrutura incorporada.

Nota: Eu tenho o xCode 9.1

Atualizado para o Xcode 10.1, a solução abaixo funcionou para mim:

É necessário remover a estrutura dos binários incorporados e adicioná-la às estruturas e bibliotecas vinculadas.

Consulte a captura de tela abaixo;

Obrigado a todas as respostas acima. Aqui está um script que trabalha com o swift 4.2 e 5 . Substitua a sequência Your_Framework_Name pelo nome original do seu 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

Esse problema foi resolvido para mim modificando levemente o script de execução da resposta do pAky88 e executando após a incorporação de estruturas. Certifique-se também de desmarcar a caixa "Executar script somente ao 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

Eu removi as arquiteturas i386 e x64_86 das Configurações de compilação - Arquiteturas válidas - Versão, e tudo funcionou bem.

Agora, o único problema seria que você não pode executar uma versão RELEASE para fins de teste em um SIMULATOR . Mas tão facilmente quanto você removeu os arcos, você pode adicioná-los novamente, se quiser.

a solução simples que funcionou para mim foi

1- remova a estrutura das estruturas incorporadas.

2- adicione a estrutura como uma estrutura vinculada

feito!

Este erro (ITMS-90240) também pode ser causado por uma biblioteca estática (.a). Aqui está um script para remover as arquiteturas em excesso. No Xcode, adicione-o ao Target> BuildPhases> Clique no + e selecione Run Script. Em seguida, cole isso na caixa de script.

O script procura por arquivos .a, verifica se contém uma arquitetura incorreta e, em seguida, cria um novo arquivo .a sem essa arquitetura.

Para o 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

Eu tive o mesmo problema. Mesmo ele não estava funcionando depois de adicionar o Run Script fornecido. Foi um problema relacionado ao Xcode. Eu estava usando o Xcode versão 9.0, mas a versão mais recente era 9.2.

Então eu instalei o mais recente Xcode (9.2) e funcionou.

Sua estrutura contém código ARMe tanto x86, que permite usá-lo em um dispositivo ou no simulador. Se você pretende enviar seu aplicativo para a App Store, execute o seguinte script para retirar o código inativo do binário.

1. Selecione o seu destino no Project Navigator e clique em Build Fhases na parte superior do editor do projeto.

2. No menu Editor, selecione Adicionar Fase de Construção e, em seguida, Adicionar Fase de Construção de Script de Execução (ou clique no botão + no canto superior esquerdo do editor de Fases de Construção).

3.Expanda o triângulo de divulgação ao lado da nova fase de criação do Script de Execução que acabou de ser adicionada. Na caixa do editor de scripts, cole o seguinte: bash

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

Aqui está um script que eu usei para remover especificamente apenas a arquitetura de uma estrutura do arquivo executável.

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

Adicione este script aos seus projetos "Fases de construção" do seu destino do projeto. Certifique-se de marcar a caixa: "Executar script apenas ao instalar"