DIY: I-compile ang Android ROM mula sa Source Code

Ang Android ang pinakamalawak na ginagamit na mobile operating system sa mundo. At ang pinakamagandang bahagi, ito ay ganap na open-source, na sa mga karaniwang termino, ay nangangahulugan na ang Source Code, ang aktwal na programa ay bukas na magagamit para sa lahat upang i-download, i-customize at bumuo ng kanilang sariling mga ROM.

Mayroong maraming mga custom na pamamahagi ng Android na magagamit doon, kasama ang mga sikat na CyanogenMod, SlimROM, Paranoid Android, AOKP, Liquid Smooth, MIUI, Xylon, Ice Cold Jelly, atbp.

Para sa gabay ngayon, isasama namin ang CyanogenMod 10.2, ang pinakasikat na Android aftermarket ROM. Ang pamamaraan ay 99% pareho para sa lahat ng pasadyang ROM sa labas, kaya ang gabay na ito ay maaaring gamitin bilang isang sanggunian upang mag-compile din ng iba pang mga ROM.

Mga pre-requisite

1. Isang Android Phone na may madaling available na Kernel at Device Source, na-root na at may naka-install na custom na recovery.
2. 64 bit Linux Distribution (Mas gusto namin ang Ubuntu).
3. Hindi bababa sa 100GB na libre sa iyong Hard Disk.
4. Paggawa ng kaalaman sa Linux Terminal Commands.
5. Makatuwirang mabilis na koneksyon sa internet.

Ituro na: Ang 64 bit Linux OS ay kinakailangan, at dapat itong isang katutubong pag-install, hindi isang Virtual Machine.

I-set Up ang Iyong Build Machine

1. I-install ang Linux OS na iyong pinili: 64 bit na bersyon, ayon sa opisyal na mga tagubilin. (Ipapalagay ng gabay na nagpapatakbo kami ng Ubuntu 13.04). Panatilihin ang partition na hindi bababa sa 100GB na may 16GB Swap Partition.

2. I-install ang sumusunod na listahan ng mga package: Buksan ang Terminal app, at i-type

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

pindutin ang enter at i-prompt ka nito para sa iyong password.

Listahan ng Package

[html]
git-core
gnupg
pagbaluktot
bison
python
rar
orihinal-awk
gawk
p7zip-puno
gprf
libsdl1.2-dev
libesd0-dev
libwxgtk2.6-dev
squashfs-tool
build-essential
sigla
kulutan
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. I-install ang Java JDK 1.6 para sa Linux 64-bit: Ang pangalan ng file ay dapat na jdk-6u##-linux-x64.bin, ## ay mga numero ng bersyon. Ilipat ang na-download na package sa iyong home directory. Buksan ang Terminal app at patakbuhin ang sumusunod na hanay ng mga command:

[html]
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
lumabas
[/ html]

Ngayon, dapat nating idagdag ang JDK Path sa .bashrc

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

Idagdag ang mga linyang ito sa dulo ng text file

[html]
# Java Path
i-export ang JAVA_HOME=/opt/java/64/jdk1.6.0_##
i-export ang PATH=$PATH:$JAVA_HOME/bin
[/ html]

4. I-install ang Android SDK: Buksan ang Terminal App

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

I-download ang Android SDK mula sa http://developer.android.com/sdk/index.html. I-extract ang mga nilalaman ng package sa ~/android/sdk Dapat nating idagdag ang Android SDK path sa .bashrc

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

Idagdag ang mga linyang ito sa dulo ng text file:

[html]
# Android SDK Path
i-export ang PATH=$PATH:~/android/sdk
i-export ang PATH=$PATH:~/android/sdk/platform-tools
i-export ang PATH=$PATH:~/android/sdk/tools
[/ html]

Ngayon, i-install ang Android SDK Tools sa pamamagitan ng pag-type

[html]
Android
[/ html]

5. I-set up ang iyong github account at remote repo: Maaari mong laktawan ang hakbang na ito kung opisyal na sinusuportahan ng CyanogenMod ang iyong telepono. Pumunta sa github.com, at gumawa ng account para sa iyong sarili. Para sa gabay na ito, isinasaalang-alang ko ang iyong username bilang 'user'.

Bisitahin ang 'github.com/CyanogenMod/android', pindutin ang Fork. Ang remote na manifest ay ma-forked, at magagamit sa iyong personal na repo.

Ngayon, pumunta sa 'github.com/user/android'. Buksan ang file default.xml, pindutin ang Edit. Hanapin ang linyang ito:

[html]

[/ html]

At palitan ito ng

[html]

[/ html]

Isinasaalang-alang ko ang kernel source, device source, at vendor libs ng iyong device para sa Android 4.3

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

Ipinapalagay ko na ang sangay ay pinangalanang 'jb4.3'. Mahahanap mo ang eksaktong pangalan sa aktwal na repo. Pagkatapos, sa dulo ng file, idagdag ang mga linyang ito, baguhin ang mga ito ayon sa source code ng iyong device.

[html]




[/ html]

Italaga ang iyong mga pagbabago. Handa nang i-deploy ang iyong remote na manifest.

6. I-install ang Repo Command: Buksan ang Terminal at i-type

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

Dapat nating idagdag ang Repo path sa .bashrc

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

Idagdag ang linyang ito sa dulo ng text file

[html]
i-export ang PATH=$PATH:~/bin
[/ html]

7. Kunin ang ROM source code: Buksan ang Terminal at i-type

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

Kung kailangan mo ng Hakbang 5, pagkatapos ay i-type

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

Kung opisyal na sinusuportahan ng iyong device ang CyanogenMod 10.2, pagkatapos ay i-type

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

Ngayon tumakbo

[html]
repo sync -j16
[/ html]

Kumuha ng kape, o kumain, magtatagal ito. Ang source code ay higit sa 10GB ang laki, kaya medyo magtatagal.

8. I-set up ang Device Specific Stuff: Kung opisyal na sinusuportahan ng iyong device ang CyanogenMod 10.2, buksan ang Terminal at i-type

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

Ito ay magtatagal, ang pinagmulan ng device ay halos 3GB ang laki. Pagkatapos, kailangan mong magkaroon ng opisyal na CM10.2 na naka-install sa iyong telepono, ikonekta ito sa iyong PC sa USB Debugging mode, at patakbuhin ang mga sumusunod na command:

[html]
ugat ng adb
cd ~/android/cm/device/ / /
./extract-files.sh
[/ html]

Kung hindi opisyal na sinusuportahan ng iyong device ang CyanogenMod 10.2, wala kang magagawa sa hakbang na ito, naghihintay na sa iyo ang mga source.

9. I-download ang Prebuilt Stuff at i-set up ang Toolchain: Buksan ang Terminal at i-type

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

Ngayon, kailangan nating idagdag ang Toolchain PATH sa ./bashrc

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

Idagdag ang mga linyang ito sa dulo ng text file

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

10. Buuin ang iyong ROM: Kaya, lahat ay maayos at handa. Oras na para buuin ang ROM. Buksan ang Terminal at i-type

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

Oras na para umidlip. Aabutin ng isang zillion na taon upang maitayo ang ROM sa isang karaniwang computer. Well, iyon ay isang pagmamalabis, ngunit sa aking tahanan PC (Core i5 2nd gen na may 8GB RAM), ito ay tumatagal ng higit sa 3 oras upang bumuo mula sa simula. Sana, walang mga error, at makumpleto nang maayos ang build. Makukuha mo ang output package

[html]
~/android/cm/out/target/product/ /cm-10.2-something-UNOPISYAL- .zip
[/ html]

Oras na para i-install ang iyong bagong compiled ROM sa iyong telepono. I-download ang Google Apps package mula sa “www.goo.im/gapps” para sa naaangkop na bersyon ng Android. Ilagay ang parehong mga pakete sa iyong telepono, at i-flash ang mga ito sa recovery mode. Voila, pinapatakbo na ngayon ng sarili mong compiled ROM ang iyong device.

Kaya, natutunan mo kung paano mag-compile ng ROM. So, ano ngayon?

I-update ang Iyong Source ROM

Para kumuha ng mga bagong update sa source code sa iyong lokal na na-download na source code, buksan ang Terminal, at i-type

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

Upang bumuo ng iyong ROM, pagkatapos i-update ang source code, buksan ang terminal, at i-type

[html]
cd ~/android/cm
gawing malinis ang install
hanapin ang ./out/ -name 'build.prop' | xargs rm
hanapin ang ./out/ -name 'cm_ -target_files-eng.*.zip' | xargs rm
. build / envsetup.sh
brunch
[/ html]

Dahil hindi ka muling nagtatayo mula sa simula, ngunit muling nagtatayo kung ano ito, aabutin ito ng mas kaunting oras, mga 15-30 minuto lamang sa karamihan ng mga kaso. Dapat mong i-sync ang iyong lokal na pinagmulan bawat linggo o higit pa, upang panatilihing sariwa ang iyong lokal na pinagmulan.

Linisin ang Iyong Working Directory

Upang ganap na linisin ang iyong gumaganang direktoryo (basahin ang: ibalik ang iyong source folder sa kondisyon ng stock), buksan ang Terminal at i-type ang mga sumusunod na command.

[html]
cd ~/android/cm
gawing malinis ang install
gumawa ng clobber
[/ html]

Tandaan, na pagkatapos patakbuhin ang mga command na ito, aalisin ang lahat ng iyong output data, kaya ang susunod na build ay tatagal muli ng 3-4 na oras, dahil ang lahat ay muling itinayo mula sa simula. Kung maliit ang partition mo sa Hard Disk, sabihin nating humigit-kumulang 100GB, dapat mong linisin ang iyong gumaganang direktoryo tungkol sa isang beses bawat 4 na build, o kung hindi, mauubusan ka ng espasyo sa Hard Disk.

Pabilisin ang iyong pagbuo sa pamamagitan ng CCACHE

Ang pagbuo ng ROM ay tumatagal ng maraming oras. Ngunit ang oras ay maaaring bawasan ng mga 30-45% sa pamamagitan ng paggamit ng CCACHE. Ang CCACHE ay kumakatawan sa compiler cache, ini-cache nito ang compilation output mula sa iyong mga naunang build, para magamit itong muli sa mga susunod na build.

Tandaan na ang CCACHE ay nangangailangan ng maraming espasyo sa iyong Hard Disk para sa pag-cache ng nilalaman, kaya inirerekomenda ito kung at kung ang iyong Hard Disk partition ay nasa isang lugar sa paligid ng 200GB o mas mataas. Upang i-set up ang CCACHE, buksan ang Terminal at i-type ang:

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

Maaari mong baguhin ang maximum na laki ng alokasyon sa CCACHE mula 50GB sa kahit anong gusto mo, ngunit ang minimum na humigit-kumulang 30GB ay dapat gamitin para sa magagandang resulta.

Kunin ang Mga Commit mula sa Iba pang mga ROM

Maaari kang pumili ng cherry-pick na mga feature mula sa ibang ROMs source code. Sabihin, halimbawa, gusto kong pumili ng Feature A, na may commit ID na "12345" mula sa repository na "github.com/user/reporepo".

Mag-navigate ka sa package sa iyong lokal na source code at patakbuhin ang mga ito sa Terminal.

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

Mga Link ng Source Code ng Mga Sikat na Pamamahagi ng Custom ROM ng Android

CyanogenMod – https://github.com/CyanogenMod
SlimROM – https://github.com/SlimRoms
Hindi mapakaling Android – https://github.com/ParanoidAndroid
AOKP – https://github.com/AOKP
LiquidSmooth – https://github.com/liquidsmooth
Xylon ROM -
Ice Cold Jelly – https://github.com/IceColdJelly

Kaya, hayan na kayo, isang simple, tuwirang gabay upang i-compile ang halos anumang Android AOSP based ROM sa 10 simpleng hakbang. Habang ang aking gabay ay nakatuon sa CyanogenMod, maaari mong i-compile ang halos lahat ng AOSP ROM doon, sa pamamagitan lamang ng pagbabago sa mga link ng repositoryo. O, maaari ka lamang pumili ng mga tampok, i-commit ang mga ito, baguhin ang mga bagay-bagay at lumikha ng iyong sariling personalized na ROM, maaaring ibahagi din ang iyong ROM online?