cómo

Cómo construir el kernel de Android en Windows 10

Appual tiene algunas guías excelentes sobre el desarrollo de Android, como Cómo construir una ROM personalizada a partir del proyecto de código abierto de Android, pero estas guías generalmente están orientadas hacia un entorno de compilación de Linux puro.

En esta guía, le mostraremos cómo compilar un kernel de Android en Windows 10; sí, seguiremos utilizando un entorno de compilación de Linux, pero será un subsistema de Linux en Windows 10. Entonces, si usted es un Windows 10 usuario interesado en desarrollar para Android, siga nuestra guía cuidadosamente.

En esta guía, aprenderemos específicamente cómo construir un kernel para dispositivos ARM y MediaTek, agregando características y una descripción básica del uso de Git.

Requisitos

Windows 10 x64 (con la actualización de Fall Creator)

Configurar el entorno Linux

En Windows 10, vaya a Configuración> Actualización y seguridad> Para desarrolladores> habilite el Modo de desarrolladores.
Ahora vaya al Panel de control> Programas> Activar o desactivar las características de Windows> habilitar el Subsistema de Windows para Linux.
Reinicia tu PC.
Inicie el subsistema Linux y permita que pase por el proceso de descarga. Establece una contraseña y no la pierdas.
Ahora ve a la tienda de aplicaciones de Windows y descarga Ubuntu.
Inicie Ubuntu en el escritorio de Windows 10, y solicitará un nombre de usuario y contraseña.
En Ubuntu, inicie la terminal nativa y escriba el siguiente comando: apt-get update
Esto procederá a actualizar todos los repositorios para aplicaciones y dependencias.
Siguiente en el tipo de terminal: sudo apt-get install -y build-essential kernel-package libncurses5-dev bzip2
Para verificar si todas las dependencias se instalaron correctamente, escriba 'gcc' en el terminal (sin comillas).
Si "gcc" ya está instalado, debería ver "gcc: error fatal: sin archivo de entrada"
Ahora puede escribir 'make' en la terminal. Si "make" ya está instalado, debería ver "make: *** no se especificó ningún objetivo y no se encontró un makefile. detener."
Luego escriba 'git', y si "git" ya está instalado, debería ver un montón de comandos básicos de git.
Ahora necesitamos algunas cadenas de herramientas (hay varios tipos, incluidos GCC, Linaro y un puñado de personalizados). Algunos dispositivos pueden requerir diferentes cadenas de herramientas, por ejemplo, no todos los núcleos de dispositivos se iniciarán o compilarán con GCC.

Para dispositivos ARM

Usaremos GCC 4.7 para esto.

Abra el terminal de Linux y escriba: mkdir kernel
Ahora escriba: cd kernel
(no tiene que ser 'kernel', esto es por simplicidad, puedes nombrarlo como quieras).
Ahora escriba: git clone //android.googlesource.com/platform/prebuilts/gcc/linux-x86/arm/arm-eabi-4.7

Para dispositivos ARM 64

Necesita un compilador de kernel de 64 bits para dispositivos ARM 64, por ejemplo aarch64.

Obtener los archivos de origen para su dispositivo

Esta es una parte complicada, ya que necesita encontrar un repositorio de GitHub que aloje la fuente de su núcleo. Por supuesto, deberá buscarlo, lo más probable es que se pueda encontrar en los foros de XDA.

Aquí hay un ejemplo de fuente de kernel Git.

En el lado superior izquierdo, debería ver "Rama: Completado por xxxx".

Existen diferentes versiones de un kernel / proyecto, generalmente separadas por "Pruebas", "Beta", "Versión final", etc.

Las carpetas del núcleo son típicamente las siguientes:

/ arch / arm / configs : contiene varios archivos de configuración para el dispositivo, como gobernadores, etc.
/ output / arch / arm / boot / : Aquí es donde se almacenará el zimage.
build.sh : un script que simplificará el proceso de construcción.
/arm-cortex-linux-gnueabi-linaro_5.2-2015.11-2 : Esta es típicamente una cadena de herramientas ubicada en la fuente del núcleo, lo que facilita su búsqueda.

Necesitará descargar la fuente de su núcleo.

Abra el terminal de Linux y asegúrese de estar en la carpeta del núcleo que creó anteriormente (núcleo del CD).

Luego escriba terminal: "git clone" URL del núcleo github "-b" nombre de la rama "

Por ejemplo: "git clone //github.com/atxoxx/android_ke…amsung_msm8974 -b xenomTW"

Construyendo el núcleo

Para hacerlo más fácil, puede navegar a la ubicación en el explorador de archivos. Debe ser / home / ID de usuario / kernel (o lo que sea que haya llamado la carpeta del kernel).

Debería ver dos carpetas dentro, para la cadena de herramientas y la fuente del núcleo. Vaya dentro de la carpeta de origen del núcleo.

Para dispositivos ARM

En una terminal, escriba los siguientes comandos:

 #! / bin / bash export ARCH = arm export CROSS_COMPILE = mkdir output make -C $ (pwd) O = output "nombre de defconfig y variante si es necesario" make -j4 -C $ (pwd) O = output

Aquí hay una descripción general de lo que hacen estos comandos, para facilitar esto en el futuro.

#! / bin / bash: le dice al script que se ejecute en el comando de shell
export ARCH = arm: definir qué tipo de arquitectura de kernel es (por ejemplo arm64, etc.)
export CROSS_COMPILE = : Localice dónde está la cadena de herramientas. Debe coincidir con la ruta exacta, y el guión al final es realmente obligatorio.
Salida de mkdir: esto crea un directorio para guardar el zimage compilado
make -C $ (pwd) O = output : definición de defconfig para guiar la compilación del kernel.
make -j4 -C $ (pwd) O = output : cuando comienza el proceso de construcción, -j # le indica qué tan rápido puede intentar compilar. Por lo general, establece este número de acuerdo con su CPU. Establecer -j32 en una CPU económica, por ejemplo, probablemente causaría una inestabilidad masiva.
cp output / arch / arm / boot / Image $ (pwd) / arch / arm / boot / zImage : Esto es para mover la imagen a una segunda ruta.

Otro ejemplo:

 #! / bin / bash export ARCH = arm export CROSS_COMPILE = $ (pwd) /arm-cortex-linux-gnueabi-linaro_5.2-2015.11-2/bin/arm-cortex-linux-gnueabi- mkdir output make -C $ (pwd) O = salida msm8974_sec_defconfig VARIANT_DEFCONFIG = msm8974_sec_ks01_skt_defconfig SELINUX_DEFCONFIG = selinux_defconfig make -j4 -C $ (pwd) O = salida cp output / arch / brazo / imagen / archivo / brazo / imagen / arch / brazo / imagen / archivo / imagen / archivo / brazo / imagen / archivo / imagen / archivo / brazo / imagen / archivo / imagen

Para dispositivos ARM 64

 #! / bin / bash export ARCH = arm64 export CROSS_COMPILE = "ruta a su cadena de herramientas" (tiene que terminar por algo como "nameofarch-something-") mkdir output make -C $ (pwd) O = output "nombre de defconfig y variante si es necesario "make -j4 -C $ (pwd) O = output

Para dispositivos Mediatek (MTK)

 #! / bin / bash export CROSS_COMPILE = "ruta a su cadena de herramientas" (tiene que terminar con algo como "nameofarch-something-") export ARCH = arm ARCH_MTK_PLATFORM = make "nombre de defconfig y variante si es necesario" make -j4

Cuando haya completado los pasos necesarios para la arquitectura de su núcleo, puede escribir en el terminal: sudo bash build.sh

Luego ingresará su contraseña de usuario y comenzará el proceso de compilación.

Puede llevar un tiempo, pero normalmente no es mucho tiempo, compilar un núcleo no es como compilar una ROM de Android completa. Esto realmente depende de la CPU; por ejemplo, un AMD Phenom X4 3.4GHz con 8GB de RAM debería tomar alrededor de 10 minutos para compilar de principio a fin.

Cuando finalice, debería notificarte con un mensaje como "zimage está listo".

Dispositivos ARM y ARM64

Vaya a "/ Salida / arch / arm / boot /" para encontrar su zimage.

Dispositivos Mediatek

Vaya a "/ arch / arm / boot /" para encontrar su zimage.

No todas las compilaciones del kernel darán como resultado un archivo Zimage, a veces se puede construir como otros formatos de imagen.

Importante: Si va a compilar nuevamente, se recomienda que ingrese los comandos make clean y make mrproper antes de comenzar nuevamente el proceso de compilación.

Hacer el arranque del kernel

Hay dos opciones para que usted elija.

Puede usar el método anykernel (como lo define el usuario XDA @ osm0sis en este hilo XDA). Debería leer el tutorial completo, pero un resumen de los pasos es el siguiente:

Coloque zImage en la raíz (dtb y / o dtbo también deben ir aquí para los dispositivos que requieren unos personalizados, cada uno recurrirá al original si no está incluido)
Coloque los archivos de ramdisk necesarios en / ramdisk y los módulos en / modules (con la ruta completa como / modules / system / lib / modules)
Coloque los archivos de parche necesarios (generalmente archivos parciales que van con comandos) en / patch
Modifique anykernel.sh para agregar el nombre de su kernel, la ubicación de la partición de arranque, los permisos para los archivos de ramdisk incluidos y use métodos para cualquier modificación de ramdisk requerida (opcionalmente, también coloque los archivos de banner y / o versión en la raíz para que se muestren durante la actualización)
`zip -r9 UPDATE-AnyKernel2.zip * -x .git README.md * marcador de posición`

El otro método que tiene disponible es desempacar boot.img desde la misma ROM (como CM, TouchWiz, EMUI, etc.) y la misma versión de Android. Luego cambiarías el Zimage. Nuevamente, este es un proceso realmente complicado y debe leer el tutorial exacto, pero un resumen de los pasos es:

Abrir la cremallera.
Utilice la línea de comandos "desempaquetar" o simplemente arrastre y suelte la imagen. Esto dividirá la imagen y descomprimirá el ramdisk en un subdirectorio.
Modifica el ramdisk como quieras.
El script por lotes repackimg no requiere entrada y simplemente recombina la zImage previamente dividida con el ramdisk modificado recientemente empaquetado utilizando toda la información de la imagen original (que también se dividió y guardó).
El script por lotes de limpieza restablece la carpeta a su estado inicial, eliminando los directorios split_img + ramdisk y cualquier nuevo ramdisk o archivo de imagen empaquetado.

Antes de actualizar su kernel, debe crear una copia de seguridad de su stock boot.img y luego flashear su kernel para ver si permite que su sistema Android arranque.

Agregar características a su kernel

Agregar características a su núcleo es una excelente manera de darle vida. Hay muchas cosas que puede modificar, como gobernadores de CPU, planificadores de E / S, overclocking de la GPU, mejoras de audio, etc.

Aquí hay un ejemplo para agregar un gobernador (este gobernador tiene el nombre en código Intellimm).

Podemos ver en los primeros 2 cuadros de texto que en "arch / arm / configs /" "msm8974_sec_defconfig" y "cm_msm8974_sec_defconfig" se han modificado.

Entre las líneas 140 y 141 de estos archivos se ha agregado este texto: “CONFIG_CPU_FREQ_GOV_INTELLIMM = y”

(Esta línea es para habilitar Intellimm cuando está compilando su núcleo)

La misma técnica se aplica a los otros cuadros de texto (lo que se ha agregado y eliminado y su ubicación)

Dependiendo de las características que agregue, se pueden modificar, agregar o eliminar más o menos archivos.

Para resumir, un Commit le permite ver todos los cambios que se han realizado y todo lo demás.

Consejos y trucos generales

Cómo cambiar el nombre y la versión del kernel:

El método simple:

Edite esta línea en su archivo defconfig:

 "CONFIG_LOCALVERSION =" - "después - en su defconfig

Ejemplo: CONFIG_LOCALVERSION = ”- XenomTW-3.2.6 ″

Los métodos avanzados:

Navegue hasta el Makefile en la carpeta raíz de la fuente de su núcleo.

Agregue estas líneas:

 CONFIG_LOCALVERSION = "nameofyourkernel" LOCALVERSION = "versionofyourkernel"

NO modifique las líneas Version, PatchLevel, Sublevel o Extraversion.

Método alternativo:

Vaya a scripts / mkcompile_h y agregue estas líneas:

 LINUX_COMPILE_BY = "nameofyourchoice" LINUX_COMPILE_HOST = "nameofyourchoice"

Resolviendo problemas de RUTA:

Si encuentra el error "¿Es correcta su ruta?", Intente esto en el terminal de Linux:

 "export PATH =" pathtotoolchainlocation "/ bin: $ PATH"

Accediendo a sus carpetas de Ubuntu desde Windows 10

Su ruta a Ubuntu normalmente debería ser:

C: \ Users ”NAME” \ AppData \ Local \ Packages \ CanonicalGroupLimited.UbuntuonWindows_79rhkp1fndgsc \ LocalState \ rootfs \ home

Pero no debe editar archivos directamente desde Windows, ya que esto normalmente romperá los permisos sobre ellos; luego deberá restablecer los permisos desde el terminal de Linux.