Essentials
Modern Android
Quickly bring your app to life with less code, using a modern declarative approach to UI, and the simplicity of Kotlin.
Explore Modern Android
Adopt Compose for teams
Get started
Start by creating your first app. Go deeper with our training courses or explore app development on your own.
Hello world
Training courses
Tutorials
Kotlin for Android
Monetization with Play ↗️
Extend by device
Build apps that give your users seamless experiences from phones to tablets, watches, and more.
Large screens (e.g., tablets)
Wear OS
Android for Cars
Android TV
ChromeOS
Cross-device SDK
Build by category
Learn to build for your use case by following Google's prescriptive and opinionated guidance.
Games
Media apps
Health & Fitness
Enterprise apps
Get the latest
Stay in touch with the latest releases throughout the year, join our preview programs, and give us your feedback.
Platform releases
Android Studio preview
Jetpack & Compose libraries
Wear OS preview
Privacy Sandbox
Design & Plan
Kits & more
Get one of our Figma kits for Android, Material Design, or Wear OS, and start designing your app's UI today.
Go to Android & Material kits
Go to Wear OS kits
UI Design
Design a beautiful user interface using Android best practices.
Design for Android
Mobile
Large screens (e.g., tablets)
Wear OS
Android TV
Architecture
Design robust, testable, and maintainable app logic and services.
Introduction
Libraries
Navigation
Modularization
Testing
Quality
Plan for app quality and align with Play store guidelines.
Overview
Core value
User experience
Technical quality
Privacy & security
Build for Billions
Create the best experience for entry-level devices
Overview
About new markets
Android (Go edition)
Develop
Gemini is here
Gemini in Android Studio is your AI coding assistant for Android development.
Learn more
Get Android Studio
Core areas
Get the samples and docs for the features you need.
Samples
User interfaces
Permissions
Background work
Data and files
User identity
All core areas ⤵️
Tools and workflow
Use the IDE to write and build your app, or create your own pipeline.
Write and debug code
Build projects
Test your app
Performance
Command-line tools
Gradle plugin API
Device tech
Write code for form factors. Connect devices and share data.
Large screens (e.g., tablets)
Wear OS
Android Health
Cross-device SDK
Android for Cars
Android TV
ChromeOS
Libraries
Browse API reference documentation with all the details.
Android platform
Jetpack libraries
Compose libraries
Google Play services ↗️
Google Play SDK index ↗️
Google Play
Community
English
Deutsch
Español – América Latina
Français
Indonesia
Italiano
Polski
Português – Brasil
Tiếng Việt
Türkçe
العربيّة
中文 – 简体
中文 – 繁體
日本語
한국어
Android Studio
Sign in
Develop
Guides
Reference
Samples
Essentials
More
Design & Plan
More
Develop
More
Guides
Reference
Samples
Google Play
Community
Android Studio
Developer guides
App basics
Build your first app
App fundamentals
App resources
About app resources
Handle configuration changes
Localization
Localize your app
Test your app with pseudolocales
Unicode and internationalization support
Language and locale resolution
Per-app language preferences
Complex XML resources
Resource types
About resource types
Animation
Color state list
Drawable
Layout
Menu
String
Style
Font
More types
App manifest file
About app manifests
<action>
<activity>
<activity-alias>
<application>
<category>
<compatible-screens>
<data>
<grant-uri-permission>
<instrumentation>
<intent-filter>
<layout>
<manifest>
<meta-data>
<path-permission>
<permission>
<permission-group>
<permission-tree>
<profileable>
<property>
<provider>
<queries>
<receiver>
<service>
<supports-gl-texture>
<supports-screens>
<uses-configuration>
<uses-feature>
<uses-library>
<uses-native-library>
<uses-permission>
<uses-permission-sdk-23>
<uses-sdk>
Devices
Device compatibility
About device compatibility
About screen compatibility
Support different pixel densities
Multiple APK support
About multiple APKs
Create multiple APKs for different API levels
Create multiple APKs for different screen sizes
Create multiple APKs for different GL textures
Create multiple APKs with several dimensions
Support different languages and cultures
Support different platform versions
Filters on Google Play
64-bit Support
Support 16 KB page sizes
Large screens — tablets, foldables, ChromeOS
Get started with large screens
Large screen canonical layouts
Large screen ready
Overview
Configuration and continuity
Camera preview and media projection
Multi-window support
Input compatibility on large screens
Large screen optimized
Overview
Support different screen sizes
Migrate your UI to responsive layouts
Navigation for responsive UIs
Activity embedding
Large screen differentiated
Overview
Learn about foldables
Make your app fold aware
Support foldable display modes
Create a note-taking app
Support advanced stylus features
Large screen compatibility mode
Large screen cookbook
Wear OS
Get started
Design Wear OS UI ⍈
Principles of Wear OS development
Wear OS versus mobile development
Wear OS user interfaces
Accessibility on Wear OS
Getting started
Wear OS developer pathway
Create and run an app
Debug a Wear OS app
Connect a watch to a phone
Capture Wear UI screenshots
Apps
About Wear OS apps
Standalone apps
Conserve power
Authentication
Request permissions
Add a splash screen
Detect location
Playing audio on wearables
Test Bluetooth audio on emulators
Appear in recents and app resume
Building UI with Compose
Use Jetpack Compose on Wear OS
View design guidelines for UI components
Compose performance
Lists with Compose
Rotary input on Compose
Navigation with Compose for Wear OS
Building UI with Views
Build View-based UIs on Wear OS
Handle different watch shapes
Create lists
Navigation
Exit full screen activities on Wear
Show confirmations
Keep your app visible on Wear
Tiles
About tiles
Get started with tiles
Show periodic updates
Show dynamic updates
Animate tile elements
Interact with tiles
Migrate to ProtoLayout namespaces
Complications
About complications
Expose data to complications
Notifications
Notifications on Wear OS
Bridging options for notifications
Ongoing Activities
Handling data
Dynamic expressions
Send and sync data on Wear OS
Network access and sync on Wear OS
Access the Wearable Data Layer
Transfer data to a new mobile device
Transfer assets
Send and receive messages
Handle data layer events
Sync data items with the Data Layer API
Use cloud backup and restore
User input
Physical buttons
Rotary input on Views
Create input method editors in Wear
Voice
Read sensor data using Health Services
Creating watch faces
About watch faces
Watch Face Format
Overview
Setup
Optimize memory usage
XML reference
Jetpack Watch Face APIs
Design watch faces
Build a watch face service
Draw watch faces
Adding complications to a watch face
Creating interactive watch faces
Provide configuration activities
Address common issues
Improve performance with hardware acceleration
Optimize performance and battery life
Self-tag watch faces
Wear OS app quality
Package Wear OS apps
Distribute to Wear OS
Create Wear OS apps for China
Releases
Wear OS 4
Overview
Prepare for behavior changes
Update target SDK version
Explore features
Wear OS 3 migration guide
Library release notes
Android TV
In this guide
Design TV UI ⍈
Build TV Apps
In this guide
Get started with TV apps
AndroidX TV libraries
Handle TV hardware
Manage TV controllers
On-screen keyboard
Create TV navigation
Best practices for driving engagement on Google TV
Build TV playback apps
In this guide
Buidling UI with Compose
Use Jetpack Compose on Android TV
Create a catalog browser
Build a details screen
Building UI with Leanback API
Create a catalog browser
Provide a card view
Build a details view
Use transport controls
Introduce first-time users to your app
Add a guided step
Build TV layouts
Ambient mode
Playback controls on TV
Implement a media session
Background playback in a Now Playing card
Audio capabilities
Match content frame rate
Help users find content on TV
About finding TV content
Recommend TV content
About recommending TV content
Channels on the home screen
Video program attributes
Audio program attributes
Game program attributes
Watch Next
Add programs
Attributes
Guidelines for app developers
Guidelines for TV providers
Preview videos
Recommendations in Android N and earlier
Make TV apps searchable
Search within TV Apps
Build TV games
About TV games
Build TV input services
About TV input services
Develop a TV input service
Work with channel data
Manage TV user interaction
Support time-shifting
Support content recording
TV Accessibility
Accessibility best practices
TalkBack evaluation examples
Support TalkBack in TV apps
Adopt system caption settings
Custom view accessibility support
Custom view accessibility sample
TV Apps checklist
Distribute to Android TV
Releases
Android 12 for TV
Android 13 for TV
Android for Cars
About Android for Cars
Car app quality ⍈
Build media apps for cars
Build media apps for cars
Add support for Android Auto
Add support for Android Automotive OS
Build messaging apps for Android Auto
Build point of interest, internet of things, and navigation apps for cars
Using the Android for Cars App Library
Build point of interest apps for cars
Build internet of things apps for cars
Build navigation apps for cars
Get coarse location
Add support for Android Auto
Add support for Android Automotive OS
Build parked apps for Android Automotive OS
About parked apps
Build video apps
Build games
Build browsers
Test Android apps for cars
Overview
Test using the Desktop Head Unit
Test using the Android Automotive OS emulator
Distribute Android apps for cars
Google Play services for cars
Notifications on Android Automotive OS
ChromeOS devices
About ChromeOS
Building apps for ChromeOS
Optimizing Apps for ChromeOS
Preparing your development environment
App Manifest Compatibility for Chromebooks
ChromeOS Device Support for Apps
App Rendering Differences on Chromebooks
Window management
Adapting Games on ChromeOS
Smooth animation on ChromeOS
Test Cases for Android Apps on ChromeOS
Cross device SDK
About the Cross device SDK
Get started
Device discovery API
Secure connection API
Sessions API
Test and debug
API Reference
Google Assistant
About Assistant for Android
Build
About App Actions
Implement built-in intents
Create shortcuts.xml
Push dynamic shortcuts to Assistant
Release notes
Test
Google Assistant plugin
App Actions Test Library
Grow
Engage your users
In-App Shortcut Promo SDK
Add more features
Custom intents
Android widgets
Foreground app invocation
Inline inventory
Web inventory
Assistant sharing
Read It
Devices
App Actions for cars
Assistant for Wear OS
Support
Android (Go edition)
About Android Go edition
Develop for Android (Go edition)
Test Android Go apps
Optimize for Android (Go edition)
Approach
Optimize app memory
Improve startup latency
Reduce app size
Best practices
App architecture
Introduction
Guide to app architecture
About app architecture
UI layer
About the UI layer
UI events
State holders and UI state
State production
Domain layer
Data layer
About the data layer
Offline first
Architecture recommendations
Learning pathway
Modularization
About modularization
Common patterns
Recipes
Navigation
Architecture components
UI layer libraries
View binding
About view binding
Migrate from Kotlin synthetics to view binding
Data binding library
About data binding
Get started
Layouts and binding expressions
Work with observable data objects
Generated binding classes
Binding adapters
Bind layout views to Architecture Components
Two-way data binding
Lifecycle-aware components
Lifecycles
Handle lifecycles
Integrate with Compose
ViewModel
About ViewModel
Create ViewModels with dependencies
ViewModel Scoping APIs
Saved State module for ViewModel
ViewModel APIs cheat sheet
LiveData
Save UI states
Use Kotlin coroutines with lifecycle-aware components
Paging Library
About paging
Load and display paged data
Page from network and database
Transform data streams
Manage and present loading states
Test your Paging implementation
Migrate to Paging 3
Paging 2
About Paging 2
Display paged lists
Load paged data
Data layer libraries
DataStore
WorkManager
About WorkManager
Getting Started
How-To Guides
Defining your WorkRequests
Work states
Managing work
Observing intermediate Worker progress
Chaining work together
Testing Worker implementation
Integration tests with WorkManager
Debugging WorkManager
Advanced Concepts
Configuration and Initialization
Threading in WorkManager
About threading in WorkManager
Threading in Worker
Threading in CoroutineWorker
Threading in RxWorker
Threading in ListenableWorker
Support for long-running workers
Migrating from Firebase JobDispatcher
Migrating from GCMNetworkManager
App entry points
Activities
Introduction to activities
The activity lifecycle
Activity state changes
Test your app's activities
Tasks and the back stack
Processes and app lifecycle
Parcelables and bundles
Loaders
Recents screen
Restrictions on starting activities from the background
App shortcuts
About app shortcuts
Create shortcuts
Add capabilities
Manage shortcuts
Best practices for shortcuts
App navigation
Principles of navigation
Navigation component
Overview
Navigation controller
Design your navigation graph
Overview
Dialog destinations
Activity destinations
Nested graphs
Deep links
New destination types
Type safety
Global actions
Build a graph programmatically using the Kotlin DSL
Use the Navigation editor
Use your navigation graph
Navigate to a destination
Navigate with options
Safe args
Pass data between destinations
Animate transitions between destinations
Conditional navigation
Interact programmatically with the Navigation component
The back stack
Overview
Dialogs and the back stack
Circular navigation and the back stack
Multiple back stacks
Integrations
Navigate with feature modules
Multi-module projects
Connect UI components to NavController
Migrate to the Navigation component
Test Navigation
Custom back navigation
Custom back navigation
Predictive back gesture
Add support for predictive back animations
Responsive design
Handling configuration changes
Design for different form factors
Swipe between views
Swipe views using ViewPager2
Swipe views using ViewPager
Fragments
About fragments
Create a fragment
Fragment manager
Fragment transactions
Animate transitions between fragments
Fragment lifecycle
Saving state with fragments
Communicate with fragments
Working with the app bar
Displaying dialogs with DialogFragment
Debug your fragments
Test your fragments
App links
About app links
Enabling links to app content
Verify app links
Create app links for instant apps
Interact with other apps
About interacting with other apps
About intents and intent filters
About common intents
Send users to another app
Get a result from an activity
Allow other apps to start your activity
Limit loading in on-device Android containers
Package visibility
About package visibility
Know which packages are visible automatically
Declare package visibility needs
Fulfill common use cases
Test package visibility
Dependency injection
About dependency injection
Manual dependency injection
Dependency injection with Hilt
Hilt in multi-module apps
Use Hilt with other Jetpack libraries
Hilt testing guide
Hilt and Dagger annotations cheat sheet
Dagger
Dagger basics
Using Dagger in Android apps
Using Dagger in multi-module apps
App Startup
Google Play
Google Play Billing ⍈
Google Play Core libraries
Engage SDK
About Engage SDK
Engage SDK Watch integration guide
Engage SDK Listen integration guide
Engage SDK Read integration guide
Engage SDK Shopping integration guide
Engage SDK Food integration guide
Engage SDK Social integration guide
Engage SDK integration workflow
Engage SDK Cluster publishing guidelines
Engage SDK Frequently asked questions
Engage SDK Release Notes
Engage SDK Sample Apps
Play Points
About Play Points
Create products and promotions
Detect and deliver products
Test products
Play Asset Delivery
About Play Asset Delivery
Integrate asset delivery (Kotlin and Java)
Integrate asset delivery (native)
Integrate asset delivery (Unity)
Target texture compression formats
Test asset delivery
Play Feature Delivery
About Play Feature Delivery
Configure install-time delivery
Configure conditional delivery
Configure on-demand delivery
On-demand delivery best practices
Configure instant delivery
Additional resources
In-app reviews
Overview
Integrate using Kotlin or Java
Integrate using native code
Integrate using Unity
Test in-app reviews
In-app updates
About in-app updates
Support in-app updates (Kotlin or Java)
Support in-app updates (Native)
Support in-app updates (Unity)
Test in-app updates
Play as you Download
About Play as you Download
Best practices
Google Play Instant
About Google Play Instant
Get started with instant apps
Create an instant-enabled app bundle
UX best practices for apps
Get started with instant games
About instant games
Unity plugin
UX best practices for games
Migrate to Android App Bundles
Implement cloud delivery of assets
Support Google Play Games Services
Instant Play games
Instant Play games checklist
Reduce the size of your instant app or game
Add ads to your instant app or game
Provide multiple entry points
Integrate with Firebase
Add Google Analytics for Firebase to your instant app
Use Firebase Dynamic Links with instant apps
Technical requirements checklist
Google Play Instant policy
Resources
Reference
Code samples
SDK release notes
Instant App Intents
Support
Known issues
StackOverflow
Play Developer APIs
Play Install Referrer
Overview
Play Install Referrer Library
Overview
Reference ⍈
Release notes
Play Install Referrer API
Play Integrity API ⍈
Play Requirements
Play Policies ⍈
Target API Level ⍈
Support 64-bit architectures ⍈
Application Licensing
Overview
Licensing Overview
Setting Up for Licensing
Adding Server-Side Verification
Adding Client-Side Verification
Licensing Reference
APK Expansion Files
App updates
Core areas
App compatibility
About app compatibility
Compatibility framework tools
Restrictions on non-SDK interfaces
User interfaces ⍈
Audio & video ⍈
Services ⍈
Background tasks ⍈
Alarms ⍈
Permissions
About permissions
Declare app permissions
Request app permissions
Request runtime permissions
Request special permissions
Explain access to more sensitive information
App permissions best practices
Permissions used only in default handlers
Restrict interactions with other apps
Define custom permissions
App data and files
About app data and files
About storage
Save to app-specific storage
Save to shared storage
About shared storage
Media
Photo picker
Documents and other files
Datasets
Manage all files on a storage device
Save key-value data
Save data in a local database
About the local database
Define data using entities
Access data using DAOs
Define relationships between objects
Write asynchronous DAO queries
Create views into a database
Prepopulate your database
Migrate your database
Test and debug your database
Reference complex data
Migrate from SQLite to Room
Save data using SQLite
Storage use cases and best practices
Sharing data
About sharing data
Sending simple data to other apps
Receiving simple data from other apps
Provide Direct Share targets
Sharing files
About sharing files
Setting up file sharing
Sharing a file
Requesting a shared file
Retrieving file information
Printing files
About printing
Printing photos
Printing HTML documents
Printing custom documents
Content providers
About content providers
Content provider basics
Creating a content provider
Open files using storage access framework
Create a custom document provider
Create a cloud media provider
App install location
User data and identity
About user data
Add sign-in workflow
Credential Manager
Sign in your user
Integrate with Sign in with Google
Migrate from FIDO2
Migrate from Smart Lock
Migrate from legacy Google Sign-In
Integrate with WebView
Integrate with your credential provider solution
Make calls on behalf of other parties for privileged apps
Autofill framework
About autofill
Optimize your app for autofill
Build autofill services
Integrate autofill with keyboards
Show a biometric authentication dialog
Identify developer-owned apps
Get a user-resettable advertising ID
About the calendar provider
Contacts provider
About the contacts provider
Retrieving a list of contacts
Retrieving details for a contact
Modifying contacts using intents
Displaying the quick contact badge
Account transfer
Data backup
About backup
Back up user data
Back up key-value pairs
Test backup and restore
Best practices for unique identifiers
Remember and authenticate users
About authentication
Remember your user
Authenticate to OAuth2 services
Create a custom account type
Add camera capabilities to your app ⍈
User location ⍈
Sensors ⍈
Connectivity ⍈
Renderscript
About Renderscript
Advanced RenderScript
Migrate from RenderScript
Overview
Migrate scripts to OpenGL ES 3.1
Migrate scripts to Vulkan
Runtime API reference
About Runtime API
Numerical types
Object types
Conversion functions
Mathematical constants and functions
Vector math functions
Matrix functions
Quaternion functions
Atomic update functions
Time functions and types
Allocation data access functions
Object characteristics functions
Kernel invocation functions and types
Input/output functions
Debugging functions
Graphics functions and types
Index
Android app bundles
About app bundles
Configure the base module
Build and test your app bundle
Add code transparency
About the app bundle format
Frequently asked questions
SDK Extensions
Build for enterprise
About enterprise apps
Developer guide
Work profiles
Set up managed configurations
App feedback
Send app feedback to EMMs
Test app feedback
Work contacts
Device management policies
Device management
Build a device policy controller
Dedicated devices
Overview
Lock task mode
Multiple users
Cookbook
Device control
Networking and telephony
Security
System updates
Network activity logging
Android versions
About the versions
Android 14
Android 13
Android 12
Android 11
Android 10
Android 9
Android 8.0
Android 7.0
Device administration
Best practices
Testing
Test apps on Android
Fundamentals
Fundamentals of testing Android apps
What to test in Android
Using test doubles in Android
Local tests
Build local tests
Instrumented tests
Build instrumented tests
Automate UI tests
AndroidX test libraries
Set up project for AndroidX Test
JUnit4 rules with AndroidX Test
AndroidJUnitRunner
Continuous integration
Basics
Types of automation
Common features
Espresso
Espresso
Espresso basics
Espresso setup instructions
Espresso cheat sheet
Espresso idling resources
Espresso-Intents
Espresso lists
Multiprocess Espresso
Espresso recipes
Espresso Web
Accessibility checking
Additional Resources for Espresso
Testing different screen sizes
Overview
Libraries and tools
Testing other components
Test content providers
Test your service
Write automated tests with UI Automator
Performance ⍈
Accessibility ⍈
Privacy ⍈
Security ⍈
SDKs
SDK best practices
Games ⍈
Health Connect ⍈
Health Services on Wear OS ⍈
Modern Android
Explore Modern Android
Adopt Compose for teams
Get started
Hello world
Training courses
Tutorials
Kotlin for Android
Monetization with Play ↗️
Extend by device
Large screens (e.g., tablets)
Wear OS
Android for Cars
Android TV
ChromeOS
Cross-device SDK
Build by category
Games
Media apps
Health & Fitness
Enterprise apps
Get the latest
Platform releases
Android Studio preview
Jetpack & Compose libraries
Wear OS preview
Privacy Sandbox
Kits & more