Cómo crear un APK x86 y ARM* con el Compilador Intel® y el gcc de GNU*

Índice

1. Introducción
2. Preparación del entorno de compilación
3. Compilación desde la línea de comandos
   1. Configuración de la aplicación
   2. Limpieza del área de trabajo de la aplicación
   3. Compilación del binario para la arquitectura ARM*
   4. Compilación del binario para la arquitectura x86
   5. Preparación del paquete de la aplicación (APK)
4. Compilación desde el IDE de Eclipse*
5. Nota sobre cómo evitar la limpieza de binarios en .\libs\[targetabi]
6. Otros artículos y recursos relacionados

Introduction

Hay dispositivos Android* que utilizan procesadores compatibles con las arquitecturas de conjunto de instrucciones (ISA) ARM* o x86. Hay diferentes ISA que no tienen compatibilidad binaria entre sí y, por lo tanto, si una aplicación contiene código nativo, debe proporcionar las bibliotecas nativas para cada ISA de destino. Los paquetes de aplicaciones "grandes" de Android* ("fat" APK) son uno de los mecanismos de distribución para tales aplicaciones.

En este artículo se dan instrucciones paso a paso para compilar ese APK grande que incluye archivos dex independientes de la ISA para máquina virtual Dalvik* (Dalvik, 2013) y las bibliotecas para diferentes ISA de destino. Incluye cómo compilar la biblioteca de aplicaciones nativas para x86 con el Compilador Intel® C++ para Android*.

En la demostración, usaremos el ejemplo hello-gl2 de la distribución r9 del NDK.

Preparación del entorno de compilación

Se deben instalar las siguientes herramientas necesarias:

• Paquete SDK de Android* (2013) se supone instalado en [android-sdk-dir]
• Kit de Desarrollo Nativo de Android* (Android NDK 2013) se supone instalado en [ndk-dir]
• Kit de Desarrollo Java* Kit 6 se supone instalado en [jdk6-dir]
• Apache* Ant* se supone instalada la versión 1.8 en [ant-dir]
• Compilador Intel® C++ para Android* se supone instalado en [icc-dir]
  Esta herramienta debe ser la última en instalarse.

Agregamos los directorios necesarios a la variable de entorno "PATH":

• Directorio "[ndk-dir]" para usar la herramienta "ndk-build" tool
• Directorio "[android-sdk-dir]\sdk\tools"para usar la herramienta "android"
• Directorio "[ant-dir]\bin" para usar la herramienta "ant"
• Directorio "[jdk6-dir]\jre\bin" para usar la máquina virtual "java".Este último lo pide la herramienta "ant"
  Para el entorno Windows, hay que asegurarse de usar nombres de carpetas cortos, como "PROGRA~2" para "program files (x86)"
• Creación de una nueva variable de entorno "JAVA_HOME=[jdk6-dir]"

Compilación desde la línea de comandos

En esta sección se incluyen las instrucciones para crear desde un entorno de compilación de línea de comandos el paquete APK que brinde compatibilidad con dispositivos Android con arquitecturas ARM* y x86.

Primero se debe abrir la ventana de comandos o la ventana de terminal en Linux*, ir al directorio del NDK de Android que contiene el ejemplo "hello-gl2" es decir [ndk-dir]\samples\hello-gl2, y seguir los pasos de abajo.

Nota: desde esta ventana, se debería poder acceder todas las herramientas indicadas más arriba.

1. Configuración de la aplicación

   Ejecute el siguiente comando desde el directorio "hello-gl2" para generar un archivo build.xml que se usará después para compilar el ejemplo.

       $ android update project --target android-18 --name HelloGL2 --path . --subprojects
        --target android-18: corresponds to Jelly Beans MR2 Android release.

2. Limpieza del área de trabajo de la aplicación

   Use el siguiente comando para limpiar todo el espacio de trabajo, incluidas las bibliotecas de todas las arquitecturas de conjunto de instrucciones.
       $ ant clean
    $ ndk-build V=1 APP_ABI=all clean
        . V=1 : imprime todos los comandos a medida que se ejecutan.
           . APP_ABI=all : fuerza la limpieza de los archivos intermedios de todos los destinos. Si se omite este parámetro, sólo se limpiará el destino armeabi.

3. 3. Compilación del binario para la arquitectura ARM*

   Use el comando de abajo para compilar el binario de la aplicación para la arquitectura ARM:
       $ ndk-build APP_ABI=armeabi V=1 NDK_TOOLCHAIN=arm-linux-androideabi-4.8
        . APP_ABI=armeabi : configura la compilación para el destino ARM*.
           . NDK_TOOLCHAIN=arm-linux-androideabi-4.8 : reemplaza el compilador predeterminado gcc 4.6 de GNU* y usa gcc 4.8.

   El binario de la aplicación (libgl2jni.so ) se crea en .\libs\armeabi\libgl2jni.so

4. 4. Compilación del binario para la arquitectura x86 con el Compilador Intel

   Use el comando de abajo para compilar el binario de la aplicación con el Compilador Intel para la arquitectura x86:
       $ ndk-build APP_ABI=x86 V=1 NDK_TOOLCHAIN=x86-icc NDK_APP.local.cleaned_binaries=true
        . APP_ABI=x86 : configura la compilación para la arquitectura x86.
           . NDK_TOOLCHAIN=x86-icc : reemplaza el compilador predeterminado gcc 4.6 por el Compilador Intel C/C++ para Android.
           . NDK_APP.local.cleaned_binaries=true : suprime la eliminación de bibliotecas en el directorio libs/armeabi. Consulte las notas del final.

   El binario de la aplicación (libgl2jni.so ) se crea en .\libs\x86\libgl2jni.so

5. 5. Preparación del paquete de aplicaciones (APK)

   Después de haber compilado todos los binarios para cada destino de Android, compruebe que el directorio libs\[targetabi contenga la biblioteca necesaria para cada arquitectura de destino.

   Para simplificar la creación del paquete y evitar la firma de paquetes, use el siguiente comando que crea un paquete de depuración:
       $ ant debug

   Después de esto, el nuevo paquete HelloGL2-debug.zip quedará en el directorio .\bin . Se puede ejecutar en emuladores x86* o ARM* que admitan nivel de API 18 o superiores suministrados por el SDK de Android
   El paquete HelloGL2-debug.zip contiene bibliotecas para dos destinos: ARM EABI y x86.

Compilación desde el IDE de Eclipse*

1. Abra Eclipse y cargue el ejemplo [ndk-dir]/samples/hello-gl2
   • Seleccione en el menú File > New > Project > Android Project...
   • Seleccione el botón Android project from existing code
   • Seleccione cualquier nivel de API superior a Android 1.5.
   • En el campo Root Directory, haga clic en Browse... y seleccione el directorio [ndk-dir]/samples/hello-gl2 .
   • Haga clic en Finish.
2. Agregue Native Support al proyecto:
   Haga clic en el nombre del proyecto y seleccione Android Tools > Add Native Support...
3. Cree una configuración de compilación aparte para cada plataforma de destino y establezca el comando de compilación.
   Haga clic con el botón derecho en el proyecto y seleccione Project properties -> C/C++ Builder -> "Manage configurations..."
   Haga clic en New para agregar las nuevas configuraciones siguientes basadas en la configuración predeterminada Default :
   • "x86_icc" para destino x86 con el Compilador Intel icc
   • "amr_gcc" para destino ARM con el gcc de GNU
   En la misma ventana de propiedades del proyecto, asigne a Configuration el valor "x86_icc":
   • Desmarque el comando predeterminado "Use default build command"
   • Agregue lo siguiente al campo Build command :
     ndk-build APP_ABI=x86 NDK_TOOLCHAIN=x86-icc
   Nuevamente, en la misma ventana de propiedades del proyecto, asigne a Configuration el valor "arm_gcc":
   • Desmarque el comando predeterminado "Use default build command"
   Build command :
   ndk-build APP_ABI=armeabi NDK_TOOLCHAIN=arm-linux-androideabi-4.8
   • o Haga clic en OK
4. Limpie el área de trabajo de la aplicación
   Haga clic con el botón derecho en el proyecto y seleccione Build configurations > Clean all…

   Nota: si Application.mk está en el directorio jni, asegúrese de que no contenga la siguiente línea:
   NDK_APP.local.cleaned_binaries=true

5. Compile el binario de la aplicación para ARM* con gcc
   • Cree Application.mk en el directorio jni y agregue la línea siguiente:
     NDK_APP.local.cleaned_binaries=true
   • Haga clic con el botón derecho en el proyecto y seleccione Build configurations > Set Active > arm_gcc
   • Haga clic con el botón derecho en el proyecto y seleccione Build Project
   • Verifique el archivo binario de salida en [eclipse-workspace-dir]\GL2JNIActivity\libs\armeabi\libgl2jni.so
6. Compile el binario de la aplicación para x86 con el Compilador Intel
   • Haga clic con el botón derecho en el proyecto y seleccione Build configurations > Set Active > x86_icc
   • Haga clic con el botón derecho en el proyecto y seleccione Build Project
   • Verifique el archivo binario de salida en [eclipse-workspace-dir]\GL2JNIActivity\libs\x86\libgl2jni.so
7. Compile todos los binarios para todos los destinos configurados
   • Cree Application.mk en el directorio jni y agregue la línea siguiente:
     NDK_APP.local.cleaned_binaries=true
   • Haga clic con el botón derecho en el proyecto y seleccione Build configurations > Build All...
   • o Verifique el archivo binario de salida en:
     • [eclipse-workspace-dir]\GL2JNIActivity\libs\armeabi\libgl2jni.so
     • [eclipse-workspace-dir]\GL2JNIActivity\libs\x86\libgl2jni.so
8. Cree paquetes de aplicaciones no firmados.
   Haga clic con el botón derecho en el proyecto y seleccione Android Tools > Export Unsigned Application Package...

Nota sobre cómo evitar la limpieza de binarios en .\libs\[targetabi]

El uso del parámetro NDK_APP.local.cleaned_binaries=true para suprimir la eliminación de bibliotecas compiladas con anterioridad puede dejar de funcionar en versiones futuras del NDK. Consulte el archivo make [ndk-dir]/build/core/setup-app.mk para conocer cómo desactivar las acciones de borrado para los binarios instalados limpios del destino.

Other Related Articles and Resources

• NDK Android* Application Porting Methodologies
• Changing the default compiler back from Intel C++ Compiler to GCC for x86 targets
• Intel® C++ Compiler for Mac OS* - Compatibility with the GNU* gcc and g++ compilers
• Android* NDK for Intel® Architecture
• Speeding Up the Android* Emulator on Intel® Architecture

To learn more about Intel tools for the Android development, visit Intel® Developer Zone for Android.