Essendo un programmatore C (uso anche altri linguaggi, ma il C e quello che uso più spesso) sono spinto a volerlo usare dapperutto! :)

Nello scorso articolo su Android vi ho fatto vedere come si installava l'SDK e, tramite questo, come si installava un pacchetto APK sull'emulatore; ma quello era un programma scritto in Java, invece e bene sapere che con l'emulatore di Android è possibile fare ben di più, è infatti possibile  provare dei programmi scritti in C!

Purtroppo, come già detto, l'SDK di Android non ci aiuta in questo, infatti il linguaggio nativo di Android è Java e l'SDK è tutto incentrato su di esso. Esiste però un modo per compilare programmi in C, anche se non del tutto banale ed immediato...

Vediamo come.

I tool di sviluppo

Innanzi tutto occorre aver installato l'SDK come ho mostrato l'altra volta. Poi occorre che vi installiate il JDK di Java versione 5 e quindi scarichiate tutti i sorgenti di Android...

Ma andiamo con ordine, prima i sorgenti di Android: su questo sito trovate tutte il informazioni al riguardo, ma le riporto qui passo passo con la spiegazione.

Iniziamo con lo scaricare un tool per la gvestione dei sorgenti dei progetti di Android. Il tool si chiama repo ed è basato su Git:

$ cd ~/bin/
$ curl http://android.git.kernel.org/repo > repo
$ chmod a+x repo

Da notare che io ho una directory ad hoc (~/bin) nella mia home per gli script privati.

Poi creiamoci l'albero dei sorgenti di Android e riempiamolo con repo:

$ cd android
$ mkdir sources && cd sources/
$ mkdir platform && cd platform/
$ repo init -u git://android.git.kernel.org/platform/manifest.git
Getting repo ...
from git://android.git.kernel.org/tools/repo.git
remote: Counting objects: 1087, done.
remote: Compressing objects: 100% (483/483), done.
remote: Total 1087 (delta 684), reused 950 (delta 583)
Receiving objects: 100% (1087/1087), 309.31 KiB | 267 KiB/s, done.
Resolving deltas: 100% (684/684), done.
From git://android.git.kernel.org/tools/repo
* [new branch]      maint      -> origin/maint
* [new branch]      master     -> origin/master
* [new branch]      stable     -> origin/stable
* [new tag]         v1.6.10.2  -> v1.6.10.2
From git://android.git.kernel.org/tools/repo
* [new tag]         v1.0       -> v1.0
* [new tag]         v1.0.1     -> v1.0.1
* [new tag]         v1.0.2     -> v1.0.2
...

Una volta finito repo vi chiederà un po' di informazioni che saranno utilizzate se decidete di contribuire al progetto. Inseritele correttamente, non si sa mai...

In fine sincronizziamo i nostri repository con quelli di Android:

$ repo sync

Questa fase durerà per un bel po', vi conviene fare una pausa e prendere un caffè! :)

Scaricati i sorgenti di Android passiamo all'JDK. Andate sul sito del JDK di Java ed eseguite la procedura per scaricare quello contenuto nel file jdk-1_5_0_22-linux-i586.bin. Poi eseguitelo ed installate il tool:

$ cd /opt
$ chmod +x jdk-1_5_0_22-linux-i586.bin
$ ./jdk-1_5_0_22-linux-i586.bin

Una volta finito i file dovrebbero essere nella directory /opt/jdk1.5.0_22.

Bene, ci siamo, ora esportiamo un po' di variabili d'ambiente per semplificarci la vita coi comandi che dovremo dare da ora in poi:

$ JAVA_HOME=/opt/jdk1.5.0_22
$ export PATH=$JAVA_HOME/bin:$PATH

Poi impostiamo la variabile ANDROID_BUILD_TOP in modo che punti alla directory dove sono i sorgenti di Android ed inizializziamo l'ambiente per la compilazione:

$ export ANDROID_BUILD_TOP=~/android/sources/platform
$ cd $ANDROID_BUILD_TOP
$ source build/envsetup.sh
WARNING: Only bash is supported, use of other shell would lead to erroneous results
including device/htc/dream/vendorsetup.sh
including device/htc/passion/vendorsetup.sh
including device/htc/sapphire/vendorsetup.sh

Se tutto è andato bene provate a dare il comando help, dovreste ottenere:

$ help
Invoke ". build/envsetup.sh" from your shell to add the following functions to your environment:
- croot:   Changes directory to the top of the tree.
- m:       Makes from the top of the tree.
- mm:      Builds all of the modules in the current directory.
- mmm:     Builds all of the modules in the supplied directories.
- cgrep:   Greps on all local C/C++ files.
- jgrep:   Greps on all local Java files.
- resgrep: Greps on all local res/*.xml files.
- godir:   Go to the directory containing a file.

Look at the source to view more functions. The complete list is:
add_lunch_combo cgrep check_product check_variant choosecombo chooseproduct choosetype choosevariant cproj croot findmakefile gdbclient get_abs_build_var get_build_var getbugreports getprebuilt gettop godir help isviewserverstarted jgrep lunch m mm mmm pid print_lunch_menu printconfig resgrep runhat runtest set_java_home set_sequence_number set_stuff_for_environment setpaths settitle smoketest startviewserver stopviewserver systemstack tapas tracedmdump

Ora dobbiamo iniziare a compilare i sorgenti di Android in modo tale che lui si crei tutti i tool che ci serviranno dopo per la cross compilazione dei programmi C che andremo a scrivere. Usiamo il comando choosecombo per impostare i parametri di compilazione:

$ choosecombo
Build for the simulator or the device?
1. Device
2. Simulator

Which would you like? [1] 1


Build type choices are:
1. release
2. debug

Which would you like? [1] 1


Which product would you like? [generic]


Variant choices are:
1. user
2. userdebug
3. eng
Which would you like? [eng] eng

============================================
PLATFORM_VERSION_CODENAME=AOSP
PLATFORM_VERSION=AOSP
TARGET_PRODUCT=generic
TARGET_BUILD_VARIANT=eng
TARGET_SIMULATOR=false
TARGET_BUILD_TYPE=release
TARGET_BUILD_APPS=
TARGET_ARCH=arm
HOST_ARCH=x86
HOST_OS=linux
HOST_BUILD_TYPE=release
BUILD_ID=OPENMASTER
============================================

Quindi diamo il mitico comando:

$ make

ed aspettiamo pazientemente che finisca...

Il programma C

Una volta che make finisce siamo pronti per compilare il nostro primo programma C su Android! Basta aggiungere una nuova directory come segue:

$ mkdir external/hello && cd external/hello

e metterci il nostro programma C; ecco il contenuto del file hello.c:

$ cat hello.c
#include

int main(int argc, char** argv) {
        char name[80];

        printf("insert your name: ");
        fflush(stdout);
        scanf("%s", name);

        printf("hello %s!\n", name);

        return 0;
}

Poi dobbiamo aggiungere il file Android.mk per definire i comandi di compilazione. Il file è fatto così:

$ cat Android.mk
LOCAL_PATH := $(call my-dir)

include $(CLEAR_VARS)

LOCAL_MODULE    := hello
LOCAL_SRC_FILES := hello.c

include $(BUILD_EXECUTABLE)

Il file si legge da solo: la variabile LOCAL_MODULE definisce il nome del programma da generare mentre LOCAL_SRC_FILES definisce i file sorgente.

Finito.

Ora torniamo nella directory precedente e lanciamo la compilazione con il comando mmm:

$ cd -
/home/giometti/android/sources/platform
$ mmm external/hello/
============================================
PLATFORM_VERSION_CODENAME=AOSP
PLATFORM_VERSION=AOSP
TARGET_PRODUCT=generic
TARGET_BUILD_VARIANT=eng
TARGET_SIMULATOR=false
TARGET_BUILD_TYPE=release
TARGET_BUILD_APPS=
TARGET_ARCH=arm
HOST_ARCH=x86
HOST_OS=linux
HOST_BUILD_TYPE=release
BUILD_ID=OPENMASTER
============================================
make: Entering directory `/home/giometti/android/sources/platform'
target thumb C: hello <= external/hello/hello.c
target Executable: hello (out/target/product/generic/obj/EXECUTABLES/hello_intermediates/LINKED/hello)
target Non-prelinked: hello (out/target/product/generic/symbols/system/bin/hello)
target Strip: hello (out/target/product/generic/obj/EXECUTABLES/hello_intermediates/hello)
Install: out/target/product/generic/system/bin/hello
make: Leaving directory `/home/giometti/android/sources/platform'

Se controlliamo il file out/target/product/generic/system/bin/hello vediamo che, effettivamente, questo è per il simulatore e non per il PC che ha architettura x86:

$ file out/target/product/generic/system/bin/hello
out/target/product/generic/system/bin/hello: ELF 32-bit LSB executable, ARM, version 1 (SYSV), dynamically linked (uses shared libs), stripped

La prova sull'emulatore

Ora dobbiamo provare ll nostro programmino. Ancora non ho un telefono con su Android e quindi ricorro ancora una volta alll'emulatore.

Innanzi tutto dobbiamo trovare del posto libero sulla flash dove memorizzare il programma che abbiamo appena creato. Per far questo lanciamo allora l'emulatore con il telefono di prova che abbiamo creato la volta scorsa:

$ emulator -avd my_phone

quindi con l'utility adb otteniamo una shell sul nostro telefonino:

$ adb shell
#

Vediamo come è configurata la flash con i comandi mount e df:

# mount
rootfs / rootfs ro 0 0
tmpfs /dev tmpfs rw,mode=755 0 0
devpts /dev/pts devpts rw,mode=600 0 0
proc /proc proc rw 0 0
sysfs /sys sysfs rw 0 0
tmpfs /sqlite_stmt_journals tmpfs rw,size=4096k 0 0
none /dev/cpuctl cgroup rw,cpu 0 0
/dev/block/mtdblock0 /system yaffs2 ro 0 0
/dev/block/mtdblock1 /data yaffs2 rw,nosuid,nodev 0 0
/dev/block/mtdblock2 /cache yaffs2 rw,nosuid,nodev 0 0
# df
/dev: 47084K total, 0K used, 47084K available (block size 4096)
/sqlite_stmt_journals: 4096K total, 0K used, 4096K available (block size 4096)
/system: 73600K total, 73600K used, 0K available (block size 4096)
/data: 65536K total, 19328K used, 46208K available (block size 4096)
/cache: 65536K total, 1156K used, 64380K available (block size 4096)

Dall'output di questi comandi credo che la directory /data faccia proprio al caso nostro... in particolare la sottodirectory /data/local:

# cd /data/local
# ls
tmp

Creiamoci qiondi un nosto ambiente in questa directory:

# mkdir bin
# ls
bin
tmp

e quindi copiamoci il programma che abbiamo compilato prima (dobbiamo uscire dalla shell del telefonino con un CTRL+D per dare il comando seguente):

$ adb push out/target/product/generic/system/bin/hello /data/local/bin/

Rientriamo poi nel telefonino, sempre con adb, e lanciamo il programma hello:

$ adb shell
# cd /data/local/bin/
# chmod 777 hello
# ./hello
insert your name: rodolfo
hello rodolfo!