Android Studio Dolphin Essentials – Java Edition: Developing Android Apps Using Android Studio 2021.3.1 and Java

Length: 806 pages
Edition: 1
Language: English
Publisher: Payload Media
Publication Date: 2022-10-09
ISBN-10: 1951442555
ISBN-13: 9781951442552
Sales Rank: #1377052 (See Top 100 Books)
Fully updated for Android Studio Dolphin, this book aims to teach you how to develop Android-based applications using the Java programming language.
This book begins with the basics and outlines the steps necessary to set up an Android development and testing environment. An overview of Android Studio is included covering areas such as tool windows, the code editor, and the Layout Editor tool. An introduction to the architecture of Android is followed by an in-depth look at the design of Android applications and user interfaces using the Android Studio environment.
Chapters are also included covering the Android Architecture Components including view models, lifecycle management, Room database access, the Database Inspector, app navigation, live data, and data binding.
More advanced topics such as intents are also covered, as are touch screen handling, gesture recognition, and the recording and playback of audio. This edition of the book also covers printing, transitions, and foldable device support.
The concepts of material design are also covered in detail, including the use of floating action buttons, Snackbars, tabbed interfaces, card views, navigation drawers, and collapsing toolbars.
Other key features of Android Studio Dolphin and Android are also covered in detail including the Layout Editor, the ConstraintLayout and ConstraintSet classes, MotionLayout Editor, view binding, constraint chains, barriers, and direct reply notifications.
Chapters also cover advanced features of Android Studio such as App Links, Dynamic Delivery, Gradle build configuration, in-app billing, and submitting apps to the Google Play Developer Console.
Assuming you already have some Java programming experience, are ready to download Android Studio and the Android SDK, have access to a Windows, Mac, or Linux system, and have ideas for some apps to develop, you are ready to get started.
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 8.1
        2.6.2 Windows 10
        2.6.3 Windows 11
        2.6.4 Linux
        2.6.5 macOS
    2.7 Android Studio memory management
    2.8 Updating Android Studio and the SDK
    2.9 Summary
3. Creating an Example Android App in Android Studio
    3.1 About the Project
    3.2 Creating a New Android Project
    3.3 Creating an Activity
    3.4 Defining the Project and SDK Settings
    3.5 Modifying the Example Application
    3.6 Modifying the User Interface 
    3.7 Reviewing the Layout and Resource Files
    3.8 Adding Interaction
    3.9 Summary
4. Creating an Android Virtual Device (AVD) in Android Studio
    4.1 About Android Virtual Devices
    4.2 Starting the Emulator
    4.3 Running the Application in the AVD
    4.4 Running on Multiple Devices
    4.5 Stopping a Running Application
    4.6 Supporting Dark Theme
    4.7 Running the Emulator in a Separate Window
    4.8 Enabling the Device Frame
    4.9 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 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 Summary
6. A Tour of the Android Studio User Interface
    6.1 The Welcome Screen
    6.2 The Main Window
    6.3 The Tool Windows
    6.4 Android Studio Keyboard Shortcuts
    6.5 Switcher and Recent Files Navigation
    6.6 Changing the Android Studio Theme
    6.7 Summary
7. Testing Android Studio Apps on a Physical Android Device
    7.1 An Overview of the Android Debug Bridge (ADB)
    7.2 Enabling USB Debugging ADB on Android Devices
        7.2.1 macOS ADB Configuration
        7.2.2 Windows ADB Configuration
        7.2.3 Linux adb Configuration
    7.3 Resolving USB Connection Issues
    7.4 Enabling Wireless Debugging on Android Devices
    7.5 Testing the adb Connection
    7.6 Summary
8. The Basics of the Android Studio Code Editor
    8.1 The Android Studio Editor
    8.2 Splitting the Editor Window
    8.3 Code Completion
    8.4 Statement Completion
    8.5 Parameter Information
    8.6 Parameter Name Hints
    8.7 Code Generation
    8.8 Code Folding
    8.9 Quick Documentation Lookup
    8.10 Code Reformatting
    8.11 Finding Sample Code
    8.12 Live Templates
    8.13 Summary
9. An Overview of the Android Architecture
    9.1 The Android Software Stack
    9.2 The Linux Kernel
    9.3 Android Runtime – ART
    9.4 Android Libraries
        9.4.1 C/C++ Libraries
    9.5 Application Framework
    9.6 Applications
    9.7 Summary
10. The Anatomy of an Android Application
    10.1 Android Activities
    10.2 Android Fragments
    10.3 Android Intents
    10.4 Broadcast Intents
    10.5 Broadcast Receivers
    10.6 Android Services
    10.7 Content Providers
    10.8 The Application Manifest
    10.9 Application Resources
    10.10 Application Context
    10.11 Summary
11. An Overview of Android View Binding
    11.1 Find View by Id
    11.2 View Binding 
    11.3 Converting the AndroidSample project
    11.4 Enabling View Binding
    11.5 Using View Binding
    11.6 Choosing an Option
    11.7 View Binding in the Book Examples
    11.8 Migrating a Project to View Binding
    11.9 Summary
12. Understanding Android Application and Activity Lifecycles
    12.1 Android Applications and Resource Management
    12.2 Android Process States
        12.2.1 Foreground Process
        12.2.2 Visible Process
        12.2.3 Service Process
        12.2.4 Background Process
        12.2.5 Empty Process
    12.3 Inter-Process Dependencies 
    12.4 The Activity Lifecycle
    12.5 The Activity Stack
    12.6 Activity States
    12.7 Configuration Changes
    12.8 Handling State Change
    12.9 Summary
13. Handling Android Activity State Changes
    13.1 New vs. Old Lifecycle Techniques
    13.2 The Activity and Fragment Classes
    13.3 Dynamic State vs. Persistent State
    13.4 The Android Lifecycle Methods
    13.5 Lifetimes
    13.6 Foldable Devices and Multi-Resume
    13.7 Disabling Configuration Change Restarts
    13.8 Lifecycle Method Limitations
    13.9 Summary
14. Android Activity State Changes by Example
    14.1 Creating the State Change Example Project
    14.2 Designing the User Interface
    14.3 Overriding the Activity Lifecycle Methods
    14.4 Filtering the Logcat Panel
    14.5 Running the Application
    14.6 Experimenting with the Activity
    14.7 Summary
15. Saving and Restoring the State of an Android Activity
    15.1 Saving Dynamic State
    15.2 Default Saving of User Interface State
    15.3 The Bundle Class
    15.4 Saving the State
    15.5 Restoring the State
    15.6 Testing the Application
    15.7 Summary
16. Understanding Android Views, View Groups and Layouts
    16.1 Designing for Different Android Devices
    16.2 Views and View Groups
    16.3 Android Layout Managers
    16.4 The View Hierarchy
    16.5 Creating User Interfaces
    16.6 Summary
17. A Guide to the Android Studio Layout Editor Tool
    17.1 Basic vs. Empty 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.1.1 Constraints
        18.1.2 Margins
        18.1.3 Opposing Constraints
        18.1.4 Constraint Bias
        18.1.5 Chains
        18.1.6 Chain Styles
    18.2 Baseline Alignment
    18.3 Configuring Widget Dimensions
    18.4 Guideline Helper
    18.5 Group Helper
    18.6 Barrier Helper
    18.7 Flow Helper
    18.8 Ratios
    18.9 ConstraintLayout Advantages
    18.10 ConstraintLayout Availability
    18.11 Summary
19. A Guide to Using ConstraintLayout in Android Studio
    19.1 Design and Layout Views
    19.2 Autoconnect Mode
    19.3 Inference Mode
    19.4 Manipulating Constraints Manually
    19.5 Adding Constraints in the Inspector
    19.6 Viewing Constraints in the Attributes Window
    19.7 Deleting Constraints
    19.8 Adjusting Constraint Bias
    19.9 Understanding ConstraintLayout Margins
    19.10 The Importance of Opposing Constraints and Bias
    19.11 Configuring Widget Dimensions
    19.12 Design Time Tools Positioning
    19.13 Adding Guidelines
    19.14 Adding Barriers
    19.15 Adding a Group
    19.16 Working with the Flow Helper
    19.17 Widget Group Alignment and Distribution
    19.18 Converting other Layouts to ConstraintLayout
    19.19 Summary 
20. Working with ConstraintLayout Chains and Ratios in Android Studio
    20.1 Creating a Chain
    20.2 Changing the Chain Style
    20.3 Spread Inside Chain Style
    20.4 Packed Chain Style
    20.5 Packed Chain Style with Bias
    20.6 Weighted Chain
    20.7 Working with Ratios
    20.8 Summary
21. An Android Studio Layout Editor ConstraintLayout Tutorial
    21.1 An Android Studio Layout Editor Tool Example
    21.2 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.4.1 Establishing Connections
        23.4.2 Applying Constraints to a Layout
        23.4.3 Parent Constraint Connections
        23.4.4 Sizing Constraints
        23.4.5 Constraint Bias
        23.4.6 Alignment Constraints
        23.4.7 Copying and Applying Constraint Sets
        23.4.8 ConstraintLayout Chains
        23.4.9 Guidelines
        23.4.10 Removing Constraints
        23.4.11 Scaling
        23.4.12 Rotation
    23.5 Summary
24. An Android ConstraintSet Tutorial
    24.1 Creating the Example Project in Android Studio
    24.2 Adding Views to an Activity
    24.3 Setting View Attributes
    24.4 Creating View IDs
    24.5 Configuring the Constraint Set
    24.6 Adding the EditText View
    24.7 Converting Density Independent Pixels (dp) to Pixels (px)
    24.8 Summary
25. A Guide to using Apply Changes in Android Studio
    25.1 Introducing Apply Changes
    25.2 Understanding Apply Changes Options
    25.3 Using Apply Changes
    25.4 Configuring Apply Changes Fallback Settings
    25.5 An Apply Changes Tutorial
    25.6 Using Apply Code Changes
    25.7 Using Apply Changes and Restart Activity
    25.8 Using Run App
    25.9 Summary
26. An Overview and Example of Android Event Handling
    26.1 Understanding Android Events
    26.2 Using the android:onClick Resource
    26.3 Event Listeners and Callback Methods
    26.4 An Event Handling Example
    26.5 Designing the User Interface
    26.6 The Event Listener and Callback Method
    26.7 Consuming Events
    26.8 Summary
27. Android Touch and Multi-touch Event Handling
    27.1 Intercepting Touch Events
    27.2 The MotionEvent Object
    27.3 Understanding Touch Actions
    27.4 Handling Multiple Touches
    27.5 An Example Multi-Touch Application
    27.6 Designing the Activity User Interface
    27.7 Implementing the Touch Event Listener
    27.8  Running the Example Application
    27.9 Summary
28. Detecting Common Gestures Using the Android Gesture Detector Class
    28.1 Implementing Common Gesture Detection
    28.2 Creating an Example Gesture Detection Project
    28.3 Implementing the Listener Class
    28.4 Creating the GestureDetectorCompat Instance
    28.5 Implementing the onTouchEvent() Method
    28.6 Testing the Application
    28.7 Summary
29. Implementing Custom Gesture and Pinch Recognition on Android
    29.1 The Android Gesture Builder Application
    29.2 The GestureOverlayView Class
    29.3 Detecting Gestures
    29.4 Identifying Specific Gestures
    29.5 Installing and Running the Gesture Builder Application
    29.6 Creating a Gestures File
    29.7 Creating the Example Project
    29.8 Extracting the Gestures File from the SD Card
    29.9 Adding the Gestures File to the Project
    29.10 Designing the User Interface
    29.11 Loading the Gestures File
    29.12 Registering the Event Listener
    29.13 Implementing the onGesturePerformed Method
    29.14 Testing the Application
    29.15 Configuring the GestureOverlayView
    29.16 Intercepting Gestures
    29.17 Detecting Pinch Gestures
    29.18 A Pinch Gesture Example Project
    29.19 Summary
30. An Introduction to Android Fragments
    30.1 What is a Fragment?
    30.2 Creating a Fragment
    30.3 Adding a Fragment to an Activity using the Layout XML File
    30.4 Adding and Managing Fragments in Code
    30.5 Handling Fragment Events
    30.6 Implementing Fragment Communication
    30.7 Summary 
31. Using Fragments in Android Studio - An Example
    31.1 About the Example Fragment Application
    31.2 Creating the Example Project
    31.3 Creating the First Fragment Layout
    31.4 Migrating a Fragment to View Binding
    31.5 Adding the Second Fragment
    31.6 Adding the Fragments to the Activity
    31.7 Making the Toolbar Fragment Talk to the Activity
    31.8 Making the Activity Talk to the Text Fragment
    31.9 Testing the Application
    31.10 Summary
32. Modern Android App Architecture with Jetpack
    32.1 What is Android Jetpack?
    32.2 The “Old” Architecture
    32.3 Modern Android Architecture
    32.4 The ViewModel Component
    32.5 The LiveData Component
    32.6 ViewModel Saved State
    32.7 LiveData and Data Binding
    32.8 Android Lifecycles
    32.9 Repository Modules
    32.10 Summary
33. An Android Jetpack ViewModel Tutorial
    33.1 About the Project
    33.2 Creating the ViewModel Example Project
    33.3 Reviewing the Project
        33.3.1 The Main Activity
        33.3.2 The Content Fragment
        33.3.3 The ViewModel
    33.4 Designing the Fragment Layout
    33.5 Implementing the View Model
    33.6 Associating the Fragment with the View Model
    33.7 Modifying the Fragment
    33.8 Accessing the ViewModel Data
    33.9 Testing the Project
    33.10 Summary
34. An Android Jetpack LiveData Tutorial
    34.1 LiveData - A Recap
    34.2 Adding LiveData to the ViewModel
    34.3 Implementing the Observer
    34.4 Summary
35. An Overview of Android Jetpack Data Binding
    35.1 An Overview of Data Binding
    35.2 The Key Components of Data Binding
        35.2.1 The Project Build Configuration
        35.2.2 The Data Binding Layout File
        35.2.3 The Layout File Data Element
        35.2.4  The Binding Classes
        35.2.5 Data Binding Variable Configuration
        35.2.6 Binding Expressions (One-Way)
        35.2.7 Binding Expressions (Two-Way)
        35.2.8 Event and Listener Bindings
    35.3 Summary
36. An Android Jetpack Data Binding Tutorial
    36.1 Removing the Redundant Code
    36.2 Enabling Data Binding
    36.3 Adding the Layout Element
    36.4 Adding the Data Element to Layout File
    36.5 Working with the Binding Class
    36.6 Assigning the ViewModel Instance to the Data Binding Variable
    36.7 Adding Binding Expressions
    36.8 Adding the Conversion Method
    36.9 Adding a Listener Binding
    36.10 Testing the App
    36.11 Summary
37. An Android ViewModel Saved State Tutorial
    37.1 Understanding ViewModel State Saving
    37.2 Implementing ViewModel State Saving
    37.3 Saving and Restoring State
    37.4 Adding Saved State Support to the ViewModelDemo Project
    37.5 Summary
38. Working with Android Lifecycle-Aware Components
    38.1 Lifecycle Awareness
    38.2 Lifecycle Owners
    38.3 Lifecycle Observers
    38.4 Lifecycle States and Events
    38.5 Summary
39. An Android Jetpack Lifecycle Awareness Tutorial
    39.1 Creating the Example Lifecycle Project
    39.2 Creating a Lifecycle Observer
    39.3 Adding the Observer
    39.4 Testing the Observer
    39.5 Creating a Lifecycle Owner
    39.6 Testing the Custom Lifecycle Owner
    39.7 Summary
40. An Overview of the Navigation Architecture Component
    40.1 Understanding Navigation
    40.2 Declaring a Navigation Host
    40.3 The Navigation Graph
    40.4 Accessing the Navigation Controller
    40.5 Triggering a Navigation Action
    40.6 Passing Arguments
    40.7 Summary
41. An Android Jetpack Navigation Component Tutorial
    41.1 Creating the NavigationDemo Project
    41.2 Adding Navigation to the Build Configuration
    41.3 Creating the Navigation Graph Resource File
    41.4 Declaring a Navigation Host
    41.5 Adding Navigation Destinations
    41.6 Designing the Destination Fragment Layouts
    41.7 Adding an Action to the Navigation Graph
    41.8 Implement the OnFragmentInteractionListener
    41.9 Adding View Binding Support to the Destination Fragments
    41.10 Triggering the Action
    41.11 Passing Data Using Safeargs
    41.12 Summary
42. An Introduction to MotionLayout
    42.1 An Overview of MotionLayout
    42.2 MotionLayout
    42.3 MotionScene
    42.4 Configuring ConstraintSets
    42.5 Custom Attributes
    42.6 Triggering an Animation
    42.7 Arc Motion
    42.8 Keyframes
        42.8.1 Attribute Keyframes
        42.8.2 Position Keyframes
    42.9 Time Linearity
    42.10 KeyTrigger
    42.11 Cycle and Time Cycle Keyframes
    42.12 Starting an Animation from Code
    42.13 Summary
43. An Android MotionLayout Editor Tutorial
    43.1 Creating the MotionLayoutDemo Project
    43.2 ConstraintLayout to MotionLayout Conversion
    43.3 Configuring Start and End Constraints
    43.4 Previewing the MotionLayout Animation
    43.5 Adding an OnClick Gesture
    43.6 Adding an Attribute Keyframe to the Transition
    43.7 Adding a CustomAttribute to a Transition
    43.8 Adding Position Keyframes
    43.9 Summary
44. A MotionLayout KeyCycle Tutorial
    44.1 An Overview of Cycle Keyframes
    44.2 Using the Cycle Editor
    44.3 Creating the KeyCycleDemo Project
    44.4 Configuring the Start and End Constraints
    44.5 Creating the Cycles
    44.6 Previewing the Animation
    44.7 Adding the KeyFrameSet to the MotionScene
    44.8 Summary
45. Working with the Floating Action Button and Snackbar
    45.1 The Material Design
    45.2 The Design Library
    45.3 The Floating Action Button (FAB) 
    45.4 The Snackbar
    45.5 Creating the Example Project
    45.6 Reviewing the Project
    45.7 Removing Navigation Features
    45.8 Changing the Floating Action Button
    45.9 Adding an Action to the Snackbar
    45.10 Summary
46. Creating a Tabbed Interface using the TabLayout Component
    46.1 An Introduction to the ViewPager2
    46.2 An Overview of the TabLayout Component
    46.3 Creating the TabLayoutDemo Project
    46.4 Creating the First Fragment
    46.5 Duplicating the Fragments
    46.6 Adding the TabLayout and ViewPager2
    46.7 Creating the Pager 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 ItemDetailFragment Class
    51.7 Modifying the ItemListFragment 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 Automatic Link Verification
    52.7 Manually Enabling Links
    52.8 Checking Intent Availability
    52.9 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 Manually Enabling the Link
    54.11 Automatic Link Verification
    54.12 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. Android Local Bound Services – A Worked Example
    56.1 Understanding Bound Services
    56.2 Bound Service Interaction Options
    56.3 A Local Bound Service Example
    56.4 Adding a Bound Service to the Project
    56.5 Implementing the Binder
    56.6 Binding the Client to the Service
    56.7 Completing the Example
    56.8 Testing the Application
    56.9 Summary
57. Android Remote Bound Services – A Worked Example
    57.1 Client to Remote Service Communication
    57.2 Creating the Example Application
    57.3 Designing the User Interface
    57.4 Implementing the Remote Bound Service
    57.5 Configuring a Remote Service in the Manifest File
    57.6 Launching and Binding to the Remote Service
    57.7 Sending a Message to the Remote Service
    57.8 Summary
58. A Basic Overview of Java Threads, Handlers and Executors
    58.1 The Application Main Thread
    58.2 Thread Handlers
    58.3 A Threading Example
    58.4 Building the App
    58.5 Creating a New Thread
    58.6 Implementing a Thread Handler
    58.7 Passing a Message to the Handler
    58.8 Java Executor Concurrency
    58.9 Working with Runnable Tasks
    58.10 Shutting down an Executor Service
    58.11 Working with Callable Tasks and Futures
    58.12 Handling a Future Result
    58.13 Scheduling Tasks
    58.14 Summary
59. An Android Notifications Tutorial
    59.1 An Overview of Notifications
    59.2 Creating the NotifyDemo Project
    59.3 Designing the User Interface
    59.4 Creating the Second Activity
    59.5 Creating a Notification Channel
    59.6 Creating and Issuing a Notification
    59.7 Launching an Activity from a Notification
    59.8 Adding Actions to a Notification
    59.9 Bundled Notifications
    59.10 Summary
60. An Android Direct Reply Notification Tutorial
    60.1 Creating the DirectReply Project
    60.2 Designing the User Interface
    60.3 Creating the Notification Channel
    60.4 Building the RemoteInput Object
    60.5 Creating the PendingIntent
    60.6 Creating the Reply Action
    60.7 Receiving Direct Reply Input
    60.8 Updating the Notification
    60.9 Summary
61.  Foldable Devices and Multi-Window Support
    61.1 Foldables and Multi-Window Support
    61.2 Using a Foldable Emulator
    61.3 Entering Multi-Window Mode
    61.4 Enabling and using Freeform Support
    61.5 Checking for Freeform Support
    61.6 Enabling Multi-Window Support in an App
    61.7 Specifying Multi-Window Attributes
    61.8 Detecting Multi-Window Mode in an Activity
    61.9 Receiving Multi-Window Notifications
    61.10 Launching an Activity in Multi-Window Mode
    61.11 Configuring Freeform Activity Size and Position
    61.12 Summary
62. An Overview of Android SQLite Databases
    62.1 Understanding Database Tables
    62.2 Introducing Database Schema 
    62.3 Columns and Data Types 
    62.4 Database Rows 
    62.5 Introducing Primary Keys 
    62.6 What is SQLite?
    62.7 Structured Query Language (SQL)
    62.8 Trying SQLite on an Android Virtual Device (AVD)
    62.9 The Android Room Persistence Library
    62.10 Summary
63. The Android Room Persistence Library
    63.1 Revisiting Modern App Architecture
    63.2 Key Elements of Room Database Persistence
        63.2.1 Repository
        63.2.2 Room Database
        63.2.3 Data Access Object (DAO)
        63.2.4 Entities
        63.2.5 SQLite Database
    63.3 Understanding Entities
    63.4 Data Access Objects
    63.5 The Room Database
    63.6 The Repository
    63.7 In-Memory Databases
    63.8 Database Inspector
    63.9 Summary
64. An Android TableLayout and TableRow Tutorial
    64.1 The TableLayout and TableRow Layout Views
    64.2 Creating the Room Database Project
    64.3 Converting to a LinearLayout
    64.4 Adding the TableLayout to the User Interface
    64.5 Configuring the TableRows
    64.6 Adding the Button Bar to the Layout
    64.7 Adding the RecyclerView
    64.8 Adjusting the Layout Margins
    64.9 Summary
65. An Android Room Database and Repository Tutorial
    65.1 About the RoomDemo Project
    65.2 Modifying the Build Configuration
    65.3 Building the Entity
    65.4 Creating the Data Access Object
    65.5 Adding the Room Database
    65.6 Adding the Repository
    65.7 Modifying the ViewModel
    65.8 Creating the Product Item Layout
    65.9 Adding the RecyclerView Adapter
    65.10 Preparing the Main Fragment
    65.11 Adding the Button Listeners
    65.12 Adding LiveData Observers
    65.13 Initializing the RecyclerView
    65.14 Testing the RoomDemo App
    65.15 Using the Database Inspector
    65.16 Summary
66. Accessing Cloud Storage using the Android Storage Access Framework
    66.1 The Storage Access Framework
    66.2  Working with the Storage Access Framework
    66.3 Filtering Picker File Listings
    66.4 Handling Intent Results
    66.5 Reading the Content of a File
    66.6 Writing Content to a File
    66.7 Deleting a File
    66.8 Gaining Persistent Access to a File
    66.9 Summary
67. An Android Storage Access Framework Example
    67.1 About the Storage Access Framework Example
    67.2 Creating the Storage Access Framework Example
    67.3 Designing the User Interface
    67.4 Adding the Activity Launchers
    67.5 Creating a New Storage File
    67.6 Saving to a Storage File
    67.7 Opening and Reading a Storage File
    67.8 Testing the Storage Access Application
    67.9 Summary
68. Video Playback on Android using the VideoView and MediaController Classes
    68.1 Introducing the Android VideoView Class
    68.2 Introducing the Android MediaController Class
    68.3 Creating the Video Playback Example
    68.4 Designing the VideoPlayer Layout
    68.5 Downloading the Video File
    68.6 Configuring the VideoView
    68.7 Adding the MediaController to the Video View
    68.8 Setting up the onPreparedListener
    68.9 Summary
69. Android Picture-in-Picture Mode
    69.1 Picture-in-Picture Features
    69.2 Enabling Picture-in-Picture Mode
    69.3 Configuring Picture-in-Picture Parameters
    69.4 Entering Picture-in-Picture Mode
    69.5 Detecting Picture-in-Picture Mode Changes
    69.6 Adding Picture-in-Picture Actions
    69.7 Summary
70. An Android Picture-in-Picture Tutorial
    70.1 Adding Picture-in-Picture Support to the Manifest
    70.2 Adding a Picture-in-Picture Button
    70.3 Entering Picture-in-Picture Mode
    70.4 Detecting Picture-in-Picture Mode Changes
    70.5 Adding a Broadcast Receiver
    70.6 Adding the PiP Action
    70.7 Testing the Picture-in-Picture Action
    70.8 Summary
71. Making Runtime Permission Requests in Android
    71.1 Understanding Normal and Dangerous Permissions
    71.2 Creating the Permissions Example Project
    71.3 Checking for a Permission
    71.4 Requesting Permission at Runtime
    71.5 Providing a Rationale for the Permission Request
    71.6 Testing the Permissions App
    71.7 Summary
72. Android Audio Recording and Playback using MediaPlayer and MediaRecorder
    72.1 Playing Audio
    72.2 Recording Audio and Video using the MediaRecorder Class
    72.3 About the Example Project
    72.4 Creating the AudioApp Project
    72.5 Designing the User Interface
    72.6 Checking for Microphone Availability
    72.7 Initializing the Activity
    72.8 Implementing the recordAudio() Method
    72.9 Implementing the stopAudio() Method
    72.10 Implementing the playAudio() method
    72.11 Configuring and Requesting Permissions
    72.12 Testing the Application
    72.13 Summary
73. Working with the Google Maps Android API in Android Studio
    73.1 The Elements of the Google Maps Android API
    73.2 Creating the Google Maps Project
    73.3 Obtaining Your Developer Signature
    73.4 Adding the Apache HTTP Legacy Library Requirement
    73.5 Testing the Application
    73.6 Understanding Geocoding and Reverse Geocoding
    73.7 Adding a Map to an Application
    73.8 Requesting Current Location Permission
    73.9 Displaying the User’s Current Location
    73.10 Changing the Map Type
    73.11 Displaying Map Controls to the User
    73.12 Handling Map Gesture Interaction
        73.12.1 Map Zooming Gestures
        73.12.2 Map Scrolling/Panning Gestures
        73.12.3 Map Tilt Gestures
        73.12.4 Map Rotation Gestures
    73.13 Creating Map Markers
    73.14 Controlling the Map Camera
    73.15 Summary
74. Printing with the Android Printing Framework
    74.1 The Android Printing Architecture
    74.2 The Print Service Plugins
    74.3 Google Cloud Print
    74.4 Printing to Google Drive
    74.5 Save as PDF
    74.6 Printing from Android Devices
    74.7 Options for Building Print Support into Android Apps
        74.7.1 Image Printing
        74.7.2 Creating and Printing HTML Content
        74.7.3 Printing a Web Page
        74.7.4 Printing a Custom Document
    74.8 Summary
75. An Android HTML and Web Content Printing Example
    75.1 Creating the HTML Printing Example Application
    75.2 Printing Dynamic HTML Content
    75.3 Creating the Web Page Printing Example
    75.4 Removing the Floating Action Button
    75.5 Removing Navigation Features
    75.6 Designing the User Interface Layout
    75.7 Accessing the WebView from the Main Activity
    75.8 Loading the Web Page into the WebView
    75.9 Adding the Print Menu Option
    75.10 Summary
76. A Guide to Android Custom Document Printing
    76.1 An Overview of Android Custom Document Printing
        76.1.1 Custom Print Adapters
    76.2 Preparing the Custom Document Printing Project
    76.3 Creating the Custom Print Adapter
    76.4 Implementing the onLayout() Callback Method
    76.5 Implementing the onWrite() Callback Method
    76.6 Checking a Page is in Range
    76.7 Drawing the Content on the Page Canvas
    76.8 Starting the Print Job
    76.9 Testing the Application
    76.10 Summary
77. An Introduction to Android App Links
    77.1 An Overview of Android App Links
    77.2 App Link Intent Filters
    77.3 Handling App Link Intents
    77.4 Associating the App with a Website
    77.5 Summary
78. An Android Studio App Links Tutorial
    78.1 About the Example App
    78.2 The Database Schema
    78.3 Loading and Running the Project
    78.4 Adding the URL Mapping
    78.5 Adding the Intent Filter
    78.6 Adding Intent Handling Code
    78.7 Testing the App
    78.8 Creating the Digital Asset Links File
    78.9 Testing the App Link
    78.10 Summary
79. An Android Biometric Authentication Tutorial
    79.1 An Overview of Biometric Authentication
    79.2 Creating the Biometric Authentication Project
    79.3 Configuring Device Fingerprint Authentication
    79.4 Adding the Biometric Permission to the Manifest File
    79.5 Designing the User Interface
    79.6 Adding a Toast Convenience Method
    79.7 Checking the Security Settings
    79.8 Configuring the Authentication Callbacks
    79.9 Adding the CancellationSignal
    79.10 Starting the Biometric Prompt
    79.11 Testing the Project
    79.12 Summary
80. Creating, Testing and Uploading an Android App Bundle
    80.1 The Release Preparation Process
    80.2 Android App Bundles
    80.3 Register for a Google Play Developer Console Account
    80.4 Configuring the App in the Console
    80.5 Enabling Google Play App Signing
    80.6 Creating a Keystore File
    80.7 Creating the Android App Bundle
    80.8 Generating Test APK Files
    80.9 Uploading the App Bundle to the Google Play Developer Console
    80.10 Exploring the App Bundle
    80.11 Managing Testers
    80.12 Rolling the App Out for Testing
    80.13 Uploading New App Bundle Revisions
    80.14 Analyzing the App Bundle File
    80.15 Summary
81. An Overview of Android In-App Billing
    81.1 Preparing a Project for In-App Purchasing
    81.2 Creating In-App Products and Subscriptions
    81.3 Billing Client Initialization
    81.4 Connecting to the Google Play Billing Library
    81.5 Querying Available Products
    81.6 Starting the Purchase Process
    81.7 Completing the Purchase
    81.8 Querying Previous Purchases
    81.9 Summary
82. An Android In-App Purchasing Tutorial
    82.1 About the In-App Purchasing Example Project
    82.2 Creating the InAppPurchase Project
    82.3 Adding Libraries to the Project
    82.4 Designing the User Interface
    82.5 Adding the App to the Google Play Store
    82.6 Creating an In-App Product
    82.7 Enabling License Testers
    82.8 Initializing the Billing Client
    82.9 Querying the Product
    82.10 Launching the Purchase Flow
    82.11 Handling Purchase Updates
    82.12 Consuming the Product
    82.13 Restoring a Previous Purchase
    82.14 Testing the App
    82.15 Troubleshooting
    82.16 Summary
83. An Overview of Android Dynamic Feature Modules
    83.1 An Overview of Dynamic Feature Modules
    83.2 Dynamic Feature Module Architecture
    83.3 Creating a Dynamic Feature Module
    83.4 Converting an Existing Module for Dynamic Delivery
    83.5 Working with Dynamic Feature Modules
    83.6 Handling Large Dynamic Feature Modules
    83.7 Summary
84. An Android Studio Dynamic Feature Tutorial
    84.1 Creating the DynamicFeature Project
    84.2 Adding Dynamic Feature Support to the Project
    84.3 Designing the Base Activity User Interface
    84.4 Adding the Dynamic Feature Module
    84.5 Reviewing the Dynamic Feature Module
    84.6 Adding the Dynamic Feature Activity
    84.7 Implementing the launchIntent() Method
    84.8 Uploading the App Bundle for Testing
    84.9 Implementing the installFeature() Method
    84.10 Adding the Update Listener
    84.11 Using Deferred Installation
    84.12 Removing a Dynamic Module
    84.13 Summary
85. Working with Material Design 3 Theming
    85.1 Material Design 2 vs Material Design 3
    85.2 Understanding Material Design Theming
    85.3 Material Design 2 Theming
    85.4 Material Design 3 Theming
    85.5 Building a Custom Theme
    85.6 Summary
86. Migrating from Material Design 2 to Material Design 3
    86.1 Creating the ThemeMigration Project
    86.2 Designing the User Interface
    86.3 Migrating to Material Design 3
    86.4 Building a New Theme
    86.5 Adding the Theme to the Project
    86.6 Enabling Dynamic Color Support
    86.7 Summary
87. An Overview of Gradle in Android Studio
    87.1 An Overview of Gradle
    87.2 Gradle and Android Studio
        87.2.1 Sensible Defaults
        87.2.2 Dependencies
        87.2.3 Build Variants
        87.2.4 Manifest Entries
        87.2.5 APK Signing
        87.2.6 ProGuard Support
    87.3 The Property and Settings Gradle Build File
    87.4 The Top-level Gradle Build File
    87.5 Module Level Gradle Build Files
    87.6 Configuring Signing Settings in the Build File
    87.7 Running Gradle Tasks from the Command-line
    87.8 Summary
Index