1. Introduction

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

2. Setting up an Android Studio Development Environment FREE CHAPTER

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

3. Creating an Example Android App in Android Studio

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

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

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

5. Using and Configuring the Android Studio AVD Emulator

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

6. A Tour of the Android Studio User Interface

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

7. Testing Android Studio Apps on a Physical Android Device

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

8. The Basics of the Android Studio Code Editor

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

9. An Overview of the Android Architecture

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

10. The Anatomy of an Android Application

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

11. An 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.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 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 (Multi Preview)
• 17.17 Summary

18. A Guide to the Android ConstraintLayout

• 18.1 How ConstraintLayout Works
• 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 Creating a New Activity
• 21.3 Preparing the Layout Editor Environment
• 21.4 Adding the Widgets to the User Interface
• 21.5 Adding the Constraints
• 21.6 Testing the Layout
• 21.7 Using the Layout Inspector
• 21.8 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.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 Jetpack ViewModel Tutorial

• 33.1 About the Project
• 33.2 Creating the ViewModel Example Project
• 33.3 Reviewing the Project
• 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.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.9 Time Linearity
• 42.10 KeyTrigger
• 42.11 Cycle and Time Cycle Keyframes
• 42.12 Starting an Animation from Code

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 Class
• 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 Creating the Fragment State Adapter
• 46.8 Performing the Initialization Tasks
• 46.9 Testing the Application
• 46.10 Customizing the TabLayout
• 46.11 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 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 Modifying the Primary/Detail Flow Template
• 51.4 Changing the Content Model
• 51.5 Changing the Detail Pane
• 51.6 Modifying the WebsiteDetailFragment Class
• 51.7 Modifying the WebsiteListFragment Class
• 51.8 Adding Manifest Permissions
• 51.9 Running the Application
• 51.10 Summary

52. An Overview of Android Intents

• 52.1 An Overview of Intents
• 52.2 Explicit Intents
• 52.3 Returning Data from an Activity
• 52.4 Implicit Intents
• 52.5 Using Intent Filters
• 52.6 Checking Intent Availability
• 52.7 Summary

53. Android Explicit Intents – A Worked Example

• 53.1 Creating the Explicit Intent Example Application
• 53.2 Designing the User Interface Layout for MainActivity
• 53.3 Creating the Second Activity Class
• 53.4 Designing the User Interface Layout for SecondActivity
• 53.5 Reviewing the Application Manifest File
• 53.6 Creating the Intent
• 53.7 Extracting Intent Data
• 53.8 Launching SecondActivity as a Sub-Activity
• 53.9 Returning Data from a Sub-Activity
• 53.10 Testing the Application
• 53.11 Summary

54. Android Implicit Intents – A Worked Example

• 54.1 Creating the Android Studio Implicit Intent Example Project
• 54.2 Designing the User Interface
• 54.3 Creating the Implicit Intent
• 54.4 Adding a Second Matching Activity
• 54.5 Adding the Web View to the UI
• 54.6 Obtaining the Intent URL
• 54.7 Modifying the MyWebView Project Manifest File
• 54.8 Installing the MyWebView Package on a Device
• 54.9 Testing the Application
• 54.10 Summary

55. Android Broadcast Intents and Broadcast Receivers

• 55.1 An Overview of Broadcast Intents
• 55.2 An Overview of Broadcast Receivers
• 55.3 Obtaining Results from a Broadcast
• 55.4 Sticky Broadcast Intents
• 55.5 The Broadcast Intent Example
• 55.6 Creating the Example Application
• 55.7 Creating and Sending the Broadcast Intent
• 55.8 Creating the Broadcast Receiver
• 55.9 Registering the Broadcast Receiver
• 55.10 Testing the Broadcast Example
• 55.11 Listening for System Broadcasts
• 55.12 Summary

56. A Basic Overview of Java Threads, Handlers and Executors

• 56.1 An Overview of Threads
• 56.2 The Application Main Thread
• 56.3 Thread Handlers
• 56.4 A Threading Example
• 56.5 Building the App
• 56.6 Creating a New Thread
• 56.7 Implementing a Thread Handler
• 56.8 Passing a Message to the Handler
• 56.9 Java Executor Concurrency
• 56.10 Working with Runnable Tasks
• 56.11 Shutting down an Executor Service
• 56.12 Working with Callable Tasks and Futures
• 56.13 Handling a Future Result
• 56.14 Scheduling Tasks
• 56.15 Summary

57. An Overview of Android Services

• 57.1 Started Services
• 57.2 Intent Service
• 57.3 Bound Service
• 57.4 The Anatomy of a Service
• 57.5 Controlling Destroyed Service Restart Options
• 57.6 Declaring a Service in the Manifest File
• 57.7 Starting a Service Running on System Startup
• 57.8 Summary

58. Implementing an Android Started Service – A Worked Example

• 58.1 Creating the Example Project
• 58.2 Designing the User Interface
• 58.3 Creating the Service Class
• 58.4 Adding the Service to the Manifest File
• 58.5 Starting the Service
• 58.6 Testing the IntentService Example
• 58.7 Using the Service Class
• 58.8 Creating the New Service
• 58.9 Launching the Service
• 58.10 Running the Application
• 58.11 Adding Threading to the Service
• 58.12 Summary

59. Android Local Bound Services – A Worked Example

• 59.1 Understanding Bound Services
• 59.2 Bound Service Interaction Options
• 59.3 A Local Bound Service Example
• 59.4 Adding a Bound Service to the Project
• 59.5 Implementing the Binder
• 59.6 Binding the Client to the Service
• 59.7 Completing the Example
• 59.8 Testing the Application
• 59.9 Summary

60. Android Remote Bound Services – A Worked Example

• 60.1 Client to Remote Service Communication
• 60.2 Creating the Example Application
• 60.3 Designing the User Interface
• 60.4 Implementing the Remote Bound Service
• 60.5 Configuring a Remote Service in the Manifest File
• 60.6 Launching and Binding to the Remote Service
• 60.7 Sending a Message to the Remote Service
• 60.8 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 Creating and Issuing a Notification
• 61.7 Launching an Activity from a Notification
• 61.8 Adding Actions to a Notification
• 61.9 Bundled Notifications
• 61.10 Summary

62. An Android Direct Reply Notification Tutorial

• 62.1 Creating the DirectReply Project
• 62.2 Designing the User Interface
• 62.3 Creating the Notification Channel
• 62.4 Building the RemoteInput Object
• 62.5 Creating the PendingIntent
• 62.6 Creating the Reply Action
• 62.7 Receiving Direct Reply Input
• 62.8 Updating the Notification
• 62.9 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.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 Modifying the ViewModel
• 67.8 Creating the Product Item Layout
• 67.9 Adding the RecyclerView Adapter
• 67.10 Preparing the Main Fragment
• 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 Declaring Request Codes
• 69.5 Creating a New Storage File
• 69.6 The onActivityResult() Method
• 69.7 Saving to a Storage File
• 69.8 Opening and Reading a Storage File
• 69.9 Testing the Storage Access Application
• 69.10 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. Making Runtime Permission Requests in Android

• 73.1 Understanding Normal and Dangerous Permissions
• 73.2 Creating the Permissions Example Project
• 73.3 Checking for a Permission
• 73.4 Requesting Permission at Runtime
• 73.5 Providing a Rationale for the Permission Request
• 73.6 Testing the Permissions App
• 73.7 Summary

74. Android Audio Recording and Playback using MediaPlayer and MediaRecorder

• 74.1 Playing Audio
• 74.2 Recording Audio and Video using the MediaRecorder Class
• 74.3 About the Example Project
• 74.4 Creating the AudioApp Project
• 74.5 Designing the User Interface
• 74.6 Checking for Microphone Availability
• 74.7 Initializing the Activity
• 74.8 Implementing the recordAudio() Method
• 74.9 Implementing the stopAudio() Method
• 74.10 Implementing the playAudio() method
• 74.11 Configuring and Requesting Permissions
• 74.12 Testing the Application
• 74.13 Summary

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

• 75.1 The Elements of the Google Maps Android API
• 75.2 Creating the Google Maps Project
• 75.3 Obtaining Your Developer Signature
• 75.4 Adding the Apache HTTP Legacy Library Requirement
• 75.5 Testing the Application
• 75.6 Understanding Geocoding and Reverse Geocoding
• 75.7 Adding a Map to an Application
• 75.8 Requesting Current Location Permission
• 75.9 Displaying the User’s Current Location
• 75.10 Changing the Map Type
• 75.11 Displaying Map Controls to the User
• 75.12 Handling Map Gesture Interaction
• 75.13 Creating Map Markers
• 75.14 Controlling the Map Camera
• 75.15 Summary

76. Printing with the Android Printing Framework

• 76.1 The Android Printing Architecture
• 76.2 The Print Service Plugins
• 76.3 Google Cloud Print
• 76.4 Printing to Google Drive
• 76.5 Save as PDF
• 76.6 Printing from Android Devices
• 76.7 Options for Building Print Support into Android Apps
• 76.8 Summary

77. An Android HTML and Web Content Printing Example

• 77.1 Creating the HTML Printing Example Application
• 77.2 Printing Dynamic HTML Content
• 77.3 Creating the Web Page Printing Example
• 77.4 Removing the Floating Action Button
• 77.5 Removing Navigation Features
• 77.6 Designing the User Interface Layout
• 77.7 Accessing the WebView from the Main Activity
• 77.8 Loading the Web Page into the WebView
• 77.9 Adding the Print Menu Option
• 77.10 Summary

78. A Guide to Android Custom Document Printing

• 78.1 An Overview of Android Custom Document Printing
• 78.2 Preparing the Custom Document Printing Project
• 78.3 Creating the Custom Print Adapter
• 78.4 Implementing the onLayout() Callback Method
• 78.5 Implementing the onWrite() Callback Method
• 78.6 Checking a Page is in Range
• 78.7 Drawing the Content on the Page Canvas
• 78.8 Starting the Print Job
• 78.9 Testing the Application
• 78.10 Summary

79. An Introduction to Android App Links

• 79.1 An Overview of Android App Links
• 79.2 App Link Intent Filters
• 79.3 Handling App Link Intents
• 79.4 Associating the App with a Website
• 79.5 Summary

80. An Android Studio App Links Tutorial

• 80.1 About the Example App
• 80.2 The Database Schema
• 80.3 Loading and Running the Project
• 80.4 Adding the URL Mapping
• 80.5 Adding the Intent Filter
• 80.6 Adding Intent Handling Code
• 80.7 Testing the App Link
• 80.8 Associating an App Link with a Web Site
• 80.9 Summary

81. A Guide to the Android Studio Profiler

• 81.1 Accessing the Android Profiler
• 81.2 Enabling Advanced Profiling
• 81.3 The Android Profiler Tool Window
• 81.4 The Sessions Panel
• 81.5 The CPU Profiler
• 81.6 Memory Profiler
• 81.7 Network Profiler
• 81.8 Energy Profiler
• 81.9 Summary

82. An Android Biometric Authentication Tutorial

• 82.1 An Overview of Biometric Authentication
• 82.2 Creating the Biometric Authentication Project
• 82.3 Configuring Device Fingerprint Authentication
• 82.4 Adding the Biometric Permission to the Manifest File
• 82.5 Designing the User Interface
• 82.6 Adding a Toast Convenience Method
• 82.7 Checking the Security Settings
• 82.8 Configuring the Authentication Callbacks
• 82.9 Adding the CancellationSignal
• 82.10 Starting the Biometric Prompt
• 82.11 Testing the Project
• 82.12 Summary

83. Creating, Testing and Uploading an Android App Bundle

• 83.1 The Release Preparation Process
• 83.2 Android App Bundles
• 83.3 Register for a Google Play Developer Console Account
• 83.4 Configuring the App in the Console
• 83.5 Enabling Google Play App Signing
• 83.6 Creating a Keystore File
• 83.7 Creating the Android App Bundle
• 83.8 Generating Test APK Files
• 83.9 Uploading the App Bundle to the Google Play Developer Console
• 83.10 Exploring the App Bundle
• 83.11 Managing Testers
• 83.12 Rolling the App Out for Testing
• 83.13 Uploading New App Bundle Revisions
• 83.14 Analyzing the App Bundle File
• 83.15 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 Handling Large Downloads
• 85.12 Using Deferred Installation
• 85.13 Removing a Dynamic Module
• 85.14 Summary

86. An Overview of Gradle in Android Studio

• 86.1 An Overview of Gradle
• 86.2 Gradle and Android Studio
• 86.3 The Top-level Gradle Build File
• 86.4 Module Level Gradle Build Files
• 86.5 Configuring Signing Settings in the Build File
• 86.6 Running Gradle Tasks from the Command-line
• 86.7 Summary

Index