hvordan

Slik bygger du Android Kernel på Windows 10

Appual's har noen gode guider for Android-utvikling, for eksempel hvordan du bygger en tilpasset ROM fra Android Open Source Project - men disse guidene er vanligvis rettet mot et rent Linux-bygningsmiljø.

I denne guiden skal vi vise deg hvordan du bygger en Android-kjerne på Windows 10 - ja, vi bruker fremdeles et Linux build-miljø, men det vil være et Linux-undersystem i Windows 10. Så hvis du er en Windows 10 bruker som er interessert i å utvikle for Android, følg vår guide nøye.

I denne guiden skal vi spesifikt lære å bygge en kjerne for ARM og MediaTek-enheter, legge til funksjoner og en grunnleggende oversikt over bruk av Git.

Krav

Windows 10 x64 (med Fall Creators oppdatering)

Sette opp Linux-miljøet

På Windows 10 går du til Innstillinger> Oppdatering og sikkerhet> For utviklere> aktiver utviklermodus.
Gå nå til Kontrollpanel> Programmer> Slå Windows-funksjoner på eller av> aktiver Windows Subsystem for Linux.
Start PCen på nytt.
Start Linux-undersystemet, og la det gå gjennom nedlastingsprosessen. Angi et passord og ikke mist det.
Gå nå til Windows app store, og last ned Ubuntu.
Start Ubuntu på Windows 10-skrivebordet, og det vil be om et brukernavn og passord.
Start Ubuntu-terminalen i Ubuntu og skriv inn følgende kommando: apt-get update
Dette fortsetter med å oppdatere alle repos for apper og avhengigheter.
Neste i terminaltypen: sudo apt-get install -y build-essential kernel-package libncurses5-dev bzip2
For å sjekke om alle avhengigheter var riktig installert, skriver du 'gcc' i terminalen (ingen anførselstegn).
Hvis “gcc” allerede er installert, skal du se “gcc: dødelig feil: ingen inndatafil”
Nå kan du skrive 'make' i terminalen. Hvis “make” allerede er installert, skal du se “make: *** intet mål spesifisert og ingen makefile funnet. Stoppe."
Neste type 'git', og hvis "git" allerede er installert, ser du haug med grunnleggende git-kommandoer.
Nå trenger vi noen verktøykjeder (det finnes flere typer, inkludert GCC, Linaro og en håndfull tilpassede). Noen enheter kan kreve forskjellige verktøykjeder, for eksempel vil ikke alle enhetskjerner starte opp eller kompilere med GCC.

For ARM-enheter

Vi bruker GCC 4.7 for dette.

Åpne Linux-terminalen og skriv: mkdir-kjernen
Skriv nå: cd kernel
(det trenger ikke å være 'kjernen', dette er for enkelhets skyld, du kan navngi det du vil.)
Skriv nå: git klone //android.googlesource.com/platform/prebuilts/gcc/linux-x86/arm/arm-eabi-4.7

For ARM 64-enheter

Du trenger en 64-biters kjernekompilator for ARM 64-enheter, for eksempel aarch64.

Få tak i kildefilene for enheten din

Dette er en vanskelig del, ettersom du trenger å finne en GitHub-repo som er vert for kjernekilden. Du vil selvfølgelig trenge å søke etter det, mest sannsynlig kan du finne det på XDA-fora.

Her er et eksempel på kjernen kilde Git.

På øvre venstre side skal du se “Gren: fullført av xxxx”.

Det er forskjellige versjoner av en kjerne / prosjekt, vanligvis adskilt med "Testing", "Beta", "Final Release", etc.

Kjerne-mappene er vanligvis som følger:

/ arch / arm / configs : Denne inneholder forskjellige konfigurasjonsfiler for enheten, for eksempel guvernører, etc.
/ output / arch / arm / boot / : Det er her zimage vil bli lagret.
build.sh : Et skript som vil forenkle byggeprosessen.
/arm-cortex-linux-gnueabi-linaro_5.2-2015.11-2 : Dette er vanligvis en verktøykjede plassert i kjernekilden, og dermed gjør det lettere å finne.

Du trenger å laste ned kjernekilden.

Åpne Linux-terminalen og sørg for at du er i kjerne-mappen du tidligere har opprettet (cd-kjerne).

Skriv deretter inn terminal: "git klone" URL til github-kjernen "-b" navnet på grenen "

For eksempel: “git klone //github.com/atxoxx/android_ke…amsung_msm8974 -b xenomTW”

Bygge kjernen

For å gjøre det enklere kan du navigere til stedet i filutforskeren. Det skal være / hjemme / bruker-ID / kjerne (eller hva du heter kjerne-mappen).

Du bør se to mapper inne, for verktøykjeden og kjernekilden. Gå inn i kildekildemappen.

For ARM-enheter

Skriv inn følgende kommandoer i en terminal:

 #! / bin / bash export ARCH = arm eksport CROSS_COMPILE = mkdir output make -C $ (pwd) O = output "name of defconfig and variant om nødvendig" make -j4 -C $ (pwd) O = output

Her er en oversikt over hva disse kommandoene gjør, for å gjøre dette lettere i fremtiden.

#! / bin / bash: Gjør at skriptet skal kjøres i shell-kommando
eksport ARCH = arm: Definere hvilken kjernearkitekturtype den er (for eksempel arm64 osv.)
export CROSS_COMPILE = : Finn hvor verktøykjeden er. Den må samsvare med den nøyaktige banen, og bindestreken til slutt er virkelig obligatorisk.
mkdir output: Dette oppretter en katalog for lagring av den kompilerte zimagen
make -C $ (pwd) O = output : Defining defconfig for guiding kernel compilation.
make -j4 -C $ (pwd) O = output : Når byggeprosessen begynner, forteller -j # hvor raskt det er å prøve og kompilere. Vanligvis angir du dette tallet i henhold til CPU-en din. Å sette på -j32 på en budsjett-CPU, for eksempel, vil sannsynligvis føre til massiv ustabilitet.
cp output / arch / arm / boot / Image $ (pwd) / arch / arm / boot / zImage : Dette er for å flytte bilde til en andre bane.

Et annet eksempel:

 #! / 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 / arm / boot / z

For ARM 64-enheter

 #! / bin / bash export ARCH = arm64 export CROSS_COMPILE = "bane til verktøykjeden din" (den må ende med noe som "nameofarch-noe-") mkdir output make -C $ (pwd) O = output "name of defconfig og variant om nødvendig "make -j4 -C $ (pwd) O = output

For Mediatek (MTK) enheter

#!.

Når du har fullført trinnene som er nødvendige for kjernearkitekturen, kan du skrive inn terminalen: sudo bash build.sh

Du vil deretter oppgi brukerpassordet ditt, og kompileringsprosessen vil begynne.

Det kan ta en stund, men vanligvis ikke så veldig lang tid, å sette sammen en kjerne er ikke som å samle en hel Android ROM. Dette er virkelig CPU-avhengig - for eksempel bør en AMD Phenom X4 3, 4 GHz med 8 GB RAM ta rundt 10 minutter å kompilere fra start til slutt.

Når den er ferdig, skal den varsle deg med en melding som “zimage is ready”.

ARM- og ARM64-enheter

Gå til “/ Output / arch / arm / boot /” for å finne din zimage.

Mediatek-enheter

Gå til “/ arch / arm / boot /” for å finne din zimage.

Ikke alle kjerneoppbygginger vil resultere i en Zimage-fil, den kan noen ganger bygges som andre bildeformater.

Viktig: Hvis du skal sammenstille igjen, anbefales det at du skriver inn kommandoene for å gjøre rene og gjøre mrproper før du begynner kompileringsprosessen igjen.

Making Kernel Boot

Det er to alternativer du kan velge.

Du kan enten bruke hvilken som helst kjernemetode (som definert av XDA-bruker @ osm0sis i denne XDA-tråden). Du bør lese hele opplæringen, men et sammendrag av trinnene er som følger:

Plasser zImage i roten (dtb og / eller dtbo bør også gå her for enheter som krever tilpassede enheter, hver vil falle tilbake til originalen hvis den ikke er inkludert)
Plasser alle nødvendige ramdiskfiler i / ramdisk og moduler i / moduler (med hele banen som / moduler / system / lib / moduler)
Plasser eventuelle nødvendige patch-filer (vanligvis delvise filer som følger med kommandoer) i / patch
Endre anykernel.sh for å legge til kjernens navn, startpartisjonsplassering, tillatelser for inkluderte ramdiskfiler, og bruk metoder for eventuelle nødvendige ramdiskmodifikasjoner (eventuelt plasser også banner- og / eller versjonsfiler i roten for å få disse vist under flash)
`zip -r9 UPDATE-AnyKernel2.zip * -x. gi README.md * plassholder`

Den andre metoden du har tilgjengelig er å pakke ut boot.img fra den samme ROM-en (for eksempel CM, TouchWiz, EMUI, etc.) og den samme Android-versjonen. Deretter bytter du Zimage. Igjen, dette er en veldig komplisert prosess, og du bør lese den nøyaktige opplæringen, men en oppsummering av trinnene er:

Unzip.
Enten bruker du kommandolinjen “pakke ut”, eller bare dra og slipp bildet. Dette vil dele bildet og pakke ut ramdisken til en underkatalog.
Endre ramdisken som du vil.
Det pakke-skriptet som pakkes om igjen krever ingen innspill og rekombinerer ganske enkelt den tidligere delte zImage med den nylig pakket modifiserte ramdisken ved å bruke all den originale bildeinformasjonen (som også ble delt og lagret).
Opprydningsbatchskriptet tilbakestiller mappen til den opprinnelige tilstanden, fjerner split_img + ramdisk-katalogene og eventuelle nye pakket ramdisk- eller bildefiler.

Før du blinker kjernen din, bør du opprette en sikkerhetskopi av lager boot.img, og deretter blinke kjernen for å se om den lar Android-systemet starte opp.

Legge til funksjoner i kjernen din

Å legge til funksjoner i kjernen din er en fin måte å krydre den på. Det er mange ting du kan finjustere, for eksempel CPU-styrere, IO-planleggere, overklokking av GPU, lydforbedringer, etc.

Et eksempel for å legge til en guvernør er her (denne guvernøren heter koden Intellimm).

Vi kan se i de to første tekstboksene at i “arch / arm / configs /” “msm8974_sec_defconfig” og “cm_msm8974_sec_defconfig” er endret.

Mellom linjene 140 og 141 i denne filene er denne teksten lagt til: "CONFIG_CPU_FREQ_GOV_INTELLIMM = y"

(Denne linjen er for å aktivere Intellimm når du kompilerer kjernen)

Samme teknikk gjelder for de andre tekstboksene (det som er lagt til og slettet og dets beliggenhet)

Avhengig av funksjonene du legger til, kan flere eller færre filer endres, legges til eller slettes.

Så for å oppsummere det, en forpliktelse, la oss se alle endringene som er gjort og alt annet!

Generelle tips og triks

Slik endrer du kjernenavn og -versjon:

Den enkle metoden:

Rediger denne linjen i defconfig-filen:

 "CONFIG_LOCALVERSION =" - "etter - i defconfig

Eksempel: CONFIG_LOCALVERSION = ”- XenomTW-3.2.6 ″

De avanserte metodene:

Naviger til Makefile i rotmappen til kjernekilden.

Legg til disse linjene:

 CONFIG_LOCALVERSION = "nameofyourkernel" LOCALVERSION = "versionofyourkernel"

Ikke endre linjene Versjon, PatchLevel, Sublevel eller Extraversion.

Alternativ metode:

Gå til skript / mkcompile_h og legg til disse linjene:

 LINUX_COMPILE_BY = "nameofyourchoice" LINUX_COMPILE_HOST = "nameofyourchoice"

Løse PATH-problemer:

Hvis du støter på feilen "Er banen din riktig?", Kan du prøve dette i Linux-terminalen:

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

Få tilgang til Ubuntu-mappene dine fra Windows 10

Veien din til Ubuntu skal vanligvis være:

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

Men du bør ikke redigere filer direkte fra Windows, da dette vanligvis vil ødelegge tillatelsene på dem - du vil da måtte tilbakestille tillatelsene fra Linux-terminalen.