Primero se debe tener instalado el SDK. Luego se crea el proyecto con el siguiente comando [1].

android create project	--target 7 \
			--name HelloWorld \
			--path ./HelloWorldProject \
			--activity HelloWorldActivity \
			--package com.hello.world

Para obtener el binario de la aplicación se entra a la carpeta HelloWorldProject.

cd HelloWorldProject

Y se ejecuta el comando:

ant debug

Obviamente debes tener instalado ant.

Luego si deseas subir la aplicación a un emulador, desde el programa android entra a Virtual Devices, y creamos uno nuevo.

android

finalmente para mandar/instalar la aplicación al dispositivo virtual usa:

adb install bin/HelloWorld-debug.apk

Mira que no es necesario indicar a que dispositivo enviar la aplicación, dado que solo hay uno, que es el virtual que hemos creado.

–target:

ID del objetivo. Para obtener la lista de ID, ejecuta:

android list target

Obteniendo como resultado (en mi caso):

Available Android targets:
id: 1 or "android-3"
     Name: Android 1.5
     Type: Platform
     API level: 3
     Revision: 4
     Skins: QVGA-P, QVGA-L, HVGA-L, HVGA (default), HVGA-P
id: 2 or "Google Inc.:Google APIs:3"
     Name: Google APIs
     Type: Add-On
...

Y asi sigue mostrando todos los ID, El ID=7 que es equivalente a decir “Android-8″ indica que usaremos Android 2.2 (Android en la versión 2.2).
.

–name:

Nombre del proyecto.

–path:

El directorio donde se creará el proyecto de nombre name.

–activity:

Actividad. Una actividad presenta una interfaz gráfica (escrita en XML) que permite al usuario interactuar con la aplicación.

–package:

paquete.

He visto una manera súper fácil de crear aplicaciones en código nativo para Android (es decir archivos binarios ejecutables) en este blog (www.myboyfriendisageek.com), aquí les dejo una variante.

Antes de continuar algunas aclaraciones:

OBJETIVO:

• Crear un archivo binario ejecutable llamado “test“.
• Dar atributos de ejecutable al programa “test”.(Hardware: Necesitas root obligatorio, Emulador: Ya viene rooteado)
• Colocar el programa “test” en nuestro dispositivo Android. Se ejecuta usando algún programa que emule una terminal en Android, escribiendo “./test”. Esto al estilo de los programa ls, mkdir, rm, etc. Que ya están en tu dispositivo Android en la dirección “/system/bin”

REQUISITOS:

• Debes tener descargado y descomprimido el SDK de Android.
• Debes tener descargado y descomprimido el NDK de Android.
• Si deseas testear el programa en un dispositivo real, este debe de estar root-eado. Caso contrario deberas usar un emulador. Por causa de que solo puedes darle atributos de ejecución a un programa cuando  eres root.

METODO:

He descomprimido la SDK y la NDK en mi carpeta “~/Android” obteniendo en el interior a la fecha (Junio-2011) las carpetas “android-sdk-linux_x86″ y “android-ndk-r5c”.

Creando la StandAlone-ToolChain (Cadena de herramientas independientes), Escribe y ejecuta el script.

creando-toolchain.sh:

ANDROIDDIR=~/Android
NDK=$ANDROIDDIR/android-ndk-r5c
 
MAKETOOLCHAIN=$NDK/build/tools/make-standalone-toolchain.sh
 
PLATFORM=android-9
 
INSTALLDIR=$NDK/.standalone/$PLATFORM-toolchain
 
chmod +x $MAKETOOLCHAIN
 
$MAKETOOLCHAIN --platform=$PLATFORM --install-dir=$INSTALLDIR

Sobre el script “creando-toolchain.sh”

• $MAKETOOLCHAIN es la dirección del script que creará el standalone-toolchain en $INSTALLDIR
• Puedes ver las plataformas disponibles en “$NDK/platforms”. Para Gingerbread API (level 9)

Eso es todo! los binarios del toolchain no dependen o contienen un path específico para el host, en otras palabras, se puede instalar en cualquier lugar, o incluso mover si es necesario. Ahora, sólo tienes que agregar la carpeta de binarios “$INSTALLDIR/bin” en tu variable de entorno $PATH:

 gedit ~/.bashrc

y escribiendo al final:

 export PATH=:~/Android/android-ndk-r5c/.standalone/android-9-toolchain/bin:$PATH

Para finalizar reinicia o cierra sesión.

Para compilar, crea el programa test.c:

#include <stdio.h>
 
int main(int argc, char** argv)
{
	printf("HOLA MUNDO\n");
	return 0;
}

y compila con:

arm-linux-androideabi-gcc -o test test.c

Esto creará el programa “test”. Para enviar y dar privilegios de ejecución al programa en tu dispositivo Android, o tu emulador, usa los siguientes comandos tomando en cuenta [1]:

adb push test /data/test
adb shell chmod 777 /data/test

Usando el programa adb tambien puedes ejecutar el programa “test” en tu dispositivo android y ver el resultado:

adb shell /data/test

Si simplemente quieres jugar con la shell de tu dispositivo android ejecuta:

adb shell

PROBLEMAS:

• Necesitas ser root!!!, no puedo esperar que todas las personas que quieran instalar mi programa(osea copiar y dar privilegios de ejecución) sean root. El problema es la instalación, una vez instalado supongo que un usuario normal podría ejecutarlo, pero el trabajo de rootearlo ya se hizo.

[1] Para que esto funcione debes tener instalado el SDK y las carpetas “$ANDROIDDIR/android-sdk-linux_x86/platform-tools” y “$ANDROIDDIR/android-sdk-linux_x86/tools” deben de estar en tu variable de entorno PATH. Para conseguirlo es necesario:

 gedit ~/.bashrc

export PATH=:~/Android/android-sdk-linux_x86/platform-tools:$PATH
export PATH=:~/Android/android-sdk-linux_x86/tools:$PATH

Para finalizar reinicia o cierra sesión.

Este post es una traducción de http://developer.android.com/sdk/ndk/overview.html

El NDK de Android es un conjunto de herramientas que permite incorporar los componentes que hacen uso de código nativo en las aplicaciones de Android.

Las aplicaciones para Android se ejecutan en la máquina virtual Dalvik. El NDK 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.

El NDK establece lo siguiente:

• Un conjunto de herramientas y archivos de construcción que se utilizan para generar bibliotecas de código nativo de fuentes en C y C + +.
• Una manera de integrar las correspondientes bibliotecas nativas en un archivo de paquete de aplicaciones (. Apk) que se pueden implementar en los dispositivos Android.
• Un conjunto de cabeceras y bibliotecas nativas del sistema  que estarán soportadas en todas las futuras versiones de la plataforma Android, a partir de Android 1.5. Las aplicaciones que utilizan actividades nativas deben de ejecutarse sobre Android 2.3 o posterior.
• Documentación, ejemplos y tutoriales.

La última versión de la NDK soporta estos conjuntos de instrucciones ARM:

• ARMv5TE (incluyendo instrucciones Thumb-1 )
• ARMv7-A (incluyendo instrucciones Thumb-2 y  VFPv3-D16, con soporte opcional para instrucciones NEON/VFPv3-D32 )

Las futuras versiones de la NDK también prestarán apoyo a:

• Instrucciones x86 (ver CPU-ARCH-ABIS.HTML para más información)

El código máquina ARMv5TE  funcionará en todos los dispositivos  ARM-Based de Android. ARMv7-A sólo se ejecutarán en los dispositivos tales como el Droid de Verizon o Google Nexus One que tengan una CPU compatible. La principal diferencia entre los dos conjuntos de instrucciones es que ARMv7-A soporta instrucciones hardware FPU, Thumb-2, y  NEON. Usted puede apuntar (Target) a uno o ambos conjuntos de instrucciones – ARMv5TE es el valor predeterminado, pero cambiar a ARMv7-A es tan fácil como añadir una línea al archivo de aplicación Application.mk , sin necesidad de cambiar nada mas en el archivo. También se puede construir para ambas arquitecturas al mismo tiempo y tenerlo todo almacenado en el *.Apk final. Toda la información se encontrará en el archivo CPU-ARCH-ABIS.HTML del paquete NDK.

El NDK proporciona las cabeceras estables para libc (la biblioteca de C), libm (la biblioteca matemática), OpenGL ES (3D Graphics Library), la interfaz JNI, y otras bibliotecas, como se indica en la sección de herramientas de desarrollo.