De modo a não reinventar a roda, usei muita da informação que está no site da google http://source.android.com/source/. Tem sido bastante actualizado nos últimos tempos e o setup que usei é o que eles recomendam (com algumas alterações, como vão depois poder constatar).
Para este setup, vou usar um Galaxy Nexus (disponibilizado pelo meu amigo Ricardo (smile) thanks man ) e um netbook asus eeePC como dispositivos de instalação. O eeePC é propriedade pessoal e é um dos dispositivo que uso no meu laboratório (smile).
Ambos os procedimentos (Nexus e Asus) podem ser usados em outros dispositivos, com alterações (necessária alguma investigação. No pain no gain...).
Galaxy Nexus
Ambiente para
construção da ROM:
Ubuntu
Server 11.04 AMD64 (*) (64-bits... quem
não tem, não vale a pena continuar a ler J)
Instalado
numa VM ProxMox (vantagem de ser Open Source ao contrário de um VMWARE...):
1.
Virtualização
total (KVM)
2.
2
CPU sockets, 1 core / socket
3.
4GiB
memoria
4.
160GB
disk SCSI
5.
2 placas de rede, 1 VLAN interna, 1 VLAN internet (router externo com NAT)
6.
CD-ROM
a apontar para ISO para instalação
7.
Setup
OS
Ubuntu
instalado
1.
Criação
de utilizador "android" com acesso sudo
a.
Login
SSH com chave pública
2.
Conectividade
Internet
3.
sudo
apt-get update
4.
sudo
apt-get upgrade
5.
sudo
/sbin/reboot
6.
uname
-a
a.
Na
minha instalação aparece "Linux linux-android-64bit 2.6.38-8-server
#42-Ubuntu SMP Mon Apr 11 03:49:04 UTC 2011 x86_64 x86_64 x86_64
GNU/Linux"
Ferramentas de
compilação
1.
sudo
apt-get install gcc g++ gcc-multilib g++-multilib
2.
gcc
--version
a.
gcc
(Ubuntu/Linaro 4.5.2-8ubuntu4) 4.5.2
3.
g++
--version
a.
g++
(Ubuntu/Linaro 4.5.2-8ubuntu4) 4.5.2
4. perl --version
a. Nota: Com perl, v5.10.1 (*) built for x86_64-linux-gnu-thread-multi
Ferramentas para build Android + Ambiente
1. Usar o comando de "Installing required packages" em
http://source.android.com/source/initializing.html
·
sudo apt-get install
git-core gnupg flex bison gperf build-essential zip curl zlib1g-dev libc6-dev
lib32ncurses5-dev ia32-libs x11proto-core-dev libx11-dev lib32readline5-dev
lib32z-dev libgl1-mesa-dev g++-multilib mingw32 tofrodos python-markdown
libxml2-utils
2.
mkdir
~/bin
3.
PATH=~/bin:$PATH
·
Se
quiserem podem colocar isto no vosso ~/.bashrc ou em qualquer outro script de
arranque
4. curl https://dl-ssl.google.com/dl/googlesource/git-repo/repo >
~/bin/repo
5. chmod a+x ~/bin/repo
6. sudo apt-get install default-jdk
7. python --version
·
Python 2.7.1+
Source Android
1. mkdir ~/ANDROID_WORKING_DIRECTORY
2. cd ~/ANDROID_WORKING_DIRECTORY
3. repo init -u https://android.googlesource.com/platform/manifest
·
Não
se esqueçam de marcar o path:
·
Para
um branch diferente: repo init –u https://android.googlesource.com/platform/manifest
-b android-2.3.7_r1
4. repo sync
·
"The initial
sync operation will take an hour or more to complete" when pulling down
master
Compilação
1. cd ~/ANDROID_WORKING_DIRECTORY
2. source build/envsetup.sh
3. lunch full-eng
o
Para build de um emulador rom, consultem o site Android source
4. make -j8
Execução em cima de um emulador genérico (para o Nexus vejam próxima secção)
1. make -j8 sdk
2.
Copiar system.img, ramdisk.img, and userdata.img
files em ~/ANDROID_WORKING_DIRECTORY/out/target/product/generic to a machine
with a GUI and the Android SDK installed
3. Na máquina com o Android
SDK, executar o emulador com
o
android-sdk-windows\tools\emulator
-system system.img -ramdisk ramdisk.img -data userdata.img
o
Actualizar os paths respectivos
4. Opcionalmente se a
máquina que estiverem a construir tiver um GUI podem sempre executar “emulator"
e por defeito ele car carregar as últimas builds
Construção da ROM
1. Preparação do ambiente
sudo -i
depois
metam a password. A partir daqui todos os comandos vão ter previlégios de root
(já não temos de estar constantemente a fazer sudo “superuser do” antes de
fazermos o que quer que seja.
Depois
temos de adicionar um repositório, de modo a que o apt-get saiba onde encontrar
o java sdk:
add-apt-repository
"deb http://archive.canonical.com/ lucid partner"
Depois
disso é necessário actualizar o repositório com o seguinte comando:
apt-get update
Agora
que o repositório foi actualizado, podemos continuar a instalação dos pacotes necessaries
de modo a contruir o build. A primeira
coisa que vamos necessitar é o Java Development kit 6:
apt-get install sun-java6-jdk
Seguido
de (isto pode já estar instalado, dependendo da versão do ubuntu instalada):
apt-get install python
Agora vamos precisar do Git (para quem não sabe Git é o sistema de controlo de versionamentos):
apt-get install git-core
Agora vamos precisar de sacar todos os pacotes de que necessitamos para
o processo de build da ROM. Lembram-se da boca que forneci logo no setup (*) a
dizer que este procedimento é apenas para máquinas de 64-bits??? Porquê? Bom,
alguns dos comandos abaixo não funcionam em 32-bits...Pois é… Quem não tem, tem
de gastar uns cobres e comprar um bicho um pouco melhorzito:
apt-get
install git-core gnupg flex bison gperf build-essential zip curl
zlib1g-dev libc6-dev lib32ncurses5-dev ia32-libs x11proto-core-dev libx11-dev
lib32readline5-dev lib32z-dev libgl1-mesa-dev g++-multilib mingw32 tofrodos
python-markdown libxml2-utils
Se
estiverem a usar o Ubuntu 11.10, metam este comando (não me perguntem porquê… Esquisitices
desta versão do Ubuntu…é para isso que serve a investigação (smile)
ln -s
/usr/lib/i386-linux-gnu/libX11.so.6 /usr/lib/i386-linux-gnu/libX11.so
Parabéns! Têm neste momento todos os paoctes necessários para
prosseguirem.
2. Configuração do USB
Este passo não é estrtitamente necessário
para o Galaxy Nexus, mas diz-me a experiência que vale a pena executá-lo...
Acreditem... e é muito simples. Basta configurar o ubuntu com adb em todos os
dispositivos android:
gksudo gedit /etc/udev/rules.d/51-android.rules
Isto vai abrir um ficheiro de texto vazio. Inserir o seguinte texto:
#Acer
SUBSYSTEM==usb, SYSFS{idVendor}==0502, MODE=0666
#ASUS
SUBSYSTEM==usb, SYSFS{idVendor}==0b05, MODE=0666
#Dell
SUBSYSTEM==usb, SYSFS{idVendor}==413c, MODE=0666
#Foxconn
SUBSYSTEM==usb, SYSFS{idVendor}==0489, MODE=0666
#Garmin-Asus
SUBSYSTEM==usb, SYSFS{idVendor}==091E, MODE=0666
#Google
SUBSYSTEM==usb, SYSFS{idVendor}==18d1, MODE=0666
#HTC
SUBSYSTEM=="usb", SYSFS{idVendor}=="0bb4", MODE=0666
#Huawei
SUBSYSTEM==usb, SYSFS{idVendor}==12d1, MODE=0666
#K-Touch
SUBSYSTEM==usb, SYSFS{idVendor}==24e3, MODE=0666
#KT Tech
SUBSYSTEM==usb, SYSFS{idVendor}==2116, MODE=0666
#Kyocera
SUBSYSTEM==usb, SYSFS{idVendor}==0482, MODE=0666
#Lenevo
SUBSYSTEM==usb, SYSFS{idVendor}==17EF, MODE=0666
#LG
SUBSYSTEM==usb, SYSFS{idVendor}==1004, MODE=0666
#Motorola
SUBSYSTEM==usb, SYSFS{idVendor}==22b8, MODE=0666
#NEC
SUBSYSTEM==usb, SYSFS{idVendor}==0409, MODE=0666
#Nook
SUBSYSTEM==usb, SYSFS{idVendor}==2080, MODE=0666
#Nvidia
SUBSYSTEM==usb,
SYSFS{idVendor}==0955, MODE=0666
#OTGV
SUBSYSTEM==usb, SYSFS{idVendor}==2257, MODE=0666
#Pantech
SUBSYSTEM==usb, SYSFS{idVendor}==10A9, MODE=0666
#Philips
SUBSYSTEM==usb, SYSFS{idVendor}==0471, MODE=0666
#PMC-Sierra
SUBSYSTEM==usb,
SYSFS{idVendor}==04da, MODE=0666
#Qualcomm
SUBSYSTEM==usb,
SYSFS{idVendor}==05c6, MODE=0666
#SK
Telesys
SUBSYSTEM==usb,
SYSFS{idVendor}==1f53, MODE=0666
#Samsung
SUBSYSTEM==usb, SYSFS{idVendor}==04e8, MODE=0666
#Sharp
SUBSYSTEM==usb, SYSFS{idVendor}==04dd, MODE=0666
#Sony Ericsson
SUBSYSTEM==usb, SYSFS{idVendor}==0fce, MODE=0666
#Toshiba
SUBSYSTEM==usb, SYSFS{idVendor}==0930, MODE=0666
#ZTE
SUBSYSTEM==usb, SYSFS{idVendor}==19D2, MODE=0666
Gravar o ficheiro e executar o seguinte comando para marcar as permissões:
chmod a+r
/etc/udev/rules.d/51-android.rules
3. Instalação e inicialização do repo (o Git só não
chega, infelizmente...)
Fazer download do repo, adicioná-lo à nossa path e marcar permissões. Aprendi à minha custa que se fecharmos o terminal com root, temos de repetir este bocado todo... Digitem cada comando numa linha separada (comando+enter, comando+enter, ...) :
mkdir ~/bin
PATH=~/bin:$PATH
curl
https://dl-ssl.google.com/dl/googlesource/git-repo/repo > ~/bin/repo
chmod
a+x ~/bin/repo
Agora necessitamos de criar uma
directoria onde va,mos colocar o código –fonte:
mkdir ICS_SOURCE
cd
ICS_SOURCE
Depois inicializamos o repo: primeiro inicializamos um branch específico
e depois o master:
USEM APENAS UM DESTES COMANDOS (IMPORTANTE!):
repo init -u
https://android.googlesource.com/platform/manifest -b android-4.0.4_r1
Ou:
repo init -u
https://android.googlesource.com/platform/manifest
Vão receber uma notificação para meterem nome e email. Metam dados
reais. Podemos depois usar o gerrit se o email for uma conta gmail.
4. Download do código-fonte
(sync)
Eu tenho uma conexão a 100Mb (down)/10Mb (up). Para quem tem ligações DSL, o tempo de download é maior...:)
repo sync
5. Obtenção dos drivers
Para quem não sabe, fica a saber.
No ICS, o android não pode ser
unicamemte compilado via código-fonte...Necessita de livrarias hardware-dependent
para ser executado (por exemplo, drivers para a componente gráfica, GSM/LTE,
etc).
Estes drivers podem
ser obtidos através do site do nexus:
https://developers.google.com/android/nexus/drivers
Cada conjunto
de drivers (ficheiros binários) vêm num ficheiro zipado. Depois de extrairmos
cada ficheiro, correr o script localizado na root de cada árvore, confirmar que
concordamos com os termos da licença e os drivers e os respectivos ficheiros de
make serão instalados na directoria do fabricante. Por exemplo, depois de
extraimos um dos ficheiros, ficamos com um 'extract-imgtech-maguro.sh'. Para
quem é do mundo Unix sabe que basta executar agora este shell script:
sh extract-imgtech-maguro.sh
NOTA IMPORTANTE: Se tivermos um Nexus S (para a malta com cheta…), necessitamos dos drivers respectivos.
6. Compilação do código-fonte (a ROM está “já ali”…)
Para quem é programador Java, pode agora brincar um pouco e fazer algumas alterações. Não aconselho aos fracos de coração… Se introduzirmos trampa no código, a compilação vai falhar e ai é necessário começar tudo de novo...:(
Para quem quiser passar já para a compilação, fechamos o ambiente através do seguinte comando:
source build/envsetup.sh
Executar o comando:
lunch
Vão aparecer uma série de opções. Se estivermos com o Nexus (codename: maguro),
digitar:
8
(7 para Nexus S and 6 para Nexus S 4G)
e enter.
Agora temos duas opções:
(1) output da ROM como ficheiro img;
(2) ROM como ficheiro zip (flashada)
Recomendo o segundo, principalmente se quisermos usar o CWM para flashar a ROM
make -j1
ou
make -j1 otapackage
Parabéns aos que chegaram a este ponto! Agora é esperar... Daqui a algum tempo, vão ter
uma ROM para meterem no Nexus! Quando a ROM estiver construída, passar ao passo seguinte.
Instalação
da ROM
Trivial. Procedimento no
seguinte link:
ROM eeePC
Ambiente para
construção da ROM:
Não é necessário. Vide ponto seguinte.
Construção da ROM
Já
existe uma ROM muito boa no seguinte site:
Fazer
download da imagem iso “android-x86-2.2-r2-eeepc.iso”.
Para
quem não for temerário, o procedimento de construção do ISO encontra-se em:
Como
podem notar, o processo é bastante mais simples do que o processo de construção
para o Nexus acima. Os comandos base são so mesmos (“lunch”, etc, mas existem algumas
especificidades de HW e afins do Nexus, que implicam que o processo deste
último seja mais envolvente.
Instalação
da ROM
Seguir o procedimento no
post que publiquei a 15 de Janeiro de 2011 neste mesmo blog: http://manuelaantao.blogspot.pt/2011/01/instalacao-do-os-android-numa.html
Digam lá que não fica bonito um netbook com o ICS 4.0.4:
Só não faz chamadas telefónicas, mas em contrapartida temos um netbook com quase 4Gb de disco de espaço útil para ser usado na instalação de aplicações do Google Play (não se esqueçam de que este versão do eeePC só vem com 4 Gb de disco de fábrica...Como o eeePC vem com slot para sdcard, estamos bem...
Dúvidas, questões, ask away...
Happy hacking.
