DIY: Android ROM compileren vanuit de broncode

Android is het meest gebruikte mobiele besturingssysteem ter wereld. En het beste is dat het volledig open-source is, wat in termen van leken betekent dat de broncode, het eigenlijke programma, openlijk beschikbaar is voor iedereen om zijn eigen ROM's te downloaden, aan te passen en te bouwen.

Er zijn veel aangepaste Android-distributies beschikbaar, met als populaire CyanogenMod, SlimROM, Paranoid Android, AOKP, Liquid Smooth, MIUI, Xylon, Ice Cold Jelly, enz.

Voor de gids van vandaag zullen we CyanogenMod 10.2 compileren, de meest populaire Android aftermarket-ROM. De procedure is 99% hetzelfde voor alle aangepaste ROM's die er zijn, dus deze handleiding kan ook als referentie worden gebruikt om andere ROM's te compileren.

Pre-requisites

1. Een Android-telefoon met direct beschikbare kernel- en apparaatbron, al geroot en met een aangepast herstel geïnstalleerd.
2. 64 bit Linux-distributie (wij geven de voorkeur aan Ubuntu).
3. Minimaal 100GB vrij op uw harde schijf.
4. Praktische kennis van Linux Terminal Commando's.
5. Redelijk snelle internetverbinding.

Let op: 64-bits Linux-besturingssysteem is een must en het moet een native installatie zijn, geen virtuele machine.

Stel uw bouwmachine in

1. Installeer het Linux-besturingssysteem van uw keuze: 64 bit-versie, volgens de officiële instructies. (De gids gaat ervan uit dat we Ubuntu 13.04 gebruiken). Houd een partitie van minimaal 100 GB aan met 16 GB Swap Partition.

2. Installeer de volgende lijst met pakketten: Open de Terminal-app en typ

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

druk op enter en het zal u om uw wachtwoord vragen.

pakket Lijst

[Html]
git kern
knuppel
buigen
bizon
python
zeldzaam
origineel-awk
gapen
p7zip-vol
gperf
libsdl1.2-dev
libesd0-dev
libwxgtk2.6-dev
squashfs-tools
build-essentiële
ritssluiting
krullen
libncurses5-dev
zlib1g-dev
pngcrush
schematool
libc6-dev
x11proto-core-dev
libx11-dev
libg11-mesa-dev
mingw32
tofrodos
python-afprijs
libxml2-utils
g++-multilib
lib32z1-dev
ia32-libs
lib32ncurses5-dev
lib32readline-gplv2-dev
gcc-multilib
g++-multilib
xsltproc
[/ Html]

3. Installeer Java JDK 1.6 voor Linux 64-bit: De bestandsnaam moet jdk-6u##-linux-x64.bin zijn, ## zijn versienummers. Verplaats het gedownloade pakket naar uw thuismap. Open de Terminal-app en voer de volgende reeks opdrachten uit:

[Html]
sudo apt-get purge openjdk-\* icedtea-\* icedtea6-\*
sudo mkdir –p /opt/java/64/
sudo cp jdk-6u##-linux-x64.bin /opt/java/64
zuid op -
cd /opt/java/64
chmod a+x jdk-6u##-linux-x64.bin
./jdk-6u##-linux-x64.bin
afrit
[/ Html]

Nu moeten we JDK Path toevoegen aan .bashrc

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

Voeg deze regels toe aan het einde van het tekstbestand

[Html]
# Java-pad
exporteren JAVA_HOME=/opt/java/64/jdk1.6.0_##
export PATH=$PATH:$JAVA_HOME/bin
[/ Html]

4. Installeer Android SDK: Terminal-app openen

[Html]
cd ~
mkdir android && cd android
mkdir-sdk
[/ Html]

Android SDK downloaden van http://developer.android.com/sdk/index.html. Pak de inhoud van het pakket uit naar ~/android/sdk We moeten het Android SDK-pad toevoegen aan .bashrc

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

Voeg deze regels toe aan het einde van het tekstbestand:

[Html]
# Android SDK-pad
export PATH=$PATH:~/android/sdk
export PATH=$PATH:~/android/sdk/platform-tools
export PATH=$PATH:~/android/sdk/tools
[/ Html]

Installeer nu Android SDK Tools door te typen

[Html]
android
[/ Html]

5. Stel uw github-account en externe repo in: U kunt deze stap overslaan als CyanogenMod uw telefoon officieel ondersteunt. Ga naar github.com en maak een account voor jezelf. Voor deze handleiding beschouw ik uw gebruikersnaam als 'gebruiker'.

Ga naar 'github.com/CyanogenMod/android', druk op Fork. Het externe manifest wordt gevorkt en is beschikbaar in uw persoonlijke repo.

Ga nu naar 'github.com/user/android'. Open het bestand default.xml, druk op Bewerken. Zoek deze regel:

[Html]

[/ Html]

En vervang dit door

[Html]

[/ Html]

Ik overweeg om de kernelbron, apparaatbron en leveranciersbibliotheken van je apparaat voor Android 4.3 te gebruiken:

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

Ik neem aan dat de branch de naam 'jb4.3' krijgt. U kunt de exacte naam vinden in de daadwerkelijke repo. Voeg vervolgens aan het einde van het bestand deze regels toe en pas ze aan volgens de broncode van uw apparaat.

[Html]




[/ Html]

Leg uw wijzigingen vast. Uw externe manifest is klaar om te worden geïmplementeerd.

6. Installeer Repo-opdracht: Terminal openen en typen

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

We moeten Repo-pad toevoegen aan .bashrc

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

Voeg deze regel toe aan het einde van het tekstbestand

[Html]
export PATH=$PATH:~/bin
[/ Html]

7. Haal de ROM-broncode op: Terminal openen en typen

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

Als je stap 5 nodig hebt, typ dan

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

Als uw apparaat officieel CyanogenMod 10.2 ondersteunt, typt u

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

Ren nu

[Html]
repo-synchronisatie -j16
[/ Html]

Ga een kopje koffie of een maaltijd halen, het gaat lang duren. De broncode is ruim 10 GB groot, dus het zal behoorlijk wat tijd kosten.

8. Stel de apparaatspecifieke dingen in: Als uw apparaat CyanogenMod 10.2 officieel ondersteunt, open dan Terminal en typ

[Html]
cd~/android/cm
. build/envsetup.sh && ontbijt
[/ Html]

Het zal enige tijd duren, de apparaatbron is ongeveer 3 GB groot. Vervolgens moet u de officiële CM10.2 op uw telefoon hebben geïnstalleerd, deze op uw pc aansluiten in de USB-foutopsporingsmodus en de volgende opdrachten uitvoeren:

[Html]
adb wortel
cd ~/android/cm/apparaat/ / /
./bestanden uitpakken.sh
[/ Html]

Als je apparaat CyanogenMod 10.2 officieel niet ondersteunt, dan heb je in deze stap niets te doen, de bronnen wachten al op je.

9. Download Prebuilt Stuff en stel Toolchain in: Terminal openen en typen

[Html]
cd ~/android/cm/verkoper/cm
sh ./get-prebuilds
[/ Html]

Nu moeten we het Toolchain PATH toevoegen aan ./bashrc

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

Voeg deze regels toe aan het einde van het tekstbestand

[Html]
# Android-toolchain
exporteer ARCH=arm
exporteren 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. Bouw je ROM: Dus alles is in orde en klaar. Het is tijd om de ROM te bouwen. Terminal openen en typen

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

Tijd om te gaan slapen. Het zal een ontelbare jaren duren om de ROM op een gemiddelde computer te bouwen. Nou, dat was overdreven, maar op mijn thuis-pc (Core i5 2e generatie met 8 GB RAM) duurt het meer dan 3 uur om helemaal opnieuw te bouwen. Hopelijk zullen er geen fouten zijn en zal de build goed worden voltooid. U krijgt het uitvoerpakket in

[Html]
~/android/cm/out/target/product/ /cm-10.2-iets-ONOFFICIEEL- .zip
[/ Html]

Het is tijd om uw nieuw gecompileerde ROM op uw telefoon te installeren. Download het Google Apps-pakket van "www.goo.im/gapps" voor de juiste Android-versie. Plaats beide pakketten in uw telefoon en flash ze in de herstelmodus. Voila, uw eigen gecompileerde ROM draait nu op uw apparaat.

Nou, dus je hebt geleerd hoe je een ROM moet compileren. Dus wat nu?

Update uw bron-ROM

Om nieuwe broncode-updates voor uw lokaal gedownloade broncode op te halen, opent u Terminal en typt u

[Html]
cd~/android/cm
repo-synchronisatie -j16
[/ Html]

Om uw ROM te bouwen, opent u na het bijwerken van de broncode de terminal en typt u

[Html]
cd~/android/cm
maak installclean
find ./out/ -name 'build.prop' | xargs rm
zoek ./out/ -name 'cm_ -target_files-eng.*.zip' | xargs rm
. build / envsetup.sh
brunch
[/ Html]

Aangezien u niet helemaal opnieuw opbouwt, maar opnieuw opbouwt zoals het is, zal het aanzienlijk minder tijd kosten, in de meeste gevallen slechts ongeveer 15-30 minuten. U moet uw lokale bron elke week of zo synchroniseren om uw lokale bron actueel te houden.

Maak uw werkmap schoon

Om uw werkmap volledig op te schonen (lees: uw bronmap terugbrengen naar de voorraadstatus), opent u Terminal en typt u de volgende opdrachten.

[Html]
cd~/android/cm
maak installclean
klodder maken
[/ Html]

Houd er rekening mee dat na het uitvoeren van deze opdrachten al uw uitvoergegevens worden verwijderd, dus de volgende build duurt weer 3-4 uur, omdat alles helemaal opnieuw wordt opgebouwd. Als uw harde schijf-partitie klein is, bijvoorbeeld ongeveer 100 GB, moet u uw werkmap ongeveer eens in de 4 builds opschonen, anders heeft u onvoldoende ruimte op de harde schijf.

Versnel uw build door CCACHE

Het bouwen van een ROM kost veel tijd. Maar de tijd kan met ongeveer 30-45% worden verkort door CCACHE te gebruiken. CCACHE staat voor compiler cache, het slaat de compilatie-uitvoer van uw eerdere builds op in de cache, zodat deze opnieuw kan worden gebruikt in latere builds.

Merk op dat CCACHE veel ruimte op uw harde schijf nodig heeft voor het cachen van de inhoud, dus het wordt aanbevolen als en alleen als uw harde schijfpartitie zich ergens in de buurt van 200 GB of hoger bevindt. Om CCACHE in te stellen, opent u Terminal en typt u:

[Html]
cd~/android/cm
exporteren USE_CCACHE=1
exporteer CACHE_DIR=~/.ccache
prebuilds/misc/linux-x86/ccache/ccache –M 50G
[/ Html]

U kunt de maximale groottetoewijzing aan CCACHE wijzigen van 50 GB in wat u maar wilt, maar voor goede resultaten moet een minimum van ongeveer 30 GB worden gebruikt.

Vastleggingen ophalen van andere ROM's

U kunt functies uit de broncode van andere ROM's kiezen. Stel, ik wil bijvoorbeeld Feature A kiezen, met commit ID "12345" uit repository "github.com/user/reporepo".

U navigeert naar het pakket in uw lokale broncode en voert deze uit in Terminal.

[Html]
cd ~/
git ophalen https://github.com/user/reporepo
git cherry-pick 12345
[/ Html]

Broncodekoppelingen van beroemde Android Custom ROM-distributies

CyanogenMod – https://github.com/CyanogenMod
SlimROM – https://github.com/SlimRoms
ParanoidAndroid – https://github.com/ParanoidAndroid
AOKP – https://github.com/AOCP
VloeistofSmooth – https://github.com/liquidsmooth
Xylon-ROM -
IJskoude gelei – https://github.com/IceColdJelly

Dus, daar gaan jullie, een eenvoudige, duidelijke handleiding om vrijwel elke op Android AOSP gebaseerde ROM in 10 eenvoudige stappen te compileren. Hoewel mijn gids zich richt op CyanogenMod, kun je vrijwel elk AOSP-ROM compileren dat er is, door alleen de repository-links aan te passen. Of je kunt gewoon functies kiezen, ze vastleggen, dingen aanpassen en je eigen gepersonaliseerde ROM maken, misschien ook je ROM online delen?