android developers training 文档学习笔记（目录）

Android Developers Training

Getting Started

Building Your First App

Creating an Android Project

Running Your App

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 an 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

Printing Photos

Printing HTML Documents

Printing 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 Slides

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 your Download Patterns Based on the Connectivity Type

---

Syncing to the Cloud

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

Receiving Location Updates

Displaying a Location Address

Creating and Monitoring Geofences

---

Adding Maps

---

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

---

Adding Sign-In

---

Building Apps for Wearables

Adding Wearable Features to Notifications

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 for Wear Devices

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

Providing Configuration Activities

Addressing Common Issues

Optimizing Performance and Battery Life

---

Detecting Location on Android Wear

---

Building Apps for TV

Building TV Apps

Get Started with TV Apps

Handling TV Hardware

Building Layouts for TV

Creating TV Navigation

---

Building TV Playback Apps

Creating a Catalog Browser

Providing a Card View

Building a Details View

Displaying a Now Playing Card

---

Helping Users Find Your 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

Providing Audio Playback for Auto

Providing Messaging for Auto

---

Building Apps for Work

Ensuring Compatibility with Managed Profiles

Implementing App Restrictions

Building a Work Policy Controller

---

Best Practices for Interaction and 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 Request

---

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 Densities

Implementing Adaptative UI Flows

---

Creating Custom Views

Creating a View Class

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 an Accessibility Service

---

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

---

Material Design for Developers

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

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 Testing

Testing Your Android Activity

Setting Up Your Test Environment

Creating and Running a Test Case

Testing UI Components

Creating Unit Tests

Creating Functional Tests

---

Automating User Interface Tests

Testing UI for a Single App

Testing UI for Multiple Apps

---

Building Effective Unit Tests

Building Local Unit Tests

Building Instrumented Unit Tests

---

Using Google Play to Distribute & Monetize

Selling In-app Products

Preparing Your In-app Billing Application

Establishing In-app Billing Products for Sale

Purchasing In-app Billing Products

Testing Your In-app Billing Application

---

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