DIY: Android-ROM aus Quellcode kompilieren

Android ist das am weitesten verbreitete mobile Betriebssystem der Welt. Und das Beste daran, es ist komplett Open Source, was für Laien bedeutet, dass der Quellcode, das eigentliche Programm, offen für jeden verfügbar ist, um seine eigenen ROMs herunterzuladen, anzupassen und zu bauen.

Es gibt viele benutzerdefinierte Android-Distributionen, darunter CyanogenMod, SlimROM, Paranoid Android, AOKP, Liquid Smooth, MIUI, Xylon, Ice Cold Jelly usw.

Für den heutigen Leitfaden werden wir CyanogenMod 10.2 kompilieren, das beliebteste Android-Aftermarket-ROM. Das Verfahren ist zu 99% für alle benutzerdefinierten ROMs gleich, daher kann dieses Handbuch auch als Referenz zum Kompilieren anderer ROMs verwendet werden.

Die Anforderungen:

1. Ein Android-Telefon mit leicht verfügbarem Kernel und Gerätequelle, bereits gerootet und mit einer installierten benutzerdefinierten Wiederherstellung.
2. 64-Bit-Linux-Distribution (Wir bevorzugen Ubuntu).
3. Mindestens 100 GB frei auf Ihrer Festplatte.
4. Kenntnisse der Linux-Terminalbefehle.
5. Relativ schnelle Internetverbindung.

Punkt zu beachten: Ein 64-Bit-Linux-Betriebssystem ist ein Muss, und es muss eine native Installation sein, keine virtuelle Maschine.

Richten Sie Ihre Build-Maschine ein

1. Installieren Sie das Linux-Betriebssystem Ihrer Wahl: 64-Bit-Version, gemäß den offiziellen Anweisungen. (Die Anleitung geht davon aus, dass wir Ubuntu 13.04 ausführen). Behalten Sie eine Partition von mindestens 100 GB mit 16 GB Swap-Partition bei.

2. Installieren Sie die folgende Paketliste: Öffnen Sie die Terminal-App und geben Sie ein

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

Drücken Sie die Eingabetaste und Sie werden zur Eingabe Ihres Passworts aufgefordert.

Paketliste

[html]
Git-Core
gnupg
biegen
Bison
python
rar
Original-awk
gaffen
p7zip-voll
gperf
libsdl1.2-dev
libesd0-dev
libwxgtk2.6-dev
squashfs-tools
bauwesentlich
Reißverschluss
curl
libncurses5-dev
zlib1g-dev
pngcrush
Schedtool
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. Installieren Sie Java JDK 1.6 für Linux 64-Bit: Der Dateiname sollte jdk-6u##-linux-x64.bin lauten, ## sind Versionsnummern. Verschieben Sie das heruntergeladene Paket in Ihr Home-Verzeichnis. Öffnen Sie die Terminal-App und führen Sie die folgenden Befehle aus:

[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üdlich auf -
cd /opt/java/64
chmod a+x jdk-6u##-linux-x64.bin
./jdk-6u##-linux-x64.bin
verlassen
[/ html]

Jetzt müssen wir den JDK-Pfad zu .bashrc hinzufügen

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

Fügen Sie diese Zeilen am Ende der Textdatei hinzu

[html]
# Java-Pfad
JAVA_HOME exportieren=/opt/java/64/jdk1.6.0_##
export PFAD=$PFAD:$JAVA_HOME/bin
[/ html]

4. Android-SDK installieren: Terminal-App öffnen

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

Android SDK herunterladen von http://developer.android.com/sdk/index.html. Extrahieren Sie den Paketinhalt nach ~/android/sdk Wir müssen den Android SDK-Pfad zu .bashrc hinzufügen

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

Fügen Sie diese Zeilen am Ende der Textdatei hinzu:

[html]
# Android SDK-Pfad
export PFAD=$PFAD:~/android/sdk
export PATH=$PATH:~/android/sdk/platform-tools
export PFAD=$PFAD:~/android/sdk/tools
[/ html]

Installieren Sie nun die Android SDK-Tools durch Eingabe von

[html]
androide
[/ html]

5. Richten Sie Ihr Github-Konto und Ihr Remote-Repository ein: Sie können diesen Schritt überspringen, wenn CyanogenMod Ihr Telefon offiziell unterstützt. Gehen Sie zu github.com und erstellen Sie ein Konto. Für diese Anleitung betrachte ich Ihren Benutzernamen als 'Benutzer'.

Besuchen Sie 'github.com/CyanogenMod/android', drücken Sie Fork. Das Remote-Manifest wird gegabelt und ist in Ihrem persönlichen Repository verfügbar.

Gehen Sie nun zu 'github.com/user/android'. Öffnen Sie die Datei default.xml, drücken Sie Bearbeiten. Finde diese Zeile:

[html]

[/ html]

Und ersetze das durch

[html]

[/ html]

Ich gehe davon aus, dass die Kernel-, Gerätequell- und Anbieter-Libs Ihres Geräts für Android 4.3 bei . sind

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

Ich gehe davon aus, dass der Zweig 'jb4.3' heißt. Den genauen Namen finden Sie im aktuellen Repo. Fügen Sie dann am Ende der Datei diese Zeilen hinzu und ändern Sie sie entsprechend dem Quellcode Ihres Geräts.

[html]




[/ html]

Bestätigen Sie Ihre Änderungen. Ihr Remotemanifest kann bereitgestellt werden.

6. Repo-Befehl installieren: Terminal öffnen und eingeben

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

Wir müssen den Repo-Pfad zu .bashrc hinzufügen

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

Fügen Sie diese Zeile am Ende der Textdatei hinzu

[html]
export PFAD=$PFAD:~/bin
[/ html]

7. Rufen Sie den ROM-Quellcode ab: Terminal öffnen und eingeben

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

Wenn Sie Schritt 5 benötigen, geben Sie ein

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

Wenn Ihr Gerät CyanogenMod 10.2 offiziell unterstützt, geben Sie ein

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

Jetzt lauf

[html]
Repo-Synchronisierung –j16
[/ html]

Holen Sie sich einen Kaffee oder eine Mahlzeit, es wird lange dauern. Der Quellcode ist weit über 10 GB groß, daher wird es einige Zeit dauern.

8. Richten Sie die gerätespezifischen Dinge ein: Wenn Ihr Gerät CyanogenMod 10.2 offiziell unterstützt, öffnen Sie Terminal und geben Sie ein

[html]
cd ~/android/cm
. build/envsetup.sh && Frühstück
[/ html]

Es wird einige Zeit dauern, die Gerätequelle ist etwa 3 GB groß. Dann müssen Sie das offizielle CM10.2 auf Ihrem Telefon installiert haben, es im USB-Debugging-Modus mit Ihrem PC verbinden und die folgenden Befehle ausführen:

[html]
adb-root
cd ~/android/cm/gerät/ / /
./extract-files.sh
[/ html]

Wenn Ihr Gerät CyanogenMod 10.2 nicht offiziell unterstützt, dann haben Sie in diesem Schritt nichts zu tun, die Quellen warten bereits auf Sie.

9. Laden Sie vorgefertigtes Material herunter und richten Sie die Toolchain ein: Terminal öffnen und eingeben

[html]
cd ~/android/cm/verkäufer/cm
sh ./get-prebuilds
[/ html]

Jetzt müssen wir den Toolchain PATH zu ./bashrc . hinzufügen

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

Fügen Sie diese Zeilen am Ende der Textdatei hinzu

[html]
# Android-Toolchain
export ARCH=arm
exportiere 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. Erstellen Sie Ihr ROM: Also, alles ist in Ordnung und bereit. Es ist Zeit, das ROM zu erstellen. Terminal öffnen und eingeben

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

Zeit, ein Nickerchen zu machen. Es wird eine Zillion Jahre dauern, um das ROM auf einem durchschnittlichen Computer zu erstellen. Nun, das war übertrieben, aber auf meinem Heim-PC (Core i5 2. Generation mit 8 GB RAM) dauert es über 3 Stunden, um von Grund auf neu zu bauen. Hoffentlich treten keine Fehler auf und der Build wird gut abgeschlossen. Sie erhalten das Ausgabepaket in

[html]
~/android/cm/out/Ziel/Produkt/ /cm-10.2-etwas-INOFFIZIELL- .Postleitzahl
[/ html]

Es ist Zeit, Ihr neu kompiliertes ROM auf Ihrem Telefon zu installieren. Laden Sie das Google Apps-Paket von „www.goo.im/gapps“ für die entsprechende Android-Version herunter. Legen Sie beide Pakete in Ihr Telefon und flashen Sie sie im Wiederherstellungsmodus. Voila, Ihr eigenes kompiliertes ROM läuft jetzt auf Ihrem Gerät.

Nun, Sie haben also gelernt, wie man ein ROM kompiliert. Also, was nun?

Aktualisieren Sie Ihr Quell-ROM

Um neue Quellcode-Updates für Ihren lokal heruntergeladenen Quellcode abzurufen, öffnen Sie Terminal und geben Sie

[html]
cd ~/android/cm
Repo-Synchronisierung –j16
[/ html]

Um Ihr ROM zu erstellen, öffnen Sie nach dem Aktualisieren des Quellcodes das Terminal und geben Sie ein

[html]
cd ~/android/cm
installclean machen
find ./out/ -name 'build.prop' | xargs rm
find ./out/ -name 'cm_ -target_files-eng.*.zip' | xargs rm
. build / envsetup.sh
Brunch
[/ html]

Da Sie nicht von Grund auf neu aufbauen, sondern wie es ist, dauert es deutlich weniger Zeit, in den meisten Fällen nur etwa 15-30 Minuten. Sie sollten Ihre lokale Quelle etwa jede Woche synchronisieren, um Ihre lokale Quelle aktuell zu halten.

Reinigen Sie Ihr Arbeitsverzeichnis

Um Ihr Arbeitsverzeichnis vollständig zu bereinigen (sprich: Ihren Quellordner in den Bestandszustand zurücksetzen), öffnen Sie Terminal und geben Sie die folgenden Befehle ein.

[html]
cd ~/android/cm
installclean machen
klumpen machen
[/ html]

Denken Sie daran, dass nach dem Ausführen dieser Befehle alle Ihre Ausgabedaten entfernt werden, sodass der nächste Build wieder 3-4 Stunden dauert, da alles von Grund auf neu erstellt wird. Wenn Ihre Festplattenpartition klein ist, sagen wir etwa 100 GB, sollten Sie Ihr Arbeitsverzeichnis etwa alle 4 Builds bereinigen, sonst wird Ihnen der Festplattenspeicher ausgehen.

Beschleunige deinen Build mit CCACHE

Das Erstellen eines ROM nimmt viel Zeit in Anspruch. Aber die Zeit kann mit CCACHE um ca. 30-45% reduziert werden. CCACHE steht für Compiler Cache, es speichert die Kompilierungsausgabe Ihrer früheren Builds, damit sie in späteren Builds wiederverwendet werden kann.

Beachten Sie, dass CCACHE viel Platz auf Ihrer Festplatte benötigt, um den Inhalt zwischenzuspeichern. Daher wird es empfohlen, wenn und nur dann, wenn sich Ihre Festplattenpartition in der Nähe von 200 GB oder höher befindet. Um CCACHE einzurichten, öffnen Sie das Terminal und geben Sie Folgendes ein:

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

Sie können die maximale Größenzuweisung für CCACHE von 50 GB auf einen beliebigen Wert ändern, aber für gute Ergebnisse sollten mindestens etwa 30 GB verwendet werden.

Commits von anderen ROMs abrufen

Sie können Funktionen aus dem Quellcode anderer ROMs auswählen. Sagen wir zum Beispiel, ich möchte Feature A mit der Commit-ID „12345“ aus dem Repository „github.com/user/reporepo“ auswählen.

Sie navigieren zu dem Paket in Ihrem lokalen Quellcode und führen diese im Terminal aus.

[html]
CD ~/
git holt https://github.com/user/reporepo
git Kirsche-Pick 12345
[/ html]

Quellcode-Links berühmter benutzerdefinierter Android-ROM-Distributionen

CyanogenMod – https://github.com/CyanogenMod
SlimROM – https://github.com/SlimRoms
ParanoidAndroid – https://github.com/ParanoidAndroid
AOKP – https://github.com/AOKP
FlüssigkeitGlatt – https://github.com/liquidsmooth
Xylon-ROM -
Eiskaltes Gelee – https://github.com/IceColdJelly

Also los, Leute, eine einfache, unkomplizierte Anleitung zum Kompilieren praktisch jedes Android AOSP-basierten ROMs in 10 einfachen Schritten. Während sich mein Leitfaden auf CyanogenMod konzentriert, können Sie so ziemlich jedes AOSP-ROM kompilieren, indem Sie einfach die Repository-Links ändern. Oder Sie können einfach Funktionen auswählen, sie festschreiben, Dinge ändern und Ihr eigenes personalisiertes ROM erstellen, vielleicht auch Ihr ROM online teilen?