DIY: Kompilera Android ROM från källkoden

Android är det mest använda mobiloperativsystemet i världen. Och det bästa är att det är helt öppen källkod, vilket i lekmannatermer betyder att källkoden, själva programmet är öppet tillgängligt för alla att ladda ner, anpassa och bygga sina egna ROM.

Det finns massor av anpassade Android-distributioner tillgängliga där ute, med de populära är CyanogenMod, SlimROM, Paranoid Android, AOKP, Liquid Smooth, MIUI, Xylon, Ice Cold Jelly, etc.

För dagens guide kommer vi att kompilera CyanogenMod 10.2, den mest populära eftermarknads-ROM för Android. Proceduren är till 99% densamma för alla anpassade ROM-skivor där ute, så den här guiden kan användas som referens för att kompilera andra ROM-skivor också.

Förutsättningar

1. En Android-telefon med lättillgänglig kärna och enhetskälla, redan rotad och med en anpassad återställning installerad.
2. 64 bitars Linux-distribution (Vi föredrar Ubuntu).
3. Minst 100 GB ledigt på din hårddisk.
4. Kunskap om Linux Terminal Commands.
5. Rimligt snabb internetuppkoppling.

Observera: 64-bitars Linux OS är ett måste, och det måste vara en inbyggd installation, inte en virtuell maskin.

Konfigurera din byggmaskin

1. Installera ditt val av Linux OS: 64-bitars version, enligt de officiella instruktionerna. (Guiden kommer att anta att vi kör Ubuntu 13.04). Behåll en partition på minst 100 GB med 16 GB Swap-partition.

2. Installera följande lista med paket: Öppna Terminal-appen och skriv

[html]sudo apt-get install [/html]

tryck på enter så kommer du att uppmanas att ange ditt lösenord.

paketet Lista

[html]
git-core
gnupg
flex
bison
pytonorm
rar
original-awk
gawk
p7zip-full
gperf
libsdl1.2-dev
libesd0-dev
libwxgtk2.6-dev
squashfs-verktyg
build-essential
zip
curl
libncurses5-dev
zlib1g-dev
pngcrush
schemaläggningsverktyg
libc6-dev
x11proto-core-dev
libx11-dev
libg11-mesa-dev
mingw32
tofrodos
python-markdown
libxml2-utils
g++-multilib
lib32z1-dev
ia32-libs
lib32ncurses5-dev
lib32readline-gplv2-dev
gcc-multilib
g++-multilib
xsltproc
[/ html]

3. Installera Java JDK 1.6 för Linux 64-bitars: Filnamnet ska vara jdk-6u##-linux-x64.bin, ## är versionsnummer. Flytta det nedladdade paketet till din hemkatalog. Öppna Terminal-appen och kör följande uppsättning kommandon:

[html]
sudo apt-get purge openjdk-\* icedtea-\* icedtea6-\*
sudo mkdir –p /opt/java/64/
sudo cp jdk-6u##-linux-x64.bin /opt/java/64
söderut -
cd /opt/java/64
chmod a+x jdk-6u##-linux-x64.bin
./jdk-6u##-linux-x64.bin
avsluta
[/ html]

Nu måste vi lägga till JDK Path till .bashrc

[html]
sudo gedit ~ / .bashrc
[/ html]

Lägg till dessa rader i slutet av textfilen

[html]
# Java-väg
exportera JAVA_HOME=/opt/java/64/jdk1.6.0_##
export PATH=$PATH:$JAVA_HOME/bin
[/ html]

4. Installera Android SDK: Öppna Terminal App

[html]
cd ~
mkdir android && cd android
mkdir sdk
[/ html]

Ladda ner Android SDK från http://developer.android.com/sdk/index.html. Extrahera paketets innehåll till ~/android/sdk Vi måste lägga till Android SDK-sökväg till .bashrc

[html]
sudo gedit ~ / .bashrc
[/ html]

Lägg till dessa rader i slutet av textfilen:

[html]
# Android SDK-sökväg
export PATH=$PATH:~/android/sdk
export PATH=$PATH:~/android/sdk/platform-tools
export PATH=$PATH:~/android/sdk/tools
[/ html]

Installera nu Android SDK-verktyg genom att skriva

[html]
android
[/ html]

5. Konfigurera ditt github-konto och fjärrrepo: Du kan hoppa över det här steget om CyanogenMod stöder din telefon officiellt. Gå till github.com och skapa ett konto för dig själv. För den här guiden betraktar jag ditt användarnamn som "användare".

Besök 'github.com/CyanogenMod/android', tryck på Fork. Fjärrmanifestet kommer att delas och är tillgängligt i din personliga repo.

Gå nu till 'github.com/user/android'. Öppna filen default.xml, tryck på Redigera. Hitta den här raden:

[html]

[/ html]

Och ersätt detta med

[html]

[/ html]

Jag överväger att din enhets kärnkälla, enhetskälla och leverantörslibs för Android 4.3 finns på

[html]
github.com/user2/kernel_source
github.com/user2/device_source
github.com/user2/device-common_source
github.com/user2/vendor
[/ html]

Jag antar att grenen heter 'jb4.3'. Du kan hitta det exakta namnet i själva repet. Lägg sedan till dessa rader i slutet av filen och modifiera dem enligt enhetens källkod.

[html]




[/ html]

Bekräfta dina ändringar. Ditt fjärrmanifest är redo att distribueras.

6. Installera Repo Command: Öppna Terminal och skriv

[html]
cd ~
mkdir ~ / bin
curl https://dl-ssl.google.com/dl/googlesource/git-repo/repo > ~/bin/repo
chmod a+x ~/bin/repo
[/ html]

Vi måste lägga till Repo-sökväg till .bashrc

[html]
sudo gedit ~ / .bashrc
[/ html]

Lägg till denna rad i slutet av textfilen

[html]
exportera PATH = $ PATH: ~ / bin
[/ html]

7. Hämta ROM-källkoden: Öppna Terminal och skriv

[html]
mkdir ~/android/cm
cd ~/android/cm
[/ html]

Om du behöver steg 5, skriv sedan

[html]
repo init –u git://github.com/user/android.git –b cm-10.2
[/ html]

Om din enhet stöder CyanogenMod 10.2 officiellt, skriv

[html]
repo init –u git://github.com/CyanogenMod/android.git –b cm-10.2
[/ html]

Kör nu

[html]
repo sync –j16
[/ html]

Gå och ta en kaffe eller en måltid, det kommer att ta lång tid. Källkoden är långt över 10GB stor, så det kommer att ta ganska lång tid.

8. Konfigurera enhetsspecifika saker: Om din enhet officiellt stöder CyanogenMod 10.2, öppna sedan Terminal och skriv

[html]
cd ~/android/cm
. build/envsetup.sh && frukost
[/ html]

Det kommer att ta lite tid, enhetskällan är cirka 3 GB stor. Sedan måste du ha officiell CM10.2 installerad på din telefon, ansluta den till din PC i USB-felsökningsläge och köra följande kommandon:

[html]
adb rot
cd ~/android/cm/device/ / /
./extract-filer.sh
[/ html]

Om din enhet inte stöder CyanogenMod 10.2 officiellt, har du inget att göra i det här steget, källorna väntar redan på dig.

9. Ladda ner Prebuilt Stuff och ställ in Toolchain: Öppna Terminal och skriv

[html]
cd ~/android/cm/vendor/cm
sh ./get-prebuilts
[/ html]

Nu måste vi lägga till Toolchain PATH till ./bashrc

[html]
cd ~/android/cm
sudo gedit ~ / .bashrc
[/ html]

Lägg till dessa rader i slutet av textfilen

[html]
# Android Verktygskedja
export ARCH=arm
exportera CCOMPILE=$CROSS_COMPILE
export CROSS_COMPILE=arm-eabi-
export PATH=$PATH:~/android/cm/prebuilt/linux-x86/toolchain/arm-eabi-4.4.3/bin
[/ html]

10. Bygg din ROM: Så allt är okej och klart. Det är dags att bygga ROM. Öppna Terminal och skriv

[html]
cd ~/android/cm
. build/envsetup.sh
brunch
[/ html]

Dags att gå och ta en tupplur. Det kommer att ta zillioner år att bygga ROM på en vanlig dator. Tja, det var en överdrift, men på min hemdator (Core i5 2nd gen med 8GB RAM) tar det över 3 timmar att bygga från grunden. Förhoppningsvis blir det inga fel och bygget kommer att slutföras bra. Du kommer att få in utgångspaketet

[html]
~/android/cm/out/target/product/ /cm-10.2-något-INOFFICIELLT- .blixtlås
[/ html]

Det är dags att installera din nykompilerade ROM på din telefon. Ladda ner Google Apps-paketet från "www.goo.im/gapps" för lämplig Android-version. Lägg båda dessa paket i din telefon och flasha dem i återställningsläge. Voila, din egen kompilerade ROM kör nu din enhet.

Tja, så du lärde dig hur man kompilerar en ROM. Så, vad nu?

Uppdatera ditt käll-ROM

För att hämta nya källkodsuppdateringar till din lokalt nedladdade källkod, öppna Terminal och skriv

[html]
cd ~/android/cm
repo sync –j16
[/ html]

För att bygga din ROM, efter att ha uppdaterat källkoden, öppna terminalen och skriv

[html]
cd ~/android/cm
gör installationen ren
hitta ./out/ -namn 'build.prop' | xargs rm
hitta ./out/ -namn 'cm_ -target_files-eng.*.zip' | xargs rm
. build/envsetup.sh
brunch
[/ html]

Eftersom du inte bygger om från grunden, utan bygger om som det är, kommer det att ta betydligt kortare tid, bara cirka 15-30 minuter i de flesta fall. Du bör synkronisera din lokala källa varje vecka eller så, för att hålla din lokala källa fräsch.

Rengör din arbetskatalog

För att rensa din arbetskatalog helt (läs: återställ din källmapp till lagerstatus), öppna Terminal och skriv följande kommandon.

[html]
cd ~/android/cm
gör installationen ren
göra klotter
[/ html]

Tänk på att efter att ha kört dessa kommandon kommer alla dina utdata att tas bort, så nästa build kommer att ta 3-4 timmar igen, eftersom allt byggs om från grunden. Om din hårddiskpartition är liten, säg runt 100 GB, bör du rengöra din arbetskatalog ungefär en gång var fjärde build, annars kommer du få slut på hårddiskutrymme.

Snabba upp ditt bygge med CCACHE

Att bygga en ROM tar mycket tid. Men tiden kan minskas med ca 30-45% genom att använda CCACHE. CCACHE står för kompilatorcache, den cachar kompileringsutdata från dina tidigare versioner, så att den kan återanvändas i senare versioner.

Observera att CCACHE behöver mycket utrymme på din hårddisk för att cachelagra innehållet, så det rekommenderas om och endast om din hårddiskpartition är någonstans i närheten av 200 GB eller högre. För att ställa in CCACHE, öppna Terminal och skriv:

[html]
cd ~/android/cm
exportera USE_CCACHE=1
exportera CACHE_DIR=~/.ccache
prebuilts/misc/linux-x86/ccache/ccache –M 50G
[/ html]

Du kan ändra den maximala storlekstilldelningen till CCACHE från 50 GB till vad du vill, men ett minimum på cirka 30 GB bör användas för bra resultat.

Hämta bekräftelser från andra ROM

Du kan välja funktioner från andra ROMs källkod. Säg till exempel att jag vill välja funktion A, med commit-ID "12345" från arkivet "github.com/user/reporepo".

Du navigerar till paketet i din lokala källkod och kör dessa i Terminal.

[html]
cd ~/
git hämta https://github.com/user/reporepo
git cherry-pick 12345
[/ html]

Källkodslänkar för kända Android Custom ROM-distributioner

CyanogenMod – https://github.com/CyanogenMod
SlimROM – https://github.com/SlimRoms
ParanoidAndroid – https://github.com/ParanoidAndroid
AOK förlängning – https://github.com/AOKP
LiquidSmooth – https://github.com/liquidsmooth
Xylon ROM -
Iskall gelé – https://github.com/IceColdJelly

Så där går ni, en enkel, okomplicerad guide för att kompilera praktiskt taget vilken Android AOSP-baserad ROM som helst i 10 enkla steg. Medan min guide fokuserar på CyanogenMod, kan du kompilera i stort sett alla AOSP ROM där ute, genom att bara modifiera förvarslänkarna. Eller så kan du bara välja funktioner, begå dem, ändra saker och skapa din egen personliga ROM, kanske dela din ROM online också?