Android Studio Giraffe Essentials - Kotlin Edition: Developing Android Apps Using Android Studio 2022.3.1 and Kotlin

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 Enabling the New Android Studio UI
3.6 Modifying the Example Application
3.7 Modifying the User Interface
3.8 Reviewing the Layout and Resource Files
3.9 Adding Interaction
3.10 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 Menu Bar
6.3 The Main Window
6.4 The Tool Windows
6.5 The Tool Window Menus
6.6 Android Studio Keyboard Shortcuts
6.7 Switcher and Recent Files Navigation
6.8 Changing the Android Studio Theme
6.9 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 App
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 Control Flow
14.1 Looping Control flow
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 Control Flow
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
18.2 View Binding
18.3 Converting the AndroidSample project
18.4 Enabling View Binding
18.5 Using View Binding
18.6 Choosing an Option
18.7 View Binding in the Book Examples
18.8 Migrating a Project to View Binding
18.9 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 Views 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 Night Mode
24.7 Code Mode
24.8 Split Mode
24.9 Setting Attributes
24.10 Transforms
24.11 Tools Visibility Toggles
24.12 Converting Views
24.13 Displaying Sample Data
24.14 Creating a Custom Device Definition
24.15 Changing the Current Device
24.16 Layout Validation
24.17 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 Configuring Widget Dimensions
25.4 Guideline Helper
25.5 Group Helper
25.6 Barrier Helper
25.7 Flow Helper
25.8 Ratios
25.9 ConstraintLayout Advantages
25.10 ConstraintLayout Availability
25.11 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 Design Time Tools Positioning
26.13 Adding Guidelines
26.14 Adding Barriers
26.15 Adding a Group
26.16 Working with the Flow Helper
26.17 Widget Group Alignment and Distribution
26.18 Converting other Layouts to ConstraintLayout
26.19 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 Preparing the Layout Editor Environment
28.3 Adding the Widgets to the User Interface
28.4 Adding the Constraints
28.5 Testing the Layout
28.6 Using the Layout Inspector
28.7 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 Migrating a Fragment to View Binding
38.5 Adding the Second Fragment
38.6 Adding the Fragments to the Activity
38.7 Making the Toolbar Fragment Talk to the Activity
38.8 Making the Activity Talk to the Text Fragment
38.9 Testing the Application
38.10 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 ViewModel Tutorial
40.1 About the Project
40.2 Creating the ViewModel Example Project
40.3 Removing Unwanted Project Elements
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 Adding View Binding Support to the Destination Fragments
48.10 Triggering the Action
48.11 Passing Data Using Safeargs
48.12 Summary
49. An Introduction to MotionLayout
49.1 An Overview of MotionLayout
49.2 MotionLayout
49.3 MotionScene
49.4 Configuring ConstraintSets
49.5 Custom Attributes
49.6 Triggering an Animation
49.7 Arc Motion
49.8 Keyframes
49.8.1 Attribute Keyframes
49.8.2 Position Keyframes
49.9 Time Linearity
49.10 KeyTrigger
49.11 Cycle and Time Cycle Keyframes
49.12 Starting an Animation from Code
49.13 Summary
50. An Android MotionLayout Editor Tutorial
50.1 Creating the MotionLayoutDemo Project
50.2 ConstraintLayout to MotionLayout Conversion
50.3 Configuring Start and End Constraints
50.4 Previewing the MotionLayout Animation
50.5 Adding an OnClick Gesture
50.6 Adding an Attribute Keyframe to the Transition
50.7 Adding a CustomAttribute to a Transition
50.8 Adding Position Keyframes
50.9 Summary
51. A MotionLayout KeyCycle Tutorial
51.1 An Overview of Cycle Keyframes
51.2 Using the Cycle Editor
51.3 Creating the KeyCycleDemo Project
51.4 Configuring the Start and End Constraints
51.5 Creating the Cycles
51.6 Previewing the Animation
51.7 Adding the KeyFrameSet to the MotionScene
51.8 Summary
52. Working with the Floating Action Button and Snackbar
52.1 The Material Design
52.2 The Design Library
52.3 The Floating Action Button (FAB)
52.4 The Snackbar
52.5 Creating the Example Project
52.6 Reviewing the Project
52.7 Removing Navigation Features
52.8 Changing the Floating Action Button
52.9 Adding an Action to the Snackbar
52.10 Summary
53. Creating a Tabbed Interface using the TabLayout Component
53.1 An Introduction to the ViewPager2
53.2 An Overview of the TabLayout Component
53.3 Creating the TabLayoutDemo Project
53.4 Creating the First Fragment
53.5 Duplicating the Fragments
53.6 Adding the TabLayout and ViewPager2
53.7 Performing the Initialization Tasks
53.8 Testing the Application
53.9 Customizing the TabLayout
53.10 Summary
54. Working with the RecyclerView and CardView Widgets
54.1 An Overview of the RecyclerView
54.2 An Overview of the CardView
54.3 Summary
55. An Android RecyclerView and CardView Tutorial
55.1 Creating the CardDemo Project
55.2 Modifying the Basic Views Activity Project
55.3 Designing the CardView Layout
55.4 Adding the RecyclerView
55.5 Adding the Image Files
55.6 Creating the RecyclerView Adapter
55.7 Initializing the RecyclerView Component
55.8 Testing the Application
55.9 Responding to Card Selections
55.10 Summary
56. Working with the AppBar and Collapsing Toolbar Layouts
56.1 The Anatomy of an AppBar
56.2 The Example Project
56.3 Coordinating the RecyclerView and Toolbar
56.4 Introducing the Collapsing Toolbar Layout
56.5 Changing the Title and Scrim Color
56.6 Summary
57. An Overview of Android Intents
57.1 An Overview of Intents
57.2 Explicit Intents
57.3 Returning Data from an Activity
57.4 Implicit Intents
57.5 Using Intent Filters
57.6 Automatic Link Verification
57.7 Manually Enabling Links
57.8 Checking Intent Availability
57.9 Summary
58. Android Explicit Intents – A Worked Example
58.1 Creating the Explicit Intent Example Application
58.2 Designing the User Interface Layout for MainActivity
58.3 Creating the Second Activity Class
58.4 Designing the User Interface Layout for SecondActivity
58.5 Reviewing the Application Manifest File
58.6 Creating the Intent
58.7 Extracting Intent Data
58.8 Launching SecondActivity as a Sub-Activity
58.9 Returning Data from a Sub-Activity
58.10 Testing the Application
58.11 Summary
59. Android Implicit Intents – A Worked Example
59.1 Creating the Android Studio Implicit Intent Example Project
59.2 Designing the User Interface
59.3 Creating the Implicit Intent
59.4 Adding a Second Matching Activity
59.5 Adding the Web View to the UI
59.6 Obtaining the Intent URL
59.7 Modifying the MyWebView Project Manifest File
59.8 Installing the MyWebView Package on a Device
59.9 Testing the Application
59.10 Manually Enabling the Link
59.11 Automatic Link Verification
59.12 Summary
60. Android Broadcast Intents and Broadcast Receivers
60.1 An Overview of Broadcast Intents
60.2 An Overview of Broadcast Receivers
60.3 Obtaining Results from a Broadcast
60.4 Sticky Broadcast Intents
60.5 The Broadcast Intent Example
60.6 Creating the Example Application
60.7 Creating and Sending the Broadcast Intent
60.8 Creating the Broadcast Receiver
60.9 Registering the Broadcast Receiver
60.10 Testing the Broadcast Example
60.11 Listening for System Broadcasts
60.12 Summary
61. An Introduction to Kotlin Coroutines
61.1 What are Coroutines?
61.2 Threads vs. Coroutines
61.3 Coroutine Scope
61.4 Suspend Functions
61.5 Coroutine Dispatchers
61.6 Coroutine Builders
61.7 Jobs
61.8 Coroutines – Suspending and Resuming
61.9 Returning Results from a Coroutine
61.10 Using withContext
61.11 Coroutine Channel Communication
61.12 Summary
62. An Android Kotlin Coroutines Tutorial
62.1 Creating the Coroutine Example Application
62.2 Adding Coroutine Support to the Project
62.3 Designing the User Interface
62.4 Implementing the SeekBar
62.5 Adding the Suspend Function
62.6 Implementing the launchCoroutines Method
62.7 Testing the App
62.8 Summary
63. An Overview of Android Services
63.1 Intent Service
63.2 Bound Service
63.3 The Anatomy of a Service
63.4 Controlling Destroyed Service Restart Options
63.5 Declaring a Service in the Manifest File
63.6 Starting a Service Running on System Startup
63.7 Summary
64. Android Local Bound Services – A Worked Example
64.1 Understanding Bound Services
64.2 Bound Service Interaction Options
64.3 A Local Bound Service Example
64.4 Adding a Bound Service to the Project
64.5 Implementing the Binder
64.6 Binding the Client to the Service
64.7 Completing the Example
64.8 Testing the Application
64.9 Summary
65. Android Remote Bound Services – A Worked Example
65.1 Client to Remote Service Communication
65.2 Creating the Example Application
65.3 Designing the User Interface
65.4 Implementing the Remote Bound Service
65.5 Configuring a Remote Service in the Manifest File
65.6 Launching and Binding to the Remote Service
65.7 Sending a Message to the Remote Service
65.8 Summary
66. An Introduction to Kotlin Flow
66.1 Understanding Flows
66.2 Creating the Sample Project
66.3 Adding the Kotlin Lifecycle Library
66.4 Declaring a Flow
66.5 Emitting Flow Data
66.6 Collecting Flow Data
66.7 Adding a Flow Buffer
66.8 Transforming Data with Intermediaries
66.9 Terminal Flow Operators
66.10 Flow Flattening
66.11 Combining Multiple Flows
66.12 Hot and Cold Flows
66.13 StateFlow
66.14 SharedFlow
66.15 Summary
67. An Android SharedFlow Tutorial
67.1 About the Project
67.2 Creating the SharedFlowDemo Project
67.3 Designing the User Interface Layout
67.4 Adding the List Row Layout
67.5 Adding the RecyclerView Adapter
67.6 Adding the ViewModel
67.7 Configuring the ViewModelProvider
67.8 Collecting the Flow Values
67.9 Testing the SharedFlowDemo App
67.10 Handling Flows in the Background
67.11 Summary
68. An Overview of Android SQLite Databases
68.1 Understanding Database Tables
68.2 Introducing Database Schema
68.3 Columns and Data Types
68.4 Database Rows
68.5 Introducing Primary Keys
68.6 What is SQLite?
68.7 Structured Query Language (SQL)
68.8 Trying SQLite on an Android Virtual Device (AVD)
68.9 The Android Room Persistence Library
68.10 Summary
69. The Android Room Persistence Library
69.1 Revisiting Modern App Architecture
69.2 Key Elements of Room Database Persistence
69.2.1 Repository
69.2.2 Room Database
69.2.3 Data Access Object (DAO)
69.2.4 Entities
69.2.5 SQLite Database
69.3 Understanding Entities
69.4 Data Access Objects
69.5 The Room Database
69.6 The Repository
69.7 In-Memory Databases
69.8 Database Inspector
69.9 Summary
70. An Android TableLayout and TableRow Tutorial
70.1 The TableLayout and TableRow Layout Views
70.2 Creating the Room Database Project
70.3 Converting to a LinearLayout
70.4 Adding the TableLayout to the User Interface
70.5 Configuring the TableRows
70.6 Adding the Button Bar to the Layout
70.7 Adding the RecyclerView
70.8 Adjusting the Layout Margins
70.9 Summary
71. An Android Room Database and Repository Tutorial
71.1 About the RoomDemo Project
71.2 Modifying the Build Configuration
71.3 Building the Entity
71.4 Creating the Data Access Object
71.5 Adding the Room Database
71.6 Adding the Repository
71.7 Adding the ViewModel
71.8 Creating the Product Item Layout
71.9 Adding the RecyclerView Adapter
71.10 Preparing the Main Activity
71.11 Adding the Button Listeners
71.12 Adding LiveData Observers
71.13 Initializing the RecyclerView
71.14 Testing the RoomDemo App
71.15 Using the Database Inspector
71.16 Summary
72. Video Playback on Android using the VideoView and MediaController Classes
72.1 Introducing the Android VideoView Class
72.2 Introducing the Android MediaController Class
72.3 Creating the Video Playback Example
72.4 Designing the VideoPlayer Layout
72.5 Downloading the Video File
72.6 Configuring the VideoView
72.7 Adding the MediaController to the Video View
72.8 Setting up the onPreparedListener
72.9 Summary
73. Android Picture-in-Picture Mode
73.1 Picture-in-Picture Features
73.2 Enabling Picture-in-Picture Mode
73.3 Configuring Picture-in-Picture Parameters
73.4 Entering Picture-in-Picture Mode
73.5 Detecting Picture-in-Picture Mode Changes
73.6 Adding Picture-in-Picture Actions
73.7 Summary
74. An Android Picture-in-Picture Tutorial
74.1 Adding Picture-in-Picture Support to the Manifest
74.2 Adding a Picture-in-Picture Button
74.3 Entering Picture-in-Picture Mode
74.4 Detecting Picture-in-Picture Mode Changes
74.5 Adding a Broadcast Receiver
74.6 Adding the PiP Action
74.7 Testing the Picture-in-Picture Action
74.8 Summary
75. Making Runtime Permission Requests in Android
75.1 Understanding Normal and Dangerous Permissions
75.2 Creating the Permissions Example Project
75.3 Checking for a Permission
75.4 Requesting Permission at Runtime
75.5 Providing a Rationale for the Permission Request
75.6 Testing the Permissions App
75.7 Summary
76. Android Audio Recording and Playback using MediaPlayer and MediaRecorder
76.1 Playing Audio
76.2 Recording Audio and Video using the MediaRecorder Class
76.3 About the Example Project
76.4 Creating the AudioApp Project
76.5 Designing the User Interface
76.6 Checking for Microphone Availability
76.7 Initializing the Activity
76.8 Implementing the recordAudio() Method
76.9 Implementing the stopAudio() Method
76.10 Implementing the playAudio() method
76.11 Configuring and Requesting Permissions
76.12 Testing the Application
76.13 Summary
77. An Android Notifications Tutorial
77.1 An Overview of Notifications
77.2 Creating the NotifyDemo Project
77.3 Designing the User Interface
77.4 Creating the Second Activity
77.5 Creating a Notification Channel
77.6 Requesting Notification Permission
77.7 Creating and Issuing a Notification
77.8 Launching an Activity from a Notification
77.9 Adding Actions to a Notification
77.10 Bundled Notifications
77.11 Summary
78. An Android Direct Reply Notification Tutorial
78.1 Creating the DirectReply Project
78.2 Designing the User Interface
78.3 Requesting Notification Permission
78.4 Creating the Notification Channel
78.5 Building the RemoteInput Object
78.6 Creating the PendingIntent
78.7 Creating the Reply Action
78.8 Receiving Direct Reply Input
78.9 Updating the Notification
78.10 Summary
79. Working with the Google Maps Android API in Android Studio
79.1 The Elements of the Google Maps Android API
79.2 Creating the Google Maps Project
79.3 Creating a Google Cloud Billing Account
79.4 Creating a New Google Cloud Project
79.5 Enabling the Google Maps SDK
79.6 Generating a Google Maps API Key
79.7 Adding the API Key to the Android Studio Project
79.8 Testing the Application
79.9 Understanding Geocoding and Reverse Geocoding
79.10 Adding a Map to an Application
79.11 Requesting Current Location Permission
79.12 Displaying the User’s Current Location
79.13 Changing the Map Type
79.14 Displaying Map Controls to the User
79.15 Handling Map Gesture Interaction
79.15.1 Map Zooming Gestures
79.15.2 Map Scrolling/Panning Gestures
79.15.3 Map Tilt Gestures
79.15.4 Map Rotation Gestures
79.16 Creating Map Markers
79.17 Controlling the Map Camera
79.18 Summary
80. Printing with the Android Printing Framework
80.1 The Android Printing Architecture
80.2 The Print Service Plugins
80.3 Google Cloud Print
80.4 Printing to Google Drive
80.5 Save as PDF
80.6 Printing from Android Devices
80.7 Options for Building Print Support into Android Apps
80.7.1 Image Printing
80.7.2 Creating and Printing HTML Content
80.7.3 Printing a Web Page
80.7.4 Printing a Custom Document
80.8 Summary
81. An Android HTML and Web Content Printing Example
81.1 Creating the HTML Printing Example Application
81.2 Printing Dynamic HTML Content
81.3 Creating the Web Page Printing Example
81.4 Removing the Floating Action Button
81.5 Removing Navigation Features
81.6 Designing the User Interface Layout
81.7 Accessing the WebView from the Main Activity
81.8 Loading the Web Page into the WebView
81.9 Adding the Print Menu Option
81.10 Summary
82. A Guide to Android Custom Document Printing
82.1 An Overview of Android Custom Document Printing
82.1.1 Custom Print Adapters
82.2 Preparing the Custom Document Printing Project
82.3 Creating the Custom Print Adapter
82.4 Implementing the onLayout() Callback Method
82.5 Implementing the onWrite() Callback Method
82.6 Checking a Page is in Range
82.7 Drawing the Content on the Page Canvas
82.8 Starting the Print Job
82.9 Testing the Application
82.10 Summary
83. An Introduction to Android App Links
83.1 An Overview of Android App Links
83.2 App Link Intent Filters
83.3 Handling App Link Intents
83.4 Associating the App with a Website
83.5 Summary
84. An Android Studio App Links Tutorial
84.1 About the Example App
84.2 The Database Schema
84.3 Loading and Running the Project
84.4 Adding the URL Mapping
84.5 Adding the Intent Filter
84.6 Adding Intent Handling Code
84.7 Testing the App
84.8 Creating the Digital Asset Links File
84.9 Testing the App Link
84.10 Summary
85. An Android Biometric Authentication Tutorial
85.1 An Overview of Biometric Authentication
85.2 Creating the Biometric Authentication Project
85.3 Configuring Device Fingerprint Authentication
85.4 Adding the Biometric Permission to the Manifest File
85.5 Designing the User Interface
85.6 Adding a Toast Convenience Method
85.7 Checking the Security Settings
85.8 Configuring the Authentication Callbacks
85.9 Adding the CancellationSignal
85.10 Starting the Biometric Prompt
85.11 Testing the Project
85.12 Summary
86. Creating, Testing, and Uploading an Android App Bundle
86.1 The Release Preparation Process
86.2 Android App Bundles
86.3 Register for a Google Play Developer Console Account
86.4 Configuring the App in the Console
86.5 Enabling Google Play App Signing
86.6 Creating a Keystore File
86.7 Creating the Android App Bundle
86.8 Generating Test APK Files
86.9 Uploading the App Bundle to the Google Play Developer Console
86.10 Exploring the App Bundle
86.11 Managing Testers
86.12 Rolling the App Out for Testing
86.13 Uploading New App Bundle Revisions
86.14 Analyzing the App Bundle File
86.15 Summary
87. An Overview of Android In-App Billing
87.1 Preparing a Project for In-App Purchasing
87.2 Creating In-App Products and Subscriptions
87.3 Billing Client Initialization
87.4 Connecting to the Google Play Billing Library
87.5 Querying Available Products
87.6 Starting the Purchase Process
87.7 Completing the Purchase
87.8 Querying Previous Purchases
87.9 Summary
88. An Android In-App Purchasing Tutorial
88.1 About the In-App Purchasing Example Project
88.2 Creating the InAppPurchase Project
88.3 Adding Libraries to the Project
88.4 Designing the User Interface
88.5 Adding the App to the Google Play Store
88.6 Creating an In-App Product
88.7 Enabling License Testers
88.8 Initializing the Billing Client
88.9 Querying the Product
88.10 Launching the Purchase Flow
88.11 Handling Purchase Updates
88.12 Consuming the Product
88.13 Restoring a Previous Purchase
88.14 Testing the App
88.15 Troubleshooting
88.16 Summary
89. Working with Material Design 3 Theming
89.1 Material Design 2 vs. Material Design 3
89.2 Understanding Material Design Theming
89.3 Material Design 3 Theming
89.4 Building a Custom Theme
89.5 Summary
90. A Material Design 3 Theming and Dynamic Color Tutorial
90.1 Creating the ThemeDemo Project
90.2 Designing the User Interface
90.3 Building a New Theme
90.4 Adding the Theme to the Project
90.5 Enabling Dynamic Color Support
90.6 Previewing Dynamic Colors
90.7 Summary
91. An Overview of Gradle in Android Studio
91.1 An Overview of Gradle
91.2 Gradle and Android Studio
91.2.1 Sensible Defaults
91.2.2 Dependencies
91.2.3 Build Variants
91.2.4 Manifest Entries
91.2.5 APK Signing
91.2.6 ProGuard Support
91.3 The Property and Settings Gradle Build File
91.4 The Top-level Gradle Build File
91.5 Module Level Gradle Build Files
91.6 Configuring Signing Settings in the Build File
91.7 Running Gradle Tasks from the Command Line
91.8 Summary
Index