En esta entrada voy a describir la manera de comunicar aplicaciones escritas en Android con programas escritos en C/C++ vía JNI utilizando el NDK de Android.
El NDK es un conjunto de herramientas que permite incorporar los componentes que hacen uso de código nativo en las aplicaciones de Android. Permite implementar parte de tus aplicaciones usando código nativo con lenguajes como C y C ++. Esto puede proporcionar beneficios a ciertas clases de aplicaciones, en la medida que se puede reutilizar el código existente y en algunos casos obtener un aumento de la velocidad.
Java Native Interface (JNI) es un framework de programación que permite que un programa escrito en Java ejecutado en la máquina virtual java (JVM) pueda interactuar con programas escritos en otros lenguajes como C, C++ y ensamblador.
La estructura de un proyecto Android que utilice JNI y NDK para permitir la intercomunicación entre aplicaciones C/C++ y Android es la siguiente:
carpeta raíz del proyecto/
- jni/
- libs/
- res/
- src/
- AndroidManifest.xml
- default.properties
- … otros ficheros …
Descripción de los ficheros:
- La carpeta src contiene el código Java de la aplicación Android
- La carpeta res contiene los recursos de la aplicación (imágenes, archivos XML que describen las capas de interfaz, etc)
- La carpeta libs *contendrá* las librerías nativas *después* de una construcción exitosa
- La carpeta jni *contiene* el código C/C++ de la aplicación con la que queremos comunicarnos, además de dos scripts importantes: Android.mk y Application.mk. Estos scripts son dos Makefiles típicos que controlan el proceso de construcción de la aplicación C++.
Veamos los pasos para ejecutar una sencilla aplicación Android que se comunique con un programa escrito en C++.
- Descargar y descomprimir NDK
Sé que hay versiones mucho más actuales, pero aún así, utilizo esta de Crystax que está bastante optimizada.
wget http://www.crystax.net/en/download/android-ndk-r4-linux-x86-crystax-4.tar.bz2 -O /tmp/android-ndk-r4-linux-x86-crystax-4.tar.bz2
cd ~ && tar xvjf /tmp/android-ndk-r4-linux-x86-crystax-4.tar.bz2
- Crear la carpeta libs en el proyecto
Pulsamos el botón derecho sobre el proyecto, y escogemos la opción New -> Folder. Escribimos libs como nombre de carpeta.
- Crear la carpeta jni en el proyecto
Pulsamos el botón derecho sobre el proyecto, y escogemos la opción New -> Folder. Escribimos jni como nombre de carpeta.
- Crear el programa C++ con el que queremos comunicarnos
Pulsamos el botón derecho sobre la carpeta JNI, y escogemos la opción New -> File. Escribimos code.cpp como nombre de fichero. Hacemos doble clic sobre el fichero y escribimos el siguiente código:
#include <jni.h>
#include <iostream>
#include <cstdlib>
#include <getopt.h>
#include <string>
#include <cassert>
#include <stdexcept>
using namespace std;
extern "C"
{
JNIEXPORT jstring JNICALL Java_blog_neonigma_AndroidActivity_SayHello(JNIEnv *env, jobject thiz, jstring name)
{
try
{
const char *myName = env->GetStringUTFChars(name, 0);
std::string nameCPP(myName);
nameCPP = "Hello: " + nameCPP;
return env->NewStringUTF(nameCPP.c_str());
}
catch (exception &ex)
{
const char *error = "Failed";
return env->NewStringUTF(error);
}
}
}
- Consideraciones sobre el código:
- El bloque extern «C» indica que el programa está escrito en C++. Sí, en C++. Si queremos escribirlo en C, eliminamos el bloque extern.
- La declaración de la función nativa tiene que coincidir con el namespace + nombre de actividad Android + nombre de función en el código Java/Android. En este caso, como nuestra actividad es AndroidActivity y se encuentra en el namespace blog.neonigma, la función debe nombrarse como Java_blog_neonigma_AndroidActivity_SayHello, siendo SayHello el nombre que damos a la función y «Java_» un texto estático.
- La función siempre recibe un puntero al entorno (JNIEnv *env) y un objeto manejador (jobject thiz)
- Para convertir const char * en jstring, usamos la función NewStringUTF del entorno
- Más información en la API oficial de JNI
- Crear los Makefiles para NDK
Pulsamos el botón derecho sobre el proyecto, y escogemos la opción New -> File. Escribimos Android.mk como nombre de fichero. El código para este fichero sería el siguiente:
LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
LOCAL_MODULE := mixed_sample
LOCAL_SRC_FILES := code.cpp
LOCAL_LDLIBS += -llog -ldl
include $(BUILD_SHARED_LIBRARY)
Los valores más importantes son code.cpp, que indica el fichero de código con el que queremos comunicar y mixed_sample, que es el nombre que damos a la librería que se va generar vía JNI.
Repetimos el proceso y creamos un fichero Application.mk.
APP_STL := gnustl_static
APP_CPPFLAGS := -frtti -fexceptions
APP_ABI := armeabi
APP_PROJECT_PATH := ~/workspace/blog-jni-c
En este caso, los valores más importantes son la arquitectura armeabi (puede cambiarse por la más moderna armeabi-v7a) y el path del proyecto, donde hay que indicar el path al workspace actual.
- Crear un builder para la compilación
Debe generarse un builder en Eclipse para la compilación del código C/C++ con NDK.
- Pulsamos en projects -> properties y escogemos la opción Builders. Pulsamos el botón New.
- En la ventana que aparece, escogemos la opción Program (sin escribir nada), y pulsamos OK.
- En la siguiente ventana configuramos el Builder en sí. En la pestaña Main, escribimos en el campo Location la ruta absoluta al programa ndk-build, en mi caso /home/neonigma/android-ndk-r4-crystax/ndk-build En el campo Working directory, pulsamos en el botón Browse workspace y escogemos el proyecto en el que estamos trabajando.
- Ahora vamos a la pestaña Refresh y marcamos Refresh upon completion, Specific resources y Recursively include sub-folders.
Pulsamos en el botón Specify resources y en la ventana que aparece, escogemos el recurso libs.
- Por último, vamos a la pestaña Build Options, dejamos las casillas ya marcadas y marcamos During auto builds y Specify working set of relevant resources.
Pulsamos en el botón Specify resources y escogemos el recurso jni de nuestro proyecto.
- Escribir el código de la actividad Android
Para enviar datos al programa en C++ y recogerlos, necesitamos escribir el código de la actividad principal de la siguiente manera:
package blog.neonigma;
import src.blog.neonigma.R;
import android.app.Activity;
import android.os.Bundle;
import android.widget.Toast;
public class AndroidActivity extends Activity {
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
String greeting = SayHello("neonigma");
Toast.makeText(this, greeting, Toast.LENGTH_LONG).show();
}
public native String SayHello(String name);
static {
System.loadLibrary("mixed_sample");
}
- Consideraciones sobre el código
- La llamada a función nativa se define como public native.
- String se equipara a jstring, e int a jint, a la hora de enviar y recibir parámetros.
- Debe definirse como estática la carga del módulo de la librería generada y que especificamos en el código del Makefile Android.mk.
Referencias:
http://opencv.itseez.com/doc/tutorials/introduction/android_binary_package/android_binary_package_using_with_NDK.html#android-binary-package-with-ndk
http://zsoluciones.com/datos/?p=246
El código del ejemplo puede descargarse desde el repositorio creado en BitBucket.
A 1 persona le gusta esta entrada
