DIY: Android ROM aus dem Quellcode kompilieren
Android ist das am weitesten verbreitete mobile Betriebssystem der Welt. Und der beste Teil, es ist komplett Open-Source, was in Laien bedeutet, dass der Quellcode, das eigentliche Programm, offen für jeden zum Herunterladen, Anpassen und Erstellen seiner eigenen ROMs verfügbar ist.
Es gibt viele benutzerdefinierte Android-Distributionen, von denen die beliebtesten CyanogenMod, SlimROM, Paranoid Android, AOKP, Liquid Smooth, MIUI, Xylon, Ice Cold Jelly usw. sind.
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.
Voraussetzungen
- Ein Android-Telefon mit leicht verfügbarem Kernel und Gerätequelle, bereits verwurzelt und mit einer benutzerdefinierten Wiederherstellung installiert.
- 64-Bit-Linux-Distribution (Wir bevorzugen Ubuntu).
- Mindestens 100GB frei auf Ihrer Festplatte.
- Kenntnisse der Linux-Terminal-Befehle.
- Relativ schnelle Internetverbindung.
Hinweis: 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. (Der Leitfaden geht davon aus, dass Ubuntu 13.04 ausgeführt wird). Halten Sie eine Partition von mindestens 100 GB mit 16 GB Swap-Partition.
2. Installieren Sie die folgende Liste von Paketen: Öffnen Sie die Terminal-App und geben Sie
ein sudo apt-get install < Paketname>
Drücken Sie die Eingabetaste und Sie werden zur Eingabe Ihres Kennworts aufgefordert.
Paket Liste
git-core
gnupg
flex
bison
python
rar
original-awk
gawk
p7zip-full
gperf
libsdl1.2-dev
libesd0-dev
libwxgtk2.6-dev
squashfs-tools
build-essential
zip
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
3. Install Java JDK 1.6 for Linux 64-bit: File name should be jdk-6u##-linux-x64.bin, ## are version numbers. Move the downloaded package to your home directory. Öffnen Sie die Terminal-App und führen Sie die folgenden Befehle aus:
sudo apt-get purge openjdk-\* icedtea-\* icedtea6-\*
sudo mkdir -p /opt/java/64/
sudo cp jdk-6u##-linux-x64.bin /opt/java/64
sudo su –
cd /opt/java/64
chmod a+x jdk-6u##-linux-x64.bin
./jdk-6u##-linux-x64.bin
exit
Jetzt müssen wir den JDK-Pfad zu hinzufügen .bashrc
sudo gedit ~/.bashrc
Fügen Sie diese Zeilen am Ende der Textdatei hinzu
# Java Pfad
export JAVA_HOME=/opt/java/64/jdk1.6.0_##
export PFAD=$PFAD:$JAVA_HOME/bin
4. Installieren Android SDK: Öffnen Terminal App
cd ~
mkdir android && cd android
mkdir sdk
Download Android SDK von http://developer.android.com/sdk/index.html. Extrahieren Sie den Paketinhalt zu ~ / android / sdk Wir Android SDK Pfad hinzufügen müssen.bashrc
sudo gedit ~/.bashrc
Fügen Sie diese Zeilen am Ende der Textdatei hinzu:
# Android SDK-Pfad
EXPORTPFAD = $ PFAD: ~ / android / sdk
EXPORTPFAD = $ PFAD:~ / android / sdk /platform-tools
EXPORTPFAD = $ PFAD:~/android/sdk/tools
Installieren Sie nun die Android SDK-Tools, indem Sie
android eingeben
5. Richten Sie Ihr Github-Konto und Ihr Remote-Repo ein: Sie können diesen Schritt überspringen, wenn CyanogenMod Ihr Telefon offiziell unterstützt. Gehe zu github.com , und machen Sie ein Konto für sich. Für diesen Leitfaden betrachte ich Ihren Benutzernamen als ‚Benutzer‘.
Besuchen ‚github.com/CyanogenMod/android ‚, Gabel drücken. Das Remote-Manifest wird gegabelt und in Ihrem persönlichen Repo verfügbar sein.
Gehen Sie nun zu ‚github.com/user/android ‚. Öffnen Sie die Datei default.xml, drücken Sie Bearbeiten. Finde diese Zeile:
< projektpfad = „android“ name =“CyanogenMod / android“ />
Und ersetzen Sie dies durch
< projektpfad = „android“ name =“Benutzer / android“ />
Ich betrachte die Kernel-Quelle, die Gerätequelle und die Hersteller-Bibliotheken Ihres Geräts für Android 4.3 als
github.com/user2/kernel_source
github.com/user2/device_source
github.com/user2/device-common_source
github.com/user2/vendor
Ich gehe davon aus, dass der Zweig ‚jb4.3‘ heißt. Den genauen Namen finden Sie im eigentlichen Repo. Fügen Sie dann am Ende der Datei diese Zeilen hinzu und ändern Sie sie entsprechend dem Quellcode Ihres Geräts.
< projektpfad = „kernel / your_company / your_device“ name = „user2 / kernel_source“ remote = „github“ revision =“jb4.3″ />
< projektpfad = „device / your_company / your_device“ name = „user2 / device_source“ remote = „github“ revision =“jb4.3″ />
< projektpfad = „device / your_company / your_device-common“ name =“user2 / device-common_source“ remote =“github“ revision =“jb4.3″ />
< projektpfad = „vendor / your_company“ name = „user2 / vendor“ remote = „github“ revision =“jb4.3″ />
Übernehmen Sie Ihre Änderungen. Ihr Remote-Manifest kann bereitgestellt werden.
6. Install Repo Befehl: Öffnen Sie Terminal und geben Sie
cd ~
mkdir ~/bin
curl https://dl-ssl.google.com/dl/googlesource/git-repo/repo > ~/bin/repo
chmod a + x ~/bin/repo
Wir müssen Repo Pfad hinzufügen .bashrc
sudo gedit ~/.bashrc
Fügen Sie diese Zeile am Ende der Textdatei hinzu
export PATH=$PATH:~/bin
7. Holen Sie sich den ROM-Quellcode: Öffnen Terminal und typ
mkdir ~/android/cm
cd ~/android/cm
Wenn sie Schritt 5, dann typ
repo init-u git://github.com/user/android.git -b cm-10.2
Wenn Ihr Gerät CyanogenMod 10.2 offiziell unterstützt, geben Sie
ein repo init -u git://github.com/CyanogenMod/android.git -b cm-10.2
Führen Sie nun
repo sync –j16
aus, 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 das Terminal und geben Sie
cd ~ / android/cm
ein. build/envsetup.sh && Frühstück <device_codename>
Es wird einige Zeit dauern, die Gerätequelle ist etwa 3 GB groß. Dann müssen Sie official CM10.2 auf Ihrem Telefon installiert haben, es im USB-Debugging-Modus mit Ihrem PC verbinden und die folgenden Befehle ausführen:
adb Wurzel
cd ~/android/cm/device/<your_company>/<your_device>/
./extract-files.sh
Wenn Ihr Gerät CyanogenMod 10.2 nicht offiziell unterstützt, haben Sie in diesem Schritt nichts zu tun.
9. Laden Sie vorgefertigte Sachen herunter und richten Sie die Toolchain ein: Öffnen Sie das Terminal und geben Sie
cd ~/android/cm/vendor/cm
sh ein./get-prebuilts
Jetzt müssen wir den Toolchain-PFAD zu hinzufügen ./bashrc
cd ~/android/cm
sudo gedit ~/.bashrc
Fügen Sie diese Zeilen am Ende der Textdatei hinzu
# Android Toolchain
ARCH exportieren =arm
CCOMPILE exportieren =$CROSS_COMPILE
CROSS_COMPILE exportieren =arm-eabi-
PFAD exportieren =$PATH:~/android/cm/ prebuilt/linux-x86 / toolchain/arm-eabi-4.4.3/bin
10. Bauen Sie Ihr ROM: Also, alles ist in Ordnung und fertig. Es ist Zeit, das ROM zu bauen. Öffnen Sie das Terminal und geben Sie
cd ~/android/cm
ein. build/envsetup.sh
und <device_codename>
Zeit für ein Nickerchen. Es wird zig Jahre dauern, um das ROM auf einem durchschnittlichen Computer zu bauen. Nun, das war eine Übertreibung, aber auf meinem Heim-PC (Core i5 2nd gen mit 8GB RAM) dauert es über 3 Stunden, um von Grund auf neu zu bauen. Hoffentlich wird es keine Fehler geben und der Build wird gut abgeschlossen. Sie erhalten das Ausgabepaket in
~/android/cm/out/target/product/<your_device>/cm-10.2-something-UNOFFICIAL-<your_device>.zip
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. Legen Sie beide Pakete in Ihr Telefon und flashen Sie sie im Wiederherstellungsmodus. Voila, Ihr eigenes kompiliertes ROM führt jetzt Ihr Gerät aus.
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
cd ~/android/cm
repo sync -j16
Um Ihr ROM zu erstellen, öffnen Sie nach dem Aktualisieren des Quellcodes Terminal und geben Sie
cd ~/android/cm
machen installclean
finden ./out/ -name ‚bauen.prop‘ | xargs rm
finden ./out/ -name ‚cm_<your_device>-Zieldateien-eng.*.zip‘ | xargs rm
. build/envsetup.sh
brunch <Ihr_gerät>
Da Sie nicht von Grund auf neu bauen, sondern so, wie es ist, wird es deutlich weniger Zeit in Anspruch nehmen, in den meisten Fällen nur etwa 15-30 Minuten. Sie sollten Ihre lokale Quelle etwa jede Woche synchronisieren, um Ihre lokale Quelle auf dem neuesten Stand zu halten.
Bereinigen Sie Ihr Arbeitsverzeichnis
Um Ihr Arbeitsverzeichnis vollständig zu bereinigen (lesen: geben Sie Ihren Quellordner in den Lagerzustand zurück), öffnen Sie Terminal und geben Sie die folgenden Befehle ein.
cd ~ / android/cm
make installclean
make clobber
Denken Sie daran, dass nach dem Ausführen dieser Befehle alle Ihre Ausgabedaten entfernt werden, sodass der nächste Build erneut 3-4 Stunden dauert, da alles von Grund auf neu erstellt wird. Wenn Ihre Festplattenpartition klein ist, z. B. etwa 100 GB, sollten Sie Ihr Arbeitsverzeichnis etwa alle 4 Builds bereinigen, da Ihnen sonst der Festplattenspeicher ausgeht.
Beschleunigen Sie Ihren Build mit CCACHE
Das Erstellen eines ROMS nimmt viel Zeit in Anspruch. Durch die Verwendung von CCACHE kann die Zeit jedoch um etwa 30-45% verkürzt werden. CCACHE steht für Compiler Cache und speichert die Kompilierungsausgabe Ihrer früheren Builds zwischen, sodass sie in späteren Builds wiederverwendet werden kann.
Beachten Sie, dass CCACHE viel Speicherplatz auf Ihrer Festplatte benötigt, um den Inhalt zwischenzuspeichern. Es wird daher nur empfohlen, wenn sich Ihre Festplattenpartition in der Nähe von 200 GB oder mehr befindet. Um CCACHE einzurichten, öffnen Sie das Terminal und geben Sie Folgendes ein:
cd ~/android/cm
exportieren Sie USE_CCACHE=1
Exportieren Sie CACHE_DIR=~/.ccache
prebuilts / misc / linux-x86 / ccache / ccache –M 50G
Sie können die maximale Größenzuweisung für CCACHE von 50 GB auf beliebig ändern, für gute Ergebnisse sollten jedoch mindestens 30 GB verwendet werden.
Commits von anderen ROMs abrufen
Sie können Funktionen aus dem Quellcode anderer ROMs auswählen. Angenommen, ich möchte Feature A mit der Commit-ID „12345“ aus dem Repository auswählen. „github.com/user/reporepo“.
Sie navigieren zu dem Paket in Ihrem lokalen Quellcode und führen diese im Terminal aus.
cd ~/<path_to_reporepo_packages>
git holen https://github.com/user/reporepo
git cherry-pick 12345
Quellcode-Links berühmter Android Custom ROM-Distributionen
CyanogenMod – https://github.com/CyanogenMod
SlimROM – https://github.com/SlimRoms
ParanoidAndroid – https://github.com/ParanoidAndroid
AOKP – https://github.com/AOKP
LiquidSmooth – https://github.com/liquidsmooth
Xylon ROM –
Eiskaltes Gelee – https://github.com/IceColdJelly
Also, da gehst du Jungs, eine einfache, unkomplizierte Anleitung zum Kompilieren praktisch jeder Android AOSP-basierten ROM 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, festlegen, Dinge ändern und Ihr eigenes personalisiertes ROM erstellen, vielleicht auch Ihr ROM online teilen?