Android es el sistema operativo móvil más utilizado en el mundo. Y la mejor parte, es completamente 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 lo descarguen, personalicen y creen sus propias ROM.
Hay muchas distribuciones personalizadas de Android disponibles, siendo las más populares 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 el mismo en un 99% para todas las ROM personalizadas, por lo que esta guía se puede utilizar como referencia para compilar otras ROM también.
Pre-requisitos
- Un teléfono Android con Kernel y Device Source fácilmente disponible, ya rooteado y con una recuperación personalizada instalada.
- Distribución Linux de 64 bits (preferimos Ubuntu).
- Al menos 100 GB gratis en su disco duro.
- Conocimiento práctico de los comandos de terminal de Linux.
- Conexión a Internet razonablemente rápida.
Punto a tener en cuenta: El sistema operativo Linux de 64 bits es imprescindible y debe ser una instalación nativa, no una máquina virtual.
Configure su máquina de construcción
1. Instale el sistema operativo Linux de su elección: Versión de 64 bits, según las instrucciones oficiales. (La guía asumirá que estamos ejecutando Ubuntu 13.04). Mantenga una partición de al menos 100 GB con partición de intercambio de 16 GB.
2. Instale la siguiente lista de paquetes: Abra la aplicación Terminal y escriba
[html] sudo apt-get install [/ html]
presione enter y le pedirá su contraseña.
Lista de paquetes
[html]
git-core
gnupg
flexionar
bisonte
pitón
raro
original-awk
papar moscas
p7zip-completo
gperf
libsdl1.2-dev
libesd0-dev
libwxgtk2.6-dev
herramientas-squashfs
build-essential
Código Postal
rizo
libncurses5-dev
zlib1g-dev
pngcrush
herramienta
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. Instale Java JDK 1.6 para Linux de 64 bits: El nombre del archivo debe ser jdk-6u ## - linux-x64.bin, ## son números de versión. Mueva el paquete descargado a su directorio personal. Abra la aplicación Terminal y ejecute el siguiente conjunto de comandos:
[html]
sudo apt-get purge openjdk - \ * icedtea - \ * icedtea6 - \ *
sudo mkdir –p / opt / java / 64 /
sudo cp jdk-6u ## - linux-x64.bin / opt / java / 64
sur en -
cd / opt / java / 64
chmod a + x jdk-6u ## - linux-x64.bin
./jdk-6u##-linux-x64.bin
salida
[/ Html]
Ahora, debemos agregar JDK Path a .bashrc
[html]
sudo gedit ~ / .bashrc
[/ Html]
Agregue estas líneas al final del archivo de texto
[html]
# Ruta de Java
exportar JAVA_HOME = / opt / java / 64 / jdk1.6.0 _ ##
export PATH = $ PATH: $ JAVA_HOME / bin
[/ Html]
4. Instale el SDK de Android: Aplicación de terminal abierta
[html]
Cd
mkdir android && cd android
SDK mkdir
[/ Html]
Descargue el SDK de Android desde http://developer.android.com/sdk/index.html. Extraiga el contenido del paquete a ~ / android / sdk Debemos agregar la ruta del SDK de Android a .bashrc
[html]
sudo gedit ~ / .bashrc
[/ Html]
Agregue estas líneas al final del archivo de texto:
[html]
# Ruta del SDK de Android
export PATH = $ PATH: ~ / android / sdk
export PATH = $ PATH: ~ / android / sdk / platform-tools
export PATH = $ PATH: ~ / android / sdk / tools
[/ Html]
Ahora, instale las herramientas del SDK de Android escribiendo
[html]
android
[/ Html]
5. Configure su cuenta de github y repositorio remoto: Puede omitir este paso si CyanogenMod es compatible con su teléfono oficialmente. Vaya a github.com y cree una cuenta. Para esta guía, considero su nombre de usuario como 'usuario'.
Visite 'github.com/CyanogenMod/android', presione Fork. El manifiesto remoto se bifurcará y estará disponible en su repositorio personal.
Ahora, vaya a 'github.com/user/android'. Abra el archivo default.xml, presione Editar. Encuentra esta línea:
[html]
[/ Html]
Y reemplaza esto con
[html]
[/ Html]
Estoy considerando que la fuente del kernel de su dispositivo, la fuente del dispositivo y las bibliotecas del proveedor para Android 4.3 estén en
[html]
github.com/user2/kernel_source
github.com/user2/device_source
github.com/user2/device-common_source
github.com/user2/vendor
[/ Html]
Supongo 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.
[html]
[/ Html]
Confirme sus cambios. Su manifiesto remoto está listo para implementarse.
6. Instale el comando Repo: Abra Terminal y escriba
[html]
Cd
mkdir ~ / bin
curl https://dl-ssl.google.com/dl/googlesource/git-repo/repo> ~ / bin / repo
chmod a + x ~ / bin / repo
[/ Html]
Debemos agregar la ruta de Repo a .bashrc
[html]
sudo gedit ~ / .bashrc
[/ Html]
Agregue esta línea al final del archivo de texto
[html]
export PATH = $ PATH: ~ / bin
[/ Html]
7. Obtenga el código fuente de la ROM: Abra Terminal y escriba
[html]
mkdir ~ / android / cm
cd ~ / android / cm
[/ Html]
Si necesita el Paso 5, escriba
[html]
repo init –u git: //github.com/user/android.git –b cm-10.2
[/ Html]
Si su dispositivo es compatible con CyanogenMod 10.2 oficialmente, escriba
[html]
repo init –u git: //github.com/CyanogenMod/android.git –b cm-10.2
[/ Html]
Ahora corre
[html]
sincronización de repositorio –j16
[/ Html]
Ve a tomar un café o una comida, te llevará mucho tiempo. El código fuente tiene un tamaño superior a los 10 GB, por lo que llevará bastante tiempo.
8. Configure las cosas específicas del dispositivo: Si su dispositivo es compatible con CyanogenMod 10.2 oficialmente, abra Terminal y escriba
[html]
cd ~ / android / cm
. build / envsetup.sh && desayuno
[/ Html]
Tomará algún tiempo, la fuente del dispositivo tiene un tamaño de aproximadamente 3 GB. Luego, debe tener CM10.2 oficial instalado en su teléfono, conectarlo a su PC en modo de depuración USB y ejecutar los siguientes comandos:
[html]
raíz adb
cd ~ / android / cm / dispositivo / / /
./extraer-archivos.sh
[/ Html]
Si su dispositivo no es compatible con CyanogenMod 10.2 oficialmente, entonces no tiene nada que hacer en este paso, las fuentes ya lo están esperando.
9. Descargue el material prediseñado y configure Toolchain: Abra Terminal y escriba
[html]
cd ~ / android / cm / vendedor / cm
sh ./get-preconstruidos
[/ Html]
Ahora, debemos agregar el PATH de la cadena de herramientas a ./bashrc
[html]
cd ~ / android / cm
sudo gedit ~ / .bashrc
[/ Html]
Agregue estas líneas al final del archivo de texto
[html]
# Cadena de herramientas de Android
exportar ARCH = armar
exportar CCOMPILE = $ CROSS_COMPILE
exportar CROSS_COMPILE = arm-eabi-
export PATH = $ PATH: ~ / android / cm / prebuilt / linux-x86 / toolchain / arm-eabi-4.4.3 / bin
[/ Html]
10. Construye tu ROM: Entonces, todo está bien y listo. Es hora de construir la ROM. Abra Terminal y escriba
[html]
cd ~ / android / cm
. build / envsetup.sh
desayuno tardío
[/ Html]
Es hora de ir a tomar una siesta. Llevará un trillón de años construir la ROM en una computadora promedio. Bueno, eso fue una exageración, pero en la PC de mi hogar (Core i5 de segunda generación con 2GB de RAM), se necesitan más de 8 horas para construir desde cero. Con suerte, no habrá errores y la compilación se completará bien. Obtendrá el paquete de salida en
[html]
~ / android / cm / out / target / product / /cm-10.2-algo-NO OFICIAL- .Código Postal
[/ Html]
Es hora de instalar su ROM recién compilada en su teléfono. Descargue el paquete de Google Apps de "www.goo.im/gapps" para la versión de Android adecuada. Coloque ambos paquetes en su teléfono y actualícelos en modo de recuperación. Voila, su propia ROM compilada ahora está ejecutando su dispositivo.
Bueno, entonces aprendiste a compilar una ROM. ¿Y ahora que?
Actualice su ROM de origen
Para obtener nuevas actualizaciones de código fuente para su código fuente descargado localmente, abra Terminal y escriba
[html]
cd ~ / android / cm
sincronización de repositorio –j16
[/ Html]
Para construir su ROM, después de actualizar el código fuente, abra el terminal y escriba
[html]
cd ~ / android / cm
hacer installclean
buscar ./out/ -name 'build.prop' | xargs rm
buscar ./out/ -name 'cm_ -archivos_destino-eng. *. zip '| xargs rm
. build / envsetup.sh
desayuno tardío
[/ Html]
Dado que no está reconstruyendo desde cero, sino reconstruyendo tal como está, tomará mucho menos tiempo, solo unos 15-30 minutos en la mayoría de los casos. Debe sincronizar su fuente local cada semana, para mantener su fuente local actualizada.
Limpia tu directorio de trabajo
Para limpiar su directorio de trabajo por completo (lea: devuelva su carpeta de origen a la condición de stock), abra Terminal y escriba los siguientes comandos.
[html]
cd ~ / android / cm
hacer installclean
hacer una paliza
[/ Html]
Tenga en cuenta que después de ejecutar estos comandos, se eliminarán todos sus datos de salida, por lo que la próxima compilación tomará de 3 a 4 horas nuevamente, 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.
Acelera tu construcción con CCACHE
Construir una ROM lleva mucho tiempo. Pero el tiempo se puede reducir en aproximadamente un 30-45% usando CCACHE. CCACHE significa caché del compilador, almacena en caché la salida de la compilación de sus compilaciones anteriores, para que pueda reutilizarse en compilaciones posteriores.
Tenga en cuenta que CCACHE necesita mucho espacio en su disco duro para almacenar en caché el contenido, por lo que se recomienda si y solo si la partición de su disco duro se encuentra en las proximidades de 200 GB o más. Para configurar CCACHE, abra Terminal y escriba:
[html]
cd ~ / android / cm
exportar USE_CCACHE = 1
exportar CACHE_DIR = ~ / .ccache
precompilados / misc / linux-x86 / ccache / ccache –M 50G
[/ Html]
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 funciones del código fuente de otras ROM. Digamos, por ejemplo, que quiero elegir la función A, con el ID de confirmación "12345" del repositorio "github.com/user/reporepo".
Navega hasta el paquete en su código fuente local y los ejecuta en Terminal.
[html]
cd ~ /
git buscar https://github.com/user/reporepo
git selección de cereza 12345
[/ Html]
Enlaces de código fuente de distribuciones de ROM personalizadas de Android famosas
CyanogenMod - https://github.com/CyanogenMod
SlimROM - https://github.com/SlimRoms
paranoidandroid - https://github.com/ParanoidAndroid
AOKP - https://github.com/AOKP
Líquido Suave - https://github.com/liquidsmooth
ROM de Xylon –
Jalea helada - https://github.com/IceColdJelly
Entonces, ahí lo tienen chicos, una guía simple y directa para compilar virtualmente cualquier ROM basada en Android AOSP en 10 simples pasos. Si bien mi guía se centra en CyanogenMod, puede compilar prácticamente todas las ROM AOSP que existen, simplemente modificando los enlaces del repositorio. ¿O simplemente puede elegir características, confirmarlas, modificar cosas y crear su propia ROM personalizada, tal vez compartir su ROM en línea también?
vishvasta
hola gracias por este artículo hoy este mundo android se está extendiendo como una epidemia así que un buen artículo
jurie estertores
¡Obras impresionantes! ¡Realmente quiero crear mi propio código para mis aplicaciones!
Jessica
Realmente me encanta ver este código, pero una parte de este código no puedo entender.
Deb Shyantan
hola Shaunak,
Android está muy extendido en todo el mundo. y gracias por esta increíble publicación
susie lamman
Excelente. Ahora, si tan solo pudiera entender estas terminologías. Entonces puedo compilar la ROM de Android