Sign In Start Free Trial

Android System Programming

By : Roger Ye, Liu

3.7 (3)

Android System Programming

3.7 (3)

By: Roger Ye, Liu

Overview of this book

Android system programming involves both hardware and software knowledge to work on system level programming. The developers need to use various techniques to debug the different components in the target devices. With all the challenges, you usually have a deep learning curve to master relevant knowledge in this area. This book will not only give you the key knowledge you need to understand Android system programming, but will also prepare you as you get hands-on with projects and gain debugging skills that you can use in your future projects. You will start by exploring the basic setup of AOSP, and building and testing an emulator image. In the first project, you will learn how to customize and extend the Android emulator. Then you’ll move on to the real challenge—building your own Android system on VirtualBox. You’ll see how to debug the init process, resolve the bootloader issue, and enable various hardware interfaces. When you have a complete system, you will learn how to patch and upgrade it through recovery. Throughout the book, you will get to know useful tips on how to integrate and reuse existing open source projects such as LineageOS (CyanogenMod), Android-x86, Xposed, and GApps in your own system.

Preface

Preface

Virtual hardware platforms

Android version used in this book

What this book covers

What you need for this book

Who this book is for

Conventions

Reader feedback

Customer support

Free Chapter

Introduction to Android System Programming

Introduction to Android System Programming

What is system programming?

What is the scope of this book?

Overview of the Android system

The third-party open source projects derived from AOSP

Strategy of integration

Virtual hardware reference platforms

Summary

Setting Up the Development Environment

Setting Up the Development Environment

Summary of Android versions

Installing Android SDK and setting up an Android Virtual Device

The AOSP build environment and the Android emulator build

Creating your own repository mirror

Summary

Discovering Kernel, HAL, and Virtual Hardware

Discovering Kernel, HAL, and Virtual Hardware

What is inside the AOSP?

Android emulator HAL

Android emulator kernel and hardware

Summary

Customizing the Android Emulator

Customizing the Android Emulator

Why customize the Android emulator

Understanding build layers

Build variants

Creating a new x86emu device

Building and testing x86emu

Summary

Enabling the ARM Translator and Introducing Native Bridge

Enabling the ARM Translator and Introducing Native Bridge

Introducing Native Bridge

Integrating Houdini to the x86emu device

Building and testing

Summary

Debugging the Boot Up Process Using a Customized ramdisk

Debugging the Boot Up Process Using a Customized ramdisk

Analyzing the Android start up process

Source code and manifest changes

The Android-x86 start up process

Building x86emu with initrd.img

Creating a filesystem image

Kernel changes

Booting a disk image on the Android emulator

Summary

Enabling Wi-Fi on the Android Emulator

Enabling Wi-Fi on the Android Emulator

Wi-Fi on Android

Adding Wi-Fi to the emulator

Building the source code

Testing Wi-Fi on an emulator

Summary

Creating Your Own Device on VirtualBox

Creating Your Own Device on VirtualBox

HAL of x86vbox

Creating a new x86vbox device

Boot up process and device initialization

Summary

Booting Up x86vbox Using PXE/NFS

Booting Up x86vbox Using PXE/NFS

Setting up a PXE boot environment

Configuring and testing the PXE boot

NFS filesystem

Configuring the PXE boot menu

Summary

Enabling Graphics

Enabling Graphics

Introduction to the Android graphics architecture

Delving into graphics HAL

Graphics HAL of the Android emulator

Summary

Enabling VirtualBox-Specific Hardware Interfaces

Enabling VirtualBox-Specific Hardware Interfaces

OpenGL ES and graphics hardware initialization

Integrating VirtualBox Guest Additions

Summary

Introducing Recovery

Introducing Recovery

Recovery introduction

Analyzing recovery

Building recovery for x86vbox

Summary

Creating OTA Packages

Creating OTA Packages

What is inside an OTA package

Preparing an OTA package for x86vbox

Removing dependencies on /system

Building and testing

Summary

Customizing and Debugging Recovery

Customizing and Debugging Recovery

Debugging and testing native Android applications

Extending recovery and the updater

Supporting the third-party recovery packages

Summary

Customer Reviews

3.7 (3)

5 star

66.7%

4 star

0

3 star

0

2 star

0

1 star

33.3%

Android emulator HAL

We built the Android emulator in Chapter 2, Setting Up the Development Environment. In order to have an overview of Android emulator HAL, we can take a look at the $OUT/system/lib/hw folder as follows:

We can see that there is a list of shared libraries. These are the shared libraries of goldfish HAL. The source code of the preceding shared libraries can be found in the device/generic/goldfish folder. The following table shows the relationship between the shared library, device node, and hardware module:

Hardware	Device	Lib (HAL)
`audio`	`/dev/eac`	`audio.primary.goldfish.so`
`camera`	`/dev/qemu_pipe`	`camera.goldfish.jpeg.so` `camera.goldfish.so`
`fingerprint`	`/dev/qemu_pipe`	`fingerprint.goldfish.so`
`gps`	`/dev/qemu_pipe`	`gps.goldfish.so`
`lights`	`/dev/qemu_pipe`	`lights.goldfish.so`
`power`	`/dev/qemu_pipe`	`power.goldfish.so`
`sensors`	`/dev/qemu_pipe`	`sensors...`

Search

Your notes and bookmarks