Como reduzir o tamanho do meu aplicativo para iPhone?

https://stackoverflow.com/questions/2490910

21-09-2019
|

Pergunta

Títulos alternativos (para auxiliar nas pesquisas)

Compactando PNGs

Reduza o tamanho de um arquivo do iPhone (.ipa)

Adicionando uma regra de construção para compactar imagens no Xcode

Os aplicativos iOS só podem ser baixados via 3G se tiverem menos de 100 MB.Quais as melhores estratégias para reduzir o tamanho de um App?

As áreas nas quais gostaria de me concentrar são:

Imagens
Bancos de dados
Código
Bibliotecas estáticas

Observação: A pergunta original pode ser visualizada nas revisões desta questão

Solução

O PNG é realmente a melhor opção para compactação de imagem sem perdas. Você pode otimizar seus PNGs para o tamanho usando Pngout, mas posso perguntar quais arquivos especificamente estão ocupando muito espaço? Como isso se compara a uma liberação que não é dega-de-debúcia?

EDIT: Se você quiser uma verificação GUIM gratuita do PNGOUT, dê uma olhada Pnggauntlet.

Outras dicas

Adicionando uma regra de compilação do Xcode para compactar PNGs

As imagens em um aplicativo iOS podem representar a maior parte do tamanho.Isso é especialmente verdadeiro se for um aplicativo universal que exige que todas as imagens sejam triplicadas (iPhone Standard, iPhone Retina iPad).

O melhor tipo de imagem para usar em um aplicativo iOS é PNG.Quando seu designer cria essas imagens no Photoshop, elas são salvas com muitos metadados que podem ser descartados.

No entanto, você não quer perder completamente todos esses dados, pois são úteis para designers se eles precisarem alterar a imagem.

Otimização PNGOUT

Existem várias ferramentas para otimizar arquivos PNG, mas pngout parece ser a melhor opção.

Baixe a versão para Mac do pngout.
Copie o aplicativo de linha de comando binário pngout para um diretório em seu projeto. Adicionar o binário ao diretório do projeto garante que ele esteja disponível para qualquer pessoa que esteja construindo o projeto em qualquer sistema.

Criando uma regra de construção (Xcode 4)

As regras de construção são específicas do destino, portanto, se você tiver mais de um destino, deverá copiar a regra em cada um.

Adicione macros DEBUG e DISTRIBUTION às suas configurações de compilação. A otimização dos PNGs é bastante intensa para o processador e, como tal, você só deseja fazê-lo em compilações de distribuição. Como você pode ver, entre outros, adicionei DEBUG_BUILD=1 e DISTRIBUTION_BUILD=1.
Adicione uma regra de compilação para arquivos PNG. Uma regra de construção simplesmente processa um arquivo (e/ou) tipo de arquivo específico durante o processo de construção.O poder disso é que as regras podem ser encadeadas. Regra de compilação - Xcode 4 http://tinypic.com/images/404.gif
Clique no botão “Adicionar Regra”;
- Defina Processo como "Arquivos de origem com nomes correspondentes" e seu valor *.png.
- Definir usando como "Script personalizado"

Cole este código na caixa de script

echo "----------------------------------------------------------------" >> "${DERIVED_FILES_DIR}/pngout-log.txt"
echo "${INPUT_FILE_PATH}" >> "${DERIVED_FILES_DIR}/pngout-log.txt"
echo "${DERIVED_FILES_DIR}/${INPUT_FILE_NAME}" >> "${DERIVED_FILES_DIR}/pngout-log.txt"
echo ${GCC_PREPROCESSOR_DEFINITIONS} >> "${DERIVED_FILES_DIR}/pngout-log.txt"

BUILD=`echo ${GCC_PREPROCESSOR_DEFINITIONS} | grep -o DISTRIBUTION_BUILD`

echo $BUILD >> "${DERIVED_FILES_DIR}/pngout-log.txt"

if [ "${BUILD}" == "DISTRIBUTION_BUILD" ]; then
echo "COMPRESS" >> "${DERIVED_FILES_DIR}/pngout-log.txt"
"${PROJECT_DIR}/build-process/pngout" -y -q -force "${INPUT_FILE_PATH}" "${DERIVED_FILES_DIR}/${INPUT_FILE_NAME}"
else
echo "COPY" >> "${DERIVED_FILES_DIR}/pngout-log.txt"
cp -f "${INPUT_FILE_PATH}" "${DERIVED_FILES_DIR}/${INPUT_FILE_NAME}"
fi

echo "...done." >> "${DERIVED_FILES_DIR}/pngout-log.txt"

Existem diversas variáveis de ambiente que são dignas de nota:

${INPUT_FILE_PATH} — caminho completo para o arquivo de imagem
${INPUT_FILE_NAME} — nome do arquivo de imagem (com extensão)
${DERIVED_FILES_DIR} - onde o Xcode armazena arquivos de construção, etc.
${GCC_PREPROCESSOR_DEFINITIONS} — as macros que você definiu acima

O trabalho é feito nesta linha:

    "${PROJECT_DIR}/build-process/pngout" -y -q -force "${INPUT_FILE_PATH}" "${DERIVED_FILES_DIR}/${INPUT_FILE_NAME}"

${PROJECT_DIR} é o caminho completo para o seu projeto, o -y substitui arquivos existentes, -q limites pngoutsaída e -force impede pngout de sair com status 2 quando um arquivo não pode ser otimizado e causar erros de criação de relatório do Xcode.

Este script simplesmente testa o ${GCC_PREPROCESSOR_DEFINITIONS} para ver se é um DISTRIBUTION_BUILD se assim for, ele usa pngout para otimizar o arquivo, caso contrário ele o copia para o ${DERIVED_FILES_DIR} para que o Xcode possa continuar a processá-lo.

Finalmente, não se esqueça de adicionar ${DERIVED_FILES_DIR}/${INPUT_FILE_NAME} para a lista "Arquivos de saída" é assim que o Xcode sabe como encontrar os arquivos que você processou.

Uma construção de depuração geralmente será muito maior que uma construção de lançamento. Tente construir no modo de liberação.

Existem algumas opções de compilador que também podem ajudar. Não tenho certeza do que o padrão é o modo de liberação do iPhone. -OS otimizará para um binário menor. Há também uma opção para a decapagem de código morto que removerá qualquer código que nunca possa ser executado. Além disso, você pode tentar remover o binário. Não tenho certeza se isso funciona para binários do iPhone.

Isso assume que seu problema se deve ao tamanho binário executável e não aos recursos da imagem.

eu usei ImageOptim e ImageAlpha Para reduzir o tamanho do aplicativo. Dê uma olhada nesse casestudo para obter mais informações. Tweetbot para iPad

@rjstelling tem uma resposta muito boa, e eu não poderia começar a dizer melhor, mas há um pequeno problema com isso. Não funcionará com imagens localizadas. Isso é apenas um problema se você incorporar texto em imagens, algo que eu recomendo nunca fazer se você puder evitá -lo. No entanto, se você precisar usar imagens localizadas, siga todas as etapas da RJstelling, exceto em vez de usar:

if [ "${BUILD}" == "DISTRIBUTION_BUILD" ]; then
echo "COMPRESS" >> "${DERIVED_FILES_DIR}/pngout-log.txt"
"${PROJECT_DIR}/build-process/pngout" -y -q -force "${INPUT_FILE_PATH}" "${DERIVED_FILES_DIR}/${INPUT_FILE_NAME}"
else
echo "COPY" >> "${DERIVED_FILES_DIR}/pngout-log.txt"
cp -f "${INPUT_FILE_PATH}" "${DERIVED_FILES_DIR}/${INPUT_FILE_NAME}"
fi

Use o código abaixo:

if [ "${BUILD}" == "DISTRIBUTION_BUILD" ]; then
echo "COMPRESS" >> "${DERIVED_FILES_DIR}/pngout-log.txt"
"${PROJECT_DIR}/build-process/pngout" -y -q -force "${INPUT_FILE_PATH}" "${DERIVED_FILES_DIR}/${INPUT_FILE_REGION_PATH_COMPONENT}${INPUT_FILE_NAME}"
else
echo "COPY" >> "${DERIVED_FILES_DIR}/pngout-log.txt"
cp -f "${INPUT_FILE_PATH}" "${DERIVED_FILES_DIR}/${INPUT_FILE_REGION_PATH_COMPONENT}${INPUT_FILE_NAME}"
fi

Observe que a única alteração é para o caminho do arquivo de exportação. Você tem que prender INPUT_FILE_REGION_PATH_COMPONENT ao caminho de exportação para obter a localização da imagem para funcionar corretamente. INPUT_FILE_REGION_PATH_COMPONENT está vazio normalmente, a menos que haja pasta localizada para o arquivo específico. Sendo esse o caso, ele fornece o nome da pasta e uma barra à direita, para que você não precise.

Você também deve mudar seu Output Files configuração para ${DERIVED_FILES_DIR}/${INPUT_FILE_REGION_PATH_COMPONENT}${INPUT_FILE_NAME} para que isso funcione.

Não tenho certeza se sou o único que já teve esse problema, mas espero que ajude alguém.

Reduzi um aplicativo iOS de 90 MB para 50 MB nos últimos meses. Aqui estão algumas dicas e ferramentas:

Para perfil do tamanho do aplicativo iOS

descompacte seu IPA para verificar os recursos como arquivos de vídeo, fonte e imagens.
Profile seu arquivo binário por biblioteca e arquivos de objeto (classes) usando o arquivo linkmap e Xcode LinkMap Parser.

Para reduzir os arquivos de imagem

usar ImageOptim-cli Para automaticamente o processo de compactação de imagem
usar Imagem não utilizada Para encontrar arquivos de imagem não utilizados

Para reduzir o arquivo binário

Símbolos de depuração da tira
Encontre importações não utilizadas usando fui

Inspecionando um arquivo .ipa

Basta alterar a extensão de um arquivo .iPA para .zip e abra -o com o Finder para descomprimir. Clique com o botão direito do mouse no pacote .App descompactado e escolha "Mostrar conteúdo do pacote" para ver os recursos dentro. Isso pode lhe dar uma idéia do que está usando mais espaço.

Você pode examinar o tamanho comprimido de cada item em seu .ipa abrindo o terminal e executando o seguinte comando:

unzip -lv /path/to/your/app.ipa

A coluna de tamanho possui o tamanho compactado de cada arquivo dentro do seu arquivo .ipa. Você deve avaliar esse tamanho enquanto trabalha para reduzir o tamanho dos recursos em seu aplicativo. Você pode reduzir muito o tamanho de um recurso, mas depois de produzir um arquivo .iPA, você pode descobrir o tamanho compactado desse recurso não mudou dramaticamente. A técnica mais eficaz para reduzir o tamanho de um arquivo .ipa é remover recursos desnecessários.

Para acessar o artigo completo, consulte o link No site da Apple Developer.

Licenciado em: CC-BY-SA com atribuição

Não afiliado a StackOverflow