come

Come compilare il kernel Android su Windows 10

Appual ha alcune ottime guide sullo sviluppo di Android, come How to Build a Custom ROM from Android Open Source Project - ma queste guide sono generalmente orientate verso un ambiente di compilazione Linux puro.

In questa guida, ti mostreremo come creare un kernel Android su Windows 10: sì, continueremo a utilizzare un ambiente di compilazione Linux, ma sarà un sottosistema Linux all'interno di Windows 10. Quindi se sei un Windows 10 utente interessato allo sviluppo per Android, segui attentamente la nostra guida.

In questa guida, impareremo in particolare come creare un kernel per i dispositivi ARM e MediaTek, aggiungendo funzionalità e una panoramica di base sull'uso di Git.

Requisiti

Windows 10 x64 (con l'aggiornamento di Fall Creator)

Impostazione dell'ambiente Linux

Su Windows 10, vai su Impostazioni> Aggiornamento e sicurezza> Per gli sviluppatori> abilita la modalità Sviluppatori.
Ora vai su Pannello di controllo> Programmi> Attiva o disattiva le funzionalità di Windows> abilita il sottosistema Windows per Linux.
Riavvia il PC.
Avviare il sottosistema Linux e consentirgli di eseguire il processo di download. Imposta una password e non perderla.
Ora vai all'App Store di Windows e scarica Ubuntu.
Avvia Ubuntu sul desktop di Windows 10 e richiederà un nome utente e una password.
In Ubuntu, avvia il terminale nativo e digita il seguente comando: apt-get update
Questo procederà ad aggiornare tutti i repository per app e dipendenze.
Avanti nel tipo di terminale: sudo apt-get install -y build-essential pacchetto kernel libncurses5-dev bzip2
Per verificare se tutte le dipendenze sono state installate correttamente, digitare 'gcc' nel terminale (senza virgolette).
Se "gcc" è già installato, dovresti vedere "gcc: errore fatale: nessun file di input"
Ora puoi digitare "make" nel terminale. Se "make" è già installato, dovresti vedere "make: *** nessuna destinazione specificata e nessun makefile trovato. fermare."
Quindi, digita "git" e se "git" è già installato, dovresti vedere un sacco di comandi git di base.
Ora abbiamo bisogno di alcune toolchain (ce ne sono di diversi tipi, tra cui GCC, Linaro e una manciata di quelli personalizzati). Alcuni dispositivi potrebbero richiedere toolchain diversi, ad esempio, non tutti i kernel del dispositivo verranno avviati o compilati con GCC.

Per dispositivi ARM

Per questo utilizzeremo GCC 4.7.

Apri il terminale Linux e digita: kernel mkdir
Ora digita: cd kernel
(non deve essere 'kernel', questo è per semplicità, puoi nominarlo come vuoi.)
Ora digita: git clone //android.googlesource.com/platform/prebuilts/gcc/linux-x86/arm/arm-eabi-4.7

Per dispositivi ARM 64

È necessario un compilatore del kernel a 64 bit per i dispositivi ARM 64, ad esempio aarch64.

Ottenere i file di origine per il tuo dispositivo

Questa è una parte difficile, poiché è necessario trovare un repository GitHub che ospita il sorgente del kernel. Ovviamente dovrai cercarlo, molto probabilmente può essere trovato sui forum XDA.

Ecco un esempio del kernel sorgente Git.

Nella parte in alto a sinistra, dovresti vedere "Branch: Completato da xxxx".

Esistono diverse versioni di un kernel / progetto, generalmente separate da "Testing", "Beta", "Final Release", ecc.

Le cartelle del kernel sono in genere le seguenti:

/ arch / arm / configs : contiene vari file di configurazione per il dispositivo, come governatori, ecc.
/ output / arch / arm / boot / : Qui è dove verrà memorizzato lo zimage.
build.sh : uno script che semplifica il processo di costruzione.
/arm-cortex-linux-gnueabi-linaro_5.2-2015.11-2 : si tratta in genere di una toolchain collocata nel sorgente del kernel, facilitando così la ricerca.

Dovrai scaricare il tuo sorgente del kernel.

Apri il terminale Linux e assicurati di trovarti nella cartella del kernel che hai creato in precedenza (cd kernel).

Quindi digitare il terminale: "git clone" URL del kernel github "-b" nome del ramo "

Ad esempio: "git clone //github.com/atxoxx/android_ke…amsung_msm8974 -b xenomTW"

Costruire il kernel

Per semplificare, è possibile navigare fino alla posizione in Esplora file. Dovrebbe essere / home / ID utente / kernel (o qualunque cosa tu abbia chiamato la cartella del kernel).

Dovresti vedere due cartelle all'interno, per la toolchain e il sorgente del kernel. Entra nella cartella dei sorgenti del kernel.

Per dispositivi ARM

In un terminale, digitare i seguenti comandi:

 #! / bin / bash export ARCH = arm export CROSS_COMPILE = mkdir output make -C $ (pwd) O = output "nome del defconfig e variante se necessario" make -j4 -C $ (pwd) O = output

Ecco una panoramica di ciò che fanno questi comandi, per renderlo più facile in futuro.

#! / bin / bash: dice allo script di essere eseguito nel comando shell
export ARCH = arm: definizione del tipo di architettura del kernel (ad esempio arm64 ecc.)
export CROSS_COMPILE = : individua dove si trova la toolchain. Deve corrispondere al percorso esatto e il trattino alla fine è davvero obbligatorio.
mkdir output: crea una directory per salvare lo zimage compilato
make -C $ (pwd) O = output : definizione di defconfig per guidare la compilazione del kernel.
make -j4 -C $ (pwd) O = output : Quando inizia il processo di costruzione, -j # indica quanto velocemente provare e compilare. In genere, si imposta questo numero in base alla propria CPU. L'impostazione di -j32 su una CPU economica, ad esempio, probabilmente causerebbe una grande instabilità.
cp output / arch / arm / boot / Image $ (pwd) / arch / arm / boot / zImage : serve per spostare l'immagine su un secondo percorso.

Un altro esempio:

 #! / 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 = output msm8974_sec_defconfig VARIANT_DEFCONFIG = msm8974_sec_ks01_skt_defconfig SELINUX_DEFCONFIG = selinux_defconfig make -j4 -C $ (pwd) O = output cp output / arch / arm / boot / Image / $ /

Per dispositivi ARM 64

 #! / bin / bash export ARCH = arm64 export CROSS_COMPILE = "percorso alla tua toolchain" (deve terminare con qualcosa come "nameofarch-qualcosa-") mkdir output make -C $ (pwd) O = output "nome di defconfig e variante se necessario "make -j4 -C $ (pwd) O = output

Per dispositivi Mediatek (MTK)

 #! / bin / bash export CROSS_COMPILE = "percorso alla tua toolchain" (deve terminare con qualcosa come "nameofarch-qualcosa-") export ARCH = arm ARCH_MTK_PLATFORM = make "nome di defconfig e variante se necessario" make -j4

Dopo aver completato i passaggi necessari per l'architettura del kernel, è possibile digitare nel terminale: sudo bash build.sh

Immetterai quindi la password dell'utente e inizierà il processo di compilazione.

Potrebbe volerci un po ', ma in genere non molto lungo, compilare un kernel non è come compilare un'intera ROM Android. Ciò dipende in realtà dalla CPU: ad esempio, un AMD Phenom X4 da 3, 4 GHz con 8 GB di RAM dovrebbe impiegare circa 10 minuti per essere compilato dall'inizio alla fine.

Al termine, dovrebbe avvisarti con un messaggio come "zimage è pronto".

Dispositivi ARM e ARM64

Vai su "/ Output / arch / arm / boot /" per trovare il tuo zimage.

Dispositivi Mediatek

Vai su "/ arch / arm / boot /" per trovare il tuo zimage.

Non tutte le build del kernel comporteranno un file Zimage, a volte può essere creato come altri formati di immagine.

Importante: se si sta per compilare di nuovo, si consiglia di immettere i comandi make clean e make mrproper prima di ricominciare il processo di compilazione.

Creare l'avvio del kernel

Ci sono due opzioni tra cui scegliere.

Puoi utilizzare il metodo anykernel (come definito dall'utente XDA @ osm0sis in questo thread XDA). Dovresti leggere l'intero tutorial, ma un riepilogo dei passaggi è il seguente:

Posiziona zImage nella radice (dtb e / o dtbo dovrebbero andare anche qui per i dispositivi che richiedono quelli personalizzati, ognuno tornerà all'originale se non incluso)
Metti tutti i file ramdisk richiesti in / ramdisk e module in / modules (con il percorso completo come / modules / system / lib / modules)
Posizionare tutti i file di patch richiesti (generalmente file parziali associati ai comandi) in / patch
Modifica anykernel.sh per aggiungere il nome del tuo kernel, la posizione della partizione di avvio, le autorizzazioni per i file ramdisk inclusi e usa i metodi per qualsiasi modifica di ramdisk richiesta (facoltativamente, posiziona anche i banner e / o i file di versione nella radice per visualizzarli durante il flash)
`zip -r9 UPDATE-AnyKernel2.zip * -x .git README.md * segnaposto`

L'altro metodo disponibile è decomprimere boot.img dalla stessa ROM (come CM, TouchWiz, EMUI, ecc.) E la stessa versione di Android. Quindi scambieresti lo Zimage. Ancora una volta, questo è un processo davvero complicato e dovresti leggere l'esercitazione esatta, ma un riepilogo dei passaggi è:

Unzip.
Utilizzare la riga di comando "decomprimere" o semplicemente trascinare e rilasciare l'immagine. Questo dividerà l'immagine e spacchetterà il ramdisk in una sottodirectory.
Modifica il ramdisk come preferisci.
Lo script batch repackimg non richiede input e ricombina semplicemente zImage precedentemente diviso con il ramdisk modificato appena compresso utilizzando tutte le informazioni sull'immagine originale (che è stata anche divisa e salvata).
Lo script batch di pulizia reimposta la cartella al suo stato iniziale, rimuovendo le directory split_img + ramdisk e tutti i nuovi file ramdisk o immagine compressi.

Prima di eseguire il flashing del kernel, è necessario creare un backup del proprio stock boot.img, quindi eseguire il flashing del kernel per vedere se consente al sistema Android di avviarsi.

Aggiunta di funzionalità al kernel

Aggiungere funzionalità al kernel è un ottimo modo per rendere più piccante. Ci sono molte cose che puoi modificare, come i regolatori della CPU, i programmatori IO, l'overclocking della GPU, i miglioramenti audio, ecc.

Un esempio per aggiungere un governatore è qui (questo governatore è in codice Intellimm).

Nelle prime 2 caselle di testo possiamo vedere che in "arch / arm / configs /" sono stati modificati "msm8974_sec_defconfig" e "cm_msm8974_sec_defconfig".

Tra le righe 140 e 141 di questo file è stato aggiunto questo testo: “CONFIG_CPU_FREQ_GOV_INTELLIMM = y”

(Questa riga serve per abilitare Intellimm durante la compilazione del kernel)

La stessa tecnica si applica alle altre caselle di testo (cosa è stato aggiunto ed eliminato e la sua posizione)

A seconda delle funzionalità aggiunte, è possibile modificare, aggiungere o eliminare più o meno file.

Quindi, per riassumere, un commit ti consente di vedere tutte le modifiche che sono state apportate e tutto il resto!

Suggerimenti e trucchi generali

Come modificare il nome e la versione del kernel:

Il metodo semplice:

Modifica questa riga nel tuo file defconfig:

 "CONFIG_LOCALVERSION =" - "after - in defconfig

Esempio: CONFIG_LOCALVERSION = ”- XenomTW-3.2.6 ″

I metodi avanzati:

Passare al Makefile nella cartella principale del proprio kernel.

Aggiungi queste righe:

 CONFIG_LOCALVERSION = "nameofyourkernel" LOCALVERSION = "versionofyourkernel"

NON modificare le righe Version, PatchLevel, Sublevel o Extraversion.

Metodo alternativo:

Vai a script / mkcompile_h e aggiungi queste righe:

 LINUX_COMPILE_BY = "nameofyourchoice" LINUX_COMPILE_HOST = "nameofyourchoice"

Risoluzione dei problemi PATH:

Se si verifica l'errore "Il percorso è corretto?", Provare questo nel terminale Linux:

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

Accesso alle cartelle Ubuntu da Windows 10

Il tuo percorso verso Ubuntu dovrebbe essere in genere:

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

Ma non dovresti modificare i file direttamente da Windows, in quanto ciò in genere romperà le autorizzazioni su di essi - dovrai quindi ripristinare le autorizzazioni dal terminale Linux.