Инструкция по сборке андроид из исходников

Введение

Глава 1: Начало начал

• Параграф 1: Выбор подходящей системы
• Параграф 2: Установка и настройка системы
• Параграф 3: Качаем исходники прошивки
• Параграф 4: Исходники устройства
• Параграф 5: Инициализация и сборка
• Параграф 6: В завершение

Глава 2: Git, с чем его едят и зачем он

• Введение
• Параграф 1: Создание аккаунта на Github и настройка git под свой аккаунт
• Параграф 2: Команды git’а

Глава 3: Изучение исходников устройства

• Введение
• Параграф 1: Что есть что и для чего (vendor, device tree, kernel)
• Параграф 2: Что такое дерево и сколько их должно быть
• Параграф 3: Что такое vendor и почему он имеет чужие библиотеки
• Параграф 4: Что такое ядро
• Параграф 5: Адаптация исходников устройства

Глава 4: Обновление исходников самостоятельно

• Введение
• Параграф 1: Дампы, vendor, proprietary-files.txt и обновление библиотек
• Параграф 2: Sed, patchself, grep
• Параграф 3: Дерево, HAL’ы, CAF
• Параграф 4: Sepolicy
• Параграф 5: Обновление и сборка ядра

Глава 5: Дополнительный материал, который не вошел в основную часть

• Параграф 1: Ошибки сборки (SELinux, нехватка пакетов, ресурсов и тд)
• Параграф 2: Базовые команды линукса
• Параграф 3: Gerrit
• Параграф 4: Изменение прошивки: как это делать и желания пользователей
• Параграф 5: Список хороших утилит
• Параграф 6: IDA: блобы, HEX, страдания

Я хочу что-то добавить/исправить, как мне это правильно сделать?

Если вы контрибьютер данного репозитория, сделайте отдельную ветку с названием, которое подходит для ваших изменений, внесите изменения в нее и сделайте мерж реквест. Если же вы не контрибьютер, для вас процедура такая же, только мерж реквест вы делаете из своего форка или другим способом.

This page details the process of building custom
kernels for Android devices. These
instructions guide you through the process of selecting the right
sources, building the kernel, and embedding the results into a system image
built from the Android Open Source Project (AOSP).

You can acquire more recent kernel sources by using
Repo; build them without further
configuration by running build/build.sh from the root of your
source checkout.

Downloading sources and build tools

For recent kernels, use repo
to download the sources, toolchain, and build scripts.
Some kernels (for example, the Pixel 3 kernels) require sources from multiple git
repositories, while others (for example, the common kernels) require only a single
source. Using the repo approach ensures a correct source
directory setup.

Download the sources for the appropriate branch:

mkdir android-kernel && cd android-kernel

repo init -u https://android.googlesource.com/kernel/manifest -b BRANCH

repo sync

The following table lists the BRANCH names for kernels available
through this method.

Device	Binary path in AOSP tree	Repo branches
Pixel 7 (panther) Pixel 7 Pro (cheetah)	device/google/pantah-kernel	android-gs-pantah-5.10-android13-qpr2
Pixel 6a (bluejay)	device/google/bluejay-kernel	android-gs-bluejay-5.10-android13-qpr2
Pixel 6 (oriole) Pixel 6 Pro (raven)	device/google/raviole-kernel	android-gs-raviole-5.10-android13-qpr2
Pixel 5a (barbet) Pixel 5 (redfin) Pixel 4a (5G) (bramble)	device/google/redbull-kernel	android-msm-redbull-4.19-android13-qpr2
Pixel 4a (sunfish)	device/google/sunfish-kernel	android-msm-sunfish-4.14-android13-qpr2
Pixel 4 (flame) Pixel 4 XL (coral)	device/google/coral-kernel	android-msm-coral-4.14-android13
Pixel 3a (sargo) Pixel 3a XL (bonito)	device/google/bonito-kernel	android-msm-bonito-4.9-android12L
Pixel 3 (blueline) Pixel 3 XL (crosshatch)	device/google/crosshatch-kernel	android-msm-crosshatch-4.9-android12
Pixel 2 (walleye) Pixel 2 XL (taimen)	device/google/wahoo-kernel	android-msm-wahoo-4.4-android10-qpr3
Pixel (sailfish) Pixel XL (marlin)	device/google/marlin-kernel	android-msm-marlin-3.18-pie-qpr2
Hikey960	device/linaro/hikey-kernel	hikey-linaro-android-4.14 hikey-linaro-android-4.19 common-android12-5.4 common-android13-5.10
Beagle x15	device/ti/beagle_x15-kernel	omap-beagle-x15-android-4.14 omap-beagle-x15-android-4.19
Android Common Kernel	N/A	common-android-4.4 common-android-4.9 common-android-4.14 common-android-4.19 common-android-4.19-stable common-android11-5.4 common-android12-5.4 common-android12-5.10 common-android13-5.10 common-android13-5.15 common-android14-5.15 common-android14-6.1 common-android-mainline

Building the kernel

Then build the kernel with this:

build/build.sh

The kernel binary, modules, and corresponding image are located in the
out/BRANCH/dist directory.

Building with Bazel (Kleaf)

Android 13 introduced building kernels with
Bazel, replacing build/build.sh.

To build the GKI kernel for the aarch64 architecture, check out
an Android Common Kernel branch no earlier than Android 13 and
then run the following command:

tools/bazel build //common:kernel_aarch64_dist

To create a distribution, run:

tools/bazel run //common:kernel_aarch64_dist -- --dist_dir=$DIST_DIR

Thereafter the kernel binary, modules, and corresponding images are located in the
$DIST_DIR directory. If --dist_dir is unspecified, see output
of the command for the location of the artifacts. For details, refer to the
documentation on AOSP.

Building the Vendor Modules for the Virtual Device

Android 11 introduced
GKI,
which separates the kernel into a Google-maintained kernel image and vendor maintained-modules,
which are built separately.

This example shows a kernel image configuration:

BUILD_CONFIG=common/build.config.gki.x86_64 build/build.sh

This example shows a module configuration (Cuttlefish and Emulator):

BUILD_CONFIG=common-modules/virtual-device/build.config.cuttlefish.x86_64 build/build.sh

In Android 12 Cuttlefish and Goldfish converge, so they share
the same kernel: virtual_device. To build that kernel’s modules, use this build
configuration:

BUILD_CONFIG=common-modules/virtual-device/build.config.virtual_device.x86_64 build/build.sh

Android 13 introduced building kernels with
Bazel (Kleaf), replacing build.sh.

To build the virtual_device‘s modules, run:

tools/bazel build //common-modules/virtual-device:virtual_device_x86_64_dist

To create a distribution, run:

tools/bazel run //common-modules/virtual-device:virtual_device_x86_64_dist -- --dist_dir=$DIST_DIR

For more details on building Android kernels with Bazel, see.
Kleaf — Building Android Kernels with Bazel.

For details on Kleaf support for individual architectures, see
Kleaf support for devices and kernels.

Kleaf support for devices and kernels

The following table lists Kleaf support for individual device kernels. For unlisted devices,
please contact the device manufacturer.

Device	Repo branches	Kleaf support	build/build.sh support
Android Common Kernel db845c Virtual Device (x86_64, arm64) Virtual Device (i686, arm) Rockpi4	common-android-4.4 common-android-4.9 common-android-4.14 common-android-4.19 common-android-4.19-stable common-android11-5.4 common-android12-5.4 common-android12-5.10	❌	✅
Android Common Kernel	common-android13-5.10 common-android13-5.15	✅	✅ (official)1
Android Common Kernel	common-android14-5.15 common-android14-6.1 common-android-mainline	✅	❌
db845c	common-android13-5.10	❌	✅
db845c	common-android13-5.15	✅	✅ (official)1
db845c	common-android14-5.15 common-android14-6.1 common-android-mainline	✅	❌
Virtual Device (x86_64, arm64)	common-android13-5.10 common-android13-5.15	✅ (official)1	⚠️ (unmaintained)2
Virtual Device (x86_64, arm64)	common-android14-5.15 common-android14-6.1 common-android-mainline	✅	❌
Virtual Device (i686, arm)	common-android13-5.10 common-android13-5.15	❌	✅
Virtual Device (i686, arm)	common-android14-5.15 common-android14-6.1 common-android-mainline	✅	❌
Rockpi4	common-android13-5.10 common-android13-5.15	❌	✅
Rockpi4	common-android14-5.15 common-android14-6.1 common-android-mainline	✅	❌
Hikey960	hikey-linaro-android-4.14 hikey-linaro-android-4.19 common-android12-5.4 common-android13-5.10	❌	✅
fips140 module	common-android12-5.10 common-android13-5.10 common-android13-5.15	❌	✅
fips140 module	common-android14-5.15	✅	❌
1«Official» means that this is the official way to build the kernel, even though the alternative way might also be used to build the kernel. 2«Unmaintained» means that building kernel with this method should work, but the build method is not continuously tested. It may stop building in the future. Use the «official» way to build instead.

Running the kernel

There are multiple ways to run a custom-built kernel. The following are
known ways suitable for various development scenarios.

Embedding into the Android image build

Copy Image.lz4-dtb to the respective kernel binary location
within the AOSP tree and rebuild the boot image.

Alternatively, define the TARGET_PREBUILT_KERNEL
variable while using make bootimage (or any other
make command line that builds a boot image). This variable is
supported by all devices as it’s set up via
device/common/populate-new-device.sh. For example:

export TARGET_PREBUILT_KERNEL=DIST_DIR/Image.lz4-dtb

Flashing and booting kernels with fastboot

Most recent devices have a bootloader extension to streamline the process of
generating and booting a boot image.

To boot the kernel without flashing:

adb reboot bootloader
fastboot boot Image.lz4-dtb

Using this method, the kernel isn’t actually flashed, and won’t persist
across a reboot.

Customizing the kernel build

To customize the kernel builds for Kleaf builds, see
Kleaf documentation.

For build/build.sh, the build process and outcome can be influenced
by environment variables.
Most of them are optional and each kernel branch should come with a proper
default configuration. The most frequently used ones are listed here. For a
complete (and up-to-date) list, refer to build/build.sh.

Environment variable	Description	Example
BUILD_CONFIG	Build config file from where you initialize the build environment. The location must be defined relative to the Repo root directory. Defaults to build.config. Mandatory for common kernels.	BUILD_CONFIG=common/build.config.gki.aarch64
CC	Override compiler to be used. Falls back to the default compiler defined by build.config.	CC=clang
DIST_DIR	Base output directory for the kernel distribution.	DIST_DIR=/path/to/my/dist
OUT_DIR	Base output directory for the kernel build.	OUT_DIR=/path/to/my/out
SKIP_DEFCONFIG	Skip make defconfig	SKIP_DEFCONFIG=1
SKIP_MRPROPER	Skip make mrproper	SKIP_MRPROPER=1

Custom kernel config for local builds

If you need to switch a kernel configuration option regularly, for example,
when working on a feature, or if you need an option to be set for development
purposes, you can achieve that flexibility by maintaining a local
modification or copy of the build config.

Set the variable POST_DEFCONFIG_CMDS to a statement that is
evaluated right after the usual make defconfig step is
done. As the build.config files are sourced into the build
environment, functions defined in build.config can be called
as part of the post-defconfig commands.

A common example is disabling link time optimization (LTO) for crosshatch
kernels during development. While LTO is beneficial for released kernels,
the overhead at build time can be significant. The following snippet added
to the local build.config disables LTO persistently when
using build/build.sh.

POST_DEFCONFIG_CMDS="check_defconfig && update_debug_config"
function update_debug_config() {
    ${KERNEL_DIR}/scripts/config --file ${OUT_DIR}/.config 
         -d LTO 
         -d LTO_CLANG 
         -d CFI 
         -d CFI_PERMISSIVE 
         -d CFI_CLANG
    (cd ${OUT_DIR} && 
     make O=${OUT_DIR} $archsubarch CC=${CC} CROSS_COMPILE=${CROSS_COMPILE} olddefconfig)
}

Identifying kernel versions

You can identify the correct version to build from two sources: the AOSP tree
and the system image.

Kernel version from AOSP tree

The AOSP tree contains prebuilt kernel versions. The git
log reveals the correct version as part of the commit message:

cd $AOSP/device/VENDOR/NAME
git log --max-count=1

If the kernel version isn’t listed in the git log, obtain it from the system
image, as described below.

Kernel version from system image

To determine the kernel version used in a system image, run the following
command against the kernel file:

file kernel

For Image.lz4-dtb files, run:

grep -a 'Linux version' Image.lz4-dtb

Building a Boot Image

It’s possible to build a boot image using the kernel build environment.

Building a Boot Image for Devices with init_boot

For devices with
the init_boot partition,
the boot image is built along with the kernel. The initramfs image is not embedded
in the boot image.

For example, with Kleaf, you may build the GKI boot image with:

tools/bazel run //common:kernel_aarch64_dist -- --dist_dir=$DIST_DIR

With build/build.sh, you may build the GKI boot image with:

BUILD_CONFIG=common/build.config.gki.aarch64 build/build.sh

The GKI boot image is located in $DIST_DIR.

Building a Boot Image for Devices without init_boot

For devices without
the init_boot partition,
you need a ramdisk binary, which you can obtain by
downloading a GKI boot image
and unpacking it. Any GKI boot image from the associated Android release will work.

tools/mkbootimg/unpack_bootimg.py --boot_img=boot-5.4-gz.img
mv $KERNEL_ROOT/out/ramdisk gki-ramdisk.lz4

The target folder is the top-level directory of the kernel tree (the current
working directory).

If you’re developing with AOSP master, you can instead download the
ramdisk-recovery.img build artifact from an aosp_arm64 build on
ci.android.com and use that as your ramdisk binary.

When you have a ramdisk binary and have copied it to gki-ramdisk.lz4 in the root
directory of the kernel build, you can generate a boot image by executing:

BUILD_BOOT_IMG=1 SKIP_VENDOR_BOOT=1 KERNEL_BINARY=Image GKI_RAMDISK_PREBUILT_BINARY=gki-ramdisk.lz4 BUILD_CONFIG=common/build.config.gki.aarch64 build/build.sh

If you’re working with x86-based architecture, replace Image
with bzImage, and aarch64 with
x86_64:

BUILD_BOOT_IMG=1 SKIP_VENDOR_BOOT=1 KERNEL_BINARY=bzImage GKI_RAMDISK_PREBUILT_BINARY=gki-ramdisk.lz4 BUILD_CONFIG=common/build.config.gki.x86_64 build/build.sh

That file is located in the artifact directory
$KERNEL_ROOT/out/$KERNEL_VERSION/dist.

The boot image is located at out/<kernel branch>/dist/boot.img.

Время на прочтение
7 мин

Количество просмотров 60K

Существует множество задач, для которых требуется пересборка ядра и операционной системы Android в целом. Например, создание и отладка собственных модулей, включение поддержки профилирования системы и просто тестирование своих приложений на новой версии Android.
Возможность запуска Android x86 внутри виртуальной машины VirtualBox позволяет энтузиастам и создателям прошивок покопаться в настройках системы, настроить и пересобрать ядро и при этом не «кирпичизировать» настоящее устройство. VirtualBox предоставляет возможность использования привычных для Linux-разработчика средств отладки ОС. Для рядовых разработчиков Android-приложений отлично подходит эмулятор, использующий технологию Intel Hardware Accelerated Execution Manager. (подробнее можно прочесть здесь)
В статье приведен ряд практических советов по сборке образа Android x86 для запуска под виртуальной машиной VirtualBox и сборке эмулятора. Исходный код Android взят из официального репозитория проекта AOSP (Android Open Source Project), в качестве ядра использована адаптированная версия ядра Linux 2.6 от Intel.

Установка окружения для сборки

Для сборки Android потребуется 64 битная версия Linux. Еще один важный момент: обратите внимание на версию GCC, которая установлена на системе. Google поддерживает версию GCC 4.4 и выше. Так же на системе должна быть установлена реализация Java от Oracle.
Установка дополнительных зависимостей для Ubuntu 12.04:

sudo -i
apt-get update
sudo apt-get install git-core gnupg flex bison gperf build-essential 
  zip curl libc6-dev libncurses5-dev:i386 x11proto-core-dev 
  libx11-dev:i386 libreadline6-dev:i386 libgl1-mesa-glx:i386 
  libgl1-mesa-dev g++-multilib mingw32 openjdk-6-jdk tofrodos 
  python-markdown libxml2-utils xsltproc zlib1g-dev:i386

Установите символьную ссылку для устранения конфликта имен:

sudo ln -s /usr/lib/i386-linux-gnu/mesa/libGL.so.1 /usr/lib/i386-linux-gnu/libGL.so

Загрузка дерева исходных кодов

Установка Repo

Repo — утилита управления репозиториями, упрощающая работу с Git для Android. Более подробную информацию можно прочесть здесь (http://source.android.com/source/version-control.html)
Для установки, инициализации и настройки Repo выполните следующие шаги:
• Убедитесь, что у вас есть директория bin в вашем домашнем каталоге и она прописана в PATH:

mkdir ~/bin
PATH=~/bin:$PATH

• Загрузите Repo скрипт и выставите права на выполнение:

curl https://dl-ssl.google.com/dl/googlesource/git-repo/repo > ~/bin/repo
chmod a+x ~/bin/repo

Инициализация Repo клиента

После установки Repo, настройте доступ к репозиториям исходных кодов Android:
• Создайте пустую директорию для исходных файлов и перейдите в нее. Например, это может выглядеть так:

mkdir aosp
cd aosp

• Запустите скрипт repo init, чтобы обновить версию самого Repo.

repo init -u https://android.googlesource.com/platform/manifest

Эта команда подключит ветку master из дерева исходных кодов Android. Вы можете указать любую другую, используя ключ -b:

repo init -u https://android.googlesource.com/platform/manifest -b android-4.1.1_r6

Для просмотра всех доступных веток введите команду:

git --git-dir .repo/manifests/.git/ branch -a

Нас интересуют наиболее последние версии Android от Google:

• Jelly Bean: remotes/origin/android-4.1.1_r6
• Ice Cream Sandwich: remotes/origin/android-4.0.4_r2.1

Можно выбрать любую на ваш вкус, дальнейшие шаги не будут отличаться. Для демонстрации процесса сборки под VirtualBox возьмем версию Jelly Bean (JB).
В случае успешной инициализации вы увидите сообщение о том, что Repo инициализирован в вашей директории и в ней появится папка .repo

Загрузка файлов

Чтобы загрузить исходные файлы из репозитория в вашу рабочую директорию выполните команду:

repo sync -j 16

Начальная синхронизация может занять больше часа времени.

Сборка ядра

Android разработан прежде всего для устройств, управляемых жестами и он не поддерживает мышь по умолчанию. Поэтому, в качестве примера, пересоберем ядро из исходников с включенной поддержкой мыши.
Создадим директорию для хранения исходников ядра:

mkdir ~/android_kernel
cd ~/android_kernel

Воспользуемся заранее подготовленной версией ядра от Intel:

wget http://software.intel.com/sites/landingpage/android/Intel_x86_sysimg_2.3.7_Source_Files.zip
unzip Intel_x86_sysimg_2.3.7_Source_Files.zip
tar -xvf kernel_sdk_x86.tar.gz

Перейдем в директорию ядра:

cd kernel

Теперь у нас есть исходники ядра. Нужно модифицировать конфигурационный файл и пересобрать. Чтобы сократить время на полную настройку ядра, воспользуемся конфигурационным файлом, который подготовили для на разработчики. Важный момент — не забывайте указать архитектуру для которой происходит сборка ядра, в нашем случае это x86.

cp arch/x86/configs/vbox_defconfig .config
make ARCH=x86 menuconfig

Через несколько секунд загрузится графическое меню настройки ядра. Стрелками «вверх», «вниз» вы можете передвигаться по пунктам меню, «Enter» чтобы зайти в подменю. Все точно так же как с обычным ядром Linux.

Чтобы включить поддержку мыши:
• Зайдите в «Device Drivers»
• Выберите «Input device Support»
• Отметьте «Mice»
Вы можете зайти в подменю «Mice» и посмотреть дополнительные настройки драйверов.
Затем выйдите из меню конфигурации ядра. Это можно сделать с помощью нескольких нажатий на «Esc». Не забудьте сохранить настройки, когда меню конфигурации предложит это сделать.
Сделав необходимые настройки ядра, соберем его. Это не займет много времени, особенно если вы используете многоядерную машину — можете указать опцию команды make: -j N, где N — число ядер (например, для написания статьи использовалась make -j 32).

make ARCH=x86 –j 32 

При успешной компиляции вы увидите сообщение:

Kernel: arch/x86/boot/bzImage is ready 

Путь до нового ядра указан в последней строке.

Подмена ядра

Путь к ядру, которое будет использовано в сборке для VirtualBox можно определить следующим образом:

grep "LOCAL_KERNEL :=" ~/aosp/build/target/board/vbox_x86/device.mk

Должно вывестись примерно следующее:

LOCAL_KERNEL := prebuilt/android-x86/kernel/kernel-vbox

Скопируем bzImage по найденному пути:

cp ~/kernel/arch/x86/boot/bzImage ~/aosp/prebuilt/android-x86/kernel/kernel-vbox

Построение Android

Установим окружение для сборки:

cd ~/aosp
. ./build/envsetup.sh

Теперь все готово к тому, чтобы начать компиляцию исходников Android. Первым шагом необходимо указать цель для сборки:

lunch vbox_x86-eng

После выполнения команды вы увидите информацию о предстоящей сборке:

============================================
PLATFORM_VERSION_CODENAME=REL
PLATFORM_VERSION=4.1.1
TARGET_PRODUCT=vbox_x86
TARGET_BUILD_VARIANT=eng
TARGET_BUILD_TYPE=release
TARGET_BUILD_APPS=
TARGET_ARCH=x86
TARGET_ARCH_VARIANT=x86
HOST_ARCH=x86
HOST_OS=linux
HOST_OS_EXTRA=Linux-2.6.32-131.0.15.el6.x86_64-x86_64-with-redhat-6.1-Santiago
HOST_BUILD_TYPE=release
BUILD_ID=JRO03R
OUT_DIR=out
============================================

Затем необходимо запустить сборку исходников командой make. Хорошим тоном считается сохранять лог сборки, это можно сделать с помощью утилиты tee.

make –j 16 | tee vbox_build.log

Процесс сборки может занять значительное время, конкретные цифры зависят от мощности центрального процессора и объема оперативной памяти машины. На системе, которая использовалась для подготовки статьи это заняло около часа. Рекомендуемое число потоков для сборки можно определить из расчета 2GB оперативной памяти на поток.
При успешной компиляции, последняя строка вывода будет содержать путь и размер образа:

Install system fs image: out/target/product/vbox_x86/system.img
out/target/product/vbox_x86/system.img+ total size is 268435456

Далее необходимо собрать загрузочный образ для VirtualBox:

make installer_vdi 

Если сборка прошла успешно, в консоли должна появиться запись:

Done with VirtualBox bootable installer image -[ out/target/product/vbox_x86/installer.vdi ]-

Настройка VirtualBox

Теперь приступим к настройке VirtualBox. Необходимо создать новую виртуальную машину, назовем ее “Android_ICS”, выберем Linux в качестве операционной системы, а версию выставим Other, как наиболее подходящую для Android.

Следующий шаг – выделение оперативной памяти. Рекомендуется 512 мегабайт и больше. В нашем случае это будет гигабайт.

Далее настраивается размер жесткого диска. Главное, чтобы после завершения настройки все жесткие диски VirtualBox были подключены к контроллеру IDE.
Установим загрузочный образ Android в качестве второго раздела нашей виртуальной машины.

При первом запуске виртуальной машины нам необходимо запустить установку Android. Во время старта нажмите F12, чтобы зайти в меню настроек BIOS. Выберете 2 “Primary Slave”, именно там и содержится установочный образ Android.
В случае успешной установки вы увидите «Done processing installer config». Иногда при первой установке могут возникнуть ошибки, просто запустите ее еще раз. Затем перезагрузите виртуальную машину в свой только что установленный Android!

Эмулятор Jelly Bean

Сборка эмулятора мало чем отличается от сборки версии для VirtualBox. Если у вас уже есть исходные коды, то приступайте к сборке с шага инициализации окружения. Для чистоты эксперимента, будет процесс постройки эмулятора будет изложен с самого начала. Поэтому создадим отдельную директорию для Jelly Bean Emulator и повторим уже знакомые шаги.

mkdir ~/jb
cd ~/jb

Инициализация репозитория

repo init -u https://android.googlesource.com/platform/manifest -b android-4.1.1_r6

Загрузка исходных кодов

repo sync -j 16

Инициализация окружения

. ./build/envsetup.sh

Выбор сборки эмулятора

lunch full_x86-eng

В случае успеха вы увидите:

============================================
PLATFORM_VERSION_CODENAME=REL
PLATFORM_VERSION=4.1.1
TARGET_PRODUCT=full_x86
TARGET_BUILD_VARIANT=eng
TARGET_BUILD_TYPE=release
TARGET_BUILD_APPS=
TARGET_ARCH=x86
TARGET_ARCH_VARIANT=x86-atom
HOST_ARCH=x86
HOST_OS=linux
HOST_OS_EXTRA=Linux-2.6.32-131.0.15.el6.x86_64-x86_64-with-redhat-6.1-Santiago
HOST_BUILD_TYPE=release
BUILD_ID=JRO03L
OUT_DIR=out
============================================

Запускаем сборку:

make –j 16 | tee emulator_build.log

Пока идет процесс компиляции, скопируем конфигурационный файл и соберем ядро для эмулятора.

cd kernel
cp arch/x86/configs/goldfish_defconfig .config
make ARCH=x86 -j16

Теперь сборка эмулятора завершена.
Самый простой способ запустить его:

emulator 

Например, можно запустить с только что собранным ядром, с разрешением 480×800, объемом оперативной памяти 512 мегабайт и включенным аппаратным ускорением графики.

emulator -kernel ~/kernel/arch/x86/boot/bzImage -skin WVGA800 -memory 512 -gpu on 

Более подробно о возможностях и настройках эмулятора можно прочитать здесь

Заключение

В данной статье рассмотрен способ установки Android x86 версии Jelly Bean для VirtualBox, сборка кастомизированного ядра и эмулятора. Существует множество разных трюков и подходов к постройке и настройке различных версий Android, которые остались за пределами данной статьи. Здесь был изложен базовый материал для того, чтобы начать свой путь в мир OS Android.

Давно мечтали собрать сами своими руками прошивку Android из исходного кода, но ни как получалось из за отсутствия внятного материала? Android +1 подготовил вам подробную интересную статью!

Предисловие

И так перед тем как начать повествовать статью, немного слов для кого она написана: вы уже знаете что такое Linux и установить Ubuntu, Mint, Fedora, OpenSuSe, по крайней мере устанавливали хотя бы один раз из этих ОС, уже знаете что такое командная строка или терминал, команда cd, ls, sh знакома и не вводит в ступор. Отлично, тогда продолжаем изучать статью. Статья Только для устройств Nexus!

Задача научить подготовить систему для компилирования вашей первой Android прошивки, а не научить устанавливать Linux, изучить команды итп.

Необходимое для создания Android прошивки из исходного код

1. Компьютер или мощный ноутбук
2. LTS версия ОС UBUNTU 64-разрядная (12.04 или 14.04)
3. Количество свободного места в разделе /home не менее 100 GB

[stextbox id=»warning»]Не открывайте, не закрывайте, не перемещайте, делайте все как написано в инструкции — последовательно, шаг за шагом, перезагружайте компьютер когда это указано.[/stextbox]

Подготовка

1. Перейдите в параметры системы UBUNTU

2. Раздел «Программы и обновления»

3. Вкладка «Программное обеспечение UBUNTU» установить Загрузить с: Основной сервер

4. Вкладка «Другое ПО», установить галочки на Партнеры Canonical и Партнеры Canonical (исходный код)

5. Нажать внизу кнопку Закрыть и после Обновить

6. Запустить программу «Обновление приложений» и обновить систему и перезагрузить компьютер

7. Запустите терминал (горячими кнопками CTRL+ALT+T)

8. Установите JAVA (объектно-ориентированный язык программирования)

Для Ubuntu 16.04:

sudo apt-get install openjdk-8-jdk

Для Ubuntu 14.04:

Загрузить версию JDK и установить с помощью команд:

sudo dpkg -i {downloaded.deb file}

sudo apt-get -f install

9. Если ранее была установлена другая среда Java, то выполнить также данные дополнительные команды:

 sudo update-alternatives --config java
sudo update-alternatives --config javac

10. Установите (на ваше усмотрение, опционально) пакет (до версии Ubuntu 14.10, далее установлен по умолчанию)

sudo apt-get install nautilus-open-terminal

11. Перезагрузите компьютер

12. Запустите терминал

13. Установите набор пакетов необходим для создания прошивки

Для Ubuntu 14.04 и новее:

sudo apt-get install git-core gnupg flex bison gperf build-essential 
  zip curl zlib1g-dev gcc-multilib g++-multilib libc6-dev-i386 
  lib32ncurses5-dev x11proto-core-dev libx11-dev lib32z-dev ccache 
  libgl1-mesa-dev libxml2-utils xsltproc unzip

Для Ubuntu 12.04:

sudo apt-get install git gnupg flex bison gperf build-essential 
  zip curl libc6-dev libncurses5-dev:i386 x11proto-core-dev 
  libx11-dev:i386 libreadline6-dev:i386 libgl1-mesa-glx:i386 
  libgl1-mesa-dev g++-multilib mingw32 tofrodos 
  python-markdown libxml2-utils xsltproc zlib1g-dev:i386
sudo ln -s /usr/lib/i386-linux-gnu/mesa/libGL.so.1 /usr/lib/i386-linux-gnu/libGL.so

14. Перезагрузите компьютер

15. Запустите терминал

16. Установите пакет еще один пакет

 sudo apt-get install phablet-tools

17. Вводим команду для «первого знакомства» с репозиториями Google

 mkdir ~/bin && curl https://commondatastorage.googleapis.com/git-repo-downloads/repo > ~/bin/repo && chmod a+x ~/bin/repo

18. Ввод команду для внесения папки bin в переменную

 sudo gedit .bashrc

после чего откроется текстовый редактор с открытым документом .bashrc, прокручиваем его в самый конец и дописываем с новой строки

 export PATH=~/bin:$PATH

Сохраняем документ и закрываем

19. Идентифицируем будущую сборку, тоесть чтобы в собранной прошивки были указаны данные кто ее собрал

git config --global user.email "ваш@эмайл"
git config --global user.name "ваш_никнейм"

20. Создаем проект в которым в дальнейшем загрузится исходный код Android и драйвера

 mkdir ~/AOSP
cd ~/AOSP

21. Скачиваем драйвера для своего Nexus в зависимости от вашей версии Android или скачиваем последние доступные версии (нестабильные)

22. Извлекаем из архива файл extracted-xxxxxxx.sh в папку AOSP

23. В терминале пишем

sudo sh extracted-xxxxxxx.sh

где xxxxxx это каждый изъятый файл, то есть вам необходимо по очереди запустить каждый файл sh, после введите команду

make clobber

и удалите файлы sh

24. Теперь о загрузке исходного кода, вам необходимо указать какой вы хотите собрать Android, то есть версию:

repo init -u https://android.googlesource.com/platform/manifest -b android-5.0.2_r1

Вместо android-5.0.2_r1 указывать необходимую версию Android

Загружаем исходный код на компьютер:

repo sync

Данная процедура будет длится долго (не менее 3 часов) и будет загружено около 30 GB

Сборка проекта

25. После того как скачается весь исходный код Android начнем сборку прошивки Android, введите команду:

source build/envsetup.sh

lunch

Перед вами появится окно со списком устройств возможных для создания AOSP прошивки, выбираем цифру и нажимаем ENTER

26. Запускаем сборку Android прошивки

make -j2 otapackage

Вместо j2 стоит указать количество ядер процессора и потоков, если процессор 2 ядреный и включена технология hyper threading (если она доступна), то у вас будет 4 потока (j4), если процессор 4 ядерный и выключена технология hyper threading, то также 4 потока (j4), а если включена то 8 (j8).

В зависимости от мощности и количества ядер участвующих в процессе сборки прошивки зависит и время сборки прошивки, от 20 минут до 24 суток.

Установка

27. После сборки вы обнаружите пакет в папке AOSP/out/target/product/кодовое_имя_nexus/ архив ZIP

28. Переместите данный архив ZIP на устройство NEXUS

29. Установите меню Recovery

30. Перейдите в меню Recovery

31. Установите архив ZIP и после сделайте обязательно wipe

Вот и все! Ничего сложного нет! Статья подошла к концу, подписывайтесь социальные группы и оставайтесь вместе с сайтом Android +1!