Android Platform Training Course

History of Android module focuses on how we got here. The goal of the module is to give us an idea of design philosophy behind Android, and what it may say about the future of the platform. At this high level, we explore both technical and business choices that effect the platform for a long time.

• Vision for Android
• History overview
• Android versions
• Android add-ons
• Android fragmentation

The Android technology stack can be divided into four layers. This module provides an overview of each layer and the role it plays in the Android platform. Topics in this module include:

• Design philosophy
• Open Source licenses
• Linux kernel space
• Native layer
• Dalvik VM
• Application layer
• Apps

The goal of this module is to have you write a simple Hello, World application. By the end of this module, you should be able to identify main parts of an app. You should also be able to verify that your tools are setup properly and that you can run the application on an Android device, either physical or emulated. Topics covered include:

• Android SDK: How to set it up and what it consists of
• About Eclipse: The power of the tools
• Creating a new Android project
• Anatomy of a project: What are all the moving parts
• Running the app: Emulator, real device, tools to monitor them both

The goal of this module is to introduce you to main components used to create Android apps. By the end of this module, you should have a good idea what Android app building blocks are, and their key properties.

Seven iterations of an app:

• Part 1 - Activities and Android UI
• Part 2 - Intents, Action Bar, and More
• Part 3 - Services
• Part 4 - Content Providers
• Part 5 - Lists and Adapters
• Part 6 - Broadcast Receivers
• Part 7 - App Widgets

This module provides an overview of some of the tools available in Android SDK that can help you with debugging your apps. By the end of this module you should have a general knowledge of what is available and how to use it. The tools we'll explore include:

• Logcat
• Debugger
• Traceview
• HierarchyViewer
• Syslog

The goal of this module is to provide high level overview of how Android security is architected. By the end of this module, you should know how apps are sandboxed and how kernel enforces security rights. Topics covered include:

• Security design overview
• Application sandboxing
• Using permissions
• Declaring permissions

This module introduces you to the Android operating system to ensure a basic familiarity with the Android architecture, background, and terminology. You also learn additional sources of information for modifying the Android OS, porting it to new hardware, and complying with Google's Android compatibility requirements.

• Overview of the Android platform architecture
• Introduction to the structure and lifecycle of Android applications
• Internet resources for Android platform developers
• Android compatibility requirements: the Compatibility Definition Document (CDD) and Compatibility Test Suite (CTS)

The Android OS is categorized into four layers. From the bottom up they are the kernel layer, the user-space native layer, the application framework layer, and the applications layer. In this module you explore each of the layers in depth to understand their role and the components they contain.

Android Kernel Layer   (3 hours)

Android Native Layer   (2 hours)

Android Application Framework Layer   (1 hour)

Android Applications Layer   (1 hour)

Much of the Android platform is implemented in Java, and yet that code needs to access functionality written in C/C++ and compiled to native machine code. Additionally, an application developer may want to implement portions of an app in C/C++ for performance or to incorporate existing native libraries and frameworks.

Java Native Interface (JNI) is a standard Java technology for integrating Java and native code. In this module, you learn the fundamentals of JNI and how to use it as a bridge between the native and Java-based runtimes. You also learn how to use Android's Native Development Kit (NDK) to implement portions of an application in native code and distribute it for use on multiple machine architectures.

• JNI development process overview
• Implementing Java methods in native code
• Mapping Java types to native types
• Managing object references in native code
• Managing Strings, arrays, and other Java object types in native code
• Throwing and catching exceptions in native code
• Using NDK to incorporate native code in an app
• Supporting multiple machine architectures with NDK
• NDK "stable" APIs
• Lab: NDK

Binder is Android's primary inter-process communication mechanism. (In fact, most standard POSIX IPC mechanisms are not available for use in Android.) Even higher-level Android IPC techniques, such as broadcast Intents and interactions between system services and client-side manager classes, use Binder as the underlying transport mechanism.

In this module, you learn: the capabilities of Binder; how to generated Binder-based interfaces in Java using Android Interface Definition Language (AIDL); how Binder is used by client-side manager classes to communication with system services; and how applications can expose their own Binder-based interfaces to other applications.

• Overview of Binder and its capabilities
• Higher-level Android IPC mechanisms based on Binder
• Binder communication and service discovery
• Generating Binder-based service interfaces in Java using Android Interface Definition Language (AIDL)
• Creating custom Parcelable Java types for use with Binder
• Exposing a Binder-based interface from an application
• Asynchronous Binder interactions
• Binder limitations
• Binder security
• Detecting and handling Binder "death notifications"
• Lab: Binder-based application service

Android extends standard Linux security to control access to device features like network interfaces, cameras, and stored personal information. In this module you learn how Android's permission model interacts with standard Linux security and how to define and enforce custom permissions to restrict access to system extensions.

• User and group ID management
• Android permission enforcement
• Declaring custom Android permissions
• Lab: Custom permissions
• Securing application components using permissions

In this module you learn how to set up an Android build system, download the Android source, build Android system images, and run them on emulators and real hardware.

• Setting up an Android build system
• Obtaining the Android source tree
• Selecting the target product and build variant
• Building Android system images from source
• Running custom Android images on emulators and real hardware

This module describes Android system startup including bootloading the kernel, launching standard Linux daemons, and initializing a variety of Binder-based system services. It also explains the importance of the Zygote daemon for reducing Android application startup time and memory consumption. Additionally, you learn how to customize the system boot process through custom init scripts.

• Bootloading the kernel
• The init process and Android's init scripting language
• The standard boot process and how to customize it
• The purpose of the Zygote daemon
• Startup of system services

This module presents an architectural overview of several of the most significant Binder-based system services in Android, explores interactions between services and client processes and between the various Android platform layers, identifies key source files in the implementation of the services, and provides references to additional resources for subject matter experts to extend and modify many services.

• Vibrator
• Power Service
• Alarm Service
• Package Service
• WiFi Service
• Location Service
• Android Media Framework
• Telephony
• Device Policy Service
• SurfaceFlinger
• Camera Service
• NFC Service

This module integrates concepts from the entire course in the hands-on creation of a custom Android system image. You learn how to implement customizations at all Android stack levels, including custom kernels, HAL user-space libraries, executables, daemons, Java libraries, system applications, and Binder-based system services. Additionally, you'll learn how to support third-party developers for your Android devices by creating an SDK add-on that exposes your custom Java APIs and provides developers with a custom image they can use to create Android Virtual Devices (AVDs) on which they can run and test their code.

• Setting up a custom device directory structure
• Registering a custom device with Android‚Äôs build system
• Adding the Makefile plumbing for a device
• Generating platform signing keys (Optional)
• Adding a custom kernel
• Adding a custom native library and executable
• Adding a custom daemon
• Creating a custom Java library to expose a native library (i.e., JNI in the platform)
• Consuming a custom Java/JNI library via a custom application (Optional)
• Implementing a custom Binder-based system service
• Building a custom application using a custom client-side manager class
• Creating and distributing a custom SDK add-on to support third-party developers (Optional)

In additional to standard utilities for monitoring and troubleshooting Linux-based systems, Android includes several custom tools of its own. This module shows you how to use these tools to monitor and troubleshoot the Android kernel, processes, system services, and applications.

• Debugging native code on Android
• Debugging Java code on Android
• Debugging applications and system services