1. Introduction

• 1.1 Downloading the Code Samples
• 1.2 Feedback
• 1.3 Errata

2. Setting up an Android Studio Development Environment FREE CHAPTER

• 2.1 System Requirements
• 2.2 Downloading the Android Studio Package
• 2.3 Installing Android Studio
• 2.4 The Android Studio Setup Wizard
• 2.5 Installing Additional Android SDK Packages
• 2.6 Making the Android SDK Tools Command-line Accessible
• 2.7 Android Studio Memory Management
• 2.8 Updating Android Studio and the SDK
• 2.9 Summary

3. Creating an Example Android App in Android Studio

• 3.1 About the Project
• 3.2 Creating a New Android Project
• 3.3 Creating an Activity
• 3.4 Defining the Project and SDK Settings
• 3.5 Modifying the Example Application
• 3.6 Modifying the User Interface
• 3.7 Reviewing the Layout and Resource Files
• 3.8 Adding Interaction
• 3.9 Summary

4. Creating an Android Virtual Device (AVD) in Android Studio

• 4.1 About Android Virtual Devices
• 4.2 Creating a New AVD
• 4.3 Starting the Emulator
• 4.4 Running the Application in the AVD
• 4.5 Stopping a Running Application
• 4.6 Supporting Dark Theme
• 4.7 AVD Command-line Creation
• 4.8 Android Virtual Device Configuration Files
• 4.9 Moving and Renaming an Android Virtual Device
• 4.10 Summary

5. Using and Configuring the Android Studio AVD Emulator

• 5.1 The Emulator Environment
• 5.2 The Emulator Toolbar Options
• 5.3 Working in Zoom Mode
• 5.4 Resizing the Emulator Window
• 5.5 Extended Control Options
• 5.6 Working with Snapshots
• 5.7 Configuring Fingerprint Emulation
• 5.8 Summary

6. A Tour of the Android Studio User Interface

• 6.1 The Welcome Screen
• 6.2 The Main Window
• 6.3 The Tool Windows
• 6.4 Android Studio Keyboard Shortcuts
• 6.5 Switcher and Recent Files Navigation
• 6.6 Changing the Android Studio Theme
• 6.7 Summary

7. Testing Android Studio Apps on a Physical Android Device

• 7.1 An Overview of the Android Debug Bridge (ADB)
• 7.2 Enabling ADB on Android based Devices
• 7.3 Testing the adb Connection
• 7.4 Summary

8. The Basics of the Android Studio Code Editor

• 8.1 The Android Studio Editor
• 8.2 Splitting the Editor Window
• 8.3 Code Completion
• 8.4 Statement Completion
• 8.5 Parameter Information
• 8.6 Parameter Name Hints
• 8.7 Code Generation
• 8.8 Code Folding
• 8.9 Quick Documentation Lookup
• 8.10 Code Reformatting
• 8.11 Finding Sample Code
• 8.12 Live Templates
• 8.13 Summary

9. An Overview of the Android Architecture

• 9.1 The Android Software Stack
• 9.2 The Linux Kernel
• 9.3 Android Runtime – ART
• 9.4 Android Libraries
• 9.5 Application Framework
• 9.6 Applications
• 9.7 Summary

10. The Anatomy of an Android Application

• 10.1 Android Activities
• 10.2 Android Fragments
• 10.3 Android Intents
• 10.4 Broadcast Intents
• 10.5 Broadcast Receivers
• 10.6 Android Services
• 10.7 Content Providers
• 10.8 The Application Manifest
• 10.9 Application Resources
• 10.10 Application Context
• 10.11 Summary

11. An Introduction to Kotlin

• 11.1 What is Kotlin?
• 11.2 Kotlin and Java
• 11.3 Converting from Java to Kotlin
• 11.4 Kotlin and Android Studio
• 11.5 Experimenting with Kotlin
• 11.6 Semi-colons in Kotlin
• 11.7 Summary

12. Kotlin Data Types,Variables and Nullability

• 12.1 Kotlin Data Types
• 12.2 Mutable Variables
• 12.3 Immutable Variables
• 12.4 Declaring Mutable and Immutable Variables
• 12.5 Data Types are Objects
• 12.6 Type Annotations and Type Inference
• 12.7 Nullable Type
• 12.8 The Safe Call Operator
• 12.9 Not-Null Assertion
• 12.10 Nullable Types and the let Function
• 12.11 Late Initialization (lateinit)
• 12.12 The Elvis Operator
• 12.13 Type Casting and Type Checking
• 12.14 Summary

13. Kotlin Operators and Expressions

• 13.1 Expression Syntax in Kotlin
• 13.2 The Basic Assignment Operator
• 13.3 Kotlin Arithmetic Operators
• 13.4 Augmented Assignment Operators
• 13.5 Increment and Decrement Operators
• 13.6 Equality Operators
• 13.7 Boolean Logical Operators
• 13.8 Range Operator
• 13.9 Bitwise Operators
• 13.10 Summary

14. Kotlin Flow Control

• 14.1 Looping Flow Control
• 14.2 Conditional Flow Control
• 14.3 Summary

15. An Overview of Kotlin Functions and Lambdas

• 15.1 What is a Function?
• 15.2 How to Declare a Kotlin Function
• 15.3 Calling a Kotlin Function
• 15.4 Single Expression Functions
• 15.5 Local Functions
• 15.6 Handling Return Values
• 15.7 Declaring Default Function Parameters
• 15.8 Variable Number of Function Parameters
• 15.9 Lambda Expressions
• 15.10 Higher-order Functions
• 15.11 Summary

16. The Basics of Object Oriented Programming in Kotlin

• 16.1 What is an Object?
• 16.2 What is a Class?
• 16.3 Declaring a Kotlin Class
• 16.4 Adding Properties to a Class
• 16.5 Defining Methods
• 16.6 Declaring and Initializing a Class Instance
• 16.7 Primary and Secondary Constructors
• 16.8 Initializer Blocks
• 16.9 Calling Methods and Accessing Properties
• 16.10 Custom Accessors
• 16.11 Nested and Inner Classes
• 16.12 Companion Objects
• 16.13 Summary

17. An Introduction to Kotlin Inheritance and Subclassing

• 17.1 Inheritance, Classes and Subclasses
• 17.2 Subclassing Syntax
• 17.3 A Kotlin Inheritance Example
• 17.4 Extending the Functionality of a Subclass
• 17.5 Overriding Inherited Methods
• 17.6 Adding a Custom Secondary Constructor
• 17.7 Using the SavingsAccount Class
• 17.8 Summary

18. An Overview of Android View Binding

• 18.1 Find View by ID and Synthetic Properties
• 18.2 View Bindings
• 18.3 Converting the AndroidSample Project
• 18.4 Enabling View Binding
• 18.5 Using View Bindings
• 18.6 Choosing an Option
• 18.7 Summary

19. Understanding Android Application and Activity Lifecycles

• 19.1 Android Applications and Resource Management
• 19.2 Android Process States
• 19.3 Inter-Process Dependencies
• 19.4 The Activity Lifecycle
• 19.5 The Activity Stack
• 19.6 Activity States
• 19.7 Configuration Changes
• 19.8 Handling State Change
• 19.9 Summary

20. Handling Android Activity State Changes

• 20.1 New vs. Old Lifecycle Techniques
• 20.2 The Activity and Fragment Classes
• 20.3 Dynamic State vs. Persistent State
• 20.4 The Android Lifecycle Methods
• 20.5 Lifetimes
• 20.6 Foldable Devices and Multi-Resume
• 20.7 Disabling Configuration Change Restarts
• 20.8 Lifecycle Method Limitations
• 20.9 Summary

21. Android Activity State Changes by Example

• 21.1 Creating the State Change Example Project
• 21.2 Designing the User Interface
• 21.3 Overriding the Activity Lifecycle Methods
• 21.4 Filtering the Logcat Panel
• 21.5 Running the Application
• 21.6 Experimenting with the Activity
• 21.7 Summary

22. Saving and Restoring the State of an Android Activity

• 22.1 Saving Dynamic State
• 22.2 Default Saving of User Interface State
• 22.3 The Bundle Class
• 22.4 Saving the State
• 22.5 Restoring the State
• 22.6 Testing the Application
• 22.7 Summary

23. Understanding Android Views, View Groups and Layouts

• 23.1 Designing for Different Android Devices
• 23.2 Views and View Groups
• 23.3 Android Layout Managers
• 23.4 The View Hierarchy
• 23.5 Creating User Interfaces
• 23.6 Summary

24. A Guide to the Android Studio Layout Editor Tool

• 24.1 Basic vs. Empty Activity Templates
• 24.2 The Android Studio Layout Editor
• 24.3 Design Mode
• 24.4 The Palette
• 24.5 Design Mode and Layout Views
• 24.6 Code Mode
• 24.7 Split Mode
• 24.8 Setting Attributes
• 24.9 Converting Views
• 24.10 Displaying Sample Data
• 24.11 Creating a Custom Device Definition
• 24.12 Changing the Current Device
• 24.13 Layout Validation (Multi Preview)
• 24.14 Summary

25. A Guide to the Android ConstraintLayout

• 25.1 How ConstraintLayout Works
• 25.2 Baseline Alignment
• 25.3 Working with Guidelines
• 25.4 Configuring Widget Dimensions
• 25.5 Working with Barriers
• 25.6 Ratios
• 25.7 ConstraintLayout Advantages
• 25.8 ConstraintLayout Availability
• 25.9 Summary

26. A Guide to using ConstraintLayout in Android Studio

• 26.1 Design and Layout Views
• 26.2 Autoconnect Mode
• 26.3 Inference Mode
• 26.4 Manipulating Constraints Manually
• 26.5 Adding Constraints in the Inspector
• 26.6 Viewing Constraints in the Attributes Window
• 26.7 Deleting Constraints
• 26.8 Adjusting Constraint Bias
• 26.9 Understanding ConstraintLayout Margins
• 26.10 The Importance of Opposing Constraints and Bias
• 26.11 Configuring Widget Dimensions
• 26.12 Adding Guidelines
• 26.13 Adding Barriers
• 26.14 Widget Group Alignment and Distribution
• 26.15 Converting other Layouts to ConstraintLayout
• 26.16 Summary

27. Working with ConstraintLayout Chains and Ratios in Android Studio

• 27.1 Creating a Chain
• 27.2 Changing the Chain Style
• 27.3 Spread Inside Chain Style
• 27.4 Packed Chain Style
• 27.5 Packed Chain Style with Bias
• 27.6 Weighted Chain
• 27.7 Working with Ratios
• 27.8 Summary

28. An Android Studio Layout Editor ConstraintLayout Tutorial

• 28.1 An Android Studio Layout Editor Tool Example
• 28.2 Creating a New Activity
• 28.3 Preparing the Layout Editor Environment
• 28.4 Adding the Widgets to the User Interface
• 28.5 Adding the Constraints
• 28.6 Testing the Layout
• 28.7 Using the Layout Inspector
• 28.8 Summary

29. Manual XML Layout Design in Android Studio

• 29.1 Manually Creating an XML Layout
• 29.2 Manual XML vs. Visual Layout Design
• 29.3 Summary

30. Managing Constraints using Constraint Sets

• 30.1 Kotlin Code vs. XML Layout Files
• 30.2 Creating Views
• 30.3 View Attributes
• 30.4 Constraint Sets
• 30.5 Summary

31. An Android ConstraintSet Tutorial

• 31.1 Creating the Example Project in Android Studio
• 31.2 Adding Views to an Activity
• 31.3 Setting View Attributes
• 31.4 Creating View IDs
• 31.5 Configuring the Constraint Set
• 31.6 Adding the EditText View
• 31.7 Converting Density Independent Pixels (dp) to Pixels (px)
• 31.8 Summary

32. A Guide to using Apply Changes in Android Studio

• 32.1 Introducing Apply Changes
• 32.2 Understanding Apply Changes Options
• 32.3 Using Apply Changes
• 32.4 Configuring Apply Changes Fallback Settings
• 32.5 An Apply Changes Tutorial
• 32.6 Using Apply Code Changes
• 32.7 Using Apply Changes and Restart Activity
• 32.8 Using Run App
• 32.9 Summary

33. An Overview and Example of Android Event Handling

• 33.1 Understanding Android Events
• 33.2 Using the android:onClick Resource
• 33.3 Event Listeners and Callback Methods
• 33.4 An Event Handling Example
• 33.5 Designing the User Interface
• 33.6 The Event Listener and Callback Method
• 33.7 Consuming Events
• 33.8 Summary

34. Android Touch and Multi-touch Event Handling

• 34.1 Intercepting Touch Events
• 34.2 The MotionEvent Object
• 34.3 Understanding Touch Actions
• 34.4 Handling Multiple Touches
• 34.5 An Example Multi-Touch Application
• 34.6 Designing the Activity User Interface
• 34.7 Implementing the Touch Event Listener
• 34.8 Running the Example Application
• 34.9 Summary

35. Detecting Common Gestures using the Android Gesture Detector Class

• 35.1 Implementing Common Gesture Detection
• 35.2 Creating an Example Gesture Detection Project
• 35.3 Implementing the Listener Class
• 35.4 Creating the GestureDetectorCompat Instance
• 35.5 Implementing the onTouchEvent() Method
• 35.6 Testing the Application
• 35.7 Summary

36. Implementing Custom Gesture and Pinch Recognition on Android

• 36.1 The Android Gesture Builder Application
• 36.2 The GestureOverlayView Class
• 36.3 Detecting Gestures
• 36.4 Identifying Specific Gestures
• 36.5 Installing and Running the Gesture Builder Application
• 36.6 Creating a Gestures File
• 36.7 Creating the Example Project
• 36.8 Extracting the Gestures File from the SD Card
• 36.9 Adding the Gestures File to the Project
• 36.10 Designing the User Interface
• 36.11 Loading the Gestures File
• 36.12 Registering the Event Listener
• 36.13 Implementing the onGesturePerformed Method
• 36.14 Testing the Application
• 36.15 Configuring the GestureOverlayView
• 36.16 Intercepting Gestures
• 36.17 Detecting Pinch Gestures
• 36.18 A Pinch Gesture Example Project
• 36.19 Summary

37. An Introduction to Android Fragments

• 37.1 What is a Fragment?
• 37.2 Creating a Fragment
• 37.3 Adding a Fragment to an Activity using the Layout XML File
• 37.4 Adding and Managing Fragments in Code
• 37.5 Handling Fragment Events
• 37.6 Implementing Fragment Communication
• 37.7 Summary

38. Using Fragments in Android Studio - An Example

• 38.1 About the Example Fragment Application
• 38.2 Creating the Example Project
• 38.3 Creating the First Fragment Layout
• 38.4 Adding the Second Fragment
• 38.5 Adding the Fragments to the Activity
• 38.6 Making the Toolbar Fragment Talk to the Activity
• 38.7 Making the Activity Talk to the Text Fragment
• 38.8 Testing the Application
• 38.9 Summary

39. Modern Android App Architecture with Jetpack

• 39.1 What is Android Jetpack?
• 39.2 The “Old” Architecture
• 39.3 Modern Android Architecture
• 39.4 The ViewModel Component
• 39.5 The LiveData Component
• 39.6 ViewModel Saved State
• 39.7 LiveData and Data Binding
• 39.8 Android Lifecycles
• 39.9 Repository Modules
• 39.10 Summary

40. An Android Jetpack ViewModel Tutorial

• 40.1 About the Project
• 40.2 Creating the ViewModel Example Project
• 40.3 Reviewing the Project
• 40.4 Designing the Fragment Layout
• 40.5 Implementing the View Model
• 40.6 Associating the Fragment with the View Model
• 40.7 Modifying the Fragment
• 40.8 Accessing the ViewModel Data
• 40.9 Testing the Project
• 40.10 Summary

41. An Android Jetpack LiveData Tutorial

• 41.1 LiveData - A Recap
• 41.2 Adding LiveData to the ViewModel
• 41.3 Implementing the Observer
• 41.4 Summary

42. An Overview of Android Jetpack Data Binding

• 42.1 An Overview of Data Binding
• 42.2 The Key Components of Data Binding
• 42.3 Summary

43. An Android Jetpack Data Binding Tutorial

• 43.1 Removing the Redundant Code
• 43.2 Enabling Data Binding
• 43.3 Adding the Layout Element
• 43.4 Adding the Data Element to Layout File
• 43.5 Working with the Binding Class
• 43.6 Assigning the ViewModel Instance to the Data Binding Variable
• 43.7 Adding Binding Expressions
• 43.8 Adding the Conversion Method
• 43.9 Adding a Listener Binding
• 43.10 Testing the App
• 43.11 Summary

44. An Android ViewModel Saved State Tutorial

• 44.1 Understanding ViewModel State Saving
• 44.2 Implementing ViewModel State Saving
• 44.3 Saving and Restoring State
• 44.4 Adding Saved State Support to the ViewModelDemo Project
• 44.5 Summary

45. Working with Android Lifecycle-Aware Components

• 45.1 Lifecycle Awareness
• 45.2 Lifecycle Owners
• 45.3 Lifecycle Observers
• 45.4 Lifecycle States and Events
• 45.5 Summary

46. An Android Jetpack Lifecycle Awareness Tutorial

• 46.1 Creating the Example Lifecycle Project
• 46.2 Creating a Lifecycle Observer
• 46.3 Adding the Observer
• 46.4 Testing the Observer
• 46.5 Creating a Lifecycle Owner
• 46.6 Testing the Custom Lifecycle Owner
• 46.7 Summary

47. An Overview of the Navigation Architecture Component

• 47.1 Understanding Navigation
• 47.2 Declaring a Navigation Host
• 47.3 The Navigation Graph
• 47.4 Accessing the Navigation Controller
• 47.5 Triggering a Navigation Action
• 47.6 Passing Arguments
• 47.7 Summary

48. An Android Jetpack Navigation Component Tutorial

• 48.1 Creating the NavigationDemo Project
• 48.2 Adding Navigation to the Build Configuration
• 48.3 Creating the Navigation Graph Resource File
• 48.4 Declaring a Navigation Host
• 48.5 Adding Navigation Destinations
• 48.6 Designing the Destination Fragment Layouts
• 48.7 Adding an Action to the Navigation Graph
• 48.8 Implement the OnFragmentInteractionListener
• 48.9 Triggering the Action
• 48.10 Passing Data Using Safeargs
• 48.11 Summary

49. Creating and Managing Overflow Menus on Android

• 49.1 The Overflow Menu
• 49.2 Creating an Overflow Menu
• 49.3 Displaying an Overflow Menu
• 49.4 Responding to Menu Item Selections
• 49.5 Creating Checkable Item Groups
• 49.6 Menus and the Android Studio Menu Editor
• 49.7 Creating the Example Project
• 49.8 Designing the Menu
• 49.9 Modifying the onOptionsItemSelected() Method
• 49.10 Testing the Application
• 49.11 Summary

50. An Introduction to MotionLayout

• 50.1 An Overview of MotionLayout
• 50.2 MotionLayout
• 50.3 MotionScene
• 50.4 Configuring ConstraintSets
• 50.5 Custom Attributes
• 50.6 Triggering an Animation
• 50.7 Arc Motion
• 50.8 Keyframes
• 50.9 Time Linearity
• 50.10 KeyTrigger
• 50.11 Cycle and Time Cycle Keyframes
• 50.12 Starting an Animation from Code
• 50.13 Summary

51. An Android MotionLayout Editor Tutorial

• 51.1 Creating the MotionLayoutDemo Project
• 51.2 ConstraintLayout to MotionLayout Conversion
• 51.3 Configuring Start and End Constraints
• 51.4 Previewing the MotionLayout Animation
• 51.5 Adding an OnClick Gesture
• 51.6 Adding an Attribute Keyframe to the Transition
• 51.7 Adding a CustomAttribute to a Transition
• 51.8 Adding Position Keyframes
• 51.9 Summary

52. A MotionLayout KeyCycle Tutorial

• 52.1 An Overview of Cycle Keyframes
• 52.2 Using the Cycle Editor
• 52.3 Creating the KeyCycleDemo Project
• 52.4 Configuring the Start and End Constraints
• 52.5 Creating the Cycles
• 52.6 Previewing the Animation
• 52.7 Adding the KeyFrameSet to the MotionScene
• 52.8 Summary

53. Working with the Floating Action Button and Snackbar

• 53.1 The Material Design
• 53.2 The Design Library
• 53.3 The Floating Action Button (FAB)
• 53.4 The Snackbar
• 53.5 Creating the Example Project
• 53.6 Reviewing the Project
• 53.7 Removing Navigation Features
• 53.8 Changing the Floating Action Button
• 53.9 Adding the ListView to the Content Layout
• 53.10 Adding Items to the ListView
• 53.11 Adding an Action to the Snackbar
• 53.12 Summary

54. Creating a Tabbed Interface using the TabLayout Component

• 54.1 An Introduction to the ViewPager
• 54.2 An Overview of the TabLayout Component
• 54.3 Creating the TabLayoutDemo Project
• 54.4 Creating the First Fragment
• 54.5 Duplicating the Fragments
• 54.6 Adding the TabLayout and ViewPager
• 54.7 Creating the Pager Adapter
• 54.8 Performing the Initialization Tasks
• 54.9 Testing the Application
• 54.10 Customizing the TabLayout
• 54.11 Displaying Icon Tab Items
• 54.12 Summary

55. Working with the RecyclerView and CardView Widgets

• 55.1 An Overview of the RecyclerView
• 55.2 An Overview of the CardView
• 55.3 Summary

56. An Android RecyclerView and CardView Tutorial

• 56.1 Creating the CardDemo Project
• 56.2 Modifying the Basic Activity Project
• 56.3 Designing the CardView Layout
• 56.4 Adding the RecyclerView
• 56.5 Creating the RecyclerView Adapter
• 56.6 Adding the Image Files
• 56.7 Initializing the RecyclerView Component
• 56.8 Testing the Application
• 56.9 Responding to Card Selections
• 56.10 Summary

57. A Layout Editor Sample Data Tutorial

• 57.1 Adding Sample Data to a Project
• 57.2 Using Custom Sample Data
• 57.3 Summary

58. Working with the AppBar and Collapsing Toolbar Layouts

• 58.1 The Anatomy of an AppBar
• 58.2 The Example Project
• 58.3 Coordinating the RecyclerView and Toolbar
• 58.4 Introducing the Collapsing Toolbar Layout
• 58.5 Changing the Title and Scrim Color
• 58.6 Summary

59. An Android Studio Master/Detail Flow Tutorial

• 59.1 The Master/Detail Flow
• 59.2 Creating a Master/Detail Flow Activity
• 59.3 The Anatomy of the Master/Detail Flow Template
• 59.4 Modifying the Master/Detail Flow Template
• 59.5 Changing the Content Model
• 59.6 Changing the Detail Pane
• 59.7 Modifying the WebsiteDetailFragment Class
• 59.8 Modifying the WebsiteListActivity Class
• 59.9 Adding Manifest Permissions
• 59.10 Running the Application
• 59.11 Summary

60. An Overview of Android Intents

• 60.1 An Overview of Intents
• 60.2 Explicit Intents
• 60.3 Returning Data from an Activity
• 60.4 Implicit Intents
• 60.5 Using Intent Filters
• 60.6 Checking Intent Availability
• 60.7 Summary

61. Android Explicit Intents – A Worked Example

• 61.1 Creating the Explicit Intent Example Application
• 61.2 Designing the User Interface Layout for MainActivity
• 61.3 Creating the Second Activity Class
• 61.4 Designing the User Interface Layout for ActivityB
• 61.5 Reviewing the Application Manifest File
• 61.6 Creating the Intent
• 61.7 Extracting Intent Data
• 61.8 Launching ActivityB as a Sub-Activity
• 61.9 Returning Data from a Sub-Activity
• 61.10 Testing the Application
• 61.11 Summary

62. Android Implicit Intents – A Worked Example

• 62.1 Creating the Android Studio Implicit Intent Example Project
• 62.2 Designing the User Interface
• 62.3 Creating the Implicit Intent
• 62.4 Adding a Second Matching Activity
• 62.5 Adding the Web View to the UI
• 62.6 Obtaining the Intent URL
• 62.7 Modifying the MyWebView Project Manifest File
• 62.8 Installing the MyWebView Package on a Device
• 62.9 Testing the Application
• 62.10 Summary

63. Android Broadcast Intents and Broadcast Receivers

• 63.1 An Overview of Broadcast Intents
• 63.2 An Overview of Broadcast Receivers
• 63.3 Obtaining Results from a Broadcast
• 63.4 Sticky Broadcast Intents
• 63.5 The Broadcast Intent Example
• 63.6 Creating the Example Application
• 63.7 Creating and Sending the Broadcast Intent
• 63.8 Creating the Broadcast Receiver
• 63.9 Registering the Broadcast Receiver
• 63.10 Testing the Broadcast Example
• 63.11 Listening for System Broadcasts
• 63.12 Summary

64. A Basic Overview of Threads and AsyncTasks

• 64.1 An Overview of Threads
• 64.2 The Application Main Thread
• 64.3 Thread Handlers
• 64.4 A Basic AsyncTask Example
• 64.5 Subclassing AsyncTask
• 64.6 Testing the App
• 64.7 Canceling a Task
• 64.8 Summary

65. An Introduction to Kotlin Coroutines

• 65.1 What are Coroutines?
• 65.2 Threads vs Coroutines
• 65.3 Coroutine Scope
• 65.4 Suspend Functions
• 65.5 Coroutine Dispatchers
• 65.6 Coroutine Builders
• 65.7 Jobs
• 65.8 Coroutines – Suspending and Resuming
• 65.9 Returning Results from a Coroutine
• 65.10 Using withContext
• 65.11 Coroutine Channel Communication
• 65.12 Summary

66. An Android Kotlin Coroutines Tutorial

• 66.1 Creating the Coroutine Example Application
• 66.2 Adding Coroutine Support to the Project
• 66.3 Designing the User Interface
• 66.4 Implementing the SeekBar
• 66.5 Adding the Suspend Function
• 66.6 Implementing the launchCoroutines Method
• 66.7 Testing the App
• 66.8 Summary

67. An Overview of Android Started and Bound Services

• 67.1 Started Services
• 67.2 Intent Service
• 67.3 Bound Service
• 67.4 The Anatomy of a Service
• 67.5 Controlling Destroyed Service Restart Options
• 67.6 Declaring a Service in the Manifest File
• 67.7 Starting a Service Running on System Startup
• 67.8 Summary

68. Implementing an Android Started Service – A Worked Example

• 68.1 Creating the Example Project
• 68.2 Creating the Service Class
• 68.3 Adding the Service to the Manifest File
• 68.4 Starting the Service
• 68.5 Testing the IntentService Example
• 68.6 Using the Service Class
• 68.7 Creating the New Service
• 68.8 Modifying the User Interface
• 68.9 Running the Application
• 68.10 Using a Coroutine for the Service Task
• 68.11 Summary

69. Android Local Bound Services – A Worked Example

• 69.1 Understanding Bound Services
• 69.2 Bound Service Interaction Options
• 69.3 An Android Studio Local Bound Service Example
• 69.4 Adding a Bound Service to the Project
• 69.5 Implementing the Binder
• 69.6 Binding the Client to the Service
• 69.7 Completing the Example
• 69.8 Testing the Application
• 69.9 Summary

70. Android Remote Bound Services – A Worked Example

• 70.1 Client to Remote Service Communication
• 70.2 Creating the Example Application
• 70.3 Designing the User Interface
• 70.4 Implementing the Remote Bound Service
• 70.5 Configuring a Remote Service in the Manifest File
• 70.6 Launching and Binding to the Remote Service
• 70.7 Sending a Message to the Remote Service
• 70.8 Summary

71. An Android Notifications Tutorial

• 71.1 An Overview of Notifications
• 71.2 Creating the NotifyDemo Project
• 71.3 Designing the User Interface
• 71.4 Creating the Second Activity
• 71.5 Creating a Notification Channel
• 71.6 Creating and Issuing a Basic Notification
• 71.7 Launching an Activity from a Notification
• 71.8 Adding Actions to a Notification
• 71.9 Bundled Notifications
• 71.10 Summary

72. An Android Direct Reply Notification Tutorial

• 72.1 Creating the DirectReply Project
• 72.2 Designing the User Interface
• 72.3 Creating the Notification Channel
• 72.4 Building the RemoteInput Object
• 72.5 Creating the PendingIntent
• 72.6 Creating the Reply Action
• 72.7 Receiving Direct Reply Input
• 72.8 Updating the Notification
• 72.9 Summary

73. Foldable Devices and Multi-Window Support

• 73.1 Foldables and Multi-Window Support
• 73.2 Using a Foldable Emulator
• 73.3 Entering Multi-Window Mode
• 73.4 Enabling and using Freeform Support
• 73.5 Checking for Freeform Support
• 73.6 Enabling Multi-Window Support in an App
• 73.7 Specifying Multi-Window Attributes
• 73.8 Detecting Multi-Window Mode in an Activity
• 73.9 Receiving Multi-Window Notifications
• 73.10 Launching an Activity in Multi-Window Mode
• 73.11 Configuring Freeform Activity Size and Position
• 73.12 Summary

74. An Overview of Android SQLite Databases

• 74.1 Understanding Database Tables
• 74.2 Introducing Database Schema
• 74.3 Columns and Data Types
• 74.4 Database Rows
• 74.5 Introducing Primary Keys
• 74.6 What is SQLite?
• 74.7 Structured Query Language (SQL)
• 74.8 Trying SQLite on an Android Virtual Device (AVD)
• 74.9 The Android Room Persistence Library
• 74.10 Summary

75. The Android Room Persistence Library

• 75.1 Revisiting Modern App Architecture
• 75.2 Key Elements of Room Database Persistence
• 75.3 Understanding Entities
• 75.4 Data Access Objects
• 75.5 The Room Database
• 75.6 The Repository
• 75.7 In-Memory Databases
• 75.8 Summary

76. An Android TableLayout and TableRow Tutorial

• 76.1 The TableLayout and TableRow Layout Views
• 76.2 Creating the Room Database Project
• 76.3 Converting to a LinearLayout
• 76.4 Adding the TableLayout to the User Interface
• 76.5 Configuring the TableRows
• 76.6 Adding the Button Bar to the Layout
• 76.7 Adding the RecyclerView
• 76.8 Adjusting the Layout Margins
• 76.9 Summary

77. An Android Room Database and Repository Tutorial

• 77.1 About the RoomDemo Project
• 77.2 Modifying the Build Configuration
• 77.3 Building the Entity
• 77.4 Creating the Data Access Object
• 77.5 Adding the Room Database
• 77.6 Adding the Repository
• 77.7 Modifying the ViewModel
• 77.8 Creating the Product Item Layout
• 77.9 Adding the RecyclerView Adapter
• 77.10 Preparing the Main Fragment
• 77.11 Adding the Button Listeners
• 77.12 Adding LiveData Observers
• 77.13 Initializing the RecyclerView
• 77.14 Testing the RoomDemo App
• 77.15 Summary

78. Accessing Cloud Storage using the Android Storage Access Framework

• 78.1 The Storage Access Framework
• 78.2 Working with the Storage Access Framework
• 78.3 Filtering Picker File Listings
• 78.4 Handling Intent Results
• 78.5 Reading the Content of a File
• 78.6 Writing Content to a File
• 78.7 Deleting a File
• 78.8 Gaining Persistent Access to a File
• 78.9 Summary

79. An Android Storage Access Framework Example

• 79.1 About the Storage Access Framework Example
• 79.2 Creating the Storage Access Framework Example
• 79.3 Designing the User Interface
• 79.4 Declaring Request Codes
• 79.5 Creating a New Storage File
• 79.6 The onActivityResult() Method
• 79.7 Saving to a Storage File
• 79.8 Opening and Reading a Storage File
• 79.9 Testing the Storage Access Application
• 79.10 Summary

80. Video Playback on Android using the VideoView and MediaController Classes

• 80.1 Introducing the Android VideoView Class
• 80.2 Introducing the Android MediaController Class
• 80.3 Creating the Video Playback Example
• 80.4 Designing the VideoPlayer Layout
• 80.5 Downloading the Video File
• 80.6 Configuring the VideoView
• 80.7 Adding the MediaController to the Video View
• 80.8 Setting up the onPreparedListener
• 80.9 Summary

81. Android Picture-in-Picture Mode

• 81.1 Picture-in-Picture Features
• 81.2 Enabling Picture-in-Picture Mode
• 81.3 Configuring Picture-in-Picture Parameters
• 81.4 Entering Picture-in-Picture Mode
• 81.5 Detecting Picture-in-Picture Mode Changes
• 81.6 Adding Picture-in-Picture Actions
• 81.7 Summary

82. An Android Picture-in-Picture Tutorial

• 82.1 Adding Picture-in-Picture Support to the Manifest
• 82.2 Adding a Picture-in-Picture Button
• 82.3 Entering Picture-in-Picture Mode
• 82.4 Detecting Picture-in-Picture Mode Changes
• 82.5 Adding a Broadcast Receiver
• 82.6 Adding the PiP Action
• 82.7 Testing the Picture-in-Picture Action
• 82.8 Summary

83. Making Runtime Permission Requests in Android

• 83.1 Understanding Normal and Dangerous Permissions
• 83.2 Creating the Permissions Example Project
• 83.3 Checking for a Permission
• 83.4 Requesting Permission at Runtime
• 83.5 Providing a Rationale for the Permission Request
• 83.6 Testing the Permissions App
• 83.7 Summary

84. Android Audio Recording and Playback using MediaPlayer and MediaRecorder

• 84.1 Playing Audio
• 84.2 Recording Audio and Video using the MediaRecorder Class
• 84.3 About the Example Project
• 84.4 Creating the AudioApp Project
• 84.5 Designing the User Interface
• 84.6 Checking for Microphone Availability
• 84.7 Performing the Activity Initialization
• 84.8 Implementing the recordAudio() Method
• 84.9 Implementing the stopAudio() Method
• 84.10 Implementing the playAudio() method
• 84.11 Configuring and Requesting Permissions
• 84.12 Testing the Application
• 84.13 Summary

85. Working with the Google Maps Android API in Android Studio

• 85.1 The Elements of the Google Maps Android API
• 85.2 Creating the Google Maps Project
• 85.3 Obtaining Your Developer Signature
• 85.4 Adding the Apache HTTP Legacy Library Requirement
• 85.5 Testing the Application
• 85.6 Understanding Geocoding and Reverse Geocoding
• 85.7 Adding a Map to an Application
• 85.8 Requesting Current Location Permission
• 85.9 Displaying the User’s Current Location
• 85.10 Changing the Map Type
• 85.11 Displaying Map Controls to the User
• 85.12 Handling Map Gesture Interaction
• 85.13 Creating Map Markers
• 85.14 Controlling the Map Camera
• 85.15 Summary

86. Printing with the Android Printing Framework

• 86.1 The Android Printing Architecture
• 86.2 The Print Service Plugins
• 86.3 Google Cloud Print
• 86.4 Printing to Google Drive
• 86.5 Save as PDF
• 86.6 Printing from Android Devices
• 86.7 Options for Building Print Support into Android Apps
• 86.8 Summary

87. An Android HTML and Web Content Printing Example

• 87.1 Creating the HTML Printing Example Application
• 87.2 Printing Dynamic HTML Content
• 87.3 Creating the Web Page Printing Example
• 87.4 Removing the Floating Action Button
• 87.5 Removing Navigation Features
• 87.6 Designing the User Interface Layout
• 87.7 Loading the Web Page into the WebView
• 87.8 Adding the Print Menu Option
• 87.9 Summary

88. A Guide to Android Custom Document Printing

• 88.1 An Overview of Android Custom Document Printing
• 88.2 Preparing the Custom Document Printing Project
• 88.3 Creating the Custom Print Adapter
• 88.4 Implementing the onLayout() Callback Method
• 88.5 Implementing the onWrite() Callback Method
• 88.6 Checking a Page is in Range
• 88.7 Drawing the Content on the Page Canvas
• 88.8 Starting the Print Job
• 88.9 Testing the Application
• 88.10 Summary

89. An Introduction to Android App Links

• 89.1 An Overview of Android App Links
• 89.2 App Link Intent Filters
• 89.3 Handling App Link Intents
• 89.4 Associating the App with a Website
• 89.5 Summary

90. An Android Studio App Links Tutorial

• 90.1 About the Example App
• 90.2 The Database Schema
• 90.3 Loading and Running the Project
• 90.4 Adding the URL Mapping
• 90.5 Adding the Intent Filter
• 90.6 Adding Intent Handling Code
• 90.7 Testing the App Link
• 90.8 Associating an App Link with a Web Site
• 90.9 Summary

91. A Guide to the Android Studio Profiler

• 91.1 Accessing the Android Profiler
• 91.2 Enabling Advanced Profiling
• 91.3 The Android Profiler Tool Window
• 91.4 The Sessions Panel
• 91.5 The CPU Profiler
• 91.6 Memory Profiler
• 91.7 Network Profiler
• 91.8 Energy Profiler
• 91.9 Summary

92. An Android Biometric Authentication Tutorial

• 92.1 An Overview of Biometric Authentication
• 92.2 Creating the Biometric Authentication Project
• 92.3 Configuring Device Fingerprint Authentication
• 92.4 Adding the Biometric Permission to the Manifest File
• 92.5 Designing the User Interface
• 92.6 Adding a Toast Convenience Method
• 92.7 Checking the Security Settings
• 92.8 Configuring the Authentication Callbacks
• 92.9 Adding the CancellationSignal
• 92.10 Starting the Biometric Prompt
• 92.11 Testing the Project
• 92.12 Summary

93. Creating, Testing and Uploading an Android App Bundle

• 93.1 The Release Preparation Process
• 93.2 Android App Bundles
• 93.3 Register for a Google Play Developer Console Account
• 93.4 Configuring the App in the Console
• 93.5 Enabling Google Play App Signing
• 93.6 Creating a Keystore File
• 93.7 Creating the Android App Bundle
• 93.8 Generating Test APK Files
• 93.9 Uploading the App Bundle to the Google Play Developer Console
• 93.10 Exploring the App Bundle
• 93.11 Managing Testers
• 93.12 Uploading New App Bundle Revisions
• 93.13 Analyzing the App Bundle File
• 93.14 Enabling Google Play Signing for an Existing App
• 93.15 Summary

94. An Overview of Android Dynamic Feature Modules

• 94.1 An Overview of Dynamic Feature Modules
• 94.2 Dynamic Feature Module Architecture
• 94.3 Creating a Dynamic Feature Module
• 94.4 Converting an Existing Module for Dynamic Delivery
• 94.5 Working with Dynamic Feature Modules
• 94.6 Handling Large Dynamic Feature Modules
• 94.7 Summary

95. An Android Studio Dynamic Feature Tutorial

• 95.1 Creating the DynamicFeature Project
• 95.2 Adding Dynamic Feature Support to the Project
• 95.3 Designing the Base Activity User Interface
• 95.4 Adding the Dynamic Feature Module
• 95.5 Reviewing the Dynamic Feature Module
• 95.6 Adding the Dynamic Feature Activity
• 95.7 Implementing the launchIntent() Method
• 95.8 Uploading the App Bundle for Testing
• 95.9 Implementing the installFeature() Method
• 95.10 Adding the Update Listener
• 95.11 Handling Large Downloads
• 95.12 Using Deferred Installation
• 95.13 Removing a Dynamic Module
• 95.14 Summary

96. An Overview of Gradle in Android Studio

• 96.1 An Overview of Gradle
• 96.2 Gradle and Android Studio
• 96.3 The Top-level Gradle Build File
• 96.4 Module Level Gradle Build Files
• 96.5 Configuring Signing Settings in the Build File
• 96.6 Running Gradle Tasks from the Command-line
• 96.7 Summary

Index