Cómo reducir el tamaño de mi aplicación para iPhone?

Agregar una regla de compilación Xcode para comprimir PNGs

Las imágenes en una aplicación iOS pueden constituir la mayor parte del tamaño. Esto es especialmente cierto si se trata de una aplicación Universal que requiere tener toda la imagen en triplicado (iPhone Estándar, iPhone Retina iPad).

El mejor tipo de imagen para usar en una aplicación iOS es un PNG. Cuando su diseñador creó estas imágenes en Photoshop, se guardan con una gran cantidad de metadatos que se pueden descartar.

Sin embargo, no quieres perder todos esos datos completamente, ya que es útil para los diseñadores si necesitan alterar la imagen.

Optimización PNGOUT

Existen varias herramientas para optimizar archivos PNG, pero pngout parece ser la mejor opción.

1. Descargue la versión para Mac de pngout.
2. Copie la aplicación binaria de línea de comandos pngout a un directorio con en su proyecto. Al agregar el binario al directorio del proyecto se asegura de que esté disponible para cualquiera que construya el proyecto en cualquier sistema.

Creando una regla de compilación (Xcode 4)

Las reglas de compilación son específicas del destino, por lo que si tiene más de un destino debe copiar la regla en cada uno.

1. Agregue macros de DEPURACIÓN y DISTRIBUCIÓN a sus configuraciones de compilación. Optimizar los PNGs es bastante intenso en el procesador y, como tal, solo desea hacerlo en compilaciones de distribución. Macros de preprocesador http://i52.tinypic.com/jtteg4.png Como se puede ver entre otros yo han añadido DEBUG_BUILD=1 y DISTRIBUTION_BUILD=1.

2. Agregue una regla de compilación para archivos PNG. Una regla de compilación simplemente procesa un tipo de archivo (y/o) específico durante el proceso de compilación. El poder de esto es que las reglas se pueden encadenar. Regla de compilación-Xcode 4 http://i56.tinypic.com/ioovut.png

3. Haga clic en el botón "Agregar regla";

   • Establezca Process en "Archivos fuente con nombres coincidentes" y su valor *.png.
   • Establecer usando " Personalizado Script "

Pegue este código en el cuadro 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"

Hay varias variables de entorno que son de destacar:

• ${INPUT_FILE_PATH} - ruta completa al archivo de imagen
• ${INPUT_FILE_NAME} - nombre del archivo de imagen (con extensión)
• ${DERIVED_FILES_DIR} - donde Xcode almacena archivos de compilación, etc
• ${GCC_PREPROCESSOR_DEFINITIONS} - las macros que configuraste arriba

El trabajo se hace en esta línea:

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

${PROJECT_DIR} es el camino completo a su proyecto, el -y sobrescribe archivos existentes, -q limita la salida de pngouty -force evita que pngout salga con el estado de 2 cuando un archivo no se puede optimizar y causa errores de compilación de informes Xcode.

Este script simplemente prueba el ${GCC_PREPROCESSOR_DEFINITIONS} para ver si es un DISTRIBUTION_BUILD si es así utiliza pngout para optimizar el archivo, de lo contrario lo copia al ${DERIVED_FILES_DIR} para que Xcode pueda continuar procesándolo.

Finalmente , no olvide agregar ${DERIVED_FILES_DIR}/${INPUT_FILE_NAME} a la lista de" Archivos de salida " así es como Xcode sabe cómo encontrar el archivos que ha procesado.

Una compilación de depuración generalmente será mucho más grande que una compilación de lanzamiento. Intenta construir en modo release.

Hay algunas opciones de compilador que también pueden ayudar. Sin embargo, no estoy seguro de cuál es el valor predeterminado para el modo de liberación de iphone. - Os optimizará para un binario más pequeño. También hay una opción para dead code stripping que eliminará cualquier código que nunca se pueda ejecutar. También puede intentar pelar el binario .. sin embargo, no estoy seguro de si eso funciona para los binarios de Iphone.

Esto es asumiendo que su problema es debido al tamaño binario ejecutable y no a los recursos de imagen.

Usé ImageOptim y ImageAlpha para reducir el tamaño de la aplicación. Echa un vistazo a este estudio de casos para obtener más información. Tweetbot para iPad

@rjstelling tiene una respuesta muy agradable, y no podría empezar a decirlo mejor, pero hay un pequeño problema con ella. No funcionará con imágenes localizadas. Esto es solo un problema si incrustas texto en imágenes, que es algo que recomiendo nunca hacer si puedes evitarlo. Sin embargo, si tiene que usar imágenes localizadas, siga todos los pasos de rjstelling excepto en lugar 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

Utilice el siguiente código:

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

Tenga en cuenta que el único cambio es en la ruta del archivo de exportación. Usted tiene que anteponer INPUT_FILE_REGION_PATH_COMPONENT a la ruta de exportación para obtener la localización de la imagen para que funcione correctamente. INPUT_FILE_REGION_PATH_COMPONENT está vacío normalmente a menos que haya una carpeta localizada para el archivo específico. Siendo ese el caso, proporciona el nombre de la carpeta y una barra diagonal final, por lo que no tiene que hacerlo.

También debe cambiar su configuración Output Files a ${DERIVED_FILES_DIR}/${INPUT_FILE_REGION_PATH_COMPONENT}${INPUT_FILE_NAME} para que esto funcione.

No estoy seguro de si soy el único que ha tenido ese problema, pero espero que ayude a alguien.

He reducido una aplicación iOS de 90MB a 50MB en los últimos meses. Estos son algunos consejos y herramientas:

Para perfilar el Tamaño de la aplicación iOS

1. Descomprima su ipa para verificar recursos como archivos de video, fuente e imágenes.

2. Perfile su archivo binario por biblioteca y archivos objeto (clases) usando Linkmap file y Xcode Linkmap Parser.

Para Reducir Archivos de Imagen

• use ImageOptim-CLI para automático el proceso de compresión de imágenes
• use Imagen no utilizada para encontrar archivos de imagen no utilizados

Para Reducir El Archivo Binario

• Eliminar símbolos de depuración
• Encuentra importaciones no utilizadas usando fui

Inspeccionando an .ipa File

Simplemente cambie la extensión de an.archivo ipa a .zip, luego ábrelo con Finder para descomprimirlo. Haga clic derecho en el desabrochado .paquete de la aplicación y elija "Mostrar contenido del paquete" para ver el recursos dentro. Esto puede darle una idea de lo que está utilizando más espacio.

Puede examinar el tamaño comprimido de cada elemento en su .ipa by abrir Terminal y ejecutar el siguiente comando:

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

La columna tamaño tiene el tamaño comprimido de cada archivo dentro de su.ipa file. Debe evaluar este tamaño a medida que trabaja para reducir el tamaño de recursos en tu app. Puede reducir mucho el tamaño de un recurso, pero después de producir un .archivo ipa, puede descubrir el tamaño comprimido de ese recurso no ha cambiado tan dramáticamente. El más eficaz técnica para reducir el tamaño de an .archivo ipa es eliminar innecesario recurso.

Para acceder al artículo completo, consulte el enlace del sitio web de Desarrolladores de Apple.