Compilando e executando o Android na Beagleboard

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!

Fonte: Sergio Prado

Participe do nosso grupo no Facebook e fique sabendo
de todas as noticias e lançamentos para o seu Android!

Curta nossa página no Facebook e fique ligado em todos os nossos Post!