Quicknav
Quicknav
Design
Develop
Distribute
Links
Google Play Developer Console
Android Developers Blog
About Android
Android Sites
Android.com
Android Developers
Android Open Source Project
close
About
Wear
TV
Auto
Get Started
Devices
Style
Patterns
Building Blocks
Downloads
Videos
Training
API Guides
Reference
Tools
Google Services
Google Play
Essentials
Get Users
Engage & Retain
Monetize
Tools & Reference
Developer Stories
Training
API Guides
Reference
Tools
Google Services
Results
Loading...
Building Apps for TV
Getting Started
Building Your First App
Creating an Android Project
Running Your Application
Building a Simple User Interface
Starting Another Activity
Adding the Action Bar
Setting Up the Action Bar
Adding Action Buttons
Styling the Action Bar
Overlaying the Action Bar
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
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
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
Syncing to the Cloud
Using the Backup API
Making the Most of Google Cloud Messaging
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
User Info & Location
Accessing Contacts Data
Retrieving a List of Contacts
Retrieving Details for a Contact
Modifying Contacts Using Intents
Displaying the Quick Contact Badge
Making Your App Location-Aware
Retrieving the Current Location
Receiving Location Updates
Displaying a Location Address
Creating and Monitoring Geofences
Recognizing the User's Current Activity
Testing Using Mock Locations
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
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
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
Building a Details View
Helping Users Find Content on TV
Recommending TV Content
Searching within TV Apps
Building TV Games
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
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
Best Practices for
User Interface
Designing for Multiple Screens
Supporting Different Screen Sizes
Supporting Different Screen Densities
Implementing Adaptive UI Flows
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
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
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
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
Developing for Enterprise
Enhancing Security with Device Management Policies
Best Practices for
Testing
Testing Your Activity
Setting Up Your Test Environment
Creating and Running a Test Case
Testing UI Components
Creating Unit Tests
Creating Functional Tests
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
Monetizing Your App
Advertising without Compromising User Experience
Building Apps for TV
These classes teach you how to build apps for TV devices.
