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

16lz 2021-01-23

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

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

Sending Simple Data to Other Apps

Receiving Simple Data from Other Apps

Requesting a Shared File

Retrieving File Information

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

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

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

Planning Screens and Their Relationships

Planning for Multiple Touchscreen Sizes

Putting it All Together: Wireframing the Example App

Creating Swipe Views with Tabs

Notifying the User

Building a Notification

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

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

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

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

更多相关文章

随机推荐