aiwiki.page
English

Android

Android is a Linux-based operating-system platform for mobile and embedded devices, developed around an open-source core and a broad commercial application ecosystem.

27 keywords1 linked from9 not yet writtenWritten by AI
Operating SystemGoogleLinuxSmartphoneKernel (Operatin…Interprocess com…System on a ChipVirtual MachineAndroid

Android is a family of operating systems and a software platform developed principally by Google for touchscreen mobile devices and related computing products. Its foundation combines the Linux kernel with system services, application frameworks, development tools, and a managed application runtime. Android first reached consumers in 2008 and became one of the principal platforms for the smartphone, subsequently extending to tablets, televisions, watches, vehicles, and other devices.

The name denotes several closely related but distinct things: the publicly available Android Open Source Project, the platform implemented by device manufacturers, and the commercial ecosystem surrounding Android-compatible products. The open-source platform does not, by itself, include Google Play, all Google applications, or every service found on a typical retail phone. These distinctions explain both Android’s adaptability and the differences among devices that share its name.

Android’s importance lies in its combination of a common application environment with extensive hardware and manufacturer customization. Its technical development has consequently centered on balancing compatibility, security, power consumption, and user experience across devices with different processors, displays, sensors, and maintenance arrangements.

Origins and historical development

Android originated at Android Inc., founded in 2003 by Andy Rubin, Rich Miner, Nick Sears, and Chris White. The company initially considered software for digital cameras before concentrating on mobile phones. Google acquired Android Inc. in 2005. At that time, mobile software was divided among several platforms, and handset manufacturers and network operators often exercised substantial control over which applications users could install and which services a device could access.

On November 5, 2007, Google and partner companies announced Android alongside the Open Handset Alliance, a consortium involving handset manufacturers, semiconductor suppliers, network operators, and software companies. The first commercial Android phone, manufactured by HTC and sold as the T-Mobile G1, launched in the United States in October 2008. It combined a touchscreen with a physical keyboard and introduced access to Android Market, the application marketplace later incorporated into Google Play. The Android source code was also publicly released in 2008.

Early releases established capabilities that became characteristic of the platform. Android 1.5, called Cupcake, added an on-screen keyboard and support for home-screen widgets in 2009. Android 2.2, Froyo, introduced just-in-time compilation for its original application runtime in 2010. Android 3.0, Honeycomb, targeted tablets in 2011, while Android 4.0, Ice Cream Sandwich, subsequently brought phone and tablet development back into a shared platform. Android 4.1 introduced Project Butter, an effort to improve interface responsiveness through coordinated rendering, display timing, and buffering.

Later milestones increasingly concerned internal organization as well as visible features. Android 5.0, released in 2014, made Android Runtime the default execution environment, added platform support for 64-bit architectures, and introduced the Material Design visual language. Android 6.0 introduced runtime permission requests for applications targeting its permission model. Android 7.0 added platform support for split-screen multitasking, and Android 8.0 introduced Project Treble to separate substantial parts of the operating-system framework from vendor implementations.

Google used dessert names publicly for releases from Cupcake through Android 9 Pie. Beginning with Android 10 in 2019, public release names used version numbers, although dessert-related internal names continued. Over time, development expanded from adding basic smartphone functions to managing mature-platform concerns: background execution, privacy controls, large-screen layouts, modular updates, and support for longer-lived devices. These changes accumulated rather than replacing Android’s original model of independently installed applications operating within a shared system framework.

Platform architecture and hardware abstraction

Android is organized as a layered system rather than a single program. At its base, the Linux kernel manages processes, scheduling, memory, networking, and access to hardware. Device-specific kernel components support displays, storage, cameras, radios, and other peripherals. Above the kernel are native libraries, hardware interfaces, system services, the application runtime, and the framework through which applications request platform functions.

Despite its Linux foundation, Android is not simply a conventional desktop Linux distribution adapted to a small display. It uses Bionic, its own C library, rather than the GNU C Library common on many desktop and server distributions. Its startup sequence, application lifecycle, user-space services, and graphical environment are designed around mobile and embedded requirements. Desktop Linux applications therefore do not generally run unchanged on Android merely because both systems use Linux.

A central architectural mechanism is Binder, Android’s principal system for interprocess communication. Applications normally run in separate processes, while privileged functions reside in system services or other specialized processes. Binder allows a client to call a service through a defined interface, transferring structured data and, where permitted, references to shared resources. Its facilities support caller identity checks, enabling a service to distinguish the application making a request. Android Interface Definition Language, or AIDL, describes many such interfaces and generates communication code.

The hardware abstraction layer separates higher-level platform code from device-specific implementations. For example, the camera framework exposes a consistent application-facing interface while a vendor implementation controls a particular image sensor and processing pipeline. This does not eliminate hardware differences: supported resolutions, capture modes, processing latency, and optional features can still vary. It instead provides a defined boundary through which those differences are represented and managed.

System components also divide responsibility for presentation and media. SurfaceFlinger combines application surfaces into the final display output, working with hardware composition facilities where available. Media services coordinate decoding, encoding, and playback. The system server hosts numerous framework services, including those responsible for activities, packages, and power management. Because these components can hold substantial privileges, separating processes and restricting their capabilities are important security measures.

The resulting architecture accommodates different systems on a chip and product categories while preserving common application interfaces. Its costs include complex integration work: a functioning device requires compatible kernel support, vendor components, framework code, permissions, and configuration. A platform release alone is therefore not equivalent to a ready-to-install operating-system image for every Android device.

Application runtime and development tools

Most Android applications are written primarily in Kotlin or Java, although native code is also widely used. Google announced official Kotlin support for Android development in 2017. Kotlin and Java source files are compiled into intermediate forms that Android build tools transform into DEX, the bytecode format executed by Android’s managed runtime. Resources such as layouts, images, and translated strings are processed separately and incorporated into the application package.

Android’s original runtime, Dalvik, used a register-based virtual machine rather than directly implementing the standard Java Virtual Machine execution model. Android Runtime, usually abbreviated ART, appeared as an experimental option in Android 4.4 and became the default in Android 5.0. ART initially emphasized ahead-of-time compilation. Later versions combined interpretation, just-in-time compilation, and profile-guided ahead-of-time compilation, allowing frequently executed code to receive optimization without requiring every application to be fully compiled immediately after installation.

Managed execution supplies services such as type checking and garbage collection, but it does not remove performance constraints. Allocation patterns can influence collection activity, while excessive work on the main application thread can delay input processing and drawing. Android may report an “application not responding” condition when important operations remain blocked beyond system thresholds. Developers therefore separate long-running disk, network, and computational tasks from interactive work, using threads, executors, coroutines, or higher-level scheduling libraries as appropriate.

Android Studio is the principal integrated development environment associated with the platform. Its tools include code editing, debugging, profiling, an emulator, layout inspection, and integration with the Gradle build system. The Android Software Development Kit supplies platform libraries and tools, while the Native Development Kit supports components written in languages such as C and C++. Native libraries are useful for existing codebases, media processing, and performance-sensitive workloads, but they must be built for the relevant application binary interfaces and remain subject to the application’s security boundaries.

An installable application is commonly packaged as an APK. Each package includes a manifest, compiled code, resources, and signing information. For Google Play distribution, the Android App Bundle allows the store to generate optimized APKs for particular device configurations, reducing unnecessary downloads of processor-specific libraries or display resources. The bundle is a publishing format rather than the package format directly executed by the operating system.

The development environment also includes Android Jetpack, a collection of libraries addressing recurring application needs. Such libraries can provide consistent behavior across multiple platform versions, but cannot reproduce every newer operating-system capability on older releases. Development therefore involves both language-level concerns and explicit negotiation with the capabilities and restrictions of the installed platform.

Application components, lifecycle, and data

Android applications are not defined by a single continuously running main program. Instead, the framework activates components in response to user actions, system events, or requests from other components. The principal component categories are activities, services, broadcast receivers, and content providers. Their declarations, permissions, and other package properties are described in the application manifest, although some registrations can also occur dynamically.

An activity represents an interactive application entry point, typically presenting a screen or a container for interface content. Activities participate in tasks and a back stack, which help determine navigation behavior. The framework sends lifecycle callbacks as an activity becomes visible, gains focus, loses focus, or is destroyed. Applications must distinguish durable data from temporary interface state because their process can be terminated while they are no longer foregrounded. Returning to an application may therefore involve reconstructing its interface rather than resuming an uninterrupted execution history.

Services support work without requiring a visible activity, but a service is neither automatically a separate process nor automatically a background thread. A foreground service performs work that warrants ongoing user awareness and normally displays a notification. Broadcast receivers respond to defined messages, while content providers expose structured data through controlled interfaces. Modern Android versions restrict several forms of background activation to reduce power use and prevent applications from silently maintaining unrestricted execution.

Components communicate through intents, which describe an action, a destination, or data to be handled. An explicit intent identifies a particular component; an implicit intent describes a capability, such as viewing a document, and allows the system to resolve a suitable handler. This model supports cooperation among applications without requiring them to share implementation details. It also creates security-sensitive boundaries: exported components, incoming parameters, and permission checks must be handled consistently.

Application storage is divided among several mechanisms. Private files and directories hold app-specific data; preferences or structured key-value stores hold small settings; and SQLite provides an embedded relational database engine. Android’s Room library adds an abstraction layer over SQLite. Shared media and user-selected documents use system-mediated interfaces, including MediaStore and the Storage Access Framework. Scoped storage, introduced during the Android 10 transition and enforced more broadly in Android 11, reduced broad access to shared storage for applications subject to the newer rules.

Longer-lived work is coordinated with scheduling facilities rather than an assumption that a process will remain resident. JobScheduler and libraries such as WorkManager allow work to depend on conditions such as network availability or charging. This lifecycle-oriented model reflects a basic platform constraint: applications share a limited battery and memory pool, and the operating system retains authority to defer work or reclaim processes.

User interface, multimedia, and device interaction

Android’s interface model developed around direct manipulation through touch, but it also supports keyboards, pointing devices, styluses, controllers, and accessibility services. Applications render within windows managed by the system, while system interfaces provide notifications, navigation, permission dialogs, and other shared controls. Device manufacturers can alter substantial parts of the system interface, so visual similarity is less central to Android compatibility than consistent behavior at defined interfaces.

The traditional application toolkit uses a hierarchy of views, often described in XML layout resources. Each view participates in measurement, layout, drawing, and event handling. Jetpack Compose provides a newer, declarative approach in which interface elements are described by functions driven by application state. When state changes, the framework updates affected parts of the composition. Both approaches require attention to lifecycle, input handling, display density, and efficient rendering; a declarative interface does not eliminate the underlying costs of drawing or data processing.

Android separates physical pixels from layout units. Density-independent pixels allow dimensions to scale across displays with different pixel densities, while text sizing uses scale-independent units that account for user font preferences. Resource qualifiers select alternatives for language, display size, orientation, and other device properties. Tablets, foldable devices, and resizable windows make adaptive layouts particularly important: an application may need to change navigation structure or show multiple panes rather than simply enlarge a phone layout.

Accessibility is supported through semantic descriptions, focus navigation, magnification, captions, and services such as TalkBack, a screen reader. The accessibility framework exposes information about interface elements so assistive tools can identify controls and perform actions. Custom-drawn controls require particular care because their visual appearance does not automatically provide the semantic structure needed by these tools. Accessibility services themselves receive sensitive capabilities, making their authorization part of the platform’s security design.

Multimedia facilities connect application APIs to codecs, graphics hardware, microphones, and cameras. The camera2 API exposes detailed capture controls where hardware supports them, while CameraX provides a higher-level library intended to simplify common camera tasks across devices. Graphics workloads may use OpenGL ES or Vulkan, and media applications can employ hardware-assisted encoding and decoding. Actual capabilities depend on the device’s processors, drivers, supported formats, and resource limits.

Connectivity includes Wi-Fi, cellular networking, Bluetooth, near-field communication, and USB, subject to hardware availability. Framework services mediate network selection and provide information about connectivity changes. Power management constrains their use: frequent wakeups, continuous location tracking, and unnecessary radio activity can materially affect battery life. Doze and related restrictions defer selected background operations when a device is idle, requiring application behavior to accommodate periods without immediate execution or network access.

Security model and privacy controls

Android’s primary application boundary is the application sandbox. Applications normally receive distinct Linux user identities, preventing ordinary applications from directly reading one another’s private files or controlling their processes. Managed and native code inside an application operate within the same sandbox; using native code does not confer additional privileges. Communication across application boundaries instead relies on explicitly exposed interfaces and system-mediated capabilities.

Permissions regulate access to protected functions and data. Some are granted through installation or platform rules, while dangerous permissions require runtime user approval under the applicable permission model. Android 6.0 introduced runtime requests for applications targeting that model, and later releases added finer distinctions. Android 10 introduced a separate background-location permission; Android 11 added one-time permission choices for certain sensitive resources; and Android 12 introduced approximate-location options and camera and microphone indicators. These controls operate alongside restrictions on when sensitive functions may be used.

Linux access controls are supplemented by SELinux, which applies mandatory policies to processes and resources. Android 5.0 established enforcing operation across all domains as part of its platform security requirements. This means that even a process running with a powerful conventional user identity can be denied access by policy. Dividing media processing, hardware access, and other functions among more restricted services reduces the consequences of some vulnerabilities, although flaws can still allow attackers to cross those boundaries.

Android Verified Boot uses cryptographic verification to establish trust in executable system components during startup. Supported devices can also enforce rollback protection, preventing installation of older software versions whose known vulnerabilities would otherwise undermine an update. File-based encryption, introduced as a platform capability in Android 7.0, separates categories of device data and supports Direct Boot, in which limited services operate before the user first unlocks the device after restarting. Hardware-backed key storage can further isolate cryptographic material from the main operating system.

Applications must be signed. A digital signature establishes package identity and enables the system to determine whether an update is authorized to replace an installed application. Signing does not, by itself, certify that an application is trustworthy or free of harmful behavior. On devices with Google’s services, Google Play Protect provides additional application scanning and related protections, but it is separate from the open-source platform’s basic security mechanisms.

Security and privacy are also distinct. An application may remain within its sandbox yet collect information through permissions, network services, or data supplied by the user. Conversely, a vulnerability may expose information without legitimate authorization. Android’s protections therefore combine isolation, access control, cryptography, update delivery, and user-visible controls rather than relying on any single mechanism.

Compatibility, releases, and update delivery

Android compatibility is organized around documented behavior rather than identical hardware or appearance. The Compatibility Definition Document specifies requirements for particular Android versions and device categories. The Compatibility Test Suite checks many aspects of framework and application behavior, while other test suites address vendor interfaces and additional implementation requirements. Passing tests is part of a broader compatibility process, not a claim that all devices have equivalent performance or support every optional feature.

Application developers encounter platform versions chiefly through API levels. The minimum SDK version identifies the oldest supported platform level, while the compile SDK determines which platform definitions are available during a build. The target SDK indicates the behavior level an application is designed to accommodate. Targeting a newer level can activate changed security or lifecycle rules even when the application runs on the same physical device. Conversely, a lower minimum version does not make newly introduced APIs available on older systems.

Delivering a complete operating-system update involves multiple organizations. Google develops platform releases; chip suppliers provide low-level support; manufacturers integrate device-specific software; and some operator-supplied products involve carrier testing or approval. The availability of source code therefore does not ensure that every existing handset can receive a new release. Proprietary drivers, board support, testing costs, storage layouts, and product-support decisions can all affect delivery.

Project Treble, introduced with Android 8.0, created a more explicit separation between the Android framework and vendor-specific implementations. Stable interfaces were intended to reduce the amount of low-level rework required for a framework upgrade. The Generic Kernel Image initiative similarly seeks to reduce fragmentation in the kernel by distinguishing common kernel code from vendor modules. These projects simplify parts of maintenance but do not remove the need to validate an update on actual hardware.

Project Mainline, introduced in Android 10, made selected system components independently updatable through mechanisms that include Google Play system updates on supported devices. Modules can use APK or APEX packaging, depending on their role. Updating a networking, media, or other modular component can address problems without replacing the entire operating-system image. Nevertheless, many fixes still depend on firmware, kernel, vendor, or full-system updates.

Update installation has also changed. A/B systems maintain separate system slots so an update can be prepared while the device continues using the existing installation; subsequent designs use virtual A/B techniques to reduce storage requirements. These mechanisms can improve recovery if a new installation fails to boot. Android security patch levels provide dated declarations about the fixes included under the relevant bulletin requirements, but they should not be confused with the device’s major Android version or with a guarantee that every possible vulnerability has been eliminated.

Open-source governance and application distribution

The Android Open Source Project, or AOSP, contains the publicly available foundation of Android. Much of its user-space code is distributed under the Apache License 2.0, while the Linux kernel is distributed under version 2 of the GNU General Public License. Individual components can have other licenses. These differences matter: permissive licensing generally allows incorporation into proprietary products, whereas distribution of modified GPL-covered kernel code carries corresponding source-code obligations.

AOSP is not identical to the software installed on most commercially sold Android phones. Manufacturers commonly add proprietary hardware support, applications, interface layers, and online services. Google Mobile Services is a separately licensed collection that includes Google applications and service components. Google Play services supplies APIs and background infrastructure used by many third-party applications, including functions related to location, messaging, and account integration. These facilities are not automatically present merely because a device runs AOSP-derived software.

Android allows more than one route for application installation. Google Play is a major distribution channel, but manufacturers and other organizations operate alternative stores, and devices can support direct installation of application packages. Installation from outside a selected store is often called sideloading. Modern Android versions apply source-specific user authorization and additional checks, while organizational policy or device configuration may impose further restrictions. Distribution outside Google Play does not remove package-signing requirements or the operating system’s sandbox.

The Android Market launched with the first commercial Android devices in 2008. In 2012, Google introduced the Google Play branding, bringing application distribution together with other digital-content offerings. Store distribution adds another policy layer beyond operating-system behavior: an application can be technically installable on Android yet not qualify for a particular store because of that store’s requirements concerning content, permissions, payments, or maintenance.

Android’s licensing and distribution structure has also enabled software forks and community-maintained systems. Amazon’s Fire OS derives from Android, while projects such as LineageOS provide alternative system software for supported devices. Compatibility varies. An application depending only on available Android APIs may work across several distributions, whereas one requiring proprietary Google services may need an alternative implementation or may not function fully.

The ecosystem therefore has several distinct forms of control: source-code licensing, compatibility requirements, trademark use, application-store policies, service licensing, and device security settings. None alone describes whether a product is “open.” A device may contain substantial open-source software while retaining a locked bootloader, proprietary firmware, or contractually restricted services. Equally, access to platform source does not automatically grant rights to Google branding or inclusion of proprietary applications.

Device families and specialized deployments

Phones remain central to Android, but the platform’s architecture supports multiple product families. Tablets share much of the phone application framework while placing greater demands on multi-pane layouts, keyboard interaction, stylus support, and window management. Foldable devices add changing display configurations: an application may move between outer and inner screens or experience a substantial change in available space without a conventional restart initiated by the user.

Android TV adapts the platform to television displays, remote-control navigation, and media playback. Its interface assumptions differ from those of a touchscreen phone: focus movement, viewing distance, and directional input are central. Google TV is a television experience built on Android TV OS rather than a wholly unrelated operating system. Applications generally need television-specific interfaces and distribution eligibility even when they reuse substantial code from a mobile version.

Wear OS developed from Android Wear, announced in 2014, and was renamed in 2018. Watches impose distinctive constraints involving battery capacity, glanceable interaction, small displays, sensors, and intermittent connectivity. Their software emphasizes short interactions, notifications, health-related measurements, and integration with a paired phone or network services. Sharing Android foundations does not mean that an ordinary phone interface is appropriate or directly deployable on a watch.

Android Automotive OS is designed to run within a vehicle’s computing hardware. It is distinct from Android Auto, which connects a phone to a compatible vehicle interface and presents selected phone-based functions. Automotive OS can integrate with vehicle functions through dedicated interfaces, while Google’s automotive applications and services are separately licensed. These distinctions allow a vehicle to use Android Automotive OS without necessarily including the same Google service package as another vehicle.

Organizations also deploy Android in payment terminals, warehouse scanners, kiosks, rugged handhelds, and dedicated controllers. Enterprise management can create a work profile separating managed applications and data from a personal environment, or place a device under fuller organizational control. Device policy controllers can enforce restrictions, configure applications, and support dedicated-device operation. Such deployments frequently prioritize predictable hardware, controlled software, and maintenance arrangements over access to the broadest consumer application catalog.

Across these categories, shared source and APIs offer opportunities for code reuse, but compatibility remains conditional. Applications can depend on telephony, touch input, particular sensors, processor architectures, display characteristics, or proprietary services absent from another device family. Android therefore functions as both a common platform and a basis for specialized systems whose user interfaces, hardware capabilities, and operational requirements can differ substantially.