Android Platform Training Course
5 days.Android Platform is composed of the following:
- Android Overview (1 day)
- Android Overview Module (1 hour)
- Android Stack Module (1 day)
- Java Native Interface (JNI) and the Android Native Development Kit (NDK) (4 hours)
- Android Inter-Process Communication (IPC) with Binder and AIDL (4 hours)
- Android Security Essentials (3 hours)
- Building Android from Source (2 hours)
- Android Startup (2 hours)
- Android Subsystems (3 hours)
- Creating a Customized Android System Image (1 day)
- Android Tools and Debugging (2 hours)
Upon completion of the course you will be able to:
- Explain the anotomy of the Android platform and get is physiology (layer interactions)
- Build native applications in Android using JNI and NDK
- Take advantage of Android AIDL to build IPC-enabled bound services
- Build the entire Android platform from source and get what's what
- Customize and extend the Android platform to build custom ROMs
- Modify and extend Android frameworks and sevices
- Take advantage of custom hardware with Android
- Understand where Android departs from standard Linux
PrerequisitiesBasic Java programming skills, or equivalent OOP language experience.
Aleksandar Gargenta is the technology brains at Marakana. Always on top of the latest in software, Aleksandar is the company's radar for technology that matters. His latest ventures are perfecting Marakana's Android Internals and Security courses.
Phew. And if that's not enough, he's also the chief architect of Marakana Spark, the on-demand software platform that powers marakana.com and a number of other training companies. As an instructor he's taught hundreds of classes for everyone from Apple to Disney, from NASA to the Department of Defense.
In his spare time Aleksandar runs the San Francisco Java, Android, and HTML5 User Groups with over three thousand members across the three groups.
Aleksandar holds a bachelor’s degree in Mathematics and Computer Science from the University of Waterloo. He is also a father, photographer, hiker, and a race-car driver :-)
Marko founded Marakana back in 2001 to help underprivileged youth, minorities, and inner-city kids learn web technologies and get ahead in life. So Marakana emerged with goal of helping people get better at what they do professionally, focused on open source software training.
Marko is the developer of Marakana Android Training series. He has taught Android for companies such as Sony-Ericsson, Qualcomm, Ericsson Canada, and many others. Marko is a co-founder of San Francisco Android Users Group and regularly teaches Android Bootcamp at Marakana.
Marko is author of Learning Android book published by O'Reilly Media. This book is based on Android Bootcamp and incorporates best learning practices for new developers to start creating applications for this exciting open source mobile platform.
Marko is also the co-chair of Android Open, an O'Reilly conference focusing on Android ecosystem.
In 2006 Marko Gargenta published "PHP and MySQL By Example", a collection on PHP examples. The book was published by Prentice Hall, world's largest technology publisher and has been also translated to Spanish.
Marko Gargenta obtained his Bachelor of Mathematics Degree from University of Waterloo (Canada's MIT) and has been developing in Java since 1996. He lives in San Francisco, California.More about Marko Gargenta...
Android Overview (1 day)
Our Android™ Overview course is designed to give you a high level overview of the entire Android platform. It is our gentle introduction to what Android operating system is, how we got here, what makes it fundamentally different than any other platform, and how to take advantage of its uniqueness. Android Overview is designed for both technical managers seeking high-level understanding of the platform as well as developers warming up for a deep dive into programming for Android. By the end of this course, you will have a complete understanding of the entire operating system, at a light level. Topics in this course include:
History of Android: How we got here, and where we may be heading
Android Stack: The big picture overview of entire Android OS
Hello, Android: Dissecting an Android app to understand all the moving parts
Architecting Android Apps: Understanding main building blocks of an Android app
Debugging and Testing: Tools that are available to you
Android Security: An overview of how Android security model works
History of Android (30 minutes)
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.Topics in this module include:
- Vision for Android
- History overview
- Android versions
- Android add-ons
- Android fragmentation
Android Stack (90 minutes)
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
Hello Android (90 minutes)
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
Architecting Android Apps (2 hours)
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
Debugging and Testing Android Apps (1 hour)
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:
Android Security Overview (1 hour)
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
Android Internals (5 days)
Android Internals training course is designed for those who are already familiar with basics of Android SDK and are looking to customize and/or extend the functionality of the platform.
Android Internals focuses on Android NDK and Android IDL APIs to give you a clean access to the underlying hardware and services with future compatibility in mind. You will learn how to build custom images and hack the platform.
Now extended to 5 days!
Android Overview Module (1 hour)
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)
Android Stack Module (1 day)
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)
In this module you learn how Google has extended the standard Linux kernel for Android and how the upper layers of the Android OS interact with these extensions.
- Where to find the source for Android's custom kernel
- Binder: Android's primary inter-process communication (IPC) mechanism
- Anonymous shared memory (ashmem): Android's replacement for POSIX SHM
- Android's physical memory allocator, ION
- Android power management extensions: wakelocks, early suspend, and alarms
- Android's low-memory process killer
- The Android logging system
- Android's user and group management and kernel security enforcement (the "paranoid network security" kernel option)
Android Native Layer (2 hours)
In this module you explore the portion of Android user-space that is implemented in native C/C++ code. You learn: in what ways Android's libc implementation, Bionic, is not POSIX-compliant (and why); how Android's user-space Hardware Abstraction Layer (HAL) defines a standard API for exposing hardware to the rest of the Android OS; what significant libraries, frameworks, and daemons are incorporated in Android; and how Android's Dalvik Virtual Machine (VM) enables both application and platform developers to write Android code in Java.
- Bionic: Android's implementation of libc and how it differs from the BSD libc
- User-space Hardware Abstraction Layer (HAL): standard APIs for accessing hardware
- Overview of standard Android native daemons (e.g., adbd, rild, ueventd, etc.) and their purpose
- Overview of other Android function libraries and frameworks
- The Dalvik Virtual Machine (VM) and how it differs from a Java VM
Android Application Framework Layer (1 hour)
Android's application framework layer not only exposes a Java API for application developers, but also implements much of the Android operating system in Java. In this module, you discover how Java-based system services manage the operating system, applications, and device hardware. You also learn the general model by which client-side manager classes interact with these system services through Binder IPC to access system features.
- System service architecture
- Significant system services and their roles (e.g., ActivityManagerService, PackageManagerService, ConnectivityManagerService, etc.)
Android Applications Layer (1 hour)
This module describes the basic structure of an Android application and how it is distributed as an Android application package (APK). It also identifies the standard set of Android system applications and where they are implemented in the source distribution.
- Android application structure
- Standard Android system applications, wallpapers, and input method editors
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 Security Essentials (3 hours)
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
Building Android from Source (2 hours)
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
Android Startup (2 hours)
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
Android Subsystems (3 hours)
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.
- Power Service
- Alarm Service
- Package Service
- WiFi Service
- Location Service
- Android Media Framework
- Device Policy Service
- 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)
Android Tools and Debugging (2 hours)
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
[top] Student Testimonials
Overall, this course was very well put together. The instructor was very knowledgeable. In a week I have a better understanding of Android than what I've been attempting to do in my free time for the past 6 months. I have also learned several tricks and best practice techniques that I would never have picked up learning on my own.
Great course that should give me a good start to my first Android project that has just started.
Instructor has excellent knowledge and allows the student copies of his work to review if they got lost. This was excellent (for me). I highly recommend him for those wanting a deep technical look at Android.
This was an excellent Android training experience. It was exactly the right mix of hands-on training and discussion. Ken is very engaging and knowledgeable. I appreciated his comments and suggestions alongside the training material.
Excellent class. I learned more in 5 days than I did in a semester long undergraduate mobile development class.
great introduction to developing android apps, sasa made the material easy to understand
Ken Jones is an excellent presenter who presents technical topics in a way that keeps your interest. He also did a great job fully-explaining concepts.
Fantastic course! Sasa knows so much that we need more than five days to cover the material for the class.
Sasa did a great job.
I had to miss portions of the course and appreciated the code snapshots that were zipped up. It allowed me to instantly catch up with the coding exercises.
Good course, although a bit too compressed. I learned a lot, but more importantly, I know where to look to learn more. Ken was a good teacher, but some of his materials were wrong or needed updating. I hope he'll send us a copy of the updated materials once they're fixed. Marakana produce a lot of free guidance and examples. I appreciate that they openly publish these things and I expect to refer to their site a lot as I continue to spin up on Android.
On a practical level, it solidified a lot of floating ideas in my head into a system of parts that fit together. His presentation of the process and how the application components reside in the process was very helpful. I feel confident that I can now makes applications that are robust and long-running.
This is a great training vendor. They know their stuff. The trainer was very quick and knew his stuff. The Android internals is really a black art and I am glad to have attended the training.