Android Studio Chipmunk Essentials – Java Edition: Developing Android Apps Using Android Studio 2021.2.1 and Java

Length: 816 pages
Edition: 1
Language: English
Publisher: Payload Media
Publication Date: 2022-05-26
ISBN-10: 1951442474
ISBN-13: 9781951442477
Sales Rank: #175479 (See Top 100 Books)
Fully updated for Android Studio Chipmunk, the goal of this book is to teach you how to develop Android-based applications using the Java programming language.
Beginning with the basics, this book provides an outline of 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 Chipmunk 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, 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 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 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. 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.2.1 Repository
        65.2.2 Room Database
        65.2.3 Data Access Object (DAO)
        65.2.4 Entities
        65.2.5 SQLite Database
    65.3 Understanding Entities
    65.4 Data Access Objects
    65.5 The Room Database
    65.6 The Repository
    65.7 In-Memory Databases
    65.8 Database Inspector
    65.9 Summary
66. An Android TableLayout and TableRow Tutorial
    66.1 The TableLayout and TableRow Layout Views
    66.2 Creating the Room Database Project
    66.3 Converting to a LinearLayout
    66.4 Adding the TableLayout to the User Interface
    66.5 Configuring the TableRows
    66.6 Adding the Button Bar to the Layout
    66.7 Adding the RecyclerView
    66.8 Adjusting the Layout Margins
    66.9 Summary
67. An Android Room Database and Repository Tutorial
    67.1 About the RoomDemo Project
    67.2 Modifying the Build Configuration
    67.3 Building the Entity
    67.4 Creating the Data Access Object
    67.5 Adding the Room Database
    67.6 Adding the Repository
    67.7 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 Adding the Activity Launchers
    69.5 Creating a New Storage File
    69.6 Saving to a Storage File
    69.7 Opening and Reading a Storage File
    69.8 Testing the Storage Access Application
    69.9 Summary
70. Video Playback on Android using the VideoView and MediaController Classes
    70.1 Introducing the Android VideoView Class
    70.2 Introducing the Android MediaController Class
    70.3 Creating the Video Playback Example
    70.4 Designing the VideoPlayer Layout
    70.5 Downloading the Video File
    70.6 Configuring the VideoView
    70.7 Adding the MediaController to the Video View
    70.8 Setting up the onPreparedListener
    70.9 Summary
71. Android Picture-in-Picture Mode
    71.1 Picture-in-Picture Features
    71.2 Enabling Picture-in-Picture Mode
    71.3 Configuring Picture-in-Picture Parameters
    71.4 Entering Picture-in-Picture Mode
    71.5 Detecting Picture-in-Picture Mode Changes
    71.6 Adding Picture-in-Picture Actions
    71.7 Summary
72. An Android Picture-in-Picture Tutorial
    72.1 Adding Picture-in-Picture Support to the Manifest
    72.2 Adding a Picture-in-Picture Button
    72.3 Entering Picture-in-Picture Mode
    72.4 Detecting Picture-in-Picture Mode Changes
    72.5 Adding a Broadcast Receiver
    72.6 Adding the PiP Action
    72.7 Testing the Picture-in-Picture Action
    72.8 Summary
73. 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.12.1 Map Zooming Gestures
        75.12.2 Map Scrolling/Panning Gestures
        75.12.3 Map Tilt Gestures
        75.12.4 Map Rotation Gestures
    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.7.1 Image Printing
        76.7.2 Creating and Printing HTML Content
        76.7.3 Printing a Web Page
        76.7.4 Printing a Custom Document
    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.1.1 Custom Print Adapters
    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
    80.8 Creating the Digital Asset Links File
    80.9 Testing the App Link
    80.10 Summary
81. An Android Biometric Authentication Tutorial
    81.1 An Overview of Biometric Authentication
    81.2 Creating the Biometric Authentication Project
    81.3 Configuring Device Fingerprint Authentication
    81.4 Adding the Biometric Permission to the Manifest File
    81.5 Designing the User Interface
    81.6 Adding a Toast Convenience Method
    81.7 Checking the Security Settings
    81.8 Configuring the Authentication Callbacks
    81.9 Adding the CancellationSignal
    81.10 Starting the Biometric Prompt
    81.11 Testing the Project
    81.12 Summary
82. Creating, Testing and Uploading an Android App Bundle
    82.1 The Release Preparation Process
    82.2 Android App Bundles
    82.3 Register for a Google Play Developer Console Account
    82.4 Configuring the App in the Console
    82.5 Enabling Google Play App Signing
    82.6 Creating a Keystore File
    82.7 Creating the Android App Bundle
    82.8 Generating Test APK Files
    82.9 Uploading the App Bundle to the Google Play Developer Console
    82.10 Exploring the App Bundle
    82.11 Managing Testers
    82.12 Rolling the App Out for Testing
    82.13 Uploading New App Bundle Revisions
    82.14 Analyzing the App Bundle File
    82.15 Summary
83. An Overview of Android In-App Billing
    83.1 Preparing a Project for In-App Purchasing
    83.2 Creating In-App Products and Subscriptions
    83.3 Billing Client Initialization
    83.4 Connecting to the Google Play Billing Library
    83.5 Displaying Available Products
    83.6 Starting the Purchase Process
    83.7 Completing the Purchase
    83.8 Querying Previous Purchases
    83.9 Summary
84. An Android In-App Purchasing Tutorial
    84.1 About the In-App Purchasing Example Project
    84.2 Creating the InAppPurchase Project
    84.3 Adding Libraries to the Project
    84.4 Designing the User Interface
    84.5 Adding the App to the Google Play Store
    84.6 Creating an In-App Product
    84.7 Enabling License Testers
    84.8 Initializing the Billing Client
    84.9 Querying the Product
    84.10 Launching the Purchase Flow
    84.11 Handling Purchase Updates
    84.12 Consuming the Product
    84.13 Testing the App
    84.14 Troubleshooting
    84.15 Summary
85. An Overview of Android Dynamic Feature Modules
    85.1 An Overview of Dynamic Feature Modules
    85.2 Dynamic Feature Module Architecture
    85.3 Creating a Dynamic Feature Module
    85.4 Converting an Existing Module for Dynamic Delivery
    85.5 Working with Dynamic Feature Modules
    85.6 Handling Large Dynamic Feature Modules
    85.7 Summary
86. An Android Studio Dynamic Feature Tutorial
    86.1 Creating the DynamicFeature Project
    86.2 Adding Dynamic Feature Support to the Project
    86.3 Designing the Base Activity User Interface
    86.4 Adding the Dynamic Feature Module
    86.5 Reviewing the Dynamic Feature Module
    86.6 Adding the Dynamic Feature Activity
    86.7 Implementing the launchIntent() Method
    86.8 Uploading the App Bundle for Testing
    86.9 Implementing the installFeature() Method
    86.10 Adding the Update Listener
    86.11 Using Deferred Installation
    86.12 Removing a Dynamic Module
    86.13 Summary
87. Working with Material Design 3 Theming
    87.1 Material Design 2 vs Material Design 3
    87.2 Understanding Material Design Theming
    87.3 Material Design 2 Theming
    87.4 Material Design 3 Theming
    87.5 Building a Custom Theme
    87.6 Summary
88. Migrating from Material Design 2 to Material Design 3
    88.1 Creating the ThemeMigration Project
    88.2 Designing the User Interface
    88.3 Migrating to Material Design 3
    88.4 Building a New Theme
    88.5 Adding the Theme to the Project
    88.6 Enabling Dynamic Color Support
    88.7 Summary
89. An Overview of Gradle in Android Studio
    89.1 An Overview of Gradle
    89.2 Gradle and Android Studio
        89.2.1 Sensible Defaults
        89.2.2 Dependencies
        89.2.3 Build Variants
        89.2.4 Manifest Entries
        89.2.5 APK Signing
        89.2.6 ProGuard Support
    89.3 The Property and Settings Gradle Build File
    89.4 The Top-level Gradle Build File
    89.5 Module Level Gradle Build Files
    89.6 Configuring Signing Settings in the Build File
    89.7 Running Gradle Tasks from the Command-line
    89.8 Summary
Index