<google>BUY_ANDROID_STUDIO</google>

1. Android Studio Development Essentials Introduction
   
   
2. Setting up a Windows, Linux or Mac OS X Android Studio Development Environment
   • System Requirements
   • Installing the Java Development Kit (JDK)
   • Windows JDK Installation
   • Mac OS X JDK Installation
   • Linux JDK Installation
   • Downloading the Android Studio Package
   • Installing Android Studio
   • Installation on Windows
   • Installation on Mac OS X
   • Installation on Linux
   • Installing the Latest Android SDK Packages
   • Making the Android SDK Tools Command-line Accessible
   • Windows 7
   • Windows 8.1
   • Linux
   • Mac OS X
   • Updating the Android Studio and the SDK
     
     
3. Creating an Example Android App in Android Studio
   • Creating a New Android Project
   • Defining the Project and SDK Settings
   • Understanding the Support Mode Settings
   • Configuring the Launcher Icon
   • Creating an Activity
   • Modifying the Example Application
   • Reviewing the Layout and Resource Files
   • Previewing the Layout
     
     
4. A Tour of the Android Studio User Interface
   • The Welcome Screen
   • The Main Window
   • The Tool Windows
   • Android Studio Keyboard Shortcuts
   • Switcher and Recent Files Navigation
   • Changing the Android Studio Theme
     
     
5. Creating an Android Virtual Device (AVD) in Android Studio
   • About Android Virtual Devices
   • Creating a New AVD
   • Starting the Emulator
   • Running the Application in the AVD
   • Run/Debug Configurations
   • Stopping a Running Application
   • AVD Command-line Creation
   • Android Virtual Device Configuration Files
   • Moving and Renaming an Android Virtual Device
     
     
6. Testing Android Studio Apps on a Physical Android Device
   • An Overview of the Android Debug Bridge (ADB)
   • Enabling ADB on Android 4.4 based Devices
   • Mac OS X ADB Configuration
   • Windows ADB Configuration
   • Testing the adb Connection
     
     
7. The Basics of the Android Studio Code Editor
   • The Android Studio Editor
   • Splitting the Editor Window
   • Code Completion
   • Statement Completion
   • Parameter Information
   • Code Generation
   • Code Folding
   • Quick Documentation Lookup
   • Code Reformatting
     
     
8. An Overview of the Android Architecture
   • The Android Software Stack
   • The Linux Kernel
   • Android Runtime - Dalvik Virtual Machine
   • Android Runtime – Core Libraries
   • Dalvik VM Specific Libraries
   • Java Interoperability Libraries
   • Android Libraries
   • C/C++ Libraries
   • Application Framework
   • Applications
     
     
9. The Anatomy of an Android Studio Android Application
   • Android Activities
   • Android Intents
   • Broadcast Intents
   • Broadcast Receivers
   • Android Services
   • Content Providers
   • The Application Manifest
   • Application Resources
   • Application Context
     
     
10. Understanding Android Application and Activity Lifecycles
    • Android Applications and Resource Management
    • Android Process States
    • Foreground Process
    • Visible Process
    • Service Process
    • Background Process
    • Empty Process
    • Inter-Process Dependencies
    • The Activity Lifecycle
    • The Activity Stack
    • Activity States
    • Configuration Changes
    • Handling State Change
      
      
11. Handling Android Activity State Changes in Android Studio
    • The Activity Class
    • Dynamic State vs. Persistent State
    • The Android Activity Lifecycle Methods
    • Activity Lifetimes
      
      
12. Android Activity State Changes - An Android Studio Example
    • Creating the State Change Example Project
    • Designing the User Interface
    • Overriding the Activity Lifecycle Methods
    • Filtering the LogCat Panel
    • Running the Application
    • Experimenting with the Activity
      
      
13. Saving and Restoring Activity State in Android Studio
    • Saving Dynamic State
    • Default Saving of User Interface State
    • The Bundle Class
    • Saving the State
    • Restoring the State
    • Testing the Application
      
      
14. Understanding Android Views, View Groups and Layouts in Android Studio
    • Designing for Different Android Devices
    • Views and View Groups
    • Android Layout Managers
    • The View Hierarchy
    • Creating User Interfaces
      
      
15. A Guide to the Android Studio Designer Tool
    • The Android Studio Designer
    • Design Mode
    • Text Mode
    • Setting Properties
    • Type Morphing
    • Creating a Custom Device Definition
      
      
16. Designing a User Interface using the Android Studio Designer Tool
    • An Android Studio Designer Tool Example
    • Creating a New Activity
    • Designing the User Interface
    • Editing View Properties
    • Running the Application
    • Manually Creating an XML Layout
    • Using the Hierarchy Viewer
      
      
17. Creating an Android User Interface in Java Code using Android Studio
    • Java Code vs. XML Layout Files
    • Creating Views
    • Properties and Layout Parameters
    • Creating the Example Project in Android Studio
    • Adding Views to an Activity
    • Setting View Properties
    • Adding Layout Parameters and Rules
    • Using View IDs
    • Converting Density Independent Pixels (dp) to Pixels (px)
      
      
18. Using the Android GridLayout Manager in Android Studio Designer
    • Introducing the Android GridLayout and Space Classes
    • The GridLayout Example
    • Creating the GridLayout Project
    • Creating the GridLayout Instance
    • Adding Views to GridLayout Cells
    • Moving and Deleting Rows and Columns
    • Implementing Cell Row and Column Spanning
    • Changing the Gravity of a GridLayout Child
      
      
19. Working with the Android GridLayout using XML Layout Resources
    • GridLayouts in XML Resource Files
    • Adding Child Views to the GridLayout
    • Declaring Cell Spanning, Gravity and Margins
      
      
20. An Overview and Android Studio Example of Android Event Handling
    • Understanding Android Events
    • Using the android:onClick Resource
    • Event Listeners and Callback Methods
    • An Event Handling Example
    • Designing the User Interface
    • The Event Listener and Callback Method
    • Consuming Events
      
      
21. Android Touch and Multi-touch Event Handling in Android Studio
    • Intercepting Touch Events
    • The MotionEvent Object
    • Understanding Touch Actions
    • Handling Multiple Touches
    • An Example Multi-Touch Application
    • Designing the Activity User Interface
    • Implementing the Touch Event Listener
    • Running the Example Application
      
      
22. Detecting Common Gestures using Android Studio and the Gesture Detector Class
    • Implementing Common Gesture Detection
    • Creating an Example Gesture Detection Project
    • Implementing the Listener Class
    • Creating the GestureDetectorCompat Instance
    • Implementing the onTouchEvent() Method
    • Testing the Application
      
      
23. Implementing Android Custom Gesture Recognition with Android Studio
    • The Android Gesture Builder Application
    • The GestureOverlayView Class
    • Detecting Gestures
    • Identifying Specific Gestures
    • Adding SD Card Support to an AVD
    • Building and Running the Gesture Builder Application
    • Creating a Gestures File
    • Extracting the Gestures File from the SD Card
    • Creating the Example Project
    • Adding the Gestures File to the Project
    • Designing the User Interface
    • Loading the Gestures File
    • Registering the Event Listener
    • Implementing the onGesturePerformed Method
    • Testing the Application
    • Configuring the GestureOverlayView
    • Intercepting Gestures
    • Detecting Pinch Gestures in Android
    • A Pinch Gesture Example Project
      
      
24. An Introduction to Using Fragments in Android Studio
    • What is a Fragment?
    • Creating a Fragment
    • Adding a Fragment to an Activity using the Layout XML File
    • Adding and Managing Fragments in Code
    • Handling Fragment Events
    • Implementing Fragment Communication
      
      
25. Using Fragments in Android Studio - An Example
    • About the Example Fragment Application
    • Creating the Example Project
    • Creating the First Fragment Layout
    • Creating the First Fragment Class
    • Creating the Second Fragment Layout
    • Adding the Fragments to the Activity
    • Making the Toolbar Fragment Talk to the Activity
    • Making the Activity Talk to the Text Fragment]
    • Testing the Application
      
      
26. An Android Studio Master/Detail Flow Tutorial
    • The Android Master/Detail Flow
    • Creating a Master/Detail Flow Activity
    • The Anatomy of the Master/Detail Flow Template
    • Modifying the Master/Detail Flow Template
    • Changing the Content Model
    • Changing the Detail Pane
    • Modifying the WebsiteDetailFragment Class
    • Adding Manifest Permissions
    • Running the Application
      
      
27. Creating and Managing Overflow Menus in Android Studio
    • The Overflow Menu
    • Creating an Overflow Menu
    • Displaying an Overflow Menu
    • Responding to Menu Item Selections
    • Creating Checkable Item Groups
    • Creating the Example Project
    • Modifying the Menu Description
    • Modifying the onOptionsItemSelected() Method
    • Testing the Application
      
      
28. Animating User Interfaces in Android Studio using the Transitions Framework
    • Introducing Android Transitions and Scenes
    • Using Interpolators with Transitions
    • Working with Scene Transitions
    • Custom Transitions and TransitionSets in Code
    • Custom Transitions and TransitionSets in XML
    • Working with Interpolators
    • Creating a Custom Interpolator
    • Using the beginDelayedTransition Method
      
      
29. An Android Studio Transition Tutorial using beginDelayedTransition
    • Creating the Android Studio TransitionDemo Project
    • Preparing the Project Files
    • Implementing beginDelayedTransition Animation
    • Customizing the Transition
      
      
30. Implementing Android Scene Transitions – An Android Studio Tutorial
    • An Overview of the Scene Transition Project
    • Creating the Android Studio SceneTransitions Project
    • Identifying and Preparing the Root Container
    • Designing the First Scene
    • Designing the Second Scene
    • Entering the First Scene
    • Loading Scene 2
    • Implementing the Transitions
    • Adding the Transition File
    • Loading and Using the Transition Set
    • Configuring Additional Transitions
      
      
31. An Overview of Intents in Android Studio
    • An Overview of Intents
    • Explicit Intents
    • Returning Data from an Activity
    • Implicit Intents
    • Using Intent Filters
    • Checking Intent Availability
      
      
32. Android Explicit Intents – An Android Studio Example
    • Creating the Explicit Intent Example Application
    • Designing the User Interface Layout for ActivityA
    • Creating the Second Activity Class
    • Designing the User Interface Layout for ActivityB
    • Reviewing the Application Manifest File
    • Creating the Intent
    • Extracting Intent Data
    • Launching ActivityB as a Sub-Activity
    • Returning Data from a Sub-Activity
    • Testing the Application
      
      
33. Android Implicit Intents – An Android Studio Example
    • Creating the Android Studio Implicit Intent Example Project
    • Designing the User Interface
    • Creating the Implicit Intent
    • Adding a Second Matching Activity
    • Adding the Web View to the UI
    • Obtaining the Intent URL
    • Modifying the MyWebView Project Manifest File
    • Testing the Application
      
      
34. Broadcast Intents and Broadcast Receivers in Android Studio
    • An Overview of Broadcast Intents
    • An Overview of Broadcast Receivers
    • Obtaining Results from a Broadcast
    • Sticky Broadcast Intents
    • The Broadcast Intent Example
    • Creating the Example Application
    • Creating and Sending the Broadcast Intent
    • Creating the Broadcast Receiver
    • Configuring a Broadcast Receiver in the Manifest File
    • Testing the Broadcast Example
    • Listening for System Broadcasts
      
      

<google>BUY_ANDROID_STUDIO</google>

1. Android Threads and Thread Handlers - An Android Studio Tutorial
   • An Overview of Threads
   • The Application Main Thread
   • Thread Handlers
   • A Basic Threading Example
   • Creating a New Thread
   • Implementing a Thread Handler
   • Passing a Message to the Handler
     
     
2. Understanding Android Started and Bound Services
   • Started Services
   • Intent Service
   • Bound Service
   • The Anatomy of a Service
   • Controlling Destroyed Service Restart Options
   • Declaring a Service in the Manifest File
   • Starting a Service Running on System Startup
     
     
3. Implementing an Android Started Service in Android Studio
   • Creating the Example Project
   • Creating the Service Class
   • Adding the Service to the Manifest File
   • Starting the Service
   • Testing the IntentService Example
   • Using the Service Class
   • Creating the New Service
   • Modifying the User Interface
   • Running the Application
   • Creating a New Thread for Service Tasks
     
     
4. Implementing Local Bound Services in Android Studio
   • Understanding Bound Services
   • Bound Service Interaction Options
   • An Android Studio Local Bound Service Example
   • Adding a Bound Service to the Project
   • Implementing the Binder
   • Binding the Client to the Service
   • Completing the Example
   • Testing the Application
     
     
5. Android Remote Bound Services – An Android Studio Tutorial
   • Client to Remote Service Communication
   • Creating the Example Application
   • Designing the User Interface
   • Implementing the Remote Bound Service
   • Configuring a Remote Service in the Manifest File
   • Launching and Binding to the Remote Service
   • Sending a Message to the Remote Service
     
     
6. An Overview of Android SQLite Databases in Android Studio
   • Understanding Database Tables
   • Introducing Database Schema
   • Columns and Data Types
   • Database Rows
   • Introducing Primary Keys
   • What is SQLite?
   • Structured Query Language (SQL)
   • Trying SQLite on an Android Virtual Device (AVD)
   • Android SQLite Java Classes
   • Cursor
   • SQLiteDatabase
   • SQLiteOpenHelper
   • ContentValues
     
     
7. An Android Studio TableLayout and TableRow Tutorial
   • The TableLayout and TableRow Layout Views
   • Creating the Database Project
   • Adding the TableLayout to the User Interface
   • Adding and Configuring the TableRows
   • Adding the Button Bar to the Layout
   • Adjusting the Layout Margins
     
     
8. An Android Studio SQLite Database Tutorial
   • About the Android Studio Database Example
   • Creating the Data Model
   • Implementing the Data Handler
   • The Add Handler Method
   • The Query Handler Method
   • The Delete Handler Method
   • Implementing the Activity Event Methods
   • Testing the Application
     
     
9. Understanding Android Content Providers in Android Studio
   • What is a Content Provider?
   • The Content Provider
   • onCreate()
   • query()
   • insert()
   • update()
   • delete()
   • getType()
   • The Content URI
   • The Content Resolver
   • The <provider> Manifest Element
     
     
10. An Android Studio Content Provider Example
    • Copying the Database Project
    • Adding the Content Provider Package
    • Creating the Content Provider Class
    • Constructing the Authority and Content URI
    • Implementing URI Matching in the Content Provider
    • Implementing the Content Provider onCreate() Method
    • Implementing the Content Provider insert() Method
    • Implementing the Content Provider query() Method
    • Implementing the Content Provider update() Method
    • Implementing the Content Provider delete() Method
    • Declaring the Content Provider in the Manifest File
    • Modifying the Database Handler
      
      
11. Accessing Cloud Storage using the Storage Access Framework in Android Studio
    • The Storage Access Framework
    • Working with the Storage Access Framework
    • Filtering Picker File Listings
    • Handling Intent Results
    • Reading the Content of a File
    • Writing Content to a File
    • Deleting a File
    • Gaining Persistent Access to a File
      
      
12. An Android Studio Storage Access Framework Example
    • About the Storage Access Framework Example
    • Creating the Storage Access Framework Example
    • Designing the User Interface
    • Declaring Request Codes
    • Creating a New Storage File
    • The onActivityResult() Method
    • Saving to a Storage File
    • Opening and Reading a Storage File
    • Testing the Storage Access Application
      
      
13. An Android Studio VideoView and MediaController Tutorial
    • Introducing the Android VideoView Class
    • Introducing the Android MediaController Class
    • Testing Video Playback
    • Creating the Video Playback Example
    • Designing the VideoPlayer Layout
    • Configuring the VideoView
    • Adding Internet Permission
    • Adding the MediaController to the Video View
    • Setting up the onPreparedListener
      
      
14. Video Recording and Image Capture using Camera Intents - An Android Studio Example
    • Checking for Camera Support
    • Calling the Video Capture Intent
    • Calling the Image Capture Intent
    • Creating an Android Studio Video Recording Project
    • Designing the User Interface Layout
    • Checking for the Camera
    • Launching the Video Capture Intent
    • Handling the Intent Return
    • Testing the Application
      
      
15. An Android Studio Recording and Playback Example using MediaPlayer and MediaRecorder
    • Playing Audio
    • Recording Audio and Video using the MediaRecorder Class
    • About the Example Project
    • Creating the AudioApp Project
    • Designing the User Interface
    • Checking for Microphone Availability
    • Performing the Activity Initialization
    • Implementing the recordAudio() Method
    • Implementing the stopAudio() Method
    • Implementing the playAudio() method
    • Configuring Permissions in the Manifest File
    • Testing the Application
      
      
16. Working with the Google Maps Android API in Android Studio
    • The Elements of the Google Maps Android API
    • Getting Ready to use the Google Maps Android API
    • Installing the Google APIs
    • Downloading the Google Play Services SDK
    • Adding the Google Play Services Library to the Gradle Build Configuration
    • Obtaining Your Developer Signature
    • Registering the Project in the Google APIs Console
    • Adding Map Support to the AndroidManifest.xml File
    • Checking for Google Play Services Support
    • Understanding Geocoding and Reverse Geocoding
    • Adding a Map to an Application
    • Displaying the User’s Current Location
    • Changing the Map Type
    • Displaying Map Controls to the User
    • Handling Map Gesture Interaction
    • Map Zooming Gestures
    • Map Scrolling/Panning Gestures
    • Map Tilt Gestures
    • Map Rotation Gestures
    • Creating Map Markers
    • Controlling the Map Camera
      
      
17. Printing with the Android Printing Framework in Android Studio
    • The Android Printing Architecture
    • The HP Print Services Plugin
    • Google Cloud Print
    • Printing to Google Drive
    • Save as PDF
    • Printing from Android Devices
    • Options for Building Print Support into Android Apps
    • Image Printing
    • Creating and Printing HTML Content
    • Printing a Web Page
    • Printing a Custom Document
      
      
18. An Android Studio HTML and Web Content Printing Example
    • Creating the HTML Printing Example Application
    • Printing Dynamic HTML Content
    • Creating the Web Page Printing Example
    • Designing the User Interface Layout
    • Adding the Print Menu Option
      
      
19. An Android Studio Custom Document Printing Example
    • An Overview of Android Custom Document Printing
    • Custom Print Adapters
    • Preparing the Custom Document Printing Project
    • Creating the Custom Print Adapter
    • Implementing the onLayout() Callback Method
    • Implementing the onWrite() Callback Method
    • Checking a Page is in Range
    • Drawing the Content on the Page Canvas
    • Starting the Print Job
    • Testing the Application
      
      
20. Generating a Signed Release APK File in Android Studio
    • The Release Preparation Process
    • Changing the Build Variant
    • Creating a Keystore File
    • Generating a Private Key
    • Creating the Application APK File
    • Register for a Google Play Developer Console Account
    • Uploading New APK Versions to the Google Play Developer Console
      
      
21. An Android Studio Google Play In-app Billing Tutorial
    • Installing the Google Play Billing Library
    • Creating the Example In-app Billing Project
    • Adding Billing Permission to the Manifest File
    • Adding the IInAppBillingService.aidl File to the Project
    • Adding the Utility Classes to the Project
    • Designing the User Interface
    • Implementing the “Click Me” Button
    • Google Play Developer Console and Google Wallet Accounts
    • Obtaining the Public License Key for the Application
    • Setting Up Google Play Billing in the Application
    • Initiating a Google Play In-app Billing Purchase
    • Implementing the onActivityResult Method
    • Implementing the Purchase Finished Listener
    • Consuming the Purchased Item
    • Releasing the IabHelper Instance
    • Modifying the Security.java File
    • Testing the In-app Billing Application
    • Building a Release APK
    • Creating a New In-app Product
    • Publishing the Application to the Alpha Distribution Channel
    • Adding In-app Billing Test Accounts
    • Configuring Group Testing
    • Resolving Problems with In-App Purchasing[
      
      
22. An Overview of Gradle in Android Studio
    • An Overview of Gradle
    • Gradle and Android Studio
    • Sensible Defaults
    • Dependencies
    • Build Variants
    • Manifest Entries
    • APK Signing
    • ProGuard Support
    • The Top-level Gradle Build File
    • Module Level Gradle Build Files
    • Configuring Signing Settings in the Build File
    • Running Gradle Tasks from the Command-line
      
      
23. An Android Studio Gradle Build Variants Example
    • Creating the Build Variant Example Project
    • Adding the Build Flavors to the Module Build File
    • Adding the Flavors to the Project Structure
    • Adding Resource Files to the Flavors
    • Testing the Build Flavors
    • Build Variants and Class Files
    • Adding Packages to the Build Flavors
    • Customizing the Activity Classes
      
      

<google>BUY_ANDROID_STUDIO</google>