A Beagleboard mostra realmente sua força quando o assunto é desenvolvimento open source.

No meu post introdutório sobre o kit, citei a existência de (até então) 210 projetos desenvolvidos pela comunidade (http://beagleboard.org/project).

Só de portes do Android existem sete: 0xdroid, Android Mini Computer, Android SDIO WIFI, Beagledroid, Android On Beagle, OMAPZoom Android e Android on OMAP3.

O último, também chamado de RowBoat, me parece ser um dos mais atualizados – acabaram de lançar o porte do Android 2.3 (Gingerbread). É este projeto que usaremos para testar o Android na Beagleboard.

ROWBOAT

A página do projeto pode ser acessada em http://arowboat.org. O que o Rowboat faz é prover um porte estável do Android para a plataforma OMAP35xx da TI, aproveitando-se das capacidades de hardware deste SOC como o DSP e o acelerador gráfico 2D/3D.

Ele trás tudo o que é necessário para compilar e gerar uma imagem do kernel e do rootfs do sistema operacional Android: toolchain, bootloader, um porte do kernel, sistema de arquivos pré-configurado e Android apps (*.apk).

Gerar uma imagem é bem fácil. Todos os detalhes do processo você pode encontrar aqui. Só vai te exigir um ambiente bem configurado e pouco de paciência.

PREPARANDO O AMBIENTE DE DESEVOLVIMENTO

A página do Android em http://source.android.com/source/initializing.html explica a configuração necessária para o ambiente de desenvolvimento. Vou detalhar o que fiz na minha máquina, mas dependendo do seu host, pode ser que precise instalar alguma outra aplicação que não citei aqui. Dê uma olhada no link acima caso encontre algum problema.

Primeiro, instale as aplicaçõ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 Development Kit). Se sua máquina host estiver atualizada, poderá estar com o JDK 1.6. Com os comandos acima, instalamos o JDK 1.5, mas você precisa se certificar de que ele estará no seu PATH antes de iniciar a compilação. O comando abaixo deverá dizer se você esta com a versão correta 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 é instalar o script “repo“, uma ferramenta do Google para gerenciar 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 apenas de que “/usr/local/bin” esteja no PATH.

COMPILANDO

Faremos nossos 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 compilando o Froyo e vai tomar um iogurte congelado. Froyo = frozen yogurt para os mais desavisados :)

O processo pode demorar algumas horas. Quando terminar, a imagem do kernel (uImage) estará disponível em:

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

O rootfs precisará ser preparado com os comandos 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

Instalaremos e executaremos o Android do cartão SD (no mínimo 256MB). Vamos criar duas partições. A primeira para o kernel, com 32MB e formatada com FAT32. A segunda para o rootfs, com o restante do espaço disponível e formatada com EXT3. Usei o gparted para esta tarefa. A formatação do cartão SD ficou conforme imagem abaixo:

Execute os comandos abaixo para copiar o kernel para o cartão SD (troque o “/dev/sde1” pelo arquivo de dispositivo da primeira partiçã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

Execute os comandos abaixo para copiar o rootfs para o cartão SD (troque o “/dev/sde2” pelo arquivo de dispositivo da segunda partiçã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 configurar o U-Boot da Beagleboard para iniciar o Android pelo cartão SD. Execute os comandos 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 minutos). Depois você terá uma imagem funcional e poderá se divertir com o Android na sua Beagleboard!

De agora em diante, estudaremos a arquitetura do Android, que de um sistema Linux, só tem o kernel mesmo. O resto é tudo diferente. Você sabia que ele não usa o System V IPC como mecanismo de comunicação entre processos, e sim um modulo do kernel chamado “binder“? Ou então que ele usa uma tal de “Bionic” como biblioteca C padrão ao invés das convencionais uclibc ou glibc? Ou que ele implementa o Toolbox ao invés de usar o Busybox? Ou ainda que um tal de Zygote é o pai de todos os processos?

Curioso, não? Então continue acompanhando!

Um abraço,

Sergio Prado