Android Architecture | MAD - 3.2

Main Ideas / Concepts Covered (Android Architecture)

Android is described as a stack of software components arranged in layers. Each lower layer provides services to the layers above it. The stack sits on top of the Linux kernel and ultimately supports the applications users interact with.

Layer-by-Layer Architecture (Bottom → Top)

1. Linux Kernel (Hardware Abstraction Layer)

• Acts as a bridge between software and hardware.
• Includes hardware drivers for components such as:
  • WiFi, display, audio, USB camera, Bluetooth, etc.
• Handles essential system tasks:
  • memory management, power management, and security
• The user does not interact directly with this layer.

2. Native Libraries / Tools (C/C++ Libraries)

• Built on top of the kernel.
• Implements heavy processing and low-level tasks.
• Examples mentioned:
  • SQLite: lightweight database storage
  • WebKit: engine to render web pages
  • OpenGL / OpenGL ES: graphics rendering (2D/3D)
  • Vulkan: graphics backend/alternative aimed at higher performance (example mentions smooth rendering up to ~60 FPS depending on usage)
  • SSL (Secure Sockets Layer): Internet security
  • FreeType: used for font/rendering (appears in the “remember these” group)
• Emphasis from the explanation:
  • OpenGL ES tends to appear on lower-end devices
  • Vulkan targets higher performance

3. Android Runtime (ART) / Dalvik Virtual Machine (DVM)

• Positioned at the same general level as native libraries (per the explanation).
• Contains:
  • Core libraries (Java-based)
  • Dalvik VM (DVM) for older versions, or ART for newer versions
• Why DVM instead of standard JVM:
  • Standard JVM is resource-heavy for mobile constraints (battery/memory)
  • Dalvik VM is designed to run Android apps quickly with low memory usage
• Language split:
  • Core libraries: written in Java
  • Native libraries: written in C/C++
• Key takeaway to remember:
  • DVM/ART + Core libraries

4. Application Framework (Manager Layer)

• Provides building blocks used by developers to build apps.
• Manages core phone/system functions that apps rely on.
• Components mentioned:
  • Activity Manager
    • Manages activities (each screen in an app is an activity)
  • Content Provider
    • Used to share data between applications (read/write)
    • Example: contacts stored by one app accessed by WhatsApp
  • Resource Manager
    • Manages app resources (screen elements, colors, layouts, graphics, etc.)
  • Notification Manager
    • Displays notifications/alerts and notification icons (status bar)
  • Also briefly referenced:
    • Window Manager
    • View System
• Exam-oriented “remember these” items:
  • Activity / Activity Manager, Content Provider, Resource Manager, Notification Manager (plus Window Manager & View System)

5. Applications (Top Layer)

• The user-visible layer.
• Includes:
  • System apps (e.g., Contacts, Phone, Browser, Home, Camera, Gallery, Clock, Calendar)
  • User-installed apps (e.g., games, social media, etc.)

---

Example Flow Used to Explain “Which Layer Does What”

• Uses a running game/app example and maps responsibilities:
  • The app runs in the Application layer
  • Screens/activities are managed by the Activity Manager
  • Screen resources are managed by the Resource Manager
  • The app needs runtime execution (explained as DVM/ART)
  • Native libraries support capabilities such as:
    • OpenGL for graphics
    • SSL for internet/security
    • WebKit for rendering web pages
  • The Linux kernel provides underlying hardware support via drivers, such as:
    • display drivers and audio drivers

---

Differences: Android vs iOS (As Stated)

Kernel

• Android: based on the Linux kernel
• iOS: based on a proprietary kernel (Darwin/XNU mentioned)

Source Code Openness

• Android: open source
• iOS: not open source; controlled by Apple

Execution Model

• Android: runs via DVM/ART runtime (bytecode executed through runtime)
• iOS: runs natively on hardware, compiled to machine code

File System Access

• Android: more flexible (direct file system access mentioned)
• iOS: more restricted

Hardware Support

• Android: runs on any hardware that supports it (phones, TVs, smart watches, etc.)
• iOS: runs on hardware created/approved by Apple (more limited to Apple devices)

---

Instruction-Like Content Included (Exam-Oriented)

How to Draw for the Exam

Draw the 5 layers vertically (top → bottom or bottom → top) and write the components inside each layer:

1. Linux kernel
   • bridge + drivers + memory/power/security
2. Native libraries/tools
   • SQLite, WebKit, OpenGL/OpenGL ES, Vulkan (mentioned), SSL, FreeType
3. Android Runtime (DVM/ART) + Core libraries
4. Application framework/manager
   • Activity Manager, Content Provider, Resource Manager, Notification Manager
   • plus Window Manager & View System
5. Applications
   • system apps + user apps

---

Speakers / Sources Featured

Speaker

• An unnamed instructor/presenter (referred to as “we”; no name given)

Sources Referenced (Technologies)

• Linux kernel
• SQLite
• WebKit
• OpenGL / OpenGL ES
• Vulkan
• SSL (Secure Sockets Layer)
• FreeType
• Dalvik Virtual Machine (DVM)
• Android Runtime (ART)
• iOS kernel (Darwin/XNU)
• JVM