DIY: Compilar la ROM de Android a partir del Código fuente

enero 18, 2022

Android es el sistema operativo móvil más utilizado en el mundo. Y la mejor parte, es de código abierto, lo que en términos sencillos, significa que el Código Fuente, el programa real, está disponible abiertamente para que todos puedan descargar, personalizar y construir sus propias ROM.

Hay muchas distribuciones personalizadas de Android disponibles, con las más populares como CyanogenMod, SlimRom, Paranoid Android,AOKP, Liquid Smooth, MIUI, Xylon, Ice Cold Jelly, etc.

Para la guía de hoy, compilaremos CyanogenMod 10.2, la ROM del mercado de accesorios de Android más popular. El procedimiento es 99% el mismo para todas las ROMs personalizadas, por lo que esta guía también se puede usar como referencia para compilar otras ROMs.

Requisitos previos

Un teléfono Android con Kernel y Fuente de dispositivo fácilmente disponibles, ya arraigados y con una recuperación personalizada instalada.
Distribución Linux de 64 bits (Preferimos Ubuntu).
Al menos 100 GB libres en su disco duro.
Conocimiento práctico de los Comandos de Terminal de Linux.
Conexión a Internet razonablemente rápida.

Tenga en cuenta: el sistema operativo Linux de 64 bits es obligatorio y debe ser una instalación nativa, no una Máquina virtual.

Configure Su Máquina De Compilación

1. Instale el sistema operativo Linux de su elección: versión de 64 bits, de acuerdo con las instrucciones oficiales. (La guía asumirá que estamos ejecutando Ubuntu 13.04). Mantenga una partición de al menos 100 GB con una partición de intercambio de 16 GB.

2. Instale la siguiente lista de paquetes: Abra la aplicación de terminal y escriba

sudo apt-get install < nombre del paquete>

presione entrar y le pedirá su contraseña.

Lista de Paquetes

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. Abra la aplicación Terminal y ejecute el siguiente conjunto de comandos:

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

Ahora, debemos agregar la ruta JDK a .bashrc

sudo gedit ~/.bashrc

Añadir estas líneas al final del archivo de texto

# Java Path
export JAVA_HOME=/opt/java/64/jdk1.6.0_##
export PATH=$PATH:JAV JAVA_HOME / bin

4. Instale el SDK de Android: Abra la aplicación de terminal

cd ~
mkdir android & & cd android
mkdir sdk

Descargue el SDK de Android desde http://developer.android.com/sdk/index.html. Extraiga el contenido del paquete a ~ / android / sdk Al que debemos agregar la ruta del SDK de Android .bashrc

sudo gedit ~/.bashrc

Añadir estas líneas al final del archivo de texto:

# la Ruta del SDK de Android
export PATH=$PATH:~/android/sdk
export PATH=$PATH:~/android/sdk/platform-tools
export PATH=$PATH:~ / android / sdk / tools

Ahora, instale las herramientas del SDK de Android escribiendo

android

5. Configura tu cuenta de github y repositorio remoto: Puedes omitir este paso si CyanogenMod admite tu teléfono oficialmente. Ir a github.com y haz una cuenta por ti mismo. Para esta guía, estoy considerando su nombre de usuario como ‘usuario’.

Visita «github.com/CyanogenMod/android’, presione el tenedor. El manifiesto remoto estará bifurcado y disponible en su repositorio personal.

Ahora, vaya a «github.com/user/android’. Abra el archivo predeterminado.xml, pulse Editar. Encuentra esta línea:

Y reemplace esto con

Estoy considerando que la fuente del núcleo de su dispositivo, la fuente del dispositivo y las bibliotecas de proveedores para Android 4.3 estén en

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

Asumo que la rama se llamará ‘jb4. 3’. Puede encontrar el nombre exacto en el repositorio real. Luego, al final del archivo, agregue estas líneas, modificándolas de acuerdo con el código fuente de su dispositivo.

confirmar los cambios. Su manifiesto remoto está listo para ser desplegado.

6. Instale la Repo de Comando: Abre el Terminal y teclea

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

debemos agregar la Repo de ruta .bashrc

sudo gedit ~/.bashrc

Añadir esta línea al final del archivo de texto

export PATH=$PATH:~/bin

7. Recuperar el código fuente de la ROM: Abre el Terminal y teclea

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

Si usted necesita el Paso 5, a continuación, escriba

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

Si su dispositivo es compatible con CyanogenMod 10.2 oficialmente, a continuación, escriba

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

Ahora ejecute

repo sync –j16

Ir a tomar un café o una comida, que va a tomar un tiempo largo. El código fuente tiene un tamaño de más de 10 GB, por lo que llevará bastante tiempo.

8. Configure las Cosas específicas del dispositivo: Si su dispositivo admite CyanogenMod 10.2 oficialmente, abra el Terminal y escriba

cd ~/android/cm
. build/envsetup.sh && desayuno <nombre del dispositivo>

Tomará algún tiempo, la fuente del dispositivo es de aproximadamente 3 GB de tamaño. Luego, debe tener instalado el CM10.2 oficial en su teléfono, conectarlo a su PC en modo de depuración USB y ejecutar los siguientes comandos:

raíz de adb
cd ~/android/cm/device/<your_company>/<your_device>/
./extract-files.sh

Si su dispositivo no es compatible oficialmente con CyanogenMod 10.2, entonces no tiene nada que hacer en este paso, las fuentes ya lo están esperando.

9. Descargue Material Preconfigurado y configure la cadena de herramientas: Abra el terminal y escriba

cd ~ / android / cm/vendor / cm
sh ./ get-prebuilts

Ahora, debemos agregar la RUTA de la cadena de herramientas a ./ bashrc

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

Añadir estas líneas al final del archivo de texto

# Android conjunto de Herramientas
exportar ARCO=brazo
exportar CCOMPILE=$CROSS_COMPILE
exportar CROSS_COMPILE=arm-eabi-
export PATH=$PATH:~/android/cm/prefabricado/linux-x86/toolchain/arm-eabi-4.4.3/bin

10. Construye tu ROM: Entonces, todo está bien y listo. Es hora de construir la ROM. Abra el terminal y escriba

cd ~ / android / cm
. build/envsetup.sh
almuerzo < device_codename>

Hora de dormir la siesta. Tomará un millón de años construir la ROM en una computadora promedio. Bueno, eso fue una exageración, pero en mi PC de casa (Core i5 de 2a generación con 8 GB de RAM), se necesitan más de 3 horas para construir desde cero. Con suerte, no habrá errores y la compilación se completará bien. Obtendrá la salida del paquete en

~/android/cm/out/target/product/<your_device>/cm-10.2-something-UNOFFICIAL-<your_device>.zip

Es hora de instalar la ROM recién compilada en el teléfono. Descargue el paquete de Google Apps desde » www.goo.im / gapps » para la versión de Android apropiada. Poner tanto los paquetes en su teléfono, y el flash en modo de recuperación. Voila, tu propia ROM compilada está ejecutando tu dispositivo.

Bueno, así que aprendiste a compilar una ROM. ¿Y ahora qué?

Actualice Su ROM de origen

Para obtener nuevas actualizaciones de código fuente a su código fuente descargado localmente, terminal abierto y escriba

cd ~/android/cm
repo sync –j16

Para compilar su ROM, después de actualizar el código fuente, terminal abierto y escriba

cd ~/android/cm
make installclean
buscar ./ out / – nombre ‘build.prop ‘ / xargs rm
buscar ./ out / – name ‘ cm_< su_dispositivo> – archivos de destino-eng.*.zip ‘ / xargs rm
. build/envsetup.sh
almuerzo < su_dispositivo>

Dado que no está reconstruyendo desde cero, sino reconstruyendo como es, tomará mucho menos tiempo, solo unos 15-30 minutos en la mayoría de los casos. Debe sincronizar su fuente local cada semana, más o menos, para mantener su fuente local fresca.

Limpie su Directorio de trabajo

Para limpiar su directorio de trabajo completamente (leer: devuelva su carpeta de origen a la condición de stock), abra Terminal y escriba los siguientes comandos.

cd ~ / android / cm
make installclean
make clobber

Tenga en cuenta que después de ejecutar estos comandos, todos los datos de salida se eliminarán, por lo que la próxima compilación tomará de 3 a 4 horas de nuevo, ya que todo se reconstruirá desde cero. Si su partición de disco duro es pequeña, digamos alrededor de 100 GB, debe limpiar su directorio de trabajo aproximadamente una vez cada 4 compilaciones, o de lo contrario, se quedará sin espacio en el disco duro.

Acelere su compilación mediante CCACHE

Crear una ROM lleva mucho tiempo. Pero el tiempo se puede reducir en aproximadamente un 30-45% mediante el uso de CCACHE. CCACHE significa caché de compilador, almacena en caché el resultado de la compilación de sus compilaciones anteriores, para que pueda reutilizarse en compilaciones posteriores.

Tenga en cuenta que CCACHE necesita mucho espacio en el disco duro para almacenar en caché el contenido, por lo que se recomienda si y solo si la partición del disco duro está cerca de 200 GB o superior. Para configurar CCACHE, abra el terminal y escriba:

cd ~ / android / cm
exportar USE_CCACHE = 1
exportar CACHE_DIR=~/.ccache
precompilados/misc / linux-x86 / ccache / ccache-M 50G

Puede cambiar la asignación de tamaño máximo a CCACHE de 50 GB a lo que desee, pero se debe usar un mínimo de alrededor de 30 GB para obtener buenos resultados.

Obtener confirmaciones de otras ROM

Puede seleccionar características del código fuente de otras ROM. Digamos, por ejemplo, que quiero elegir la característica A, con el ID de confirmación «12345» del repositorio «github.com/user/reporepo».

Navegue hasta el paquete en su código fuente local y ejecútelo en Terminal.

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

Enlaces de código Fuente de famosas Distribuciones ROM Personalizadas de Android

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 –
Gelatina helada– https://github.com/IceColdJelly

Así que, ahí lo tienen, chicos, una guía sencilla y directa para compilar prácticamente cualquier ROM basada en Android AOSP en 10 sencillos pasos. Aunque mi guía se centra en CyanogenMod, puedes compilar prácticamente todas las ROM AOSP que existen, simplemente modificando los enlaces al repositorio. O, puede simplemente elegir características, confirmarlas, modificar cosas y crear su propia ROM personalizada, tal vez compartir su ROM en línea también.

NCPEA Professor

Blog, Lifestyle and News