Android Studio Flamingo Essentials - Java Edition: Developing Android Apps Using Android Studio 2022.2.1 and Java

1. Introduction
	1.1 Downloading the Code Samples
	1.2 Feedback
	1.3 Errata
2. Setting up an Android Studio Development Environment
	2.1 System requirements
	2.2 Downloading the Android Studio package
	2.3 Installing Android Studio
		2.3.1 Installation on Windows
		2.3.2 Installation on macOS
		2.3.3 Installation on Linux
	2.4 The Android Studio setup wizard
	2.5 Installing additional Android SDK packages
	2.6 Installing the Android SDK Command-line Tools
		2.6.1 Windows 8.1
		2.6.2 Windows 10
		2.6.3 Windows 11
		2.6.4 Linux
		2.6.5 macOS
	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 Starting the Emulator
	4.3 Running the Application in the AVD
	4.4 Running on Multiple Devices
	4.5 Stopping a Running Application
	4.6 Supporting Dark Theme
	4.7 Running the Emulator in a Separate Window
	4.8 Enabling the Device Frame
	4.9 Summary
5. Using and Configuring the Android Studio AVD Emulator
	5.1 The Emulator Environment
	5.2 Emulator Toolbar Options
	5.3 Working in Zoom Mode
	5.4 Resizing the Emulator Window
	5.5 Extended Control Options
		5.5.1 Location
		5.5.2 Displays
		5.5.3 Cellular
		5.5.4 Battery
		5.5.5 Camera
		5.5.6 Phone
		5.5.7 Directional Pad
		5.5.8 Microphone
		5.5.9 Fingerprint
		5.5.10 Virtual Sensors
		5.5.11 Snapshots
		5.5.12 Record and Playback
		5.5.13 Google Play
		5.5.14 Settings
		5.5.15 Help
	5.6 Working with Snapshots
	5.7 Configuring Fingerprint Emulation
	5.8 The Emulator in Tool Window Mode
	5.9 Creating a Resizable Emulator
	5.10 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 USB Debugging ADB on Android Devices
		7.2.1 macOS ADB Configuration
		7.2.2 Windows ADB Configuration
		7.2.3 Linux adb Configuration
	7.3 Resolving USB Connection Issues
	7.4 Enabling Wireless Debugging on Android Devices
	7.5 Testing the adb Connection
	7.6 Device Mirroring
	7.7 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.4.1 C/C++ 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 Overview of Android View Binding
	11.1 Find View by Id
	11.2 View Binding
	11.3 Converting the AndroidSample project
	11.4 Enabling View Binding
	11.5 Using View Binding
	11.6 Choosing an Option
	11.7 View Binding in the Book Examples
	11.8 Migrating a Project to View Binding
	11.9 Summary
12. Understanding Android Application and Activity Lifecycles
	12.1 Android Applications and Resource Management
	12.2 Android Process States
		12.2.1 Foreground Process
		12.2.2 Visible Process
		12.2.3 Service Process
		12.2.4 Background Process
		12.2.5 Empty Process
	12.3 Inter-Process Dependencies
	12.4 The Activity Lifecycle
	12.5 The Activity Stack
	12.6 Activity States
	12.7 Configuration Changes
	12.8 Handling State Change
	12.9 Summary
13. Handling Android Activity State Changes
	13.1 New vs. Old Lifecycle Techniques
	13.2 The Activity and Fragment Classes
	13.3 Dynamic State vs. Persistent State
	13.4 The Android Lifecycle Methods
	13.5 Lifetimes
	13.6 Foldable Devices and Multi-Resume
	13.7 Disabling Configuration Change Restarts
	13.8 Lifecycle Method Limitations
	13.9 Summary
14. Android Activity State Changes by Example
	14.1 Creating the State Change Example Project
	14.2 Designing the User Interface
	14.3 Overriding the Activity Lifecycle Methods
	14.4 Filtering the Logcat Panel
	14.5 Running the Application
	14.6 Experimenting with the Activity
	14.7 Summary
15. Saving and Restoring the State of an Android Activity
	15.1 Saving Dynamic State
	15.2 Default Saving of User Interface State
	15.3 The Bundle Class
	15.4 Saving the State
	15.5 Restoring the State
	15.6 Testing the Application
	15.7 Summary
16. Understanding Android Views, View Groups and Layouts
	16.1 Designing for Different Android Devices
	16.2 Views and View Groups
	16.3 Android Layout Managers
	16.4 The View Hierarchy
	16.5 Creating User Interfaces
	16.6 Summary
17. A Guide to the Android Studio Layout Editor Tool
	17.1 Basic vs. Empty Views Activity Templates
	17.2 The Android Studio Layout Editor
	17.3 Design Mode
	17.4 The Palette
	17.5 Design Mode and Layout Views
	17.6 Night Mode
	17.7 Code Mode
	17.8 Split Mode
	17.9 Setting Attributes
	17.10 Transforms
	17.11 Tools Visibility Toggles
	17.12 Converting Views
	17.13 Displaying Sample Data
	17.14  Creating a Custom Device Definition
	17.15 Changing the Current Device
	17.16 Layout Validation
	17.17 Summary
18. A Guide to the Android ConstraintLayout
	18.1 How ConstraintLayout Works
		18.1.1 Constraints
		18.1.2 Margins
		18.1.3 Opposing Constraints
		18.1.4 Constraint Bias
		18.1.5 Chains
		18.1.6 Chain Styles
	18.2 Baseline Alignment
	18.3 Configuring Widget Dimensions
	18.4 Guideline Helper
	18.5 Group Helper
	18.6 Barrier Helper
	18.7 Flow Helper
	18.8 Ratios
	18.9 ConstraintLayout Advantages
	18.10 ConstraintLayout Availability
	18.11 Summary
19. A Guide to Using ConstraintLayout in Android Studio
	19.1 Design and Layout Views
	19.2 Autoconnect Mode
	19.3 Inference Mode
	19.4 Manipulating Constraints Manually
	19.5 Adding Constraints in the Inspector
	19.6 Viewing Constraints in the Attributes Window
	19.7 Deleting Constraints
	19.8 Adjusting Constraint Bias
	19.9 Understanding ConstraintLayout Margins
	19.10 The Importance of Opposing Constraints and Bias
	19.11 Configuring Widget Dimensions
	19.12 Design Time Tools Positioning
	19.13 Adding Guidelines
	19.14 Adding Barriers
	19.15 Adding a Group
	19.16 Working with the Flow Helper
	19.17 Widget Group Alignment and Distribution
	19.18 Converting other Layouts to ConstraintLayout
	19.19 Summary
20. Working with ConstraintLayout Chains and Ratios in Android Studio
	20.1 Creating a Chain
	20.2 Changing the Chain Style
	20.3 Spread Inside Chain Style
	20.4 Packed Chain Style
	20.5 Packed Chain Style with Bias
	20.6 Weighted Chain
	20.7 Working with Ratios
	20.8 Summary
21. An Android Studio Layout Editor ConstraintLayout Tutorial
	21.1 An Android Studio Layout Editor Tool Example
	21.2 Preparing the Layout Editor Environment
	21.3 Adding the Widgets to the User Interface
	21.4 Adding the Constraints
	21.5 Testing the Layout
	21.6 Using the Layout Inspector
	21.7 Summary
22. Manual XML Layout Design in Android Studio
	22.1 Manually Creating an XML Layout
	22.2 Manual XML vs. Visual Layout Design
	22.3 Summary
23. Managing Constraints using Constraint Sets
	23.1 Java Code vs. XML Layout Files
	23.2 Creating Views
	23.3 View Attributes
	23.4 Constraint Sets
		23.4.1 Establishing Connections
		23.4.2 Applying Constraints to a Layout
		23.4.3 Parent Constraint Connections
		23.4.4 Sizing Constraints
		23.4.5 Constraint Bias
		23.4.6 Alignment Constraints
		23.4.7 Copying and Applying Constraint Sets
		23.4.8 ConstraintLayout Chains
		23.4.9 Guidelines
		23.4.10 Removing Constraints
		23.4.11 Scaling
		23.4.12 Rotation
	23.5 Summary
24. An Android ConstraintSet Tutorial
	24.1 Creating the Example Project in Android Studio
	24.2 Adding Views to an Activity
	24.3 Setting View Attributes
	24.4 Creating View IDs
	24.5 Configuring the Constraint Set
	24.6 Adding the EditText View
	24.7 Converting Density Independent Pixels (dp) to Pixels (px)
	24.8 Summary
25. A Guide to using Apply Changes in Android Studio
	25.1 Introducing Apply Changes
	25.2 Understanding Apply Changes Options
	25.3 Using Apply Changes
	25.4 Configuring Apply Changes Fallback Settings
	25.5 An Apply Changes Tutorial
	25.6 Using Apply Code Changes
	25.7 Using Apply Changes and Restart Activity
	25.8 Using Run App
	25.9 Summary
26. An Overview and Example of Android Event Handling
	26.1 Understanding Android Events
	26.2 Using the android:onClick Resource
	26.3 Event Listeners and Callback Methods
	26.4 An Event Handling Example
	26.5 Designing the User Interface
	26.6 The Event Listener and Callback Method
	26.7 Consuming Events
	26.8 Summary
27. Android Touch and Multi-touch Event Handling
	27.1 Intercepting Touch Events
	27.2 The MotionEvent Object
	27.3 Understanding Touch Actions
	27.4 Handling Multiple Touches
	27.5 An Example Multi-Touch Application
	27.6 Designing the Activity User Interface
	27.7 Implementing the Touch Event Listener
	27.8 Running the Example Application
	27.9 Summary
28. Detecting Common Gestures Using the Android Gesture Detector Class
	28.1 Implementing Common Gesture Detection
	28.2 Creating an Example Gesture Detection Project
	28.3 Implementing the Listener Class
	28.4 Creating the GestureDetectorCompat Instance
	28.5 Implementing the onTouchEvent() Method
	28.6 Testing the Application
	28.7 Summary
29. Implementing Custom Gesture and Pinch Recognition on Android
	29.1 The Android Gesture Builder Application
	29.2 The GestureOverlayView Class
	29.3 Detecting Gestures
	29.4 Identifying Specific Gestures
	29.5 Installing and Running the Gesture Builder Application
	29.6 Creating a Gestures File
	29.7 Creating the Example Project
	29.8 Extracting the Gestures File from the SD Card
	29.9 Adding the Gestures File to the Project
	29.10 Designing the User Interface
	29.11 Loading the Gestures File
	29.12 Registering the Event Listener
	29.13 Implementing the onGesturePerformed Method
	29.14 Testing the Application
	29.15 Configuring the GestureOverlayView
	29.16 Intercepting Gestures
	29.17 Detecting Pinch Gestures
	29.18 A Pinch Gesture Example Project
	29.19 Summary
30. An Introduction to Android Fragments
	30.1 What is a Fragment?
	30.2 Creating a Fragment
	30.3 Adding a Fragment to an Activity using the Layout XML File
	30.4 Adding and Managing Fragments in Code
	30.5 Handling Fragment Events
	30.6 Implementing Fragment Communication
	30.7 Summary
31. Using Fragments in Android Studio - An Example
	31.1 About the Example Fragment Application
	31.2 Creating the Example Project
	31.3 Creating the First Fragment Layout
	31.4 Migrating a Fragment to View Binding
	31.5 Adding the Second Fragment
	31.6 Adding the Fragments to the Activity
	31.7 Making the Toolbar Fragment Talk to the Activity
	31.8 Making the Activity Talk to the Text Fragment
	31.9 Testing the Application
	31.10 Summary
32. Modern Android App Architecture with Jetpack
	32.1 What is Android Jetpack?
	32.2 The “Old” Architecture
	32.3 Modern Android Architecture
	32.4 The ViewModel Component
	32.5 The LiveData Component
	32.6 ViewModel Saved State
	32.7 LiveData and Data Binding
	32.8 Android Lifecycles
	32.9 Repository Modules
	32.10 Summary
33. An Android ViewModel Tutorial
	33.1 About the Project
	33.2 Creating the ViewModel Example Project
	33.3 Removing Unwanted Project Elements
	33.4 Designing the Fragment Layout
	33.5 Implementing the View Model
	33.6 Associating the Fragment with the View Model
	33.7 Modifying the Fragment
	33.8 Accessing the ViewModel Data
	33.9 Testing the Project
	33.10 Summary
34. An Android Jetpack LiveData Tutorial
	34.1 LiveData - A Recap
	34.2 Adding LiveData to the ViewModel
	34.3 Implementing the Observer
	34.4 Summary
35. An Overview of Android Jetpack Data Binding
	35.1 An Overview of Data Binding
	35.2 The Key Components of Data Binding
		35.2.1 The Project Build Configuration
		35.2.2 The Data Binding Layout File
		35.2.3 The Layout File Data Element
		35.2.4 The Binding Classes
		35.2.5 Data Binding Variable Configuration
		35.2.6 Binding Expressions (One-Way)
		35.2.7 Binding Expressions (Two-Way)
		35.2.8 Event and Listener Bindings
	35.3 Summary
36. An Android Jetpack Data Binding Tutorial
	36.1 Removing the Redundant Code
	36.2 Enabling Data Binding
	36.3 Adding the Layout Element
	36.4 Adding the Data Element to Layout File
	36.5 Working with the Binding Class
	36.6 Assigning the ViewModel Instance to the Data Binding Variable
	36.7 Adding Binding Expressions
	36.8 Adding the Conversion Method
	36.9 Adding a Listener Binding
	36.10 Testing the App
	36.11 Summary
37. An Android ViewModel Saved State Tutorial
	37.1 Understanding ViewModel State Saving
	37.2 Implementing ViewModel State Saving
	37.3 Saving and Restoring State
	37.4 Adding Saved State Support to the ViewModelDemo Project
	37.5 Summary
38. Working with Android Lifecycle-Aware Components
	38.1 Lifecycle Awareness
	38.2 Lifecycle Owners
	38.3 Lifecycle Observers
	38.4 Lifecycle States and Events
	38.5 Summary
39. An Android Jetpack Lifecycle Awareness Tutorial
	39.1 Creating the Example Lifecycle Project
	39.2 Creating a Lifecycle Observer
	39.3 Adding the Observer
	39.4 Testing the Observer
	39.5 Creating a Lifecycle Owner
	39.6 Testing the Custom Lifecycle Owner
	39.7 Summary
40. An Overview of the Navigation Architecture Component
	40.1 Understanding Navigation
	40.2 Declaring a Navigation Host
	40.3 The Navigation Graph
	40.4 Accessing the Navigation Controller
	40.5 Triggering a Navigation Action
	40.6 Passing Arguments
	40.7 Summary
41. An Android Jetpack Navigation Component Tutorial
	41.1 Creating the NavigationDemo Project
	41.2 Adding Navigation to the Build Configuration
	41.3 Creating the Navigation Graph Resource File
	41.4 Declaring a Navigation Host
	41.5 Adding Navigation Destinations
	41.6 Designing the Destination Fragment Layouts
	41.7 Adding an Action to the Navigation Graph
	41.8 Implement the OnFragmentInteractionListener
	41.9 Adding View Binding Support to the Destination Fragments
	41.10 Triggering the Action
	41.11 Passing Data Using Safeargs
	41.12 Summary
42. An Introduction to MotionLayout
	42.1 An Overview of MotionLayout
	42.2 MotionLayout
	42.3 MotionScene
	42.4 Configuring ConstraintSets
	42.5 Custom Attributes
	42.6 Triggering an Animation
	42.7 Arc Motion
	42.8 Keyframes
		42.8.1 Attribute Keyframes
		42.8.2 Position Keyframes
	42.9 Time Linearity
	42.10 KeyTrigger
	42.11 Cycle and Time Cycle Keyframes
	42.12 Starting an Animation from Code
	42.13 Summary
43. An Android MotionLayout Editor Tutorial
	43.1 Creating the MotionLayoutDemo Project
	43.2 ConstraintLayout to MotionLayout Conversion
	43.3 Configuring Start and End Constraints
	43.4 Previewing the MotionLayout Animation
	43.5 Adding an OnClick Gesture
	43.6 Adding an Attribute Keyframe to the Transition
	43.7 Adding a CustomAttribute to a Transition
	43.8 Adding Position Keyframes
	43.9 Summary
44. A MotionLayout KeyCycle Tutorial
	44.1 An Overview of Cycle Keyframes
	44.2 Using the Cycle Editor
	44.3 Creating the KeyCycleDemo Project
	44.4 Configuring the Start and End Constraints
	44.5 Creating the Cycles
	44.6 Previewing the Animation
	44.7 Adding the KeyFrameSet to the MotionScene
	44.8 Summary
45. Working with the Floating Action Button and Snackbar
	45.1 The Material Design
	45.2 The Design Library
	45.3 The Floating Action Button (FAB)
	45.4 The Snackbar
	45.5 Creating the Example Project
	45.6 Reviewing the Project
	45.7 Removing Navigation Features
	45.8 Changing the Floating Action Button
	45.9 Adding an Action to the Snackbar
	45.10 Summary
46. Creating a Tabbed Interface using the TabLayout Component
	46.1 An Introduction to the ViewPager2
	46.2 An Overview of the TabLayout Component
	46.3 Creating the TabLayoutDemo Project
	46.4 Creating the First Fragment
	46.5 Duplicating the Fragments
	46.6 Adding the TabLayout and ViewPager2
	46.7 Performing the Initialization Tasks
	46.8 Testing the Application
	46.9 Customizing the TabLayout
	46.10 Summary
47. Working with the RecyclerView and CardView Widgets
	47.1 An Overview of the RecyclerView
	47.2 An Overview of the CardView
	47.3 Summary
48. An Android RecyclerView and CardView Tutorial
	48.1 Creating the CardDemo Project
	48.2 Modifying the Basic Views Activity Project
	48.3 Designing the CardView Layout
	48.4 Adding the RecyclerView
	48.5 Adding the Image Files
	48.6 Creating the RecyclerView Adapter
	48.7 Initializing the RecyclerView Component
	48.8 Testing the Application
	48.9 Responding to Card Selections
	48.10 Summary
49. A Layout Editor Sample Data Tutorial
	49.1 Adding Sample Data to a Project
	49.2 Using Custom Sample Data
	49.3 Summary
50. Working with the AppBar and Collapsing Toolbar Layouts
	50.1 The Anatomy of an AppBar
	50.2 The Example Project
	50.3 Coordinating the RecyclerView and Toolbar
	50.4 Introducing the Collapsing Toolbar Layout
	50.5 Changing the Title and Scrim Color
	50.6 Summary
51. An Android Studio Primary/Detail Flow Tutorial
	51.1 The Primary/Detail Flow
	51.2 Creating a Primary/Detail Flow Activity
	51.3 Adding the Primary/Detail Flow Activity
	51.4 Modifying the Primary/Detail Flow Template
	51.5 Changing the Content Model
	51.6 Changing the Detail Pane
	51.7 Modifying the ItemDetailFragment Class
	51.8 Modifying the ItemListFragment Class
	51.9 Adding Manifest Permissions
	51.10 Running the Application
	51.11 Summary
52. An Overview of Android Services
	52.1 Intent Service
	52.2 Bound Service
	52.3 The Anatomy of a Service
	52.4 Controlling Destroyed Service Restart Options
	52.5 Declaring a Service in the Manifest File
	52.6 Starting a Service Running on System Startup
	52.7 Summary
53. An Overview of Android Intents
	53.1 An Overview of Intents
	53.2 Explicit Intents
	53.3 Returning Data from an Activity
	53.4 Implicit Intents
	53.5 Using Intent Filters
	53.6 Automatic Link Verification
	53.7 Manually Enabling Links
	53.8 Checking Intent Availability
	53.9 Summary
54. Android Explicit Intents – A Worked Example
	54.1 Creating the Explicit Intent Example Application
	54.2 Designing the User Interface Layout for MainActivity
	54.3 Creating the Second Activity Class
	54.4 Designing the User Interface Layout for SecondActivity
	54.5 Reviewing the Application Manifest File
	54.6 Creating the Intent
	54.7 Extracting Intent Data
	54.8 Launching SecondActivity as a Sub-Activity
	54.9 Returning Data from a Sub-Activity
	54.10 Testing the Application
	54.11 Summary
55. Android Implicit Intents – A Worked Example
	55.1 Creating the Android Studio Implicit Intent Example Project
	55.2 Designing the User Interface
	55.3 Creating the Implicit Intent
	55.4 Adding a Second Matching Activity
	55.5 Adding the Web View to the UI
	55.6 Obtaining the Intent URL
	55.7 Modifying the MyWebView Project Manifest File
	55.8 Installing the MyWebView Package on a Device
	55.9 Testing the Application
	55.10 Manually Enabling the Link
	55.11 Automatic Link Verification
	55.12 Summary
56. Android Broadcast Intents and Broadcast Receivers
	56.1 An Overview of Broadcast Intents
	56.2 An Overview of Broadcast Receivers
	56.3 Obtaining Results from a Broadcast
	56.4 Sticky Broadcast Intents
	56.5 The Broadcast Intent Example
	56.6 Creating the Example Application
	56.7 Creating and Sending the Broadcast Intent
	56.8 Creating the Broadcast Receiver
	56.9 Registering the Broadcast Receiver
	56.10 Testing the Broadcast Example
	56.11 Listening for System Broadcasts
	56.12 Summary
57. Android Local Bound Services – A Worked Example
	57.1 Understanding Bound Services
	57.2 Bound Service Interaction Options
	57.3 A Local Bound Service Example
	57.4 Adding a Bound Service to the Project
	57.5 Implementing the Binder
	57.6 Binding the Client to the Service
	57.7 Completing the Example
	57.8 Testing the Application
	57.9 Summary
58. Android Remote Bound Services – A Worked Example
	58.1 Client to Remote Service Communication
	58.2 Creating the Example Application
	58.3 Designing the User Interface
	58.4 Implementing the Remote Bound Service
	58.5 Configuring a Remote Service in the Manifest File
	58.6 Launching and Binding to the Remote Service
	58.7 Sending a Message to the Remote Service
	58.8 Summary
59. A Basic Overview of Java Threads, Handlers and Executors
	59.1 The Application Main Thread
	59.2 Thread Handlers
	59.3 A Threading Example
	59.4 Building the App
	59.5 Creating a New Thread
	59.6 Implementing a Thread Handler
	59.7 Passing a Message to the Handler
	59.8 Java Executor Concurrency
	59.9 Working with Runnable Tasks
	59.10 Shutting down an Executor Service
	59.11 Working with Callable Tasks and Futures
	59.12 Handling a Future Result
	59.13 Scheduling Tasks
	59.14 Summary
60. Making Runtime Permission Requests in Android
	60.1 Understanding Normal and Dangerous Permissions
	60.2 Creating the Permissions Example Project
	60.3 Checking for a Permission
	60.4 Requesting Permission at Runtime
	60.5 Providing a Rationale for the Permission Request
	60.6 Testing the Permissions App
	60.7 Summary
61. An Android Notifications Tutorial
	61.1 An Overview of Notifications
	61.2 Creating the NotifyDemo Project
	61.3 Designing the User Interface
	61.4 Creating the Second Activity
	61.5 Creating a Notification Channel
	61.6 Requesting Notification Permission
	61.7 Creating and Issuing a Notification
	61.8 Launching an Activity from a Notification
	61.9 Adding Actions to a Notification
	61.10 Bundled Notifications
	61.11 Summary
62. An Android Direct Reply Notification Tutorial
	62.1 Creating the DirectReply Project
	62.2 Designing the User Interface
	62.3 Requesting Notification Permission
	62.4 Creating the Notification Channel
	62.5 Building the RemoteInput Object
	62.6 Creating the PendingIntent
	62.7 Creating the Reply Action
	62.8 Receiving Direct Reply Input
	62.9 Updating the Notification
	62.10 Summary
63.  Foldable Devices and Multi-Window Support
	63.1 Foldables and Multi-Window Support
	63.2 Using a Foldable Emulator
	63.3 Entering Multi-Window Mode
	63.4 Enabling and using Freeform Support
	63.5 Checking for Freeform Support
	63.6 Enabling Multi-Window Support in an App
	63.7 Specifying Multi-Window Attributes
	63.8 Detecting Multi-Window Mode in an Activity
	63.9 Receiving Multi-Window Notifications
	63.10 Launching an Activity in Multi-Window Mode
	63.11 Configuring Freeform Activity Size and Position
	63.12 Summary
64. An Overview of Android SQLite Databases
	64.1 Understanding Database Tables
	64.2 Introducing Database Schema
	64.3 Columns and Data Types
	64.4 Database Rows
	64.5 Introducing Primary Keys
	64.6 What is SQLite?
	64.7 Structured Query Language (SQL)
	64.8 Trying SQLite on an Android Virtual Device (AVD)
	64.9 The Android Room Persistence Library
	64.10 Summary
65. The Android Room Persistence Library
	65.1 Revisiting Modern App Architecture
	65.2 Key Elements of Room Database Persistence
		65.2.1 Repository
		65.2.2 Room Database
		65.2.3 Data Access Object (DAO)
		65.2.4 Entities
		65.2.5 SQLite Database
	65.3 Understanding Entities
	65.4 Data Access Objects
	65.5 The Room Database
	65.6 The Repository
	65.7 In-Memory Databases
	65.8 Database Inspector
	65.9 Summary
66. An Android TableLayout and TableRow Tutorial
	66.1 The TableLayout and TableRow Layout Views
	66.2 Creating the Room Database Project
	66.3 Converting to a LinearLayout
	66.4 Adding the TableLayout to the User Interface
	66.5 Configuring the TableRows
	66.6 Adding the Button Bar to the Layout
	66.7 Adding the RecyclerView
	66.8 Adjusting the Layout Margins
	66.9 Summary
67. An Android Room Database and Repository Tutorial
	67.1 About the RoomDemo Project
	67.2 Modifying the Build Configuration
	67.3 Building the Entity
	67.4 Creating the Data Access Object
	67.5 Adding the Room Database
	67.6 Adding the Repository
	67.7 Adding the ViewModel
	67.8 Creating the Product Item Layout
	67.9 Adding the RecyclerView Adapter
	67.10 Preparing the Main Activity
	67.11 Adding the Button Listeners
	67.12 Adding LiveData Observers
	67.13 Initializing the RecyclerView
	67.14 Testing the RoomDemo App
	67.15 Using the Database Inspector
	67.16 Summary
68. Accessing Cloud Storage using the Android Storage Access Framework
	68.1 The Storage Access Framework
	68.2  Working with the Storage Access Framework
	68.3 Filtering Picker File Listings
	68.4 Handling Intent Results
	68.5 Reading the Content of a File
	68.6 Writing Content to a File
	68.7 Deleting a File
	68.8 Gaining Persistent Access to a File
	68.9 Summary
69. An Android Storage Access Framework Example
	69.1 About the Storage Access Framework Example
	69.2 Creating the Storage Access Framework Example
	69.3 Designing the User Interface
	69.4 Adding the Activity Launchers
	69.5 Creating a New Storage File
	69.6 Saving to a Storage File
	69.7 Opening and Reading a Storage File
	69.8 Testing the Storage Access Application
	69.9 Summary
70. Video Playback on Android using the VideoView and MediaController Classes
	70.1 Introducing the Android VideoView Class
	70.2 Introducing the Android MediaController Class
	70.3 Creating the Video Playback Example
	70.4 Designing the VideoPlayer Layout
	70.5 Downloading the Video File
	70.6 Configuring the VideoView
	70.7 Adding the MediaController to the Video View
	70.8 Setting up the onPreparedListener
	70.9 Summary
71. Android Picture-in-Picture Mode
	71.1 Picture-in-Picture Features
	71.2 Enabling Picture-in-Picture Mode
	71.3 Configuring Picture-in-Picture Parameters
	71.4 Entering Picture-in-Picture Mode
	71.5 Detecting Picture-in-Picture Mode Changes
	71.6 Adding Picture-in-Picture Actions
	71.7 Summary
72. An Android Picture-in-Picture Tutorial
	72.1 Adding Picture-in-Picture Support to the Manifest
	72.2 Adding a Picture-in-Picture Button
	72.3 Entering Picture-in-Picture Mode
	72.4 Detecting Picture-in-Picture Mode Changes
	72.5 Adding a Broadcast Receiver
	72.6 Adding the PiP Action
	72.7 Testing the Picture-in-Picture Action
	72.8 Summary
73. Android Audio Recording and Playback using MediaPlayer and MediaRecorder
	73.1 Playing Audio
	73.2 Recording Audio and Video using the MediaRecorder Class
	73.3 About the Example Project
	73.4 Creating the AudioApp Project
	73.5 Designing the User Interface
	73.6 Checking for Microphone Availability
	73.7 Initializing the Activity
	73.8 Implementing the recordAudio() Method
	73.9 Implementing the stopAudio() Method
	73.10 Implementing the playAudio() method
	73.11 Configuring and Requesting Permissions
	73.12 Testing the Application
	73.13 Summary
74. Working with the Google Maps Android API in Android Studio
	74.1 The Elements of the Google Maps Android API
	74.2 Creating the Google Maps Project
	74.3 Creating a Google Cloud Billing Account
	74.4 Creating a New Google Cloud Project
	74.5 Enabling the Google Maps SDK
	74.6 Generating a Google Maps API Key
	74.7 Adding the API Key to the Android Studio Project
	74.8 Testing the Application
	74.9 Understanding Geocoding and Reverse Geocoding
	74.10 Adding a Map to an Application
	74.11 Requesting Current Location Permission
	74.12 Displaying the User’s Current Location
	74.13 Changing the Map Type
	74.14 Displaying Map Controls to the User
	74.15 Handling Map Gesture Interaction
		74.15.1 Map Zooming Gestures
		74.15.2 Map Scrolling/Panning Gestures
		74.15.3 Map Tilt Gestures
		74.15.4 Map Rotation Gestures
	74.16 Creating Map Markers
	74.17 Controlling the Map Camera
	74.18 Summary
75. Printing with the Android Printing Framework
	75.1 The Android Printing Architecture
	75.2 The Print Service Plugins
	75.3 Google Cloud Print
	75.4 Printing to Google Drive
	75.5 Save as PDF
	75.6 Printing from Android Devices
	75.7 Options for Building Print Support into Android Apps
		75.7.1 Image Printing
		75.7.2 Creating and Printing HTML Content
		75.7.3 Printing a Web Page
		75.7.4 Printing a Custom Document
	75.8 Summary
76. An Android HTML and Web Content Printing Example
	76.1 Creating the HTML Printing Example Application
	76.2 Printing Dynamic HTML Content
	76.3 Creating the Web Page Printing Example
	76.4 Removing the Floating Action Button
	76.5 Removing Navigation Features
	76.6 Designing the User Interface Layout
	76.7 Accessing the WebView from the Main Activity
	76.8 Loading the Web Page into the WebView
	76.9 Adding the Print Menu Option
	76.10 Summary
77. A Guide to Android Custom Document Printing
	77.1 An Overview of Android Custom Document Printing
		77.1.1 Custom Print Adapters
	77.2 Preparing the Custom Document Printing Project
	77.3 Creating the Custom Print Adapter
	77.4 Implementing the onLayout() Callback Method
	77.5 Implementing the onWrite() Callback Method
	77.6 Checking a Page is in Range
	77.7 Drawing the Content on the Page Canvas
	77.8 Starting the Print Job
	77.9 Testing the Application
	77.10 Summary
78. An Introduction to Android App Links
	78.1 An Overview of Android App Links
	78.2 App Link Intent Filters
	78.3 Handling App Link Intents
	78.4 Associating the App with a Website
	78.5 Summary
79. An Android Studio App Links Tutorial
	79.1 About the Example App
	79.2 The Database Schema
	79.3 Loading and Running the Project
	79.4 Adding the URL Mapping
	79.5 Adding the Intent Filter
	79.6 Adding Intent Handling Code
	79.7 Testing the App
	79.8 Creating the Digital Asset Links File
	79.9 Testing the App Link
	79.10 Summary
80. An Android Biometric Authentication Tutorial
	80.1 An Overview of Biometric Authentication
	80.2 Creating the Biometric Authentication Project
	80.3 Configuring Device Fingerprint Authentication
	80.4 Adding the Biometric Permission to the Manifest File
	80.5 Designing the User Interface
	80.6 Adding a Toast Convenience Method
	80.7 Checking the Security Settings
	80.8 Configuring the Authentication Callbacks
	80.9 Adding the CancellationSignal
	80.10 Starting the Biometric Prompt
	80.11 Testing the Project
	80.12 Summary
81. Creating, Testing and Uploading an Android App Bundle
	81.1 The Release Preparation Process
	81.2 Android App Bundles
	81.3 Register for a Google Play Developer Console Account
	81.4 Configuring the App in the Console
	81.5 Enabling Google Play App Signing
	81.6 Creating a Keystore File
	81.7 Creating the Android App Bundle
	81.8 Generating Test APK Files
	81.9 Uploading the App Bundle to the Google Play Developer Console
	81.10 Exploring the App Bundle
	81.11 Managing Testers
	81.12 Rolling the App Out for Testing
	81.13 Uploading New App Bundle Revisions
	81.14 Analyzing the App Bundle File
	81.15 Summary
82. An Overview of Android In-App Billing
	82.1 Preparing a Project for In-App Purchasing
	82.2 Creating In-App Products and Subscriptions
	82.3 Billing Client Initialization
	82.4 Connecting to the Google Play Billing Library
	82.5 Querying Available Products
	82.6 Starting the Purchase Process
	82.7 Completing the Purchase
	82.8 Querying Previous Purchases
	82.9 Summary
83. An Android In-App Purchasing Tutorial
	83.1 About the In-App Purchasing Example Project
	83.2 Creating the InAppPurchase Project
	83.3 Adding Libraries to the Project
	83.4 Designing the User Interface
	83.5 Adding the App to the Google Play Store
	83.6 Creating an In-App Product
	83.7 Enabling License Testers
	83.8 Initializing the Billing Client
	83.9 Querying the Product
	83.10 Launching the Purchase Flow
	83.11 Handling Purchase Updates
	83.12 Consuming the Product
	83.13 Restoring a Previous Purchase
	83.14 Testing the App
	83.15 Troubleshooting
	83.16 Summary
84. An Overview of Android Dynamic Feature Modules
	84.1 An Overview of Dynamic Feature Modules
	84.2 Dynamic Feature Module Architecture
	84.3 Creating a Dynamic Feature Module
	84.4 Converting an Existing Module for Dynamic Delivery
	84.5 Working with Dynamic Feature Modules
	84.6 Handling Large Dynamic Feature Modules
	84.7 Summary
85. An Android Studio Dynamic Feature Tutorial
	85.1 Creating the DynamicFeature Project
	85.2 Adding Dynamic Feature Support to the Project
	85.3 Designing the Base Activity User Interface
	85.4 Adding the Dynamic Feature Module
	85.5 Reviewing the Dynamic Feature Module
	85.6 Adding the Dynamic Feature Activity
	85.7 Implementing the launchIntent() Method
	85.8 Uploading the App Bundle for Testing
	85.9 Implementing the installFeature() Method
	85.10 Adding the Update Listener
	85.11 Using Deferred Installation
	85.12 Removing a Dynamic Module
	85.13 Summary
86. Working with Material Design 3 Theming
	86.1 Material Design 2 vs Material Design 3
	86.2 Understanding Material Design Theming
	86.3 Material Design 3 Theming
	86.4 Building a Custom Theme
	86.5 Summary
87. A Material Design 3 Theming and Dynamic Color Tutorial
	87.1 Creating the ThemeDemo Project
	87.2 Designing the User Interface
	87.3 Building a New Theme
	87.4 Adding the Theme to the Project
	87.5 Enabling Dynamic Color Support
	87.6 Previewing Dynamic Colors
	87.7 Summary
88. An Overview of Gradle in Android Studio
	88.1 An Overview of Gradle
	88.2 Gradle and Android Studio
		88.2.1 Sensible Defaults
		88.2.2 Dependencies
		88.2.3 Build Variants
		88.2.4 Manifest Entries
		88.2.5 APK Signing
		88.2.6 ProGuard Support
	88.3 The Property and Settings Gradle Build File
	88.4 The Top-level Gradle Build File
	88.5 Module Level Gradle Build Files
	88.6 Configuring Signing Settings in the Build File
	88.7 Running Gradle Tasks from the Command-line
	88.8 Summary
Index