hur

Hur man bygger Android Kernel på Windows 10

Appual's har några bra guider för Android-utveckling, till exempel hur man bygger en anpassad ROM från Android Open Source Project - men dessa guider är vanligtvis inriktade på en ren Linux-byggmiljö.

I den här guiden kommer vi att visa dig hur man bygger en Android-kärna på Windows 10 - ja, vi kommer fortfarande att använda en Linux-byggmiljö, men det kommer att vara ett Linux-delsystem inom Windows 10. Så om du är en Windows 10 användare som är intresserade av att utveckla för Android, följ vår guide noggrant.

I den här guiden kommer vi att lära oss specifikt hur man bygger en kärna för ARM- och MediaTek-enheter, lägger till funktioner och en grundläggande översikt över att använda Git.

Krav

Windows 10 x64 (med Fall Creators uppdatering)

Ställa in Linux-miljön

I Windows 10 går du till Inställningar> Uppdatering och säkerhet> För utvecklare> aktivera utvecklarläge.
Gå nu till Kontrollpanelen> Program> Aktivera eller inaktivera Windows-funktioner> aktivera Windows-subsystem för Linux.
Starta om din dator.
Starta Linux-undersystemet och låt det gå igenom nedladdningsprocessen. Ställ in ett lösenord och tappa inte det.
Gå nu till Windows app store och ladda ner Ubuntu.
Starta Ubuntu på Windows 10-skrivbordet, och det kommer att begära ett användarnamn och lösenord.
I Ubuntu, starta den ursprungliga terminalen och skriv följande kommando: apt-get update
Detta fortsätter för att uppdatera alla repor för appar och beroenden.
Nästa i terminaltypen: sudo apt-get install -y build-essential kernel-package libncurses5-dev bzip2
För att kontrollera om alla beroenden är korrekt installerade, skriv 'gcc' i terminalen (inga citat).
Om "gcc" redan är installerat, bör du se "gcc: fatal error: no input file"
Nu kan du skriva 'make' i terminalen. Om “fabrikat” redan är installerat, bör ni se “make: *** inget mål anges och ingen makefil hittades. sluta."
Nästa typ 'git', och om "git" redan är installerat, bör du se massor av grundläggande git-kommandon.
Nu behöver vi några verktygskedjor (det finns flera typer, inklusive GCC, Linaro och en handfull anpassade). Vissa enheter kan kräva olika verktygskedjor, till exempel kommer inte alla enhetskärnor att starta eller kompilera med GCC.

För ARM-enheter

Vi kommer att använda GCC 4.7 för detta.

Öppna Linux-terminalen och skriv: mkdir-kärna
Skriv nu: cd-kärna
(det behöver inte vara "kärna", det är för enkelhets skull, du kan namnge det du vill.)
Skriv nu: git klon //android.googlesource.com/platform/prebuilts/gcc/linux-x86/arm/arm-eabi-4.7

För ARM 64-enheter

Du behöver en 64-bitars kärnkompilerare för ARM 64-enheter, till exempel aarch64.

Hämta källfilerna för din enhet

Detta är en knepig del, eftersom du behöver hitta en GitHub-repo som är värd för din kärnkälla. Du kommer naturligtvis att behöva söka efter det, troligtvis finns det på XDA-forum.

Här är ett exempel på kärnkälla Git.

På den övre vänstra sidan bör du se “Gren: Avslutad av xxxx”.

Det finns olika versioner av en kärna / projekt, vanligtvis separerade med "Testing", "Beta", "Final Release", etc.

Kärnmapparna är vanligtvis enligt följande:

/ arch / arm / configs : Detta innehåller olika konfigurationsfiler för enheten, till exempel guvernörer, etc.
/ output / arch / arm / boot / : Det är här zimage lagras.
build.sh : Ett skript som kommer att förenkla byggprocessen.
/arm-cortex-linux-gnueabi-linaro_5.2-2015.11-2 : Detta är vanligtvis en verktygskedja placerad i källkällan, vilket gör det lättare att hitta.

Du kommer att behöva ladda ner din källkälla.

Öppna Linux-terminalen och se till att du befinner dig i kärnmappen du tidigare skapade (cd-kärna).

Skriv sedan terminal: "git klon" URL till githubkärnan "-b" grenens namn "

Till exempel: "git klon //github.com/atxoxx/android_ke…amsung_msm8974 -b xenomTW"

Bygga kärnan

För att göra det enklare kan du navigera till platsen i filutforskaren. Det borde vara / hem / användar-ID / kärna (eller vad du känt kärnmappen).

Du bör se två mappar inuti, för verktygskedjan och källkällan. Gå in i källkällmappen.

För ARM-enheter

Skriv följande kommandon i en terminal:

 #! / bin / bash export ARCH = arm export CROSS_COMPILE = mkdir output make -C $ (pwd) O = output "name of defconfig och variant om det behövs" make -j4 -C $ (pwd) O = output

Här är en översikt över vad dessa kommandon gör för att underlätta i framtiden.

#! / bin / bash: Beräknar att skriptet ska köras i shell-kommando
export ARCH = arm: Definiera vilken kärnarkitekturtyp den är (till exempel arm64 etc)
export CROSS_COMPILE = : Hitta var verktygskedjan är. Det måste matcha den exakta vägen, och strecket i slutändan är verkligen obligatoriskt.
mkdir-utgång: Detta skapar en katalog för att spara den kompilerade zimagen
make -C $ (pwd) O = output : Definiera defconfig för att styra kärnkompilering.
make -j4 -C $ (pwd) O = output : När byggprocessen börjar berättar -j # hur snabbt det är att försöka kompilera. Vanligtvis ställer du in detta nummer enligt din CPU. Att ställa in -j32 på en budget-CPU, till exempel, skulle förmodligen orsaka massiv instabilitet.
cp output / arch / arm / boot / Image $ (pwd) / arch / arm / boot / zImage : Detta är för att flytta bilden till en andra bana.

Ett annat exempel:

 #! / 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 gör -j4-C $ (pwd) O = output cp output / arch / arm / arm / boot / image / (

För ARM 64-enheter

 #! / bin / bash export ARCH = arm64 export CROSS_COMPILE = "sökväg till din verktygskedja" (det måste sluta med något som "nameofarch-något-") mkdir output make -C $ (pwd) O = output "name of defconfig och variant om det behövs "make -j4 -C $ (pwd) O = output

För Mediatek-enheter (MTK)

#!.

När du har slutfört de steg som krävs för din kärnarkitektur kan du skriva in terminalen: sudo bash build.sh

Du kommer sedan att ange ditt användarlösenord och kompileringsprocessen kommer att börja.

Det kan ta ett tag men vanligtvis inte så lång tid, att sammanställa en kärna är inte som att sammanställa en hel Android-ROM. Detta är verkligen beroende av CPU - till exempel bör en AMD Phenom X4 3, 4 GHz med 8 GB RAM ta cirka 10 minuter att kompilera från början till slut.

När det är klart bör det meddela dig med ett meddelande som "zimage är redo".

ARM- och ARM64-enheter

Gå till “/ Output / arch / arm / boot /” för att hitta din zimage.

Mediatek-enheter

Gå till “/ arch / arm / boot /” för att hitta din zimage.

Inte alla kernel builds kommer att resultera i en Zimage-fil, den kan ibland byggas som andra bildformat.

Viktigt: Om du ska kompilera igen rekommenderas att du anger kommandona gör rent och gör mrproper innan du börjar kompileringsprocessen igen.

Göra Kernel Boot

Det finns två alternativ för dig att välja.

Du kan antingen använda anykernel-metoden (som definieras av XDA-användare @ osm0sis i denna XDA-tråd). Du bör läsa hela handledningen, men en sammanfattning av stegen är som följer:

Placera zImage i roten (dtb och / eller dtbo bör också gå här för enheter som kräver anpassade enheter, var och en kommer att falla tillbaka till originalet om det inte ingår)
Placera alla nödvändiga ramdiskfiler i / ramdisk och moduler i / moduler (med hela sökvägen som / moduler / system / lib / moduler)
Placera alla nödvändiga patchfiler (vanligtvis delvisa filer som följer med kommandon) i / patch
Ändra anykernel.sh för att lägga till kärnans namn, startpartitionsplats, behörigheter för inkluderade ramdiskfiler och använda metoder för alla nödvändiga ramdiskmodifieringar (valfritt, placera också banner- och / eller versionfiler i roten för att dessa ska visas under blixt)
`zip -r9 UPDATE-AnyKernel2.zip * -x. få README.md * platshållare`

Den andra metoden du har tillgängligt är att packa upp boot.img från samma ROM (som CM, TouchWiz, EMUI, etc.) och samma Android-version. Du skulle sedan byta Zimage. Återigen, detta är en riktigt komplicerad process och du bör läsa exakt handledning, men en sammanfattning av stegen är:

Packa upp.
Använd antingen kommandoraden "packa upp" eller dra eller släpp bilden. Detta delar bilden och packar upp ramdisken till en underkatalog.
Ändra ramdisken som du vill.
Batchskriptet ompaketerat kräver ingen inmatning och kombinerar helt enkelt den tidigare delade zImage med den nyligen packade modifierade ramdisken med all originalbildinformation (som också delades och sparades).
Rengöringssatsskriptet återställer mappen till dess ursprungliga tillstånd och tar bort split_img + ramdisk-katalogerna och alla nya packade ramdisk- eller bildfiler.

Innan du blinkar din kärna bör du skapa en säkerhetskopia av din stock boot.img och sedan blinka din kärna för att se om den tillåter ditt Android-system att starta.

Lägga till funktioner i din kärna

Att lägga till funktioner i din kärna är ett bra sätt att krydda den. Det finns många saker du kan justera, till exempel CPU-regulatorer, IO-schemaläggare, överklockning av GPU, ljudförbättringar, etc.

Ett exempel för att lägga till en guvernör är här (den här guvernören kallas Intellimm).

Vi kan se i de första två textrutorna att i “arch / arm / configs /” “msm8974_sec_defconfig” och “cm_msm8974_sec_defconfig” har ändrats.

Mellan raderna 140 och 141 i denna fil har denna text lagts till: "CONFIG_CPU_FREQ_GOV_INTELLIMM = y"

(Den här raden är avsedd att aktivera Intellimm när du sammanställer din kärna)

Samma teknik gäller för de andra textrutorna (vad som har lagts till och raderats och dess plats)

Beroende på vilka funktioner du lägger till kan fler eller färre filer ändras, läggas till eller tas bort.

Så för att sammanfatta det, ett åtagande, låt dig se alla förändringar som har gjorts och allt annat!

Allmänna tips och tricks

Hur man ändrar kärnans namn och version:

Den enkla metoden:

Redigera den här raden i din defconfig-fil:

 "CONFIG_LOCALVERSION =" - "efter - i din defconfig

Exempel: CONFIG_LOCALVERSION = ”- XenomTW-3.2.6 ″

De avancerade metoderna:

Navigera till Makefile i rotmappen för din kärnkälla.

Lägg till dessa rader:

 CONFIG_LOCALVERSION = "nameofyourkernel" LOCALVERSION = "versionofyourkernel"

Ändra INTE raderna Version, PatchLevel, Sublevel eller Extraversion.

Alternativ metod:

Gå till skript / mkcompile_h och lägg till dessa rader:

 LINUX_COMPILE_BY = "nameofyourchoice" LINUX_COMPILE_HOST = "nameofyourchoice"

Lösa PATH-problem:

Om du stöter på felet "Är din sökväg rätt?" Kan du prova detta i Linux-terminalen:

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

Få åtkomst till dina Ubuntu-mappar från Windows 10

Din väg till Ubuntu bör vanligtvis vara:

C: \ Användare ”NAME” \ AppData \ Local \ Packages \ CanonicalGroupLimited.UbuntuonWindows_79rhkp1fndgsc \ LocalState \ rootfs \ home

Men du bör inte redigera filer direkt från Windows, eftersom det vanligtvis kommer att bryta behörigheterna på dem - du skulle då behöva återställa behörigheterna från Linux-terminalen.