Android Architectre

In this blog, I’ll explain Android Architecture — what work happens in each layer.

Android is divided in to 5 layers:

• Application Layer
• Framework Layer
• ART and Native Libraries
• HAL
• Linux Kernel

1. Application Layer This layer is where all apps run.Whenever a user interacts with the device, tapping a button, opening an app, or triggering a feature, the request originates here. Applications do not directly interact with hardware. Instead, they rely on the Application Framework to perform any operation. This separation ensures security, modularity, and stability. Each app runs in its own isolated process (sandbox), which prevents it from interfering with other apps or the system. For example, if a user presses a button to turn on the AC in a car app, the app does not control the AC hardware directly. It simply sends a request to the framework.
2. Framework Layer The Application Framework is the brain of Android. This layer receives requests from applications and decides how to handle them. It acts as a controller that manages system behavior, resources, and communication between components. This layer contains Managers (client-side APIs) and Services (system-side implementations). Managers are what developers use inside apps (e.g., ActivityManager, LocationManager), while Services are the backend system components (e.g., ActivityManagerService) that actually execute the logic. When an app makes a request, it goes through a Manager, which internally communicates with the corresponding Service using Binder IPC. The Service processes the request, performs validations, manages resources, and then forwards the request to lower layers if needed. In Android Automotive, this layer also includes components like CarService, which handles vehicle-related operations and communicates with the Vehicle HAL.
3. Android Runtime & Native Libraries This layer is responsible for executing code efficiently and handling performance critical operations. ART runs application code.It ensures that apps run efficiently without developers worrying about low-level memory management. Alongside ART, this layer contains native libraries written in C/C++. These libraries handle performance-intensive tasks such as graphics rendering, audio processing, and database operations. The framework often calls these native libraries to achieve better performance. JNI (Java Native Interface) plays a crucial role here by acting as a bridge between Java and C++ code. This is especially important in system-level and embedded work, where performance matters.This layer is especially critical when performance and low-level control are required.
4. Hardware Abstraction Layer(HAL) The HAL layer acts as a translator between the Android Framework and hardware. It hides hardware-specific complexities and provides a standard interface for the framework to interact with different hardware components. When the framework sends a request (e.g., turn on AC), HAL converts that request into a format that the hardware understands. In automotive systems, this is especially important, as vehicle data and signals need to be handled in a structured way. Vehicle HAL (VHAL) is a specialized HAL used in Android Automotive to manage vehicle properties like speed, Engine rpm,etc.
5. Linux Kernel The Linux Kernel is the foundation of Android System. It directly interacts with hardware and is responsible for managing core system operations such as memory, processes, and device communication. It contains device drivers that control hardware components. The kernel also handles process scheduling, ensuring efficient CPU usage, and manages memory allocation for different applications. It is also responsible for low-level security and system stability. Responsibilities include: Manages device drivers (camera, audio, sensors, CAN)

• Handles process scheduling
• Controls memory management
• Ensures system security
• Contains Binder driver (IPC support)
• Direct interaction with hardware

How all layers work together with a simple example: User presses a button in an app → Application sends request → Framework (Manager → Service) processes it → Binder IPC transfers request →HAL translates it → Kernel driver executes it → Hardware responds

Android is designed as a layered system so that each component focuses on a specific responsibility.

I’m currently exploring Android system internals, and this blog reflects my understanding so far.If you notice anything that can be improved or corrected, I’d really appreciate your feedback — I’m learning and refining my knowledge along the way.

In the upcoming blogs, I’ll dive deeper into individual layers.