Android platform glossary

See the list below to learn the basic terminology of the Android Open Source Project (AOSP). Here are other sources for definitions of key terms:

See Code with respect for examples of terminology to use and avoid for a more inclusive ecosystem.

Apps

APK (.apk) file
Android app package file with the extension .apk. Each Android app is compiled and packaged in a single file that includes all of the app's code (DEX files with the extension .dex), resources, assets, and manifest file. The app package file can have any name but must use the .apk extension, for example, myExampleAppname.apk. For convenience, an app package file is often called an APK.

Related: app

action
A description of something that an intent sender wants done. An action is a string value assigned to an intent. Action strings can be defined by Android or by a third-party developer. For example, android.intent.action.VIEW for a web URL, or com.example.rumbler.SHAKE_PHONE for a custom app to vibrate the phone.

Related: intent

activity
A single screen in an app, with supporting Java code, derived from the Activity class. Most commonly, an activity is visibly represented by a full screen window that can receive and handle UI events and perform complex tasks, because of the window it uses to render its window. An activity is typically full screen, but it can also be floating or transparent.
app
From a component perspective, an Android app consists of one or more activities, services, listeners, and intent receivers. From a source file perspective, an Android app consists of code, resources, assets, and a single manifest. During compilation, these files are packaged in a single file called an app package file (APK).

Related: APK (.apk) file, activity

broadcast receiver
An object based on the BroadcastReceiver class that listens for intents that are broadcast, rather than being sent to a single target app or activity. The system delivers a broadcast intent to all interested broadcast receivers, which handle the intents sequentially.

Related: intent, intent filter

content provider
A data-abstraction layer that you can use to safely expose your app's data to other apps. A content provider is built on the ContentProvider class, which handles content query strings of a specific format to return data in a specific format. See Content providers for more information.

Related: URIs in Android

dialog
A floating window that acts as a lightweight form. A dialog can have button controls only and is intended to perform a simple action (such as button choice) and perhaps return a value. A dialog isn't intended to persist in the history stack, contain complex layout, or perform complex actions. Android provides a default simple dialog with optional buttons, or you can define your own dialog layout. The base class for dialogs is Dialog.

Related: activity

intent
A message object that you can use to launch or communicate with other apps or activities asynchronously. An intent object is an instance of the Intent class. It includes several criteria fields that you can supply to determine what app or activity receives the intent and what the receiver does when handling the intent. Available criteria include the desired action, a category, a data string, the MIME type of the data, and a handling class. An app sends an intent to the Android system, rather than sending it directly to another app or activity. The app can send the intent to a single target app or it can send it as a broadcast, which can in turn be handled by multiple apps sequentially. The Android system is responsible for resolving the best-available receiver for each intent, based on the criteria supplied in the intent and the intent filters defined by other apps. For more information, see Intents and intent filters.

Related: intent filter, broadcast receiver

intent filter
A filter object that an app declares in its manifest file, to tell the system what types of intents each of its components is willing to accept and with what criteria. Through an intent filter, an app can express interest in specific data types, intent actions, URI formats, and so on. When resolving an intent, the system evaluates all of the available intent filters in all apps and passes the intent to the app or activity that best matches the intent and criteria. For more information, see Intents and intent filters.

Related: intent, broadcast receiver

resources
Nonprogrammatic app components that are external to the compiled app code, but which can be loaded from app code using a well-known reference format. Android supports a variety of resource types, but a typical app's resources would consist of UI strings, UI layout components, graphics or other media files, and so on. An app uses resources to efficiently support localization and varied device profiles and states. For example, an app would include a separate set of resources for each supported local or device type, and it could include layout resources that are specific to the current screen orientation (landscape or portrait). For more information about resources, see App resources overview. The resources of an app are always stored in the res/* subfolders of the project.
service
An object of class Service that runs in the background (without any UI presence) to perform various persistent actions, such as playing music or monitoring network activity.

Related: activity

URIs in Android
Android uses uniform resource identifier (URI) strings as the basis for requesting data in a content provider (such as to retrieve a list of contacts) and for requesting actions in an intent (such as opening a web page in a browser). The URI scheme and format is specialized according to the type of use, and an app can handle specific URI schemes and strings in any preferred way. Some URI schemes are reserved by system components. For example, requests for data from a content provider must use content://. In an intent, a URI using an http:// scheme are handled by the browser.

Build

adb
Android Debug Bridge, a command-line debugging app included with the SDK. adb provides tools to browse the device, copy tools on the device, and forward ports for debugging. If you're developing in Android Studio, adb is integrated into your development environment. The acronym is written in all lower case in plain text. When referring specifically to the command, it's written as adb. See Verify that you have fastboot and adb for more information.
Android project
A Git repository on an Android Gerrit host. See Git source editor for more information on how Git works.

Related: Git repository

build fingerprint
A unique, human-readable string containing manufacturer information issued to each build. See Build OTA packages for more information.
Git branch - canonical
Distinct versions for each Git repository, such as android-11.0.0_r1, found at cs.android.com/android/platform/superproject/+/android-11.0.0_r1. See Git Branching - Branches in a Nutshell for more information.
Git branch - local
A temporary branch in the current Repo client to make code changes, started with the repo start branch-name . command. This is an active line of development. The most recent commit on a branch is called the tip of that branch.
Git repository
Sometimes called a project, this is a portion of the codebase representing a particular component or type of device, such as frameworks/base or platform/packages/apps/Car/Media.

Related: Android project

manifest file
An XML file that describes a grouping of Git repositories per branch, the Git revisions at which to check out those repositories, and their layout on a file system. This XML file, typically named default.xml, is associated with a Repo branch and describes the Git repositories and Git branches checked out when you initialize and sync the Repo branch. This file defines the various Git repositories the Repo tool should fetch into a Repo client checkout to build a product (such as Android Automotive OS). See all manifests at android.googlesource.com/platform/manifest/+refs. See the default manifest included in manifest files to pull in Android platform (AOSP) files at android.googlesource.com/platform/manifest/+/refs/heads/main/default.xml. See App manifest overview for app information and repo Manifest Format for platform development.
over-the-air (OTA) update
Android devices in the field can receive and install over-the-air (OTA) updates to the system, app software, and time zone rules. See OTA updates for more information.
Repo branch
A collection of Git repositories captured in a manifest file that represents a version (build) of the Android codebase, such as android11-gsi or aosp-android-games-sdk, downloaded with repo init and repo sync commands. See the manifest file description for links to all manifest files and use Android Code Search to search for their builds.
uprev
In general, uprev updates a constituent subproject of a larger project to a newer version. An uprev changes a revision level to either the next incremented version or to the latest available version. In the case of a HIDL package, to maintain the package-level backwards-compatible extensibility, a minor-version uprev updates the new package to a higher minor version while keeping the same name and major version as the old package. In the case of the Bootloader configuration, an uprev updates the boot header version support to the latest version.

Platform

Android Runtime (ART) and Dalvik
Android Runtime (ART) is the managed runtime used by apps and some system services on Android. ART is the default runtime for devices running Android 5.0 (API level 21) and higher. ART and its predecessor Dalvik were originally created specifically for the Android Open Source Project. ART as the runtime executes the Dalvik Executable format and Dex bytecode specification. ART and Dalvik are compatible runtimes running Dex bytecode, so apps developed for Dalvik should work when running with ART.
DEX (.dex) file
Compiled Android app code file. Android programs are compiled into Dalvik Executable (DEX) files with the extension .dex, which are in turn zipped into a single APK file on the device. DEX files can be created by automatically translating compiled apps written in the Java programming language.