Android Studio 4.0 Development Essentials - Kotlin Edition: Developing Android Apps Using Android Studio 4.0, Kotlin and Android Jetpack

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 Making the Android SDK Tools Command-line Accessible
		2.6.1 Windows 7
		2.6.2 Windows 8.1
		2.6.3 Windows 10
		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 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.5.1 Location
		5.5.2 Displays
		5.5.3 Cellular
		5.5.4 Camera
		5.5.5 Battery
		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 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.2.1 macOS ADB Configuration
		7.2.2 Windows ADB Configuration
		7.2.3 Linux adb Configuration
	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.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 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.1.1 Integer Data Types
		12.1.2  Floating Point Data Types
		12.1.3 Boolean Data Type
		12.1.4 Character Data Type
		12.1.5 String Data Type
		12.1.6 Escape Sequences
	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.9.1 Bitwise Inversion
		13.9.2 Bitwise AND
		13.9.3 Bitwise OR
		13.9.4 Bitwise XOR
		13.9.5 Bitwise Left Shift
		13.9.6 Bitwise Right Shift
	13.10 Summary
14. Kotlin Flow Control
	14.1 Looping Flow Control
		14.1.1 The Kotlin for-in Statement
		14.1.2 The while Loop
		14.1.3 The do ... while loop
		14.1.4 Breaking from Loops
		14.1.5 The continue Statement
		14.1.6 Break and Continue Labels
	14.2 Conditional Flow Control
		14.2.1 Using the if Expressions
		14.2.2 Using if ... else … Expressions
		14.2.3 Using if ... else if ... Expressions
		14.2.4 Using the when Statement
	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.2.1 Foreground Process
		19.2.2 Visible Process
		19.2.3 Service Process
		19.2.4 Background Process
		19.2.5 Empty Process
	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.1.1 Constraints
		25.1.2 Margins
		25.1.3 Opposing Constraints
		25.1.4 Constraint Bias
		25.1.5 Chains
		25.1.6 Chain Styles
	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.4.1 Establishing Connections
		30.4.2 Applying Constraints to a Layout
		30.4.3 Parent Constraint Connections
		30.4.4 Sizing Constraints
		30.4.5 Constraint Bias
		30.4.6 Alignment Constraints
		30.4.7 Copying and Applying Constraint Sets
		30.4.8 ConstraintLayout Chains
		30.4.9 Guidelines
		30.4.10 Removing Constraints
		30.4.11 Scaling
		30.4.12 Rotation
	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.3.1 The Main Activity
		40.3.2 The Content Fragment
		40.3.3 The ViewModel
	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.2.1 The Project Build Configuration
		42.2.2 The Data Binding Layout File
		42.2.3 The Layout File Data Element
		42.2.4  The Binding Classes
		42.2.5 Data Binding Variable Configuration
		42.2.6 Binding Expressions (One-Way)
		42.2.7 Binding Expressions (Two-Way)
		42.2.8 Event and Listener Bindings
	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.8.1 Attribute Keyframes
		50.8.2 Position 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.2.1 Repository
		75.2.2 Room Database
		75.2.3 Data Access Object (DAO)
		75.2.4 Entities
		75.2.5 SQLite Database
	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.12.1 Map Zooming Gestures
		85.12.2 Map Scrolling/Panning Gestures
		85.12.3 Map Tilt Gestures
		85.12.4 Map Rotation Gestures
	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.7.1 Image Printing
		86.7.2 Creating and Printing HTML Content
		86.7.3 Printing a Web Page
		86.7.4 Printing a Custom Document
	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.1.1 Custom Print Adapters
	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.2.1 Sensible Defaults
		96.2.2 Dependencies
		96.2.3 Build Variants
		96.2.4 Manifest Entries
		96.2.5 APK Signing
		96.2.6 ProGuard Support
	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
_GoBack
_Ref381951250
_Ref381951280
_Ref381877478
_Ref382489559
_Ref382490730
_GoBack
_GoBack
_Ref384718331
_Ref324774345