Android Studio 4. 0 Development Essentials - Java Edition : Developing Android Apps Using Android Studio 4. 0, Java and Android Jetpack.

✍ Scribed by Neil Smyth

• Year: 2020
• Tongue: English
• Leaves: 795
• Category: Library

✦ Table of Contents

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 7
   2.6.2 Windows 8.1
   2.6.3 Windows 10
   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 Creating a New AVD
   4.3 Starting the Emulator
   4.4 Running the Application in the AVD
   4.5 Stopping a Running Application
   4.6 Supporting Dark Theme
   4.7 AVD Command-line Creation
   4.8 Android Virtual Device Configuration Files
   4.9 Moving and Renaming an Android Virtual Device
   4.10 Summary
5. Using and Configuring the Android Studio AVD Emulator
   5.1 The Emulator Environment
   5.2 The Emulator Toolbar Options
   5.3 Working in Zoom Mode
   5.4 Resizing the Emulator Window
   5.5 Extended Control Options
   5.5.1 Location
   5.5.2 Displays
   5.5.3 Cellular
   5.5.4 Camera
   5.5.5 Battery
   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 Summary
6. A Tour of the Android Studio User Interface
   6.1 The Welcome Screen
   6.2 The Main Window
   6.3 The Tool Windows
   6.4 Android Studio Keyboard Shortcuts
   6.5 Switcher and Recent Files Navigation
   6.6 Changing the Android Studio Theme
   6.7 Summary
7. Testing Android Studio Apps on a Physical Android Device
   7.1 An Overview of the Android Debug Bridge (ADB)
   7.2 Enabling ADB on Android based Devices
   7.2.1 macOS ADB Configuration
   7.2.2 Windows ADB Configuration
   7.2.3 Linux adb Configuration
   7.3 Testing the adb Connection
   7.4 Summary
8. The Basics of the Android Studio Code Editor
   8.1 The Android Studio Editor
   8.2 Splitting the Editor Window
   8.3 Code Completion
   8.4 Statement Completion
   8.5 Parameter Information
   8.6 Parameter Name Hints
   8.7 Code Generation
   8.8 Code Folding
   8.9 Quick Documentation Lookup
   8.10 Code Reformatting
   8.11 Finding Sample Code
   8.12 Live Templates
   8.13 Summary
9. An Overview of the Android Architecture
   9.1 The Android Software Stack
   9.2 The Linux Kernel
   9.3 Android Runtime – ART
   9.4 Android Libraries
   9.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 Bindings
    11.3 Converting the AndroidSample Project
    11.4 Enabling View Binding
    11.5 Using View Bindings
    11.6 Choosing an Option
    11.7 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 Code Mode
    17.7 Split Mode
    17.8 Setting Attributes
    17.9 Converting Views
    17.10 Displaying Sample Data
    17.11 Creating a Custom Device Definition
    17.12 Changing the Current Device
    17.13 Layout Validation (Multi Preview)
    17.14 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 Working with Guidelines
    18.4 Configuring Widget Dimensions
    18.5 Working with Barriers
    18.6 Ratios
    18.7 ConstraintLayout Advantages
    18.8 ConstraintLayout Availability
    18.9 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 Adding Guidelines
    19.13 Adding Barriers
    19.14 Widget Group Alignment and Distribution
    19.15 Converting other Layouts to ConstraintLayout
    19.16 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 Adding the Second Fragment
    31.5 Adding the Fragments to the Activity
    31.6 Making the Toolbar Fragment Talk to the Activity
    31.7 Making the Activity Talk to the Text Fragment
    31.8 Testing the Application
    31.9 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 Triggering the Action
    41.10 Passing Data Using Safeargs
    41.11 Summary
42. Creating and Managing Overflow Menus on Android
    42.1 The Overflow Menu
    42.2 Creating an Overflow Menu
    42.3 Displaying an Overflow Menu
    42.4 Responding to Menu Item Selections
    42.5 Creating Checkable Item Groups
    42.6 Menus and the Android Studio Menu Editor
    42.7 Creating the Example Project
    42.8 Designing the Menu
    42.9 Modifying the onOptionsItemSelected() Method
    42.10 Testing the Application
    42.11 Summary
43. An Introduction to MotionLayout
    43.1 An Overview of MotionLayout
    43.2 MotionLayout
    43.3 MotionScene
    43.4 Configuring ConstraintSets
    43.5 Custom Attributes
    43.6 Triggering an Animation
    43.7 Arc Motion
    43.8 Keyframes
    43.8.1 Attribute Keyframes
    43.8.2 Position Keyframes
    43.9 Time Linearity
    43.10 KeyTrigger
    43.11 Cycle and Time Cycle Keyframes
    43.12 Starting an Animation from Code
    43.13 Summary
44. An Android MotionLayout Editor Tutorial
    44.1 Creating the MotionLayoutDemo Project
    44.2 ConstraintLayout to MotionLayout Conversion
    44.3 Configuring Start and End Constraints
    44.4 Previewing the MotionLayout Animation
    44.5 Adding an OnClick Gesture
    44.6 Adding an Attribute Keyframe to the Transition
    44.7 Adding a CustomAttribute to a Transition
    44.8 Adding Position Keyframes
    44.9 Summary
45. A MotionLayout KeyCycle Tutorial
    45.1 An Overview of Cycle Keyframes
    45.2 Using the Cycle Editor
    45.3 Creating the KeyCycleDemo Project
    45.4 Configuring the Start and End Constraints
    45.5 Creating the Cycles
    45.6 Previewing the Animation
    45.7 Adding the KeyFrameSet to the MotionScene
    45.8 Summary
46. Working with the Floating Action Button and Snackbar
    46.1 The Material Design
    46.2 The Design Library
    46.3 The Floating Action Button (FAB)
    46.4 The Snackbar
    46.5 Creating the Example Project
    46.6 Reviewing the Project
    46.7 Removing Navigation Features
    46.8 Changing the Floating Action Button
    46.9 Adding the ListView to the Content Layout
    46.10 Adding Items to the ListView
    46.11 Adding an Action to the Snackbar
    46.12 Summary
47. Creating a Tabbed Interface using the TabLayout Component
    47.1 An Introduction to the ViewPager
    47.2 An Overview of the TabLayout Component
    47.3 Creating the TabLayoutDemo Project
    47.4 Creating the First Fragment
    47.5 Duplicating the Fragments
    47.6 Adding the TabLayout and ViewPager
    47.7 Creating the Pager Adapter
    47.8 Performing the Initialization Tasks
    47.9 Testing the Application
    47.10 Customizing the TabLayout
    47.11 Displaying Icon Tab Items
    47.12 Summary
48. Working with the RecyclerView and CardView Widgets
    48.1 An Overview of the RecyclerView
    48.2 An Overview of the CardView
    48.3 Summary
49. An Android RecyclerView and CardView Tutorial
    49.1 Creating the CardDemo Project
    49.2 Modifying the Basic Activity Project
    49.3 Designing the CardView Layout
    49.4 Adding the RecyclerView
    49.5 Creating the RecyclerView Adapter
    49.6 Adding the Image Files
    49.7 Initializing the RecyclerView Component
    49.8 Testing the Application
    49.9 Responding to Card Selections
    49.10 Summary
50. A Layout Editor Sample Data Tutorial
    50.1 Adding Sample Data to a Project
    50.2 Using Custom Sample Data
    50.3 Summary
51. Working with the AppBar and Collapsing Toolbar Layouts
    51.1 The Anatomy of an AppBar
    51.2 The Example Project
    51.3 Coordinating the RecyclerView and Toolbar
    51.4 Introducing the Collapsing Toolbar Layout
    51.5 Changing the Title and Scrim Color
    51.6 Summary
52. An Android Studio Master/Detail Flow Tutorial
    52.1 The Master/Detail Flow
    52.2 Creating a Master/Detail Flow Activity
    52.3 The Anatomy of the Master/Detail Flow Template
    52.4 Modifying the Master/Detail Flow Template
    52.5 Changing the Content Model
    52.6 Changing the Detail Pane
    52.7 Modifying the WebsiteDetailFragment Class
    52.8 Modifying the WebsiteListActivity Class
    52.9 Adding Manifest Permissions
    52.10 Running the Application
    52.11 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 Checking Intent Availability
    53.7 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 ActivityB
    54.5 Reviewing the Application Manifest File
    54.6 Creating the Intent
    54.7 Extracting Intent Data
    54.8 Launching ActivityB 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 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. A Basic Overview of Threads and AsyncTasks
    57.1 An Overview of Threads
    57.2 The Application Main Thread
    57.3 Thread Handlers
    57.4 A Basic AsyncTask Example
    57.5 Subclassing AsyncTask
    57.6 Testing the App
    57.7 Canceling a Task
    57.8 Summary
58. An Overview of Android Started and Bound Services
    58.1 Started Services
    58.2 Intent Service
    58.3 Bound Service
    58.4 The Anatomy of a Service
    58.5 Controlling Destroyed Service Restart Options
    58.6 Declaring a Service in the Manifest File
    58.7 Starting a Service Running on System Startup
    58.8 Summary
59. Implementing an Android Started Service – A Worked Example
    59.1 Creating the Example Project
    59.2 Creating the Service Class
    59.3 Adding the Service to the Manifest File
    59.4 Starting the Service
    59.5 Testing the IntentService Example
    59.6 Using the Service Class
    59.7 Creating the New Service
    59.8 Modifying the User Interface
    59.9 Running the Application
    59.10 Creating an AsyncTask for Service Tasks
    59.11 Summary
60. Android Local Bound Services – A Worked Example
    60.1 Understanding Bound Services
    60.2 Bound Service Interaction Options
    60.3 An Android Studio Local Bound Service Example
    60.4 Adding a Bound Service to the Project
    60.5 Implementing the Binder
    60.6 Binding the Client to the Service
    60.7 Completing the Example
    60.8 Testing the Application
    60.9 Summary
61. Android Remote Bound Services – A Worked Example
    61.1 Client to Remote Service Communication
    61.2 Creating the Example Application
    61.3 Designing the User Interface
    61.4 Implementing the Remote Bound Service
    61.5 Configuring a Remote Service in the Manifest File
    61.6 Launching and Binding to the Remote Service
    61.7 Sending a Message to the Remote Service
    61.8 Summary
62. An Android Notifications Tutorial
    62.1 An Overview of Notifications
    62.2 Creating the NotifyDemo Project
    62.3 Designing the User Interface
    62.4 Creating the Second Activity
    62.5 Creating a Notification Channel
    62.6 Creating and Issuing a Basic Notification
    62.7 Launching an Activity from a Notification
    62.8 Adding Actions to a Notification
    62.9 Bundled Notifications
    62.10 Summary
63. An Android Direct Reply Notification Tutorial
    63.1 Creating the DirectReply Project
    63.2 Designing the User Interface
    63.3 Creating the Notification Channel
    63.4 Building the RemoteInput Object
    63.5 Creating the PendingIntent
    63.6 Creating the Reply Action
    63.7 Receiving Direct Reply Input
    63.8 Updating the Notification
    63.9 Summary
64. Foldable Devices and Multi-Window Support
    64.1 Foldables and Multi-Window Support
    64.2 Using a Foldable Emulator
    64.3 Entering Multi-Window Mode
    64.4 Enabling and using Freeform Support
    64.5 Checking for Freeform Support
    64.6 Enabling Multi-Window Support in an App
    64.7 Specifying Multi-Window Attributes
    64.8 Detecting Multi-Window Mode in an Activity
    64.9 Receiving Multi-Window Notifications
    64.10 Launching an Activity in Multi-Window Mode
    64.11 Configuring Freeform Activity Size and Position
    64.12 Summary
65. An Overview of Android SQLite Databases
    65.1 Understanding Database Tables
    65.2 Introducing Database Schema
    65.3 Columns and Data Types
    65.4 Database Rows
    65.5 Introducing Primary Keys
    65.6 What is SQLite?
    65.7 Structured Query Language (SQL)
    65.8 Trying SQLite on an Android Virtual Device (AVD)
    65.9 The Android Room Persistence Library
    65.10 Summary
66. The Android Room Persistence Library
    66.1 Revisiting Modern App Architecture
    66.2 Key Elements of Room Database Persistence
    66.2.1 Repository
    66.2.2 Room Database
    66.2.3 Data Access Object (DAO)
    66.2.4 Entities
    66.2.5 SQLite Database
    66.3 Understanding Entities
    66.4 Data Access Objects
    66.5 The Room Database
    66.6 The Repository
    66.7 In-Memory Databases
    66.8 Summary
67. An Android TableLayout and TableRow Tutorial
    67.1 The TableLayout and TableRow Layout Views
    67.2 Creating the Room Database Project
    67.3 Converting to a LinearLayout
    67.4 Adding the TableLayout to the User Interface
    67.5 Configuring the TableRows
    67.6 Adding the Button Bar to the Layout
    67.7 Adding the RecyclerView
    67.8 Adjusting the Layout Margins
    67.9 Summary
68. An Android Room Database and Repository Tutorial
    68.1 About the RoomDemo Project
    68.2 Modifying the Build Configuration
    68.3 Building the Entity
    68.4 Creating the Data Access Object
    68.5 Adding the Room Database
    68.6 Adding the Repository
    68.7 Modifying the ViewModel
    68.8 Creating the Product Item Layout
    68.9 Adding the RecyclerView Adapter
    68.10 Preparing the Main Fragment
    68.11 Adding the Button Listeners
    68.12 Adding LiveData Observers
    68.13 Initializing the RecyclerView
    68.14 Testing the RoomDemo App
    68.15 Summary
69. Accessing Cloud Storage using the Android Storage Access Framework
    69.1 The Storage Access Framework
    69.2 Working with the Storage Access Framework
    69.3 Filtering Picker File Listings
    69.4 Handling Intent Results
    69.5 Reading the Content of a File
    69.6 Writing Content to a File
    69.7 Deleting a File
    69.8 Gaining Persistent Access to a File
    69.9 Summary
70. An Android Storage Access Framework Example
    70.1 About the Storage Access Framework Example
    70.2 Creating the Storage Access Framework Example
    70.3 Designing the User Interface
    70.4 Declaring Request Codes
    70.5 Creating a New Storage File
    70.6 The onActivityResult() Method
    70.7 Saving to a Storage File
    70.8 Opening and Reading a Storage File
    70.9 Testing the Storage Access Application
    70.10 Summary
71. Video Playback on Android using the VideoView and MediaController Classes
    71.1 Introducing the Android VideoView Class
    71.2 Introducing the Android MediaController Class
    71.3 Creating the Video Playback Example
    71.4 Designing the VideoPlayer Layout
    71.5 Downloading the Video File
    71.6 Configuring the VideoView
    71.7 Adding the MediaController to the Video View
    71.8 Setting up the onPreparedListener
    71.9 Summary
72. Android Picture-in-Picture Mode
    72.1 Picture-in-Picture Features
    72.2 Enabling Picture-in-Picture Mode
    72.3 Configuring Picture-in-Picture Parameters
    72.4 Entering Picture-in-Picture Mode
    72.5 Detecting Picture-in-Picture Mode Changes
    72.6 Adding Picture-in-Picture Actions
    72.7 Summary
73. An Android Picture-in-Picture Tutorial
    73.1 Adding Picture-in-Picture Support to the Manifest
    73.2 Adding a Picture-in-Picture Button
    73.3 Entering Picture-in-Picture Mode
    73.4 Detecting Picture-in-Picture Mode Changes
    73.5 Adding a Broadcast Receiver
    73.6 Adding the PiP Action
    73.7 Testing the Picture-in-Picture Action
    73.8 Summary
74. Making Runtime Permission Requests in Android
    74.1 Understanding Normal and Dangerous Permissions
    74.2 Creating the Permissions Example Project
    74.3 Checking for a Permission
    74.4 Requesting Permission at Runtime
    74.5 Providing a Rationale for the Permission Request
    74.6 Testing the Permissions App
    74.7 Summary
75. Android Audio Recording and Playback using MediaPlayer and MediaRecorder
    75.1 Playing Audio
    75.2 Recording Audio and Video using the MediaRecorder Class
    75.3 About the Example Project
    75.4 Creating the AudioApp Project
    75.5 Designing the User Interface
    75.6 Checking for Microphone Availability
    75.7 Performing the Activity Initialization
    75.8 Implementing the recordAudio() Method
    75.9 Implementing the stopAudio() Method
    75.10 Implementing the playAudio() method
    75.11 Configuring and Requesting Permissions
    75.12 Testing the Application
    75.13 Summary
76. Working with the Google Maps Android API in Android Studio
    76.1 The Elements of the Google Maps Android API
    76.2 Creating the Google Maps Project
    76.3 Obtaining Your Developer Signature
    76.4 Adding the Apache HTTP Legacy Library Requirement
    76.5 Testing the Application
    76.6 Understanding Geocoding and Reverse Geocoding
    76.7 Adding a Map to an Application
    76.8 Requesting Current Location Permission
    76.9 Displaying the User’s Current Location
    76.10 Changing the Map Type
    76.11 Displaying Map Controls to the User
    76.12 Handling Map Gesture Interaction
    76.12.1 Map Zooming Gestures
    76.12.2 Map Scrolling/Panning Gestures
    76.12.3 Map Tilt Gestures
    76.12.4 Map Rotation Gestures
    76.13 Creating Map Markers
    76.14 Controlling the Map Camera
    76.15 Summary
77. Printing with the Android Printing Framework
    77.1 The Android Printing Architecture
    77.2 The Print Service Plugins
    77.3 Google Cloud Print
    77.4 Printing to Google Drive
    77.5 Save as PDF
    77.6 Printing from Android Devices
    77.7 Options for Building Print Support into Android Apps
    77.7.1 Image Printing
    77.7.2 Creating and Printing HTML Content
    77.7.3 Printing a Web Page
    77.7.4 Printing a Custom Document
    77.8 Summary
78. An Android HTML and Web Content Printing Example
    78.1 Creating the HTML Printing Example Application
    78.2 Printing Dynamic HTML Content
    78.3 Creating the Web Page Printing Example
    78.4 Removing the Floating Action Button
    78.5 Removing Navigation Features
    78.6 Designing the User Interface Layout
    78.7 Loading the Web Page into the WebView
    78.8 Adding the Print Menu Option
    78.9 Summary
79. A Guide to Android Custom Document Printing
    79.1 An Overview of Android Custom Document Printing
    79.1.1 Custom Print Adapters
    79.2 Preparing the Custom Document Printing Project
    79.3 Creating the Custom Print Adapter
    79.4 Implementing the onLayout() Callback Method
    79.5 Implementing the onWrite() Callback Method
    79.6 Checking a Page is in Range
    79.7 Drawing the Content on the Page Canvas
    79.8 Starting the Print Job
    79.9 Testing the Application
    79.10 Summary
80. An Introduction to Android App Links
    80.1 An Overview of Android App Links
    80.2 App Link Intent Filters
    80.3 Handling App Link Intents
    80.4 Associating the App with a Website
    80.5 Summary
81. An Android Studio App Links Tutorial
    81.1 About the Example App
    81.2 The Database Schema
    81.3 Loading and Running the Project
    81.4 Adding the URL Mapping
    81.5 Adding the Intent Filter
    81.6 Adding Intent Handling Code
    81.7 Testing the App Link
    81.8 Associating an App Link with a Web Site
    81.9 Summary
82. A Guide to the Android Studio Profiler
    82.1 Accessing the Android Profiler
    82.2 Enabling Advanced Profiling
    82.3 The Android Profiler Tool Window
    82.4 The Sessions Panel
    82.5 The CPU Profiler
    82.6 Memory Profiler
    82.7 Network Profiler
    82.8 Energy Profiler
    82.9 Summary
83. An Android Biometric Authentication Tutorial
    83.1 An Overview of Biometric Authentication
    83.2 Creating the Biometric Authentication Project
    83.3 Configuring Device Fingerprint Authentication
    83.4 Adding the Biometric Permission to the Manifest File
    83.5 Designing the User Interface
    83.6 Adding a Toast Convenience Method
    83.7 Checking the Security Settings
    83.8 Configuring the Authentication Callbacks
    83.9 Adding the CancellationSignal
    83.10 Starting the Biometric Prompt
    83.11 Testing the Project
    83.12 Summary
84. Creating, Testing and Uploading an Android App Bundle
    84.1 The Release Preparation Process
    84.2 Android App Bundles
    84.3 Register for a Google Play Developer Console Account
    84.4 Configuring the App in the Console
    84.5 Enabling Google Play App Signing
    84.6 Creating a Keystore File
    84.7 Creating the Android App Bundle
    84.8 Generating Test APK Files
    84.9 Uploading the App Bundle to the Google Play Developer Console
    84.10 Exploring the App Bundle
    84.11 Managing Testers
    84.12 Uploading New App Bundle Revisions
    84.13 Analyzing the App Bundle File
    84.14 Enabling Google Play Signing for an Existing App
    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 Handling Large Downloads
    86.12 Using Deferred Installation
    86.13 Removing a Dynamic Module
    86.14 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 Top-level Gradle Build File
    87.4 Module Level Gradle Build Files
    87.5 Configuring Signing Settings in the Build File
    87.6 Running Gradle Tasks from the Command-line
    87.7 Summary
    Index
    _GoBack
    _Ref381951250
    _Ref381951280
    _Ref381877478
    _Ref382489559
    _Ref382490730
    _GoBack
    _GoBack
    _Ref384718331
    _Ref324774345