Developers
Design
Develop
Distribute
Developer
Console
Back
Getting Started
Building Your First App
Creating an Android Project
Running Your Application
Building a Simple User Interface
Starting Another Activity
Supporting Different Devices
Supporting Different Languages
Supporting Different Screens
Supporting Different Platform Versions
Managing the Activity Lifecycle
Starting an Activity
Pausing and Resuming an Activity
Stopping and Restarting an Activity
Recreating an Activity
Building a Dynamic UI with Fragments
Creating a Fragment
Building a Flexible UI
Communicating with Other Fragments
Saving Data
Saving Key-Value Sets
Saving Files
Saving Data in SQL Databases
Interacting with Other Apps
Sending the User to Another App
Getting a Result from the Activity
Allowing Other Apps to Start Your Activity
Working with System Permissions
Declaring Permissions
Requesting Permissions at Run Time
Best Practices for Runtime Permissions
Building Apps with
Content Sharing
Sharing Simple Data
Sending Simple Data to Other Apps
Receiving Simple Data from Other Apps
Adding an Easy Share Action
Sharing Files
Setting Up File Sharing
Sharing a File
Requesting a Shared File
Retrieving File Information
Sharing Files with NFC
Sending Files to Another Device
Receiving Files from Another Device
Building Apps with
Multimedia
Managing Audio Playback
Controlling Your App's Volume and Playback
Managing Audio Focus
Dealing with Audio Output Hardware
Capturing Photos
Taking Photos Simply
Recording Videos Simply
Controlling the Camera
Printing Content
Photos
HTML Documents
Custom Documents
Building Apps with
Graphics & Animation
Displaying Bitmaps Efficiently
Loading Large Bitmaps Efficiently
Processing Bitmaps Off the UI Thread
Caching Bitmaps
Managing Bitmap Memory
Displaying Bitmaps in Your UI
Displaying Graphics with OpenGL ES
Building an OpenGL ES Environment
Defining Shapes
Drawing Shapes
Applying Projection and Camera Views
Adding Motion
Responding to Touch Events
Animating Views Using Scenes and Transitions
The Transitions Framework
Creating a Scene
Applying a Transition
Creating Custom Transitions
Adding Animations
Crossfading Two Views
Using ViewPager for Screen Slide
Displaying Card Flip Animations
Zooming a View
Animating Layout Changes
Building Apps with
Connectivity & the Cloud
Connecting Devices Wirelessly
Using Network Service Discovery
Creating P2P Connections with Wi-Fi
Using Wi-Fi P2P for Service Discovery
Performing Network Operations
Connecting to the Network
Managing Network Usage
Parsing XML Data
Transferring Data Without Draining the Battery
Optimizing Downloads for Efficient Network Access
Minimizing the Effect of Regular Updates
Redundant Downloads are Redundant
Modifying Patterns Based on the Connectivity Type
Backing up App Data to the Cloud
Configuring Auto Backup
Using the Backup API
Resolving Cloud Save Conflicts
Transferring Data Using Sync Adapters
Creating a Stub Authenticator
Creating a Stub Content Provider
Creating a Sync Adapter
Running a Sync Adapter
Transmitting Network Data Using Volley
Sending a Simple Request
Setting Up a RequestQueue
Making a Standard Request
Implementing a Custom Request
Building Apps with
Location & Maps
Making Your App Location-Aware
Getting the Last Known Location
Changing Location Settings
Receiving Location Updates
Displaying a Location Address
Creating and Monitoring Geofences
Adding Maps
Building Apps with
User Info & Sign-In
Accessing Contacts Data
Retrieving a List of Contacts
Retrieving Details for a Contact
Modifying Contacts Using Intents
Displaying the Quick Contact Badge
Adding Sign-In
Building Apps for
Wearables
Adding Wearable Features to Notifications
Creating a Notification
Receiving Voice Input in a Notification
Adding Pages to a Notification
Stacking Notifications
Creating Wearable Apps
Creating and Running a Wearable App
Creating Custom Layouts
Keeping Your App Visible
Adding Voice Capabilities
Packaging Wearable Apps
Debugging over Bluetooth
Creating Custom UIs
Defining Layouts
Creating Cards
Creating Lists
Creating a 2D Picker
Showing Confirmations
Exiting Full-Screen Activities
Sending and Syncing Data
Accessing the Wearable Data Layer
Syncing Data Items
Transferring Assets
Sending and Receiving Messages
Handling Data Layer Events
Creating Watch Faces
Designing Watch Faces
Building a Watch Face Service
Drawing Watch Faces
Showing Information in Watch Faces
Creating Interactive Watch Faces
Providing Configuration Activities
Addressing Common Issues
Optimizing Performance and Battery Life
Detecting Location
Requesting Permissions
Using the Speaker
Building Apps for
TV
Building TV Apps
Getting Started with TV Apps
Handling TV Hardware
Building TV Layouts
Creating TV Navigation
Building TV Playback Apps
Creating a Catalog Browser
Providing a Card View
Building a Details View
Displaying a Now Playing Card
Adding a Guided Step
Enabling Background Playback
Helping Users Find Content on TV
Recommending TV Content
Making TV Apps Searchable
Searching within TV Apps
Building TV Games
Building TV Channels
Developing a TV Input Service
Working with Channel Data
Managing User Interaction
TV Apps Checklist
Building Apps for
Auto
Getting Started with Auto
Playing Audio for Auto
Messaging for Auto
Testing Auto Apps
Best Practices for
Interaction & Engagement
Designing Effective Navigation
Planning Screens and Their Relationships
Planning for Multiple Touchscreen Sizes
Providing Descendant and Lateral Navigation
Providing Ancestral and Temporal Navigation
Putting it All Together: Wireframing the Example App
Implementing Effective Navigation
Creating Swipe Views with Tabs
Creating a Navigation Drawer
Providing Up Navigation
Providing Proper Back Navigation
Implementing Descendant Navigation
Notifying the User
Building a Notification
Preserving Navigation when Starting an Activity
Updating Notifications
Using Big View Styles
Displaying Progress in a Notification
Supporting Swipe-to-Refresh
Adding Swipe-to-Refresh To Your App
Responding to a Refresh Gesture
Adding Search Functionality
Setting up the Search Interface
Storing and Searching for Data
Remaining Backward Compatible
Making Your App Content Searchable by Google
Enabling Deep Links for App Content
Specifying App Content for Indexing
Optimizing Content for the Assistant
Handling App Links
Best Practices for
User Interface
Designing for Multiple Screens
Supporting Different Screen Sizes
Supporting Different Screen Densities
Implementing Adaptive UI Flows
Adding the App Bar
Setting Up the App Bar
Adding and Handling Actions
Adding an Up Action
Action Views and Action Providers
Showing Pop-Up Messages
Building and Displaying a Pop-Up Message
Adding an Action to a Message
Creating Custom Views
Creating a Custom View Class
Implementing Custom Drawing
Making the View Interactive
Optimizing the View
Creating Backward-Compatible UIs
Abstracting the New APIs
Proxying to the New APIs
Creating an Implementation with Older APIs
Using the Version-Aware Component
Implementing Accessibility
Developing Accessible Applications
Developing Accessibility Services
Accessibility Testing Checklist
Managing the System UI
Dimming the System Bars
Hiding the Status Bar
Hiding the Navigation Bar
Using Immersive Full-Screen Mode
Responding to UI Visibility Changes
Creating Apps with Material Design
Getting Started
Using the Material Theme
Creating Lists and Cards
Defining Shadows and Clipping Views
Working with Drawables
Defining Custom Animations
Maintaining Compatibility
Best Practices for
User Input
Using Touch Gestures
Detecting Common Gestures
Tracking Movement
Animating a Scroll Gesture
Handling Multi-Touch Gestures
Dragging and Scaling
Managing Touch Events in a ViewGroup
Handling Keyboard Input
Specifying the Input Method Type
Handling Input Method Visibility
Supporting Keyboard Navigation
Handling Keyboard Actions
Supporting Game Controllers
Handling Controller Actions
Supporting Controllers Across Android Versions
Supporting Multiple Game Controllers
Best Practices for
Background Jobs
Running in a Background Service
Creating a Background Service
Sending Work Requests to the Background Service
Reporting Work Status
Loading Data in the Background
Running a Query with a CursorLoader
Handling the Results
Managing Device Awake State
Keeping the Device Awake
Scheduling Repeating Alarms
Best Practices for
Performance
Managing Your App's Memory
Performance Tips
Improving Layout Performance
Optimizing Layout Hierarchies
Re-using Layouts with <include/>
Loading Views On Demand
Making ListView Scrolling Smooth
Optimizing Battery Life
Reducing Network Battery Drain
Collecting Network Traffic Data
Analyzing Network Traffic Data
Optimizing User-Initiated Network Use
Optimizing App-Initiated Network Use
Optimizing Server-Initiated Network Use
Optimizing General Network Use
Optimizing for Doze and App Standby
Monitoring the Battery Level and Charging State
Determining and Monitoring the Docking State and Type
Determining and Monitoring the Connectivity Status
Manipulating Broadcast Receivers On Demand
Sending Operations to Multiple Threads
Specifying the Code to Run on a Thread
Creating a Manager for Multiple Threads
Running Code on a Thread Pool Thread
Communicating with the UI Thread
Keeping Your App Responsive
JNI Tips
SMP Primer for Android
Best Practices for
Security & Privacy
Security Tips
Security with HTTPS and SSL
Updating Your Security Provider to Protect Against SSL Exploits
Checking Device Compatibility with SafetyNet
Enhancing Security with Device Management Policies
Best Practices for
Permissions & Identifiers
Permissions and User Data
Best Practices for App Permissions
Best Practices for Unique Identifiers
Best Practices for
Testing
Getting Started with Testing
Building Effective Unit Tests
Building Local Unit Tests
Building Instrumented Unit Tests
Automating UI Tests
Testing UI for a Single App
Testing UI for Multiple Apps
Testing App Component Integrations
Testing Your Service
Testing Your Content Provider
Testing Display Performance
Using Google Play to
Distribute & Monetize
Selling In-app Products
Preparing Your App
Establishing Products for Sale
Purchasing Products
Testing Your App
Maintaining Multiple APKs
Creating Multiple APKs for Different API Levels
Creating Multiple APKs for Different Screen Sizes
Creating Multiple APKs for Different GL Textures
Creating Multiple APKs with 2+ Dimensions
Home
Android
Wear
TV
Auto
Design
Develop
Training
API Guides
Reference
Tools
Google Services
Distribute
Google Play
Essentials
Get Users
Engage & Retain
Earn
Analyze
Stories
Preview
Roblox Blunt «2026 Edition»
Otherwise, I must decline to generate the requested content.
Developers