Zrób to sam: skompiluj ROM Androida z kodu źródłowego

Android to najczęściej używany mobilny system operacyjny na świecie. A najlepsze jest to, że jest całkowicie open-source, co w kategoriach laików oznacza, że ​​kod źródłowy, rzeczywisty program, jest dostępny dla każdego, aby mógł pobierać, dostosowywać i budować własne ROM-y.

Dostępnych jest wiele niestandardowych dystrybucji Androida, z których popularne to CyanogenMod, SlimROM, Paranoid Android, AOKP, Liquid Smooth, MIUI, Xylon, Ice Cold Jelly itp.

W dzisiejszym przewodniku skompilujemy CyanogenMod 10.2, najpopularniejszy ROM na rynku wtórnym dla Androida. Procedura jest w 99% taka sama dla wszystkich niestandardowych ROM-ów, więc ten przewodnik może być używany jako odniesienie do kompilacji innych ROM-ów.

Wymagania wstępne

1. Telefon z Androidem z łatwo dostępnym jądrem i źródłem urządzenia, już zrootowany i z zainstalowanym niestandardowym odzyskiwaniem.
2. 64-bitowa dystrybucja Linuksa (preferujemy Ubuntu).
3. Co najmniej 100 GB za darmo na dysku twardym.
4. Praktyczna znajomość poleceń terminalowych systemu Linux.
5. Dość szybkie łącze internetowe.

Warto zwrócić uwagę: 64-bitowy system operacyjny Linux jest koniecznością i musi to być instalacja natywna, a nie maszyna wirtualna.

Skonfiguruj swoją maszynę do budowy

1. Zainstaluj wybrany system operacyjny Linux: Wersja 64-bitowa, zgodnie z oficjalnymi instrukcjami. (Przewodnik zakłada, że ​​używamy Ubuntu 13.04). Zachowaj partycję o wielkości co najmniej 100 GB z 16 GB Swap Partition.

2. Zainstaluj następującą listę pakietów: Otwórz aplikację Terminal i wpisz

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

naciśnij enter, a pojawi się monit o podanie hasła.

Lista opakowanie

[html]
git-core
gnupg
zgiąć
bizon
pyton
rar
oryginalny-awk
gapić się
p7zip-pełny
gperf
libsdl1.2-dev
libesd0-dev
libwxgtk2.6-dev
squashfs-narzędzia
build-essential
zamek błyskawiczny
curl
libncurses5-dev
zlib1g-dev
pngcrush
narzędzie harmonogramu
libc6-dev
x11proto-core-dev
libx11-dev
libg11-mesa-dev
mw32
tofrody
python-przecena
libxml2-narzędzia
g++-multilib
lib32z1-dev
ia32-libs
lib32ncurses5-dev
lib32readline-gplv2-dev
gcc-multilib
g++-multilib
xsltproc
[/ html]

3. Zainstaluj Java JDK 1.6 dla 64-bitowego systemu Linux: Nazwa pliku powinna brzmieć jdk-6u##-linux-x64.bin, ## to numery wersji. Przenieś pobrany pakiet do swojego katalogu domowego. Otwórz aplikację Terminal i uruchom następujący zestaw poleceń:

[html]
sudo apt-get purge openjdk-\* icedtea-\* icedtea6-\*
sudo mkdir –p /opt/java/64/
sudo cp jdk-6u##-linux-x64.bin /opt/java/64
na południe -
cd /opcja/java/64
chmod a+x jdk-6u##-linux-x64.bin
./jdk-6u##-linux-x64.bin
wyjście
[/ html]

Teraz musimy dodać ścieżkę JDK do .bashrc

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

Dodaj te linie na końcu pliku tekstowego

[html]
# Ścieżka Java
eksportuj JAVA_HOME=/opt/java/64/jdk1.6.0_##
eksportuj PATH=$PATH:$JAVA_HOME/bin
[/ html]

4. Zainstaluj pakiet Android SDK: Otwórz aplikację terminala

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

Pobierz pakiet Android SDK z http://developer.android.com/sdk/index.html. Wypakuj zawartość pakietu do ~/android/sdk Musimy dodać ścieżkę Android SDK do .bashrc

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

Dodaj te wiersze na końcu pliku tekstowego:

[html]
# Ścieżka SDK na Androida
eksportuj PATH=$PATH:~/android/sdk
export PATH=$PATH:~/Android/sdk/platform-tools
export PATH=$PATH:~/android/sdk/tools
[/ html]

Teraz zainstaluj narzędzia Android SDK, wpisując

[html]
android
[/ html]

5. Skonfiguruj swoje konto github i zdalne repozytorium: Możesz pominąć ten krok, jeśli CyanogenMod oficjalnie obsługuje Twój telefon. Wejdź na github.com i załóż konto dla siebie. W tym przewodniku twoją nazwę użytkownika uważam za „użytkownik”.

Odwiedź „github.com/CyanogenMod/android”, naciśnij Widelec. Zdalny manifest zostanie rozwidlony i będzie dostępny w Twoim osobistym repozytorium.

Teraz przejdź do „github.com/user/android”. Otwórz plik default.xml, naciśnij Edytuj. Znajdź tę linię:

[html]

[/ html]

I zastąp to

[html]

[/ html]

Uważam, że źródła jądra twojego urządzenia, źródła urządzenia i biblioteki dostawców dla Androida 4.3 są na

[html]
github.com/user2/źródło_jądra
https://github.com/user2/device_source
https://github.com/user2/device-common_source
github.com/user2/dostawca
[/ html]

Zakładam, że gałąź ma nazwę „jb4.3”. Dokładną nazwę można znaleźć w rzeczywistym repozytorium. Następnie na końcu pliku dodaj te wiersze, modyfikując je zgodnie z kodem źródłowym urządzenia.

[html]




[/ html]

Zatwierdź swoje zmiany. Twój zdalny manifest jest gotowy do wdrożenia.

6. Zainstaluj polecenie repozytorium: Otwórz terminal i wpisz

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

Musimy dodać ścieżkę Repo do .bashrc

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

Dodaj tę linię na końcu pliku tekstowego

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

7. Pobierz kod źródłowy ROM: Otwórz terminal i wpisz

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

Jeśli potrzebujesz kroku 5, wpisz

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

Jeśli Twoje urządzenie oficjalnie obsługuje CyanogenMod 10.2, wpisz

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

Teraz biegnij

[html]
synchronizacja repo –j16
[/ html]

Idź na kawę lub posiłek, zajmie to dużo czasu. Kod źródłowy ma rozmiar znacznie ponad 10 GB, więc zajmie to trochę czasu.

8. Skonfiguruj elementy specyficzne dla urządzenia: Jeśli Twoje urządzenie oficjalnie obsługuje CyanogenMod 10.2, otwórz Terminal i wpisz

[html]
cd ~/Android/cm
. build/envsetup.sh i śniadanie
[/ html]

To zajmie trochę czasu, źródło urządzenia ma rozmiar około 3 GB. Następnie musisz mieć zainstalowany oficjalny CM10.2 w telefonie, podłączyć go do komputera w trybie debugowania USB i uruchomić następujące polecenia:

[html]
korzeń adb
cd ~/android/cm/urządzenie/ / /
./extract-files.sh
[/ html]

Jeśli Twoje urządzenie oficjalnie nie obsługuje CyanogenMod 10.2, to nie masz nic do zrobienia w tym kroku, źródła już na Ciebie czekają.

9. Pobierz gotowe elementy i skonfiguruj Toolchain: Otwórz terminal i wpisz

[html]
cd ~/android/cm/dostawca/cm
sh ./get-prebuilds
[/ html]

Teraz musimy dodać ścieżkę Toolchain PATH do ./bashrc

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

Dodaj te linie na końcu pliku tekstowego

[html]
# Łańcuch narzędzi Androida
eksportuj ARCH=ramię
eksportuj CCOMPILE=$CROSS_COMPILE
eksportuj CROSS_COMPILE=arm-eabi-
export PATH=$PATH:~/android/cm/prebuilt/linux-x86/toolchain/arm-eabi-4.4.3/bin
[/ html]

10. Zbuduj swój ROM: Więc wszystko jest w porządku i gotowe. Czas zbudować ROM. Otwórz terminal i wpisz

[html]
cd ~/Android/cm
. build/envsetup.sh
późne śniadanie
[/ html]

Czas iść się zdrzemnąć. Zbudowanie pamięci ROM na przeciętnym komputerze zajmie milion lat. Cóż, to była przesada, ale na moim domowym komputerze (Core i5 2. generacji z 8 GB RAM) budowanie od zera zajmuje ponad 3 godziny. Mamy nadzieję, że nie będzie żadnych błędów, a kompilacja zakończy się dobrze. Pakiet wyjściowy otrzymasz za

[html]
~/android/cm/out/cel/produkt/ /cm-10.2-coś-NIEOFICJALNE- .zamek błyskawiczny
[/ html]

Czas zainstalować nowo skompilowaną pamięć ROM w telefonie. Pobierz pakiet Google Apps ze strony „www.goo.im/gapps” dla odpowiedniej wersji Androida. Umieść oba te pakiety w telefonie i sflashuj je w trybie odzyskiwania. Voila, Twój własny skompilowany ROM obsługuje teraz Twoje urządzenie.

Cóż, więc nauczyłeś się kompilować ROM. I co teraz?

Zaktualizuj swoją źródłową pamięć ROM

Aby pobrać nowe aktualizacje kodu źródłowego do lokalnie pobranego kodu źródłowego, otwórz Terminal i wpisz

[html]
cd ~/Android/cm
synchronizacja repo –j16
[/ html]

Aby zbudować ROM, po zaktualizowaniu kodu źródłowego otwórz terminal i wpisz

[html]
cd ~/Android/cm
spraw, aby instalacja była czysta
find ./out/ -name 'build.prop' | xargs rm
znajdź ./out/ -nazwa 'cm_ -target_files-eng.*.zip' | xargs rm
. build/envsetup.sh
późne śniadanie
[/ html]

Ponieważ nie budujesz od podstaw, ale odbudowujesz taki, jaki jest, zajmie to znacznie mniej czasu, w większości przypadków tylko około 15-30 minut. Należy synchronizować lokalne źródło mniej więcej co tydzień, aby zachować aktualność lokalnego źródła.

Wyczyść swój katalog roboczy

Aby całkowicie wyczyścić katalog roboczy (czytaj: przywróć folder źródłowy do stanu magazynowego), otwórz Terminal i wpisz następujące polecenia.

[html]
cd ~/Android/cm
spraw, aby instalacja była czysta
zrobić clobbera
[/ html]

Pamiętaj, że po uruchomieniu tych poleceń wszystkie dane wyjściowe zostaną usunięte, więc następna kompilacja zajmie 3-4 godziny, ponieważ wszystko jest budowane od nowa. Jeśli partycja na dysku twardym jest mała, powiedzmy około 100 GB, należy wyczyścić katalog roboczy mniej więcej raz na 4 kompilacje, w przeciwnym razie zabraknie miejsca na dysku twardym.

Przyspiesz swoją budowę przez CCACHE

Budowanie pamięci ROM zajmuje dużo czasu. Ale czas można skrócić o około 30-45% za pomocą CCACHE. CCACHE oznacza pamięć podręczną kompilatora, buforuje dane wyjściowe kompilacji z wcześniejszych kompilacji, dzięki czemu można je ponownie wykorzystać w późniejszych kompilacjach.

Pamiętaj, że CCACHE potrzebuje dużo miejsca na dysku twardym do buforowania zawartości, więc jest zalecane wtedy i tylko wtedy, gdy partycja dysku twardego ma około 200 GB lub więcej. Aby skonfigurować CCACHE, otwórz Terminal i wpisz:

[html]
cd ~/Android/cm
eksportuj USE_CCACHE=1
eksportuj CACHE_DIR=~/.ccache
prekompilacje/misc/linux-x86/ccache/ccache –M 50G
[/ html]

Możesz zmienić maksymalny rozmiar przydziału na CCACHE z 50 GB na dowolny, ale dla dobrych wyników należy użyć minimum około 30 GB.

Pobierz polecenia z innych ROM-ów

Możesz wybrać funkcje z innych kodów źródłowych ROM-ów. Powiedzmy na przykład, że chcę wybrać funkcję A z identyfikatorem zatwierdzenia „12345” z repozytorium „github.com/user/reporepo”.

Przechodzisz do pakietu w lokalnym kodzie źródłowym i uruchamiasz je w Terminalu.

[html]
cd ~/
git pobieranie https://github.com/user/reporepo
git cherrypick 12345
[/ html]

Linki do kodu źródłowego znanych niestandardowych dystrybucji ROM Androida

CyanogenMod – https://github.com/CyanogenMod
SlimROM – https://github.com/SlimRoms
ParanoidAndroid – https://github.com/ParanoidAndroid
AOKP – https://github.com/AOKP
PłynnyGładki – https://github.com/liquidsmooth
Xylon ROM -
Lodowa Galaretka – https://github.com/IceColdJelly

Tak więc, proszę, prosty, prosty przewodnik do kompilacji praktycznie dowolnej pamięci ROM opartej na systemie Android AOSP w 10 prostych krokach. Podczas gdy mój przewodnik koncentruje się na CyanogenMod, możesz skompilować prawie każdy ROM AOSP, po prostu modyfikując łącza do repozytorium. Lub możesz po prostu wybrać funkcje, zatwierdzić je, zmodyfikować rzeczy i stworzyć własny spersonalizowany ROM, a może udostępnić ROM również online?