Gráficos cada vez más rápidos. Cómo usar NDK y RenderScript

Motorola Mobility

Peter van der Linden
Evangelista de la tecnología Android
Plataformas y Servicios del Desarrollador

Gráficos cada vez más rápidos. Cómo usar
NDK y RenderScript

MOTODEV App Summit 2011 Page 2

1 CÓMO INSTALAR LAS HERRAMIENTAS

2 ESCRIBA SU CÓDIGO

3 CREE SU CÓDIGO

4 CÓMO LLAMAR A C DESDE JAVA (la JNI)

5 RESUMEN. Síntesis, Control de calidad

© 2011 Motorola Mobility, © 2011 Motorola Mobility, Inc.
Inc. Versión 1.0


¿POR QUÉ C/C++ CÓDIGO EN ANDROID?

• Open GL

• Desempeño

• Puerto

© 2011 Motorola Mobility, Inc.


Limitaciones de NDK C++
•  Originalmente para escribir partes críticas de
desempeño del código en C

•  No necesita una abstracción POO para eso (y
Dalvik VM es mucho más rápido, con el compilador
JIT desde 2.2)

•  El soporte de C++ es algo limitado
•  no tiene soporte para las excepciones
•  conocidas como bugs en invocaciones de destructor/
constructor estático

•  De manera es más probable que el código NDK se
escriba en C en lugar de C++ © 2011 Motorola Mobility, Inc.


Arquitecturas CON SOPORTE DE CPU
•  NDK soporta dos conjuntos de instrucción ARM:
•  ARMv5TE (incluye instrucciones Thumb-1). Este es el
destino predeterminado y el código compilado para que
esto se ejecute en todos los dispositivos basados en ARM
Android. Elija otro destino al cambiar una línea en el
archivo Application.mk.
•  ARMv7-A (incluye Thumb-2 e instrucciones VFPv3-D16
con soporte opcional para instrucciones NEON/VFPv3-
D32). El código compilado para ARMv7-A se ejecutará
sólo en dispositivos, tales como Verizon Droid o Motorola
XOOM que tienen v7 CPU. El código para NEON se
ejecutará sólo en un ARMv7 con soporte para NEON.

•  Hay una tercera arquitectura "en los
trabajos" (experimental, sin soporte):
•  conjunto de instrucciones x86

CÓMO INSTALAR LAS
HERRAMIENTAS
MOTOROLA y el logotipo estilizado "M" son marcas de fábrica o marcas registradas de Motorola Trademark Holdings, Versión 1.0
LLC. Todas las demás marcas comerciales son propiedad de sus respectivos dueños. © 2011 Motorola Mobility, Inc.
Todos los derechos reservados.


Cómo descargar el Native Development Kit

• Verifique compatibilidad: XP o Vista, MacOS X 10.5,
Ubuntu

• Descargue el archivo comprimido de 50 MB o el archivo
tar.bz2 desde:
http://developer.android.com/sdk/ndk/index.html

• Descomprímalo en el lugar que elija; recuerde dónde en
$NDK
export NDK=~/android-ndk-r5b

• Requiere GNU make y GNU awk! Usuarios de Windows:
instalar Cygwin 1.7 o superior © 2011 Motorola Mobility, Inc.


Usuarios de Windows
•  Descargar e instalar Cygwin 1.7 o superior

•  Herramientas de la línea de comando Unix/Linux para los usuarios de
Windows
http://cygwin.com



Sugerencias para Windows y MacOS X

• No dejar espacios en los nombres de rutas. ¡En ningún
lugar!
• Cygwin sólo instala los paquetes base.
• Usted necesita los paquetes de desarrollo. Es más fácil
instalar la rama completa de Devel.
1.  Ejecute setup.exe .
2.  Haga clic en la palabra "Default" al lado del nódulo
Devel de la raíz.
3.  "Default" cambia a "Install" para el nódulo Devel.
4.  Haga clic en "next” para instalar. Vaya a almorzar
mientras se instala.
5.  Deje que cree un icono de la consola cygwin en su
computadora.
6.  Escriba "make –v" en la consola de cygwin para

verificar que está bien.


Abra el Native Development Kit
• Hay 7 carpetas y varias cosas para leer:



Carpetas NDK

• build : 4 carpetas con notas de awk & shell, archivos makefiles para construir
sus archivos C/C++
• docs: alrededor de 20 archivos de texto (preguntas frecuentes sobre NDK);
acceda a ellas en documentation.html
• platforms: archivos .h y system library.so p/los distintos niveles IPA
• samples: una docena de ejemplos
• sources: algunas fuentes para asuntos relacionados con el sistema
• tests: notas para probar el mismo NDK. Probablemente aquí por error.
• toolchains: cadena de herramientas para cross-compilación



Agregar soporte C/C++ a Eclipse

•  Eclipse tiene un plugin para C/C++, como para Android

•  Cómo usar Eclipse
Help > Install new software

•  Escriba http://download.eclipse.org/releases/helios/ en el
campo "work with" (o en la versión que use)

•  Advertencias habituales sobre proxies de la red en el trabajo
(configúrelas en MOTODEV Studio > Preferences >
Network Conn.)

•  Haga clic en Programming Langs > C/C++ Development Tools



•  Hay un plugin para C/C++, como para Android

•  Cómo usar Eclipse
Help > Install new software


Escriba su código C

MOTOROLA y el logotipo estilizado "M" son marcas de fábrica o marcas registradas de Motorola Trademark Holdings,


Enfoque general

• Comience con una aplicación Java Android y agréguele
piezas de NDK

• Ponga sus fuentes nativas C/C++ en $PROJECT/jni:

• Construya su código nativo en las bibliotecas.

• Su código Android Java puede recibir estas bibliotecas
nativas

• El código nativo puede también retornar a Java y acceder
a objetos de Java



Cree el proyecto
Android de la
manera habitual



Cree la carpeta jni para su proyecto

•  Resalte el proyecto Eclipse que usará el código nativo

•  El nombre de su paquete se usa para acceder al código
nativo, por eso, hágalo corto y simple, ej. "com.greet" p/
fines de capacitación

•  File > New > Folder
•  póngale el nombre "jni"

•  Dentro de esa carpeta jni recién creada, agregaremos
•  un archivo makefile
•  algunos archivos C



Agregue dos archivos a la carpeta "jni" en su
proyecto

•  File > New > Other …
•  Seleccione "General", luego "file", luego navegue
•  Seleccione la carpeta jni c/un nombre de archivo
"Android.mk">Finish
•  Repita, al crear un archivo "myhello.c", también en
la carpeta jni
•  Eso le da
•  jni/Android.mk
•  jni/myhello.c



Complete la carpeta jnien la carpeta jni
Cómo crear archivos en su proyecto

salud
ar



Cómo crear mkfile en la carpeta jni



Complete el archivo Android.mk makefile
•  Corrija el archivo jni/Android.mk que recién creó
•  Ponga estas palabras mágicas en makefile

LOCAL_PATH := $(call my-dir)!

include $(CLEAR_VARS)!

# numere nuestro archivo fuente y la biblioteca!
# desde él!
LOCAL_MODULE := hello!
LOCAL_SRC_FILES := hello.c!

include $(BUILD_SHARED_LIBRARY)!



Acerca de make
•  Make fue creado por Stu Feldman en 1977 en los Laboratorios Bell
•  En 2003, Dr. Feldman recibió el premio ACM Software System Award
por publicar esta herramienta de gran difusión.
•  Usted no sabía de mí, pero el conocimiento del software tiene eso que…

# cada comando que sigue la línea de dependencia,
# por ejemplo, el DESTINO a la izquierda, debe ser indentado por un
# caracter de TAB.

target: component-to-build
<TAB>commands-to-build-it!



Cree el código C en su carpeta jni

• Corrija el archivo jni/myhello.c que recién creó
• Ponga estas palabras mágicas en el archivo
• Usa el objeto JNIEnv p/crear 1 cadena Java desde 1 literal

#include <string.h>
#include <jni.h>

jstring Java_com_greet_MyActivity_myCFunction
(JNIEnv* env, jobject javaThis) {
return (*env)->NewStringUTF(env, "Hello from native
code!");
}


Código C explicado
Cuando JVM invoca una función nativa, pasa
•  un puntero JNIEnv (estructura que tiene la interfaz a JVM p/C)
•  un puntero jobject (el objeto "this")
•  cualquier argumento Java declarado por el método Java.

Estos tipos vienen de #include <jni.h> (consulte en "platforms")
Su método C debe escribirse para esperar estos argumentos
El método C se denomina "Java"_classname_activity_methodname

#include <string.h>
#include <jni.h>

jstring Java_com_greet_MyActivity_myCFunction
(JNIEnv* env, jobject javaThis) {
return (*env)->NewStringUTF(env, "Hello from native code!");
}!

•  … parece, pero no es, ¿una pérdida de memoria?

Cree su código C



Cómo llamar entre idiomas

• Android sigue el camino estándar para hablar entre Java
yC

• JNI: Java Native Interface (Interfaz nativa Java)

• Enlace a documentos JNI
http://java.sun.com/docs/books/jni/

• Eso incluye un libro completo, un tutorial, ejemplos, etc.



Cree su biblioteca C
•  Traiga 1 emulador de terminal y cd en su carpeta jni d/proyecto
•  Use la nota "ndk-build" del directorio NDK (un contenido adicional
GNU Make) (puede poner $NDK en su ruta, si desea)
•  La nota compila su código C, lo convierte en una biblioteca
compartida
•  Pasa libhello.so a una nueva carpeta de proyecto libs/armeabi



Enfoque general para crear una biblioteca
•  Guarde los archivos en Eclipse
•  Traiga un emulador de terminal y cd en su carpeta jni del proyecto
•  Ejecute el script ndk-build para convertir su código C en un .so
•  Ese lib*.so se agregará en su archivo de aplicación .apk
•  File > Refresh en Eclipse (para sincronizar con el sistema de archivos)

$ cd MYECLIPSEPROJECT/jni!
$ $NDK/ndk-build !

Compilar thumb : hello <= hello.c!
SharedLibrary : libhello.so!
Instalar : libhello.so => libs/armeabi/libhello.so!



CONSTRUYA SU BIBLIOTECA: resumen

•  Eclipse no construye su código NDK, GNU Make sí

•  El plugin C/C++ le da colores de sintaxis y corrección
(solamente)

•  Ejecute el scrip "ndk-build" después de cada corrección de
su código C

•  Luego, haga clic en File > Refresh, (F5), para mantener a
Eclipse en sincronismo c/ sus archivos nativos


El lado Java de JNI



El código Java que llama al código nativo

•  Comience c/la aplicación básica que le da Eclipse

package com.greet;!

import android.app.Activity;!
import android.os.Bundle;!

public class MyActivity extends Activity {!
/** Llamado cuando la actividad se crea por primera
vez. */!
@Override!
public void onCreate(Bundle savedInstanceState) {!
super.onCreate(savedInstanceState);!
setContentView(R.layout.main);!
}!
}!


Agregar la carga de biblioteca

•  Agregue la llamada para cargar nuestra biblioteca
nativa libhello.so
•  el nombre debe coincidir con el nombre de la
biblioteca sin "lib" ni ".so“
•  entonces libhello.so es "hello"

static {!
System.loadLibrary("hello");!
}!



Agregar la declaración de la función nativa

•  Agregar la declaración del prototipo de la función C

•  Del lado de C, tiene dos argumentos explícitos, un envp, un this

•  Del lado de Java, esos argumentos son implícitos

private native String myCFunction(); !



Agregar el llamado a la función nativa

•  Vamos a obtener la cadena de C y mostrarla como una
notificación (“toast”).

import static android.widget.Toast.*;!
import android.widget.Toast;!

. . .!

String msg = myCFunction();!
Toast.makeText(this, msg, LENGTH_LONG).show();!



Cómo juntamos las piezas
package com.greet;!

Import android.app.Activity;!
import android.os.Bundle;!
import static android.widget.Toast.*;!
import android.widget.Toast;!

public class MyActivity extends Activity {!

static { System.loadLibrary("hello"); }!

private native String myCFunction(); !

@Override!
public void onCreate(Bundle savedInstanceState) {!
super.onCreate(savedInstanceState);!
setContentView(R.layout.main);!

String msg = myCFunction();!

Toast.makeText(this, msg, LENGTH_LONG).show();!
}!
}!



EL COMIENZO

Este puede ser un hermoso comienzo de un largo camino

• http://groups.google.com/group/android-ndk/topics

•  http://java.sun.com/docs/books/jni/

• http://developer.android.com/sdk/ndk/index.html


MOTODEV App Summit 2011 Page
Página39

Renderscript
•  Nuevo, API de gráficos en 3D de alto
desempeño
•  Se usó en Froyo para papel tapiz en
vivo
•  Se usa en Honeycomb para
aplicaciones de Books y YouTube
•  Honeycomb presenta Renderscript
como una API pública
•  Para código crítico de desempeño
donde las API del marco tradicional
Open GL ES no son los
suficientemente rápidas.

© 2010 Motorola Mobility, Inc. Versión 1.0

Página40

Ejemplo de Renderscript


Página41

App Books y Renderscript


Página42

API de Renderscript

•  Una API de "computing" para localizar puntos móviles en 3D
•  Una API de "rendering" para dibujar texturas sobre los puntos
•  Un lenguaje de script basado en C para acceder a esta API
•  Única meta: exprimir hasta la última onza de desempeño de
los gráficos
•  Enfoque: API es una capa delgada sobre las características con
soporte de hardware
•  http://community.developer.motorola.com/t5/MOTODEV-Blog/
Introduction-to-Renderscript/ba-p/12136


Página43

API de Renderscript

•  Android construye elementos que compilan su archivo Renderscript .rs
a bytecode intermedio
•  Y lo empaquetan dentro de su archivo de aplicación .apk
•  En el dispositivo, el bytecode se compila (justo a tiempo – JIT) en el
código de máquina que se optimiza para el dispositivo exacto que
se está ejecutando
•  El código de la máquina se pone en caché para uso futuro
•  Así se elimina la necesidad de apuntar a una arquitectura específica
durante le proceso de desarrollo. ¡Excelente!


Página44

Ejemplo de archivo .rs (de muestras de Honeycomb)
#pragma rs java_package_name(com.android.rs.helloworld)!

#include "rs_graphics.rsh" // header de API de gráficos!

// gTouchX y gTouchY son variables que se reflejarán para uso!
// por la API de java. Podemos usarlas para notificar la nota de!
// eventos táctiles.!
int gTouchX;!
int gTouchY;!

// Esto se invoca automáticamente cuando se crean las instrucciones!
void init() {!
gTouchX = 50.0f;!
gTouchY = 50.0f;!
}!

int root(int launchID) {!
// Borrar el color de fondo!
rsgClearColor(0.0f, 0.0f, 0.0f, 0.0f);!
// Decir al tiempo de ejecución cuál será el color de la fuente!
rsgFontColor(1.0f, 1.0f, 1.0f, 1.0f);!
// Presentarnos al mundo al diseñar un saludo!
// en la posición que el usuario tocó la pantalla!
rsgDrawText("Hello World!", gTouchX, gTouchY);!

// El valor de retorno le dice a RS la frecuencia para rediseñar!
// en este caso 20 ms!
© 2011 Versión 1.0
Motorola Mobility, Inc.
return 20;!
}!


¿Desea
formular
alguna

pregunta?
Brasil - #appsum11br
Argentina - #appsum11ar
México - #appsum11mx

community.developer.motorola.com


gracias



Licencias

Los ejemplos del código fuente que se exhiben en esta presentación pueden estar bajo la licencia
de Apache, Versión 2 según lo siguiente:

Copyright © 2010, Android Open Source Project. Todos los derechos reservados, salvo indicación
expresa en contrario.

Con licencia de Apache, Versión 2.0 (la "Licencia"); no podrá usar este archivo, salvo que cumpla con
lo que establece la Licencia. Puede conseguir una copia de la licencia en
http://www.apache.org/licenses/LICENSE-2.0.

Salvo que lo exija la legislación vigente o se preste conformidad por escrito, el software se distribuye
bajo la Licencia "EN EL ESTADO EN QUE SE ENCUENTRA", SIN GARANTÍAS NI CONDICIONES
DE NINGÚN TIPO, explícitas o implícitas. Consulte la Licencia para ver los permisos y las limitaciones
que rigen para la Licencia según el idioma específico.



Licencias
Los ejemplos del código fuente que se muestran en esta presentación pueden estar bajo la
licencia BSD, según lo siguiente:

Copyright © 2010-2011, Motorola, Inc. Todos los derechos reservados, salvo indicación expresa en contrario.
Se permite la redistribución y el uso en forma de fuente o binaria, con o sin modificación, siempre y cuando se cumpla con
las siguientes condiciones:
Las redistribuciones del código fuente deben conservar el aviso de derechos de autor arriba mencionado, la presente
lista de condiciones y el siguiente descargo de responsabilidad.
Las redistribuciones en forma binaria deben reproducir el aviso de derechos de autor arriba mencionado, la presente
lista de condiciones y el siguiente descargo de responsabilidad en la documentación y/u otros materiales suministrados
con la distribución.
Ni el nombre de Motorola, Inc. ni los nombres de sus distribuidores pueden usarse para avalar o promover productos
que deriven de este software sin previa autorización específica por escrito.

EL PRESENTE SOFTWARE SE SUMINISTRA POR LOS TITULARES DE LOS DERECHOS DE AUTOR Y
CONTRIBUYENTES EN EL ESTADO "EN QUE SE ENCUENTRA" Y SE RECHAZA TODA RESPONSABILIDAD DE
GARANTÍA IMPLÍCITA O EXPLÍCITA, A TÍTULO ENUNCIATIVO, LAS GARANTÍAS IMPLÍCITAS DE
COMERCIALIZACIÓN Y DE APTITUD PARA UN PROPÓSITO PARTICULAR. EN NINGÚN CASO PODRÁ EL
TITULAR DE LOS DERECHOS DE AUTOR O LOS CONTRIBUYENTES SER RESPONSABLE POR NINGÚN DAÑO
Y PERJUICIO DIRECTO, INDIRECTO, INCIDENTAL, ESPECIAL, PUNITIVO, O CONSECUENCIAL (A TÍTULO
ENUNCIATIVO DE ABASTECIMIENTO DE BIENES O SERVICIOS DE SUSTITUCIÓN; PÉRDIDA DE USO, DATOS O
GANANCIAS O INTERRUPCIÓN DE ACTIVIDADES) INDEPENDIENTEMENTE DE SU ORIGEN Y DE TODA TEORÍA
DE RESPONSABILIDAD, YA SEA EN EL CONTRATO, RESPONSABILIDAD ESTRICTA O POR LESIÓN JURÍDICA
(INCLUSO NEGLIGENCIA O DE OTRO MODO) QUE SURJA DE ALGUNA MANERA DEL USO DE ESTE
SOFTWARE, INCLUSO SI SE ADVIRTIÓ DE LA POSIBILIDAD DE DICHO DAÑO.

Gráficos cada vez más rápidos. Cómo usar NDK y RenderScript

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (19)

Similaire à Gráficos cada vez más rápidos. Cómo usar NDK y RenderScript

Similaire à Gráficos cada vez más rápidos. Cómo usar NDK y RenderScript (20)

Plus de Motorola Mobility - MOTODEV

Plus de Motorola Mobility - MOTODEV (20)

Dernier

Dernier (15)

Gráficos cada vez más rápidos. Cómo usar NDK y RenderScript