Android Studio Electric Eel Essentials – Java Edition: Developing Android Apps Using Android Studio 2022.1.1 and Java

Length: 820 pages
Edition: 1
Language: English
Publisher: Payload Media
Publication Date: 2023-01-22
ISBN-10: 195144258X
ISBN-13: 9781951442583
Sales Rank: #1257349 (See Top 100 Books)
Fully updated for Android Studio Electric Eel, 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 how 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 book edition 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 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 Installing the Android SDK Command-line Tools
        2.6.1 Windows 8.1
        2.6.2 Windows 10
        2.6.3 Windows 11
        2.6.4 Linux
        2.6.5 macOS
    2.7 Android Studio memory management
    2.8 Updating Android Studio and the SDK
    2.9 Summary
3. Creating an Example Android App in Android Studio
    3.1 About the Project
    3.2 Creating a New Android Project
    3.3 Creating an Activity
    3.4 Defining the Project and SDK Settings
    3.5 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 Creating a Resizable Emulator
    5.10 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 Device Mirroring
    7.7 Summary
8. The Basics of the Android Studio Code Editor
    8.1 The Android Studio Editor
    8.2 Splitting the Editor Window
    8.3 Code Completion
    8.4 Statement Completion
    8.5 Parameter Information
    8.6 Parameter Name Hints
    8.7 Code Generation
    8.8 Code Folding
    8.9 Quick Documentation Lookup
    8.10 Code Reformatting
    8.11 Finding Sample Code
    8.12 Live Templates
    8.13 Summary
9. An Overview of the Android Architecture
    9.1 The Android Software Stack
    9.2 The Linux Kernel
    9.3 Android Runtime – ART
    9.4 Android Libraries
        9.4.1 C/C++ Libraries
    9.5 Application Framework
    9.6 Applications
    9.7 Summary
10. The Anatomy of an Android 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
    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 Services
    52.1 Intent Service
    52.2 Bound Service
    52.3 The Anatomy of a Service
    52.4 Controlling Destroyed Service Restart Options
    52.5 Declaring a Service in the Manifest File
    52.6 Starting a Service Running on System Startup
    52.7 Summary
53. An Overview of Android Intents
    53.1 An Overview of Intents
    53.2 Explicit Intents
    53.3 Returning Data from an Activity
    53.4 Implicit Intents
    53.5 Using Intent Filters
    53.6 Automatic Link Verification
    53.7 Manually Enabling Links
    53.8 Checking Intent Availability
    53.9 Summary
54. Android Explicit Intents – A Worked Example
    54.1 Creating the Explicit Intent Example Application
    54.2 Designing the User Interface Layout for MainActivity
    54.3 Creating the Second Activity Class
    54.4 Designing the User Interface Layout for SecondActivity
    54.5 Reviewing the Application Manifest File
    54.6 Creating the Intent
    54.7 Extracting Intent Data
    54.8 Launching SecondActivity as a Sub-Activity
    54.9 Returning Data from a Sub-Activity
    54.10 Testing the Application
    54.11 Summary
55. Android Implicit Intents – A Worked Example
    55.1 Creating the Android Studio Implicit Intent Example Project
    55.2 Designing the User Interface
    55.3 Creating the Implicit Intent
    55.4 Adding a Second Matching Activity
    55.5 Adding the Web View to the UI
    55.6 Obtaining the Intent URL
    55.7 Modifying the MyWebView Project Manifest File
    55.8 Installing the MyWebView Package on a Device
    55.9 Testing the Application
    55.10 Manually Enabling the Link
    55.11 Automatic Link Verification
    55.12 Summary
56. Android Broadcast Intents and Broadcast Receivers
    56.1 An Overview of Broadcast Intents
    56.2 An Overview of Broadcast Receivers
    56.3 Obtaining Results from a Broadcast
    56.4 Sticky Broadcast Intents
    56.5 The Broadcast Intent Example
    56.6 Creating the Example Application
    56.7 Creating and Sending the Broadcast Intent
    56.8 Creating the Broadcast Receiver
    56.9 Registering the Broadcast Receiver
    56.10 Testing the Broadcast Example
    56.11 Listening for System Broadcasts
    56.12 Summary
57. Android Local Bound Services – A Worked Example
    57.1 Understanding Bound Services
    57.2 Bound Service Interaction Options
    57.3 A Local Bound Service Example
    57.4 Adding a Bound Service to the Project
    57.5 Implementing the Binder
    57.6 Binding the Client to the Service
    57.7 Completing the Example
    57.8 Testing the Application
    57.9 Summary
58. Android Remote Bound Services – A Worked Example
    58.1 Client to Remote Service Communication
    58.2 Creating the Example Application
    58.3 Designing the User Interface
    58.4 Implementing the Remote Bound Service
    58.5 Configuring a Remote Service in the Manifest File
    58.6 Launching and Binding to the Remote Service
    58.7 Sending a Message to the Remote Service
    58.8 Summary
59. A Basic Overview of Java Threads, Handlers and Executors
    59.1 The Application Main Thread
    59.2 Thread Handlers
    59.3 A Threading Example
    59.4 Building the App
    59.5 Creating a New Thread
    59.6 Implementing a Thread Handler
    59.7 Passing a Message to the Handler
    59.8 Java Executor Concurrency
    59.9 Working with Runnable Tasks
    59.10 Shutting down an Executor Service
    59.11 Working with Callable Tasks and Futures
    59.12 Handling a Future Result
    59.13 Scheduling Tasks
    59.14 Summary
60. Making Runtime Permission Requests in Android
    60.1 Understanding Normal and Dangerous Permissions
    60.2 Creating the Permissions Example Project
    60.3 Checking for a Permission
    60.4 Requesting Permission at Runtime
    60.5 Providing a Rationale for the Permission Request
    60.6 Testing the Permissions App
    60.7 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 Requesting Notification Permission
    61.7 Creating and Issuing a Notification
    61.8 Launching an Activity from a Notification
    61.9 Adding Actions to a Notification
    61.10 Bundled Notifications
    61.11 Summary
62. An Android Direct Reply Notification Tutorial
    62.1 Creating the DirectReply Project
    62.2 Designing the User Interface
    62.3 Requesting Notification Permission
    62.4 Creating the Notification Channel
    62.5 Building the RemoteInput Object
    62.6 Creating the PendingIntent
    62.7 Creating the Reply Action
    62.8 Receiving Direct Reply Input
    62.9 Updating the Notification
    62.10 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. Android Audio Recording and Playback using MediaPlayer and MediaRecorder
    73.1 Playing Audio
    73.2 Recording Audio and Video using the MediaRecorder Class
    73.3 About the Example Project
    73.4 Creating the AudioApp Project
    73.5 Designing the User Interface
    73.6 Checking for Microphone Availability
    73.7 Initializing the Activity
    73.8 Implementing the recordAudio() Method
    73.9 Implementing the stopAudio() Method
    73.10 Implementing the playAudio() method
    73.11 Configuring and Requesting Permissions
    73.12 Testing the Application
    73.13 Summary
74. Working with the Google Maps Android API in Android Studio
    74.1 The Elements of the Google Maps Android API
    74.2 Creating the Google Maps Project
    74.3 Creating a Google Cloud Billing Account
    74.4 Creating a New Google Cloud Project
    74.5 Enabling the Google Maps SDK
    74.6 Generating a Google Maps API Key
    74.7 Adding the API Key to the Android Studio Project
    74.8 Adding the Apache HTTP Legacy Library Requirement
    74.9 Testing the Application
    74.10 Understanding Geocoding and Reverse Geocoding
    74.11 Adding a Map to an Application
    74.12 Requesting Current Location Permission
    74.13 Displaying the User’s Current Location
    74.14 Changing the Map Type
    74.15 Displaying Map Controls to the User
    74.16 Handling Map Gesture Interaction
        74.16.1 Map Zooming Gestures
        74.16.2 Map Scrolling/Panning Gestures
        74.16.3 Map Tilt Gestures
        74.16.4 Map Rotation Gestures
    74.17 Creating Map Markers
    74.18 Controlling the Map Camera
    74.19 Summary
75. Printing with the Android Printing Framework
    75.1 The Android Printing Architecture
    75.2 The Print Service Plugins
    75.3 Google Cloud Print
    75.4 Printing to Google Drive
    75.5 Save as PDF
    75.6 Printing from Android Devices
    75.7 Options for Building Print Support into Android Apps
        75.7.1 Image Printing
        75.7.2 Creating and Printing HTML Content
        75.7.3 Printing a Web Page
        75.7.4 Printing a Custom Document
    75.8 Summary
76. An Android HTML and Web Content Printing Example
    76.1 Creating the HTML Printing Example Application
    76.2 Printing Dynamic HTML Content
    76.3 Creating the Web Page Printing Example
    76.4 Removing the Floating Action Button
    76.5 Removing Navigation Features
    76.6 Designing the User Interface Layout
    76.7 Accessing the WebView from the Main Activity
    76.8 Loading the Web Page into the WebView
    76.9 Adding the Print Menu Option
    76.10 Summary
77. A Guide to Android Custom Document Printing
    77.1 An Overview of Android Custom Document Printing
        77.1.1 Custom Print Adapters
    77.2 Preparing the Custom Document Printing Project
    77.3 Creating the Custom Print Adapter
    77.4 Implementing the onLayout() Callback Method
    77.5 Implementing the onWrite() Callback Method
    77.6 Checking a Page is in Range
    77.7 Drawing the Content on the Page Canvas
    77.8 Starting the Print Job
    77.9 Testing the Application
    77.10 Summary
78. An Introduction to Android App Links
    78.1 An Overview of Android App Links
    78.2 App Link Intent Filters
    78.3 Handling App Link Intents
    78.4 Associating the App with a Website
    78.5 Summary
79. An Android Studio App Links Tutorial
    79.1 About the Example App
    79.2 The Database Schema
    79.3 Loading and Running the Project
    79.4 Adding the URL Mapping
    79.5 Adding the Intent Filter
    79.6 Adding Intent Handling Code
    79.7 Testing the App
    79.8 Creating the Digital Asset Links File
    79.9 Testing the App Link
    79.10 Summary
80. An Android Biometric Authentication Tutorial
    80.1 An Overview of Biometric Authentication
    80.2 Creating the Biometric Authentication Project
    80.3 Configuring Device Fingerprint Authentication
    80.4 Adding the Biometric Permission to the Manifest File
    80.5 Designing the User Interface
    80.6 Adding a Toast Convenience Method
    80.7 Checking the Security Settings
    80.8 Configuring the Authentication Callbacks
    80.9 Adding the CancellationSignal
    80.10 Starting the Biometric Prompt
    80.11 Testing the Project
    80.12 Summary
81. Creating, Testing and Uploading an Android App Bundle
    81.1 The Release Preparation Process
    81.2 Android App Bundles
    81.3 Register for a Google Play Developer Console Account
    81.4 Configuring the App in the Console
    81.5 Enabling Google Play App Signing
    81.6 Creating a Keystore File
    81.7 Creating the Android App Bundle
    81.8 Generating Test APK Files
    81.9 Uploading the App Bundle to the Google Play Developer Console
    81.10 Exploring the App Bundle
    81.11 Managing Testers
    81.12 Rolling the App Out for Testing
    81.13 Uploading New App Bundle Revisions
    81.14 Analyzing the App Bundle File
    81.15 Summary
82. An Overview of Android In-App Billing
    82.1 Preparing a Project for In-App Purchasing
    82.2 Creating In-App Products and Subscriptions
    82.3 Billing Client Initialization
    82.4 Connecting to the Google Play Billing Library
    82.5 Querying Available Products
    82.6 Starting the Purchase Process
    82.7 Completing the Purchase
    82.8 Querying Previous Purchases
    82.9 Summary
83. An Android In-App Purchasing Tutorial
    83.1 About the In-App Purchasing Example Project
    83.2 Creating the InAppPurchase Project
    83.3 Adding Libraries to the Project
    83.4 Designing the User Interface
    83.5 Adding the App to the Google Play Store
    83.6 Creating an In-App Product
    83.7 Enabling License Testers
    83.8 Initializing the Billing Client
    83.9 Querying the Product
    83.10 Launching the Purchase Flow
    83.11 Handling Purchase Updates
    83.12 Consuming the Product
    83.13 Restoring a Previous Purchase
    83.14 Testing the App
    83.15 Troubleshooting
    83.16 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 Using Deferred Installation
    85.12 Removing a Dynamic Module
    85.13 Summary
86. Working with Material Design 3 Theming
    86.1 Material Design 2 vs Material Design 3
    86.2 Understanding Material Design Theming
    86.3 Material Design 2 Theming
    86.4 Material Design 3 Theming
    86.5 Building a Custom Theme
    86.6 Summary
87. Migrating from Material Design 2 to Material Design 3
    87.1 Creating the ThemeMigration Project
    87.2 Designing the User Interface
    87.3 Migrating to Material Design 3
    87.4 Building a New Theme
    87.5 Adding the Theme to the Project
    87.6 Enabling Dynamic Color Support
    87.7 Summary
88. An Overview of Gradle in Android Studio
    88.1 An Overview of Gradle
    88.2 Gradle and Android Studio
        88.2.1 Sensible Defaults
        88.2.2 Dependencies
        88.2.3 Build Variants
        88.2.4 Manifest Entries
        88.2.5 APK Signing
        88.2.6 ProGuard Support
    88.3 The Property and Settings Gradle Build File
    88.4 The Top-level Gradle Build File
    88.5 Module Level Gradle Build Files
    88.6 Configuring Signing Settings in the Build File
    88.7 Running Gradle Tasks from the Command-line
    88.8 Summary
Index