A Bea­gle­board mostra real­mente sua força quando o assunto é desen­volvi­mento open source.

No meu post intro­dutório sobre o kit, citei a existên­cia de (até então) 210 pro­je­tos desen­volvi­dos pela comu­nidade (http://beagleboard.org/project).

Só de portes do Android exis­tem sete: 0xdroid, Android Mini Com­puter, Android SDIO WIFI, Bea­gle­droid, Android On Bea­gle, OMAP­Zoom Android e Android on OMAP3.

O último, tam­bém chamado de Row­Boat, me parece ser um dos mais atu­al­iza­dos — acabaram de lançar o porte do Android 2.3 (Gin­ger­bread). É este pro­jeto que usare­mos para tes­tar o Android na Bea­gle­board.

ROWBOAT

A página do pro­jeto pode ser aces­sada em http://arowboat.org. O que o Row­boat faz é prover um porte estável do Android para a plataforma OMAP35xx da TI, aproveitando-se das capaci­dades de hard­ware deste SOC como o DSP e o acel­er­ador grá­fico 2D/3D.

Ele trás tudo o que é necessário para com­pi­lar e gerar uma imagem do ker­nel e do rootfs do sis­tema opera­cional Android: tool­chain, boot­loader, um porte do ker­nel, sis­tema de arquivos pré-configurado e Android apps (*.apk).

Gerar uma imagem é bem fácil. Todos os detal­hes do processo você pode encon­trar aqui. Só vai te exi­gir um ambi­ente bem con­fig­u­rado e pouco de paciên­cia.

PREPARANDO O AMBIENTE DE DESEVOLVIMENTO

A página do Android em http://source.android.com/source/initializing.html explica a con­fig­u­ração necessária para o ambi­ente de desen­volvi­mento. Vou detal­har o que fiz na minha máquina, mas depen­dendo do seu host, pode ser que pre­cise insta­lar alguma outra apli­cação que não citei aqui. Dê uma olhada no link acima caso encon­tre algum problema.

Primeiro, instale as apli­cações necessárias para o processo de build:

$ sudo add-apt-repository "deb http://archive.ubuntu.com/ubuntu dapper main multiverse"
$ sudo add-apt-repository "deb http://archive.ubuntu.com/ubuntu dapper-updates main multiverse"
$ sudo apt-get update
$ sudo apt-get install sun-java5-jdk
$ sudo apt-get install git-core gnupg flex bison gperf build-essential zip curl
$ sudo apt-get install zlib1g-dev libc6-dev libncurses5-dev x11proto-core-dev libx11-dev libreadline5-dev libz-dev libgl1-mesa-dev
$ sudo apt-get install git-core gnupg sun-java5-jdk flex bison gperf libsdl-dev libesd0-dev
$ sudo apt-get install libwxgtk2.6-dev build-essential zip curl libncurses5-dev zlib1g-dev minicom tftpd uboot-mkimage
$ sudo apt-get install expect kpartx

Um detalhe aqui é o uso do JDK 1.5 (Java Devel­op­ment Kit). Se sua máquina host estiver atu­al­izada, poderá estar com o JDK 1.6. Com os coman­dos acima, insta­lamos o JDK 1.5, mas você pre­cisa se cer­ti­ficar de que ele estará no seu PATH antes de ini­ciar a com­pi­lação. O comando abaixo dev­erá dizer se você esta com a ver­são cor­reta do Java:

$ java -version
java version "1.5.0_22"
Java(TM) 2 Runtime Environment, Standard Edition (build 1.5.0_22-b03)
Java HotSpot(TM) Server VM (build 1.5.0_22-b03, mixed mode)

O último passo é insta­lar o script “repo”, uma fer­ra­menta do Google para geren­ciar repositórios Git do Android:

$ curl https://android.git.kernel.org/repo >./repo
$ chmod a+x ./repo
$ sudo mv ./repo /usr/local/bin

Certifique-se ape­nas de que “/usr/local/bin” esteja no PATH.

COMPILANDO

Fare­mos nos­sos testes com o Android 2.2 (Froyo). O primeiro passo é baixar o repositório do RowBoat:

$ mkdir rowboat-android
$ cd rowboat-android
$ repo init -u git://gitorious.org/rowboat/manifest.git -m rowboat-froyo.xml
$ repo sync

E depois compilar:

$ make TARGET_PRODUCT=beagleboard

Agora aproveite que você esta com­pi­lando o Froyo e vai tomar um iogurte con­ge­lado. Froyo = frozen yogurt para os mais desavisados :)

O processo pode demorar algu­mas horas. Quando ter­mi­nar, a imagem do ker­nel (uIm­age) estará disponível em:

$ ls kernel/arch/arm/boot/
bootp  compressed  Image  install.sh  Makefile  uImage  zImage

O rootfs pre­cis­ará ser preparado com os coman­dos abaixo:

$ cd out/target/product/beagleboard
$ mkdir android_rootfs
$ cp -r root/* android_rootfs
$ cp -r system android_rootfs
$ sudo ../../../../build/tools/mktarball.sh ../../../host/linux-x86/bin/fs_get_stats android_rootfs . rootfs rootfs.tar.bz2
$ cd -

INSTALANDO

Insta­lare­mos e exe­cutare­mos o Android do cartão SD (no mín­imo 256MB). Vamos criar duas par­tições. A primeira para o ker­nel, com 32MB e for­matada com FAT32. A segunda para o rootfs, com o restante do espaço disponível e for­matada com EXT3. Usei o gparted para esta tarefa. A for­matação do cartão SD ficou con­forme imagem abaixo:

Exe­cute os coman­dos abaixo para copiar o ker­nel para o cartão SD (troque o “/dev/sde1″ pelo arquivo de dis­pos­i­tivo da primeira par­tição do cartão SD):

$ sudo mkdir -p /mnt/kernel
$ sudo mount /dev/sde1 /mnt/kernel
$ sudo cp kernel/arch/arm/boot/uImage /mnt/kernel
$ sync
$ sudo umount /mnt/kernel

Exe­cute os coman­dos abaixo para copiar o rootfs para o cartão SD (troque o “/dev/sde2″ pelo arquivo de dis­pos­i­tivo da segunda par­tição do cartão SD):

$ sudo mkdir -p /mnt/rootfs
$ sudo mount /dev/sde2 /mnt/rootfs
$ sudo tar jxfv out/target/product/beagleboard/rootfs.tar.bz2 --numeric-owner -C /mnt/rootfs
$ sync
$ sudo umount /mnt/rootfs

TESTANDO

Agora só falta con­fig­u­rar o U-Boot da Bea­gle­board para ini­ciar o Android pelo cartão SD. Exe­cute os coman­dos abaixo no prompt do U-Boot:

# setenv bootcmd 'mmc init; fatload mmc 0 84000000 uImage; bootm 84000000'
# setenv bootargs 'mem=256M androidboot.console=ttyS2 console=tty0 console=ttyS2,115200n8 root=/dev/mmcblk0p2 rw init=/init rootwait omapfb.video_mode=640x480MR-16@60'
# saveenv
# reset

O primeiro boot pode demorar um pouco (1 a 2 min­u­tos). Depois você terá uma imagem fun­cional e poderá se diver­tir com o Android na sua Beagleboard!

De agora em diante, estu­dare­mos a arquite­tura do Android, que de um sis­tema Linux, só tem o ker­nel mesmo. O resto é tudo difer­ente. Você sabia que ele não usa o Sys­tem V IPC como mecan­ismo de comu­ni­cação entre proces­sos, e sim um mod­ulo do ker­nel chamado “binder”? Ou então que ele usa uma tal de “Bionic” como bib­lioteca C padrão ao invés das con­ven­cionais uclibc ou glibc? Ou que ele imple­menta o Tool­box ao invés de usar o Busy­box? Ou ainda que um tal de Zygote é o pai de todos os proces­sos?

Curioso, não? Então con­tinue acom­pan­hando!

Um abraço,

Ser­gio Prado

Posts rela­ciona­dos:

1. Bea­gle­Board — O cachor­rinho open-source
2. Mini2440 — Insta­lando o Android
3. Wind River apo­s­tando na plataforma Android