El documento introduce el Android NDK, permitiendo compilar componentes nativos en C/C++ para aplicaciones Android. Explica qué es el NDK, qué permite hacer como usar librerías C/C++ e invocar código nativo desde Java. También cubre las librerías incluidas, cuándo usar el NDK y los primeros pasos de instalación y ejemplos.
6. ¿Qué permite?
Entre otras cosas permite
Utilizar librerías C/C++
Invocar código C/C++ desde Java (y al revés)
OpenGL ES 1.0 y 2.0
Desde NDKr5 (Gingerbread)
Aplicación android escrita completamente en C/C++
(activities nativas)
Acceder input (teclado, touch screen)
Acceder sensores (acelerómetro, brújula...)
Reproducir audio
Recuperar recursos incluidos en el APK (R.*)
7. Librerías incluidas
JNI interface headers libjnigraphics (Pixel buffer
access) header (for
libc (C library) headers
Android 2.2 and above).
libm (math library) A Minimal set of headers
headers
for C++ support
libz (Zlib compression) OpenSL ES native audio
headers
libraries
liblog (Android logging) Android native application
header
APIS
OpenGL ES 1.1 and
OpenGL ES 2.0 (3D
graphics libraries)
headers
8. ¿Cuándo usarlo?
No recomendado para la mayoría de las aplicaciones
No siempre aumenta el rendimiento pero siempe
incrementa la complejidad
Sospechosos habituales
Operaciones de CPU intensivas, que no reserven mucha
memoria: procesamiento de señales, simulaciones
físicas, juegos...
10. Requisitos
Android SDK
Android 1.5 SDK o superior
Sistemas operativos soportados
Windows XP (32-bit) o Vista (32- or 64-bit).
Mac OS X 10.4.8 o superior (x86 only).
Linux (32 o 64-bit).
Herramienta de desarrollo requeridas
GNU Make 3.81 o superior.
Versión reciente de awk.
Para Windows, Cygwin 1.7 o superior.
11. Instalación
Descargar e instalar Android SDK
http://developer.android.com/sdk/index.html
Descargar y descomprimir Android NDK
http://developer.android.com/sdk/ndk/index.html
Incluir directorio NDK en el PATH
export NDK_ROOT=/home/fegabe/android-ndk-r5
export PATH=$PATH:$NDK_ROOT
12. Ejemplos incluidos con NDK
La mejor manera de aprender NDK y saber qué
se puede hacer
hello-jni hello-neon
two-libs bitmap-plasma
san-angeles native-activity
hello-gl2 native-plasma
13. Calculadora NDK
Código Java
Código C
Android.mk
Compilar y ejecutar
14. Código Java. Calculator.java
Calculadora NDK
package org.gtug.bcn.fegabe.ndk.calculator;
// Cargamos la librería 'sample-calculator' durante
// el arranque de la aplicación.
static {
System.loadLibrary("sample-calculator");
}
// Método nativo que se implementa en la librería
// nativa 'sample-calculator', se empaqueta junto a esta
// aplicación.
Private static native int operate(int value1, int value2,
String operation);
public static int performOperation(int value1, int value2,
String operation) {
// Se invoca el método nativo como si fuera un método
// normal
return operate(value1, value2, operation);
}
15. Código C. calculator.c
Calculadora NDK
// El nombre del método en el código nativo se
// forma concatenando el package donde está definido
// (org.gtug.bcn.fegabe.ndk.calculator), el nombre de la
// clase (Calculator) y el nombre del método (operate)
jint Java_org_gtug_bcn_fegabe_ndk_calculator_Calculator_operate
(JNIEnv *env,jclass clazz, jint value1, jint value2, jstring
operation) {
int result = 0;
const char* strOperation;
strOperation = (*env)->GetStringUTFChars(env, operation, 0);
if (strcmp(strOperation, "+") == 0)
result = value1 + value2;
LOGI("Calculator_operate: %d %s %d = %d", value1,
strOperation, value2, result);
return result;
}
16. Android.mk 1/2
Calculadora NDK
Se trata de un Makefile que describe
al compilador de NDK los ficheros
C/C++.
Crear estos makefiles es una de las
partes más complicadas de NDK, por
ello conviene echar una vistazo a los
ejemplos que vienen para ver otros
Android.mk que incluyen comentarios.
17. Android.mk 2/2
Calculadora NDK
# Android.mk debe comenzar con la variable LOCAL_PATH que localiza los
fuentes en el árbol de directorios. En este caso, la macro 'my-dir'
devuelve el path del directorio actual.
LOCAL_PATH := $(call my-dir)
# CLEAR_VARS limpia las variables LOCAL_XXX (LOCAL_MODULE,
LOCAL_SRC_FILES...) excepto LOCAL_PATH.
include $(CLEAR_VARS)
# LOCAL_MODULE debe ser definida para identificar cada módulo descrito en
el Android.mk. El nombre debe ser único y no contener espacios. La librería
dinámica recibirá el nombre del módulo, en este caso se generará el fichero
'libsample-calculator.so'.
LOCAL_MODULE := sample-calculator
# LOCAL_SRC_FILES contiene la lista de ficheros C y/o C++.
LOCAL_SRC_FILES := calculator.c
# Lista de flags de linkado usados durante la compilación.
LOCAL_LDLIBS := -llog
# BUILD_SHARED_LIBRARY indica que el módulo ha acabado indicando qué
compilar. Existe también la variable BUILD_STATIC_LIBRARY para generar una
librería estática.
include $(BUILD_SHARED_LIBRARY)
18. Compilar y ejecutar
Calculadora NDK
$ <directorio-proyecto-ndk>/ndk-build
Se genera la librería 'libsample-calculator.so'
en la carpeta 'libs'
Finalmente compilamos el proyecto en Eclipse
para generar el .APK y ya podemos ejecutarlo
en el emulador o dispositivo.
21. Recibir/enviar Strings
What else?
jstring to C/C++ strings construct new String
GetStringUTFChars NewStringUTF
ReleaseStringUTFChars
Demo Whatelse
Con otras referencias como Arrays sucede similar
22. Generar Headers
What else?
Utilizando javah podemos generar
automáticamente los headers en código C
/bin$ javah -jni
org.gtug.bcn.fegabe.ndk.calculator
.WhatelseActivity
25. CrystaX NDK
What else?
Android NDK personalizado con soporte para
excepciones C++, RTTI y STL
Muy útil para compilar librerías ya existentes
con NDK
http://www.crystax.net/android/ndk.php
26. Parsec. Ejemplo real NDK
Shoot'em old-school hecho por IdeaKnow para
iPhone y Android gracias a NDK
Addictive gameplay
Cool vector graphics
20 amazing levels
GAME CENTER / Openfeint
Online achievements & hiscores
Weapon upgrades
Bosses
Items
Allows to play your own
music while in-game
parsec.ideaknow.com
27. Parsec. Experiencia
90 % código C común
Cada plataforma implementa:
ciclo de vida,
inicialización vista OpenGL,
gamecenter/openfeint,
gestión inputs,
gestión audio
Lo más complicado: conseguir crear un
Android.mk para compilarlo (un par de días)