DIY: kompilere Android ROM fra kildekode

januar 18, 2022

Android er den mest udbredte mobile operativsystem i verden. Og det bedste, det er helt open source, som i lægmand vilkår, betyder, at kildekoden, selve programmet er tilgængelig åbent for alle at hente, tilpasse og bygge deres egne ROM ‘ er.

der er masser af brugerdefinerede Android-distributioner tilgængelige derude, hvor de populære er CyanogenMod, SlimROM, Paranoid Android, AOKP, flydende glat, MIUI, iskold Jelly osv.

til dagens guide vil vi kompilere CyanogenMod 10.2, den mest populære Android aftermarket ROM. Proceduren er 99% den samme for alle brugerdefinerede ROM ‘er derude, så denne vejledning kan også bruges som reference til at kompilere andre rom’ er.

forudsætninger

en Android-telefon med let tilgængelig kerne-og Enhedskilde, allerede rodfæstet og med en brugerdefineret gendannelse installeret.
64 bit Distribution (Vi foretrækker Ubuntu).
mindst 100 GB gratis på din harddisk.
praktisk viden om terminalkommandoer.
rimelig hurtig internetforbindelse.

Bemærk: 64 bit OS er et must, og det skal være en indbygget installation, ikke en virtuel maskine.

Opsæt Din Bygge Maskine

1. 64 bit version, i henhold til de officielle instruktioner. (Guiden antager, at vi kører Ubuntu 13.04). Hold en partition på mindst 100 GB med 16 GB Byttepartition.

2. Installer følgende liste over pakker: Åbn Terminal app, og skriv

sudo apt-get install <package-name>

tryk på enter, og det vil bede dig om din adgangskode.

pakkeliste

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. Åbn Terminal-appen, og kør følgende sæt kommandoer:

sudo apt-get purge openjdk – \ * icedtea – \ * icedtea6 – \ *
sudo mkdir –p /opt/java/64/
sudo cp jdk-6u##-linuk-64.bin/opt/java / 64
sudo su –
cd /opt/java/64
chmod a+jdk-6u##-linuk-64.bin
./jdk-6u # # – linuk-64.bin
Afslut

nu skal vi tilføje JDK sti til .bashrc

sudo gedit ~/.bashrc

tilføj disse linjer i slutningen af tekstfilen

# Java sti
eksport JAVA_HOME=/opt/java/64/jdk1.6.0_##
eksport sti=$sti:$ JAVA_HOME / bin

4. Installer Android SDK: åben Terminal App

cd ~
mkdir android && cd android
mkdir sdk

Hent Android SDK fra http://developer.android.com/sdk/index.html. Uddrag Pakkens indhold til ~ / android / sdk vi skal tilføje Android SDK sti til .bashrc

sudo gedit ~/.bashrc

tilføj disse linjer til slutningen af tekstfilen:

# Android SDK sti
eksport sti= $ sti:~ / android/sdk
eksport sti= $ sti:~ / android / sdk / platform-værktøjer
eksport sti= $ sti:~ / android / sdk / tools

Installer nu Android SDK Tools ved at skrive

android

5. Opret din github-konto og remote repo: du kan springe dette trin over, hvis CyanogenMod officielt understøtter din telefon. Gå til github.com, og lav en konto for dig selv. I denne vejledning overvejer jeg dit Brugernavn som’bruger’.

besøg ‘github.com/CyanogenMod/android’, tryk gaffel. Fjernbetjeningen manifest vil blive kløvet, og tilgængelig i din personlige repo.

gå nu til ‘github.com/user/android’. Åbn filen standard.tryk på Rediger. Find denne linje:

og erstatte det med

jeg overvejer din enheds kernekilde, enhedskilde og leverandør libs til Android 4.3 at være på

github.com/user2/kernel_source
github.com/user2/device_source
github.com/user2/device-common_source
github.com/user2/vendor

jeg antager, at filialen hedder ‘jb4.3’. Du kan finde det nøjagtige navn i den faktiske repo. Derefter skal du i slutningen af filen tilføje disse linjer og ændre dem i henhold til enhedens kildekode.

Foretag dine ændringer. Din remote manifest er klar til at blive indsat.

6. Installer Repo kommando: Åbn Terminal og skriv

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

vi skal tilføje Repo sti til .bashrc

sudo gedit ~/.bashrc

Tilføj denne linje til slutningen af tekstfilen

Eksporter sti= $ sti:~ / bin

7. Hent ROM-kildekoden: Åbn Terminal og skriv

mkdir ~ / android / cm
cd ~ / android / cm

hvis du har brug for trin 5, skriv derefter

repo init –u git://github.com/user/android.git –B cm-10.2

hvis din enhed understøtter CyanogenMod 10.2 officielt, skal du skrive

repo init – u git: / / github. com / CyanogenMod / android.git –B cm-10.2

Kør nu

repo sync –j16

tag en kop kaffe eller et måltid, det tager lang tid. Kildekoden er godt over 10 GB i størrelse, så det vil tage lidt tid.

8. Indstil enhedens specifikke ting: hvis din enhed understøtter CyanogenMod 10.2 officielt, skal du åbne Terminal og skrive

cd ~/android/cm
. build/envsetup.sh && morgenmad <enhed_kodenavn>

det vil tage lidt tid, enhedskilden er omkring 3 GB i størrelse. Derefter skal du have officiel CM10.2 installeret på din telefon, tilslutte den til din PC i USB-Fejlretningstilstand og køre følgende kommandoer:

adb rod
cd ~/android/cm/device/<your_company>/<your_device>/
./extract-files.sh

hvis din enhed ikke understøtter CyanogenMod 10.2 officielt, så har du intet at gøre i dette trin, kilderne venter allerede på dig.

9. Hent forudbyggede ting og oprette Toolchain: åben Terminal og type

cd ~/android/cm/leverandør/cm
sh ./ get-prebuilts

nu skal vi tilføje Toolchain-stien til ./ bashrc

cd ~ / android / cm
sudo gedit ~/.bashrc

tilføj disse linjer til slutningen af tekstfilen

# Android Toolchain
eksport ARCH=arm
eksport CCOMPILE= $ CROSS_COMPILE
eksport CROSS_COMPILE=arm-eabi-
eksport sti= $ sti:~ / android / cm / forudbygget / Linuks-86 / toolchain / arm-eabi-4.4.3 / bin

10. Byg din ROM: så alt er okay og klar. Det er tid til at bygge ROM. Åbn Terminal og skriv

cd ~/android/cm
. build/envsetup.sh
brunch <enhed_kodenavn>

tid til at tage en lur. Det vil tage en million år at bygge ROM på en gennemsnitlig computer. Nå, det var en overdrivelse, men på min hjemme-PC (Core i5 2.gen med 8 GB RAM) tager det over 3 timer at bygge fra bunden. Forhåbentlig vil der ikke være nogen fejl, og bygningen vil fuldføre fint. Du får outputpakken i

~/android/cm/out/target/product/<your_device>/cm-10.2-something-UNOFFICIAL-<your_device>.lynlås

det er tid til at installere din nyligt kompileret ROM på din telefon. Hent Google Apps-pakken fra ” .Goo.im / gapps ” til den relevante Android-version. Sæt begge disse pakker i din telefon, og flash dem i recovery mode. Voila, din egen kompilerede ROM kører nu din enhed.

nå, så du lærte at kompilere en ROM. Så hvad nu?

Opdater din kilde ROM

for at hente nye kildekodeopdateringer til din lokalt hentede kildekode, åbn Terminal og skriv

cd ~/android/cm
repo sync –j16

for at opbygge din ROM, efter opdatering af kildekoden, åbn terminal og skriv

cd ~/Android/cm
lav installclean
find ./ ud / – navn ‘ build.RM
finde ./ ud / – name ‘ cm_<your_device> -target_files-eng.*.RM
. build/envsetup.sh
brunch <your_device>

da du ikke genopbygger fra bunden, men genopbygger som det er, vil det tage betydeligt mindre tid, kun omkring 15-30 minutter i de fleste tilfælde. Du skal synkronisere din lokale kilde hver uge eller deromkring for at holde din lokale kilde frisk.

rengør din arbejdsmappe

for at rense din arbejdsmappe fuldstændigt (Læs: returner din kildemappe til lagertilstand), åbn Terminal og skriv følgende kommandoer.

cd ~/android/cm
make installclean
make clobber

Husk, at efter at have kørt disse kommandoer fjernes alle dine outputdata, så den næste build tager 3-4 timer igen, da alt genopbygges fra bunden. Hvis din harddiskpartition er lille, siger omkring 100 GB, skal du rense din arbejdsmappe cirka en gang hver 4.bygning, ellers løber du tør for harddiskplads.

fremskynde din build af CCACHE

opbygning af en ROM tager en masse tid. Men tiden kan skæres ned med omkring 30-45% ved hjælp af CCACHE. CCACHE står for compiler cache, det cacher kompilering output fra dine tidligere builds, så det kan genbruges i senere builds.

Bemærk, at CCACHE har brug for meget plads på din harddisk til caching af indholdet, så det anbefales, hvis og kun hvis din harddiskpartition er et sted i nærheden af 200 GB eller højere. For at konfigurere CCACHE skal du åbne Terminal og skrive:

cd ~/android/cm
eksport USE_CCACHE=1
eksport CACHE_DIR=~/.ccache
prebuilts/misc / Linuks-86 / ccache / ccache – m 50G

du kan ændre den maksimale størrelsesfordeling til CCACHE fra 50 GB til hvad du vil, men et minimum på omkring 30 GB skal bruges til gode resultater.

Hent forpligter fra andre rom ‘er

du kan cherry-pick funktioner fra andre rom’ er kildekode. Sig for eksempel, Jeg vil vælge funktion A, med commit ID “12345” fra repository “github.com/user/reporepo”.

du navigerer til pakken i din lokale kildekode og kører disse i Terminal.

cd ~ / < path_to_reporepo_packages>
Git Hent https://github.com/user/reporepo
Git cherry-pick 12345

kildekode Links af berømte Android Custom ROM distributioner

CyanogenMod – https://github.com/CyanogenMod
SlimROM – https://github.com/SlimRoms
ParanoidAndroid – https://github.com/ParanoidAndroid
AOKP – https://github.com/AOKP
Væskeglat – https://github.com/liquidsmooth
– https://github.com/IceColdJelly

så, der går du fyre, en enkel, ligetil guide til at kompilere stort set alle Android AOSP baseret ROM i 10 enkle trin. Mens min guide fokuserer på CyanogenMod, du kan kompilere stort set alle AOSP ROM derude, ved blot at ændre repository links. Eller, du kan bare vælge Funktioner, begå dem, ændre ting og oprette din egen personlige ROM, måske dele din ROM online også?

NCPEA Professor

Blog, Lifestyle and News