Android Studio 4.0 Development Essentials - Kotlin Edition: Developing Android Apps Using Android Studio 4.0, Kotlin and Android Jetpack

✍ Scribed by Neil Smyth

• Publisher: Payload Media
• Year: 2020
• Tongue: English
• Leaves: 817
• Category: Library

✦ Synopsis

Fully updated for Android Studio 4.0, the goal of this book is to teach the skills necessary to develop Android based applications using the Kotlin programming language.

Beginning with the basics, this book provides an outline of the steps necessary to set up an Android development and testing environment followed by an introduction to programming in Kotlin including data types, flow control, functions, lambdas, coroutines and object-oriented programming.

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, 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, cloud-based file storage 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.

In addition to covering general Android development techniques, the book also includes Google Play specific topics such as implementing maps using the Google Maps Android API, and submitting apps to the Google Play Developer Console. Other key features of Android Studio 4.0 and the Android SDK are also covered in detail including the Layout Editor, the ConstraintLayout and ConstraintSet classes, view binding, MotionLayout animation, constraint chains and barriers, direct reply notifications and foldable device support.

Chapters also cover advanced features of Android Studio such as App Links, Dynamic Delivery, the Android Studio Profiler and Gradle build configuration.

Assuming you already have some programming experience, are ready to download Android Studio and the Android SDK, have access to a Windows, Mac or Linux system and ideas for some apps to develop, you are ready to get started.

✦ 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 Introduction to Kotlin
    11.1 What is Kotlin?
    11.2 Kotlin and Java
    11.3 Converting from Java to Kotlin
    11.4 Kotlin and Android Studio
    11.5 Experimenting with Kotlin
    11.6 Semi-colons in Kotlin
    11.7 Summary
12. Kotlin Data Types,Variables and Nullability
    12.1 Kotlin Data Types
    12.1.1 Integer Data Types
    12.1.2 Floating Point Data Types
    12.1.3 Boolean Data Type
    12.1.4 Character Data Type
    12.1.5 String Data Type
    12.1.6 Escape Sequences
    12.2 Mutable Variables
    12.3 Immutable Variables
    12.4 Declaring Mutable and Immutable Variables
    12.5 Data Types are Objects
    12.6 Type Annotations and Type Inference
    12.7 Nullable Type
    12.8 The Safe Call Operator
    12.9 Not-Null Assertion
    12.10 Nullable Types and the let Function
    12.11 Late Initialization (lateinit)
    12.12 The Elvis Operator
    12.13 Type Casting and Type Checking
    12.14 Summary
13. Kotlin Operators and Expressions
    13.1 Expression Syntax in Kotlin
    13.2 The Basic Assignment Operator
    13.3 Kotlin Arithmetic Operators
    13.4 Augmented Assignment Operators
    13.5 Increment and Decrement Operators
    13.6 Equality Operators
    13.7 Boolean Logical Operators
    13.8 Range Operator
    13.9 Bitwise Operators
    13.9.1 Bitwise Inversion
    13.9.2 Bitwise AND
    13.9.3 Bitwise OR
    13.9.4 Bitwise XOR
    13.9.5 Bitwise Left Shift
    13.9.6 Bitwise Right Shift
    13.10 Summary
14. Kotlin Flow Control
    14.1 Looping Flow Control
    14.1.1 The Kotlin for-in Statement
    14.1.2 The while Loop
    14.1.3 The do ... while loop
    14.1.4 Breaking from Loops
    14.1.5 The continue Statement
    14.1.6 Break and Continue Labels
    14.2 Conditional Flow Control
    14.2.1 Using the if Expressions
    14.2.2 Using if ... else … Expressions
    14.2.3 Using if ... else if ... Expressions
    14.2.4 Using the when Statement
    14.3 Summary
15. An Overview of Kotlin Functions and Lambdas
    15.1 What is a Function?
    15.2 How to Declare a Kotlin Function
    15.3 Calling a Kotlin Function
    15.4 Single Expression Functions
    15.5 Local Functions
    15.6 Handling Return Values
    15.7 Declaring Default Function Parameters
    15.8 Variable Number of Function Parameters
    15.9 Lambda Expressions
    15.10 Higher-order Functions
    15.11 Summary
16. The Basics of Object Oriented Programming in Kotlin
    16.1 What is an Object?
    16.2 What is a Class?
    16.3 Declaring a Kotlin Class
    16.4 Adding Properties to a Class
    16.5 Defining Methods
    16.6 Declaring and Initializing a Class Instance
    16.7 Primary and Secondary Constructors
    16.8 Initializer Blocks
    16.9 Calling Methods and Accessing Properties
    16.10 Custom Accessors
    16.11 Nested and Inner Classes
    16.12 Companion Objects
    16.13 Summary
17. An Introduction to Kotlin Inheritance and Subclassing
    17.1 Inheritance, Classes and Subclasses
    17.2 Subclassing Syntax
    17.3 A Kotlin Inheritance Example
    17.4 Extending the Functionality of a Subclass
    17.5 Overriding Inherited Methods
    17.6 Adding a Custom Secondary Constructor
    17.7 Using the SavingsAccount Class
    17.8 Summary
18. An Overview of Android View Binding
    18.1 Find View by ID and Synthetic Properties
    18.2 View Bindings
    18.3 Converting the AndroidSample Project
    18.4 Enabling View Binding
    18.5 Using View Bindings
    18.6 Choosing an Option
    18.7 Summary
19. Understanding Android Application and Activity Lifecycles
    19.1 Android Applications and Resource Management
    19.2 Android Process States
    19.2.1 Foreground Process
    19.2.2 Visible Process
    19.2.3 Service Process
    19.2.4 Background Process
    19.2.5 Empty Process
    19.3 Inter-Process Dependencies
    19.4 The Activity Lifecycle
    19.5 The Activity Stack
    19.6 Activity States
    19.7 Configuration Changes
    19.8 Handling State Change
    19.9 Summary
20. Handling Android Activity State Changes
    20.1 New vs. Old Lifecycle Techniques
    20.2 The Activity and Fragment Classes
    20.3 Dynamic State vs. Persistent State
    20.4 The Android Lifecycle Methods
    20.5 Lifetimes
    20.6 Foldable Devices and Multi-Resume
    20.7 Disabling Configuration Change Restarts
    20.8 Lifecycle Method Limitations
    20.9 Summary
21. Android Activity State Changes by Example
    21.1 Creating the State Change Example Project
    21.2 Designing the User Interface
    21.3 Overriding the Activity Lifecycle Methods
    21.4 Filtering the Logcat Panel
    21.5 Running the Application
    21.6 Experimenting with the Activity
    21.7 Summary
22. Saving and Restoring the State of an Android Activity
    22.1 Saving Dynamic State
    22.2 Default Saving of User Interface State
    22.3 The Bundle Class
    22.4 Saving the State
    22.5 Restoring the State
    22.6 Testing the Application
    22.7 Summary
23. Understanding Android Views, View Groups and Layouts
    23.1 Designing for Different Android Devices
    23.2 Views and View Groups
    23.3 Android Layout Managers
    23.4 The View Hierarchy
    23.5 Creating User Interfaces
    23.6 Summary
24. A Guide to the Android Studio Layout Editor Tool
    24.1 Basic vs. Empty Activity Templates
    24.2 The Android Studio Layout Editor
    24.3 Design Mode
    24.4 The Palette
    24.5 Design Mode and Layout Views
    24.6 Code Mode
    24.7 Split Mode
    24.8 Setting Attributes
    24.9 Converting Views
    24.10 Displaying Sample Data
    24.11 Creating a Custom Device Definition
    24.12 Changing the Current Device
    24.13 Layout Validation (Multi Preview)
    24.14 Summary
25. A Guide to the Android ConstraintLayout
    25.1 How ConstraintLayout Works
    25.1.1 Constraints
    25.1.2 Margins
    25.1.3 Opposing Constraints
    25.1.4 Constraint Bias
    25.1.5 Chains
    25.1.6 Chain Styles
    25.2 Baseline Alignment
    25.3 Working with Guidelines
    25.4 Configuring Widget Dimensions
    25.5 Working with Barriers
    25.6 Ratios
    25.7 ConstraintLayout Advantages
    25.8 ConstraintLayout Availability
    25.9 Summary
26. A Guide to using ConstraintLayout in Android Studio
    26.1 Design and Layout Views
    26.2 Autoconnect Mode
    26.3 Inference Mode
    26.4 Manipulating Constraints Manually
    26.5 Adding Constraints in the Inspector
    26.6 Viewing Constraints in the Attributes Window
    26.7 Deleting Constraints
    26.8 Adjusting Constraint Bias
    26.9 Understanding ConstraintLayout Margins
    26.10 The Importance of Opposing Constraints and Bias
    26.11 Configuring Widget Dimensions
    26.12 Adding Guidelines
    26.13 Adding Barriers
    26.14 Widget Group Alignment and Distribution
    26.15 Converting other Layouts to ConstraintLayout
    26.16 Summary
27. Working with ConstraintLayout Chains and Ratios in Android Studio
    27.1 Creating a Chain
    27.2 Changing the Chain Style
    27.3 Spread Inside Chain Style
    27.4 Packed Chain Style
    27.5 Packed Chain Style with Bias
    27.6 Weighted Chain
    27.7 Working with Ratios
    27.8 Summary
28. An Android Studio Layout Editor ConstraintLayout Tutorial
    28.1 An Android Studio Layout Editor Tool Example
    28.2 Creating a New Activity
    28.3 Preparing the Layout Editor Environment
    28.4 Adding the Widgets to the User Interface
    28.5 Adding the Constraints
    28.6 Testing the Layout
    28.7 Using the Layout Inspector
    28.8 Summary
29. Manual XML Layout Design in Android Studio
    29.1 Manually Creating an XML Layout
    29.2 Manual XML vs. Visual Layout Design
    29.3 Summary
30. Managing Constraints using Constraint Sets
    30.1 Kotlin Code vs. XML Layout Files
    30.2 Creating Views
    30.3 View Attributes
    30.4 Constraint Sets
    30.4.1 Establishing Connections
    30.4.2 Applying Constraints to a Layout
    30.4.3 Parent Constraint Connections
    30.4.4 Sizing Constraints
    30.4.5 Constraint Bias
    30.4.6 Alignment Constraints
    30.4.7 Copying and Applying Constraint Sets
    30.4.8 ConstraintLayout Chains
    30.4.9 Guidelines
    30.4.10 Removing Constraints
    30.4.11 Scaling
    30.4.12 Rotation
    30.5 Summary
31. An Android ConstraintSet Tutorial
    31.1 Creating the Example Project in Android Studio
    31.2 Adding Views to an Activity
    31.3 Setting View Attributes
    31.4 Creating View IDs
    31.5 Configuring the Constraint Set
    31.6 Adding the EditText View
    31.7 Converting Density Independent Pixels (dp) to Pixels (px)
    31.8 Summary
32. A Guide to using Apply Changes in Android Studio
    32.1 Introducing Apply Changes
    32.2 Understanding Apply Changes Options
    32.3 Using Apply Changes
    32.4 Configuring Apply Changes Fallback Settings
    32.5 An Apply Changes Tutorial
    32.6 Using Apply Code Changes
    32.7 Using Apply Changes and Restart Activity
    32.8 Using Run App
    32.9 Summary
33. An Overview and Example of Android Event Handling
    33.1 Understanding Android Events
    33.2 Using the android:onClick Resource
    33.3 Event Listeners and Callback Methods
    33.4 An Event Handling Example
    33.5 Designing the User Interface
    33.6 The Event Listener and Callback Method
    33.7 Consuming Events
    33.8 Summary
34. Android Touch and Multi-touch Event Handling
    34.1 Intercepting Touch Events
    34.2 The MotionEvent Object
    34.3 Understanding Touch Actions
    34.4 Handling Multiple Touches
    34.5 An Example Multi-Touch Application
    34.6 Designing the Activity User Interface
    34.7 Implementing the Touch Event Listener
    34.8 Running the Example Application
    34.9 Summary
35. Detecting Common Gestures using the Android Gesture Detector Class
    35.1 Implementing Common Gesture Detection
    35.2 Creating an Example Gesture Detection Project
    35.3 Implementing the Listener Class
    35.4 Creating the GestureDetectorCompat Instance
    35.5 Implementing the onTouchEvent() Method
    35.6 Testing the Application
    35.7 Summary
36. Implementing Custom Gesture and Pinch Recognition on Android
    36.1 The Android Gesture Builder Application
    36.2 The GestureOverlayView Class
    36.3 Detecting Gestures
    36.4 Identifying Specific Gestures
    36.5 Installing and Running the Gesture Builder Application
    36.6 Creating a Gestures File
    36.7 Creating the Example Project
    36.8 Extracting the Gestures File from the SD Card
    36.9 Adding the Gestures File to the Project
    36.10 Designing the User Interface
    36.11 Loading the Gestures File
    36.12 Registering the Event Listener
    36.13 Implementing the onGesturePerformed Method
    36.14 Testing the Application
    36.15 Configuring the GestureOverlayView
    36.16 Intercepting Gestures
    36.17 Detecting Pinch Gestures
    36.18 A Pinch Gesture Example Project
    36.19 Summary
37. An Introduction to Android Fragments
    37.1 What is a Fragment?
    37.2 Creating a Fragment
    37.3 Adding a Fragment to an Activity using the Layout XML File
    37.4 Adding and Managing Fragments in Code
    37.5 Handling Fragment Events
    37.6 Implementing Fragment Communication
    37.7 Summary
38. Using Fragments in Android Studio - An Example
    38.1 About the Example Fragment Application
    38.2 Creating the Example Project
    38.3 Creating the First Fragment Layout
    38.4 Adding the Second Fragment
    38.5 Adding the Fragments to the Activity
    38.6 Making the Toolbar Fragment Talk to the Activity
    38.7 Making the Activity Talk to the Text Fragment
    38.8 Testing the Application
    38.9 Summary
39. Modern Android App Architecture with Jetpack
    39.1 What is Android Jetpack?
    39.2 The “Old” Architecture
    39.3 Modern Android Architecture
    39.4 The ViewModel Component
    39.5 The LiveData Component
    39.6 ViewModel Saved State
    39.7 LiveData and Data Binding
    39.8 Android Lifecycles
    39.9 Repository Modules
    39.10 Summary
40. An Android Jetpack ViewModel Tutorial
    40.1 About the Project
    40.2 Creating the ViewModel Example Project
    40.3 Reviewing the Project
    40.3.1 The Main Activity
    40.3.2 The Content Fragment
    40.3.3 The ViewModel
    40.4 Designing the Fragment Layout
    40.5 Implementing the View Model
    40.6 Associating the Fragment with the View Model
    40.7 Modifying the Fragment
    40.8 Accessing the ViewModel Data
    40.9 Testing the Project
    40.10 Summary
41. An Android Jetpack LiveData Tutorial
    41.1 LiveData - A Recap
    41.2 Adding LiveData to the ViewModel
    41.3 Implementing the Observer
    41.4 Summary
42. An Overview of Android Jetpack Data Binding
    42.1 An Overview of Data Binding
    42.2 The Key Components of Data Binding
    42.2.1 The Project Build Configuration
    42.2.2 The Data Binding Layout File
    42.2.3 The Layout File Data Element
    42.2.4 The Binding Classes
    42.2.5 Data Binding Variable Configuration
    42.2.6 Binding Expressions (One-Way)
    42.2.7 Binding Expressions (Two-Way)
    42.2.8 Event and Listener Bindings
    42.3 Summary
43. An Android Jetpack Data Binding Tutorial
    43.1 Removing the Redundant Code
    43.2 Enabling Data Binding
    43.3 Adding the Layout Element
    43.4 Adding the Data Element to Layout File
    43.5 Working with the Binding Class
    43.6 Assigning the ViewModel Instance to the Data Binding Variable
    43.7 Adding Binding Expressions
    43.8 Adding the Conversion Method
    43.9 Adding a Listener Binding
    43.10 Testing the App
    43.11 Summary
44. An Android ViewModel Saved State Tutorial
    44.1 Understanding ViewModel State Saving
    44.2 Implementing ViewModel State Saving
    44.3 Saving and Restoring State
    44.4 Adding Saved State Support to the ViewModelDemo Project
    44.5 Summary
45. Working with Android Lifecycle-Aware Components
    45.1 Lifecycle Awareness
    45.2 Lifecycle Owners
    45.3 Lifecycle Observers
    45.4 Lifecycle States and Events
    45.5 Summary
46. An Android Jetpack Lifecycle Awareness Tutorial
    46.1 Creating the Example Lifecycle Project
    46.2 Creating a Lifecycle Observer
    46.3 Adding the Observer
    46.4 Testing the Observer
    46.5 Creating a Lifecycle Owner
    46.6 Testing the Custom Lifecycle Owner
    46.7 Summary
47. An Overview of the Navigation Architecture Component
    47.1 Understanding Navigation
    47.2 Declaring a Navigation Host
    47.3 The Navigation Graph
    47.4 Accessing the Navigation Controller
    47.5 Triggering a Navigation Action
    47.6 Passing Arguments
    47.7 Summary
48. An Android Jetpack Navigation Component Tutorial
    48.1 Creating the NavigationDemo Project
    48.2 Adding Navigation to the Build Configuration
    48.3 Creating the Navigation Graph Resource File
    48.4 Declaring a Navigation Host
    48.5 Adding Navigation Destinations
    48.6 Designing the Destination Fragment Layouts
    48.7 Adding an Action to the Navigation Graph
    48.8 Implement the OnFragmentInteractionListener
    48.9 Triggering the Action
    48.10 Passing Data Using Safeargs
    48.11 Summary
49. Creating and Managing Overflow Menus on Android
    49.1 The Overflow Menu
    49.2 Creating an Overflow Menu
    49.3 Displaying an Overflow Menu
    49.4 Responding to Menu Item Selections
    49.5 Creating Checkable Item Groups
    49.6 Menus and the Android Studio Menu Editor
    49.7 Creating the Example Project
    49.8 Designing the Menu
    49.9 Modifying the onOptionsItemSelected() Method
    49.10 Testing the Application
    49.11 Summary
50. An Introduction to MotionLayout
    50.1 An Overview of MotionLayout
    50.2 MotionLayout
    50.3 MotionScene
    50.4 Configuring ConstraintSets
    50.5 Custom Attributes
    50.6 Triggering an Animation
    50.7 Arc Motion
    50.8 Keyframes
    50.8.1 Attribute Keyframes
    50.8.2 Position Keyframes
    50.9 Time Linearity
    50.10 KeyTrigger
    50.11 Cycle and Time Cycle Keyframes
    50.12 Starting an Animation from Code
    50.13 Summary
51. An Android MotionLayout Editor Tutorial
    51.1 Creating the MotionLayoutDemo Project
    51.2 ConstraintLayout to MotionLayout Conversion
    51.3 Configuring Start and End Constraints
    51.4 Previewing the MotionLayout Animation
    51.5 Adding an OnClick Gesture
    51.6 Adding an Attribute Keyframe to the Transition
    51.7 Adding a CustomAttribute to a Transition
    51.8 Adding Position Keyframes
    51.9 Summary
52. A MotionLayout KeyCycle Tutorial
    52.1 An Overview of Cycle Keyframes
    52.2 Using the Cycle Editor
    52.3 Creating the KeyCycleDemo Project
    52.4 Configuring the Start and End Constraints
    52.5 Creating the Cycles
    52.6 Previewing the Animation
    52.7 Adding the KeyFrameSet to the MotionScene
    52.8 Summary
53. Working with the Floating Action Button and Snackbar
    53.1 The Material Design
    53.2 The Design Library
    53.3 The Floating Action Button (FAB)
    53.4 The Snackbar
    53.5 Creating the Example Project
    53.6 Reviewing the Project
    53.7 Removing Navigation Features
    53.8 Changing the Floating Action Button
    53.9 Adding the ListView to the Content Layout
    53.10 Adding Items to the ListView
    53.11 Adding an Action to the Snackbar
    53.12 Summary
54. Creating a Tabbed Interface using the TabLayout Component
    54.1 An Introduction to the ViewPager
    54.2 An Overview of the TabLayout Component
    54.3 Creating the TabLayoutDemo Project
    54.4 Creating the First Fragment
    54.5 Duplicating the Fragments
    54.6 Adding the TabLayout and ViewPager
    54.7 Creating the Pager Adapter
    54.8 Performing the Initialization Tasks
    54.9 Testing the Application
    54.10 Customizing the TabLayout
    54.11 Displaying Icon Tab Items
    54.12 Summary
55. Working with the RecyclerView and CardView Widgets
    55.1 An Overview of the RecyclerView
    55.2 An Overview of the CardView
    55.3 Summary
56. An Android RecyclerView and CardView Tutorial
    56.1 Creating the CardDemo Project
    56.2 Modifying the Basic Activity Project
    56.3 Designing the CardView Layout
    56.4 Adding the RecyclerView
    56.5 Creating the RecyclerView Adapter
    56.6 Adding the Image Files
    56.7 Initializing the RecyclerView Component
    56.8 Testing the Application
    56.9 Responding to Card Selections
    56.10 Summary
57. A Layout Editor Sample Data Tutorial
    57.1 Adding Sample Data to a Project
    57.2 Using Custom Sample Data
    57.3 Summary
58. Working with the AppBar and Collapsing Toolbar Layouts
    58.1 The Anatomy of an AppBar
    58.2 The Example Project
    58.3 Coordinating the RecyclerView and Toolbar
    58.4 Introducing the Collapsing Toolbar Layout
    58.5 Changing the Title and Scrim Color
    58.6 Summary
59. An Android Studio Master/Detail Flow Tutorial
    59.1 The Master/Detail Flow
    59.2 Creating a Master/Detail Flow Activity
    59.3 The Anatomy of the Master/Detail Flow Template
    59.4 Modifying the Master/Detail Flow Template
    59.5 Changing the Content Model
    59.6 Changing the Detail Pane
    59.7 Modifying the WebsiteDetailFragment Class
    59.8 Modifying the WebsiteListActivity Class
    59.9 Adding Manifest Permissions
    59.10 Running the Application
    59.11 Summary
60. An Overview of Android Intents
    60.1 An Overview of Intents
    60.2 Explicit Intents
    60.3 Returning Data from an Activity
    60.4 Implicit Intents
    60.5 Using Intent Filters
    60.6 Checking Intent Availability
    60.7 Summary
61. Android Explicit Intents – A Worked Example
    61.1 Creating the Explicit Intent Example Application
    61.2 Designing the User Interface Layout for MainActivity
    61.3 Creating the Second Activity Class
    61.4 Designing the User Interface Layout for ActivityB
    61.5 Reviewing the Application Manifest File
    61.6 Creating the Intent
    61.7 Extracting Intent Data
    61.8 Launching ActivityB as a Sub-Activity
    61.9 Returning Data from a Sub-Activity
    61.10 Testing the Application
    61.11 Summary
62. Android Implicit Intents – A Worked Example
    62.1 Creating the Android Studio Implicit Intent Example Project
    62.2 Designing the User Interface
    62.3 Creating the Implicit Intent
    62.4 Adding a Second Matching Activity
    62.5 Adding the Web View to the UI
    62.6 Obtaining the Intent URL
    62.7 Modifying the MyWebView Project Manifest File
    62.8 Installing the MyWebView Package on a Device
    62.9 Testing the Application
    62.10 Summary
63. Android Broadcast Intents and Broadcast Receivers
    63.1 An Overview of Broadcast Intents
    63.2 An Overview of Broadcast Receivers
    63.3 Obtaining Results from a Broadcast
    63.4 Sticky Broadcast Intents
    63.5 The Broadcast Intent Example
    63.6 Creating the Example Application
    63.7 Creating and Sending the Broadcast Intent
    63.8 Creating the Broadcast Receiver
    63.9 Registering the Broadcast Receiver
    63.10 Testing the Broadcast Example
    63.11 Listening for System Broadcasts
    63.12 Summary
64. A Basic Overview of Threads and AsyncTasks
    64.1 An Overview of Threads
    64.2 The Application Main Thread
    64.3 Thread Handlers
    64.4 A Basic AsyncTask Example
    64.5 Subclassing AsyncTask
    64.6 Testing the App
    64.7 Canceling a Task
    64.8 Summary
65. An Introduction to Kotlin Coroutines
    65.1 What are Coroutines?
    65.2 Threads vs Coroutines
    65.3 Coroutine Scope
    65.4 Suspend Functions
    65.5 Coroutine Dispatchers
    65.6 Coroutine Builders
    65.7 Jobs
    65.8 Coroutines – Suspending and Resuming
    65.9 Returning Results from a Coroutine
    65.10 Using withContext
    65.11 Coroutine Channel Communication
    65.12 Summary
66. An Android Kotlin Coroutines Tutorial
    66.1 Creating the Coroutine Example Application
    66.2 Adding Coroutine Support to the Project
    66.3 Designing the User Interface
    66.4 Implementing the SeekBar
    66.5 Adding the Suspend Function
    66.6 Implementing the launchCoroutines Method
    66.7 Testing the App
    66.8 Summary
67. An Overview of Android Started and Bound Services
    67.1 Started Services
    67.2 Intent Service
    67.3 Bound Service
    67.4 The Anatomy of a Service
    67.5 Controlling Destroyed Service Restart Options
    67.6 Declaring a Service in the Manifest File
    67.7 Starting a Service Running on System Startup
    67.8 Summary
68. Implementing an Android Started Service – A Worked Example
    68.1 Creating the Example Project
    68.2 Creating the Service Class
    68.3 Adding the Service to the Manifest File
    68.4 Starting the Service
    68.5 Testing the IntentService Example
    68.6 Using the Service Class
    68.7 Creating the New Service
    68.8 Modifying the User Interface
    68.9 Running the Application
    68.10 Using a Coroutine for the Service Task
    68.11 Summary
69. Android Local Bound Services – A Worked Example
    69.1 Understanding Bound Services
    69.2 Bound Service Interaction Options
    69.3 An Android Studio Local Bound Service Example
    69.4 Adding a Bound Service to the Project
    69.5 Implementing the Binder
    69.6 Binding the Client to the Service
    69.7 Completing the Example
    69.8 Testing the Application
    69.9 Summary
70. Android Remote Bound Services – A Worked Example
    70.1 Client to Remote Service Communication
    70.2 Creating the Example Application
    70.3 Designing the User Interface
    70.4 Implementing the Remote Bound Service
    70.5 Configuring a Remote Service in the Manifest File
    70.6 Launching and Binding to the Remote Service
    70.7 Sending a Message to the Remote Service
    70.8 Summary
71. An Android Notifications Tutorial
    71.1 An Overview of Notifications
    71.2 Creating the NotifyDemo Project
    71.3 Designing the User Interface
    71.4 Creating the Second Activity
    71.5 Creating a Notification Channel
    71.6 Creating and Issuing a Basic Notification
    71.7 Launching an Activity from a Notification
    71.8 Adding Actions to a Notification
    71.9 Bundled Notifications
    71.10 Summary
72. An Android Direct Reply Notification Tutorial
    72.1 Creating the DirectReply Project
    72.2 Designing the User Interface
    72.3 Creating the Notification Channel
    72.4 Building the RemoteInput Object
    72.5 Creating the PendingIntent
    72.6 Creating the Reply Action
    72.7 Receiving Direct Reply Input
    72.8 Updating the Notification
    72.9 Summary
73. Foldable Devices and Multi-Window Support
    73.1 Foldables and Multi-Window Support
    73.2 Using a Foldable Emulator
    73.3 Entering Multi-Window Mode
    73.4 Enabling and using Freeform Support
    73.5 Checking for Freeform Support
    73.6 Enabling Multi-Window Support in an App
    73.7 Specifying Multi-Window Attributes
    73.8 Detecting Multi-Window Mode in an Activity
    73.9 Receiving Multi-Window Notifications
    73.10 Launching an Activity in Multi-Window Mode
    73.11 Configuring Freeform Activity Size and Position
    73.12 Summary
74. An Overview of Android SQLite Databases
    74.1 Understanding Database Tables
    74.2 Introducing Database Schema
    74.3 Columns and Data Types
    74.4 Database Rows
    74.5 Introducing Primary Keys
    74.6 What is SQLite?
    74.7 Structured Query Language (SQL)
    74.8 Trying SQLite on an Android Virtual Device (AVD)
    74.9 The Android Room Persistence Library
    74.10 Summary
75. The Android Room Persistence Library
    75.1 Revisiting Modern App Architecture
    75.2 Key Elements of Room Database Persistence
    75.2.1 Repository
    75.2.2 Room Database
    75.2.3 Data Access Object (DAO)
    75.2.4 Entities
    75.2.5 SQLite Database
    75.3 Understanding Entities
    75.4 Data Access Objects
    75.5 The Room Database
    75.6 The Repository
    75.7 In-Memory Databases
    75.8 Summary
76. An Android TableLayout and TableRow Tutorial
    76.1 The TableLayout and TableRow Layout Views
    76.2 Creating the Room Database Project
    76.3 Converting to a LinearLayout
    76.4 Adding the TableLayout to the User Interface
    76.5 Configuring the TableRows
    76.6 Adding the Button Bar to the Layout
    76.7 Adding the RecyclerView
    76.8 Adjusting the Layout Margins
    76.9 Summary
77. An Android Room Database and Repository Tutorial
    77.1 About the RoomDemo Project
    77.2 Modifying the Build Configuration
    77.3 Building the Entity
    77.4 Creating the Data Access Object
    77.5 Adding the Room Database
    77.6 Adding the Repository
    77.7 Modifying the ViewModel
    77.8 Creating the Product Item Layout
    77.9 Adding the RecyclerView Adapter
    77.10 Preparing the Main Fragment
    77.11 Adding the Button Listeners
    77.12 Adding LiveData Observers
    77.13 Initializing the RecyclerView
    77.14 Testing the RoomDemo App
    77.15 Summary
78. Accessing Cloud Storage using the Android Storage Access Framework
    78.1 The Storage Access Framework
    78.2 Working with the Storage Access Framework
    78.3 Filtering Picker File Listings
    78.4 Handling Intent Results
    78.5 Reading the Content of a File
    78.6 Writing Content to a File
    78.7 Deleting a File
    78.8 Gaining Persistent Access to a File
    78.9 Summary
79. An Android Storage Access Framework Example
    79.1 About the Storage Access Framework Example
    79.2 Creating the Storage Access Framework Example
    79.3 Designing the User Interface
    79.4 Declaring Request Codes
    79.5 Creating a New Storage File
    79.6 The onActivityResult() Method
    79.7 Saving to a Storage File
    79.8 Opening and Reading a Storage File
    79.9 Testing the Storage Access Application
    79.10 Summary
80. Video Playback on Android using the VideoView and MediaController Classes
    80.1 Introducing the Android VideoView Class
    80.2 Introducing the Android MediaController Class
    80.3 Creating the Video Playback Example
    80.4 Designing the VideoPlayer Layout
    80.5 Downloading the Video File
    80.6 Configuring the VideoView
    80.7 Adding the MediaController to the Video View
    80.8 Setting up the onPreparedListener
    80.9 Summary
81. Android Picture-in-Picture Mode
    81.1 Picture-in-Picture Features
    81.2 Enabling Picture-in-Picture Mode
    81.3 Configuring Picture-in-Picture Parameters
    81.4 Entering Picture-in-Picture Mode
    81.5 Detecting Picture-in-Picture Mode Changes
    81.6 Adding Picture-in-Picture Actions
    81.7 Summary
82. An Android Picture-in-Picture Tutorial
    82.1 Adding Picture-in-Picture Support to the Manifest
    82.2 Adding a Picture-in-Picture Button
    82.3 Entering Picture-in-Picture Mode
    82.4 Detecting Picture-in-Picture Mode Changes
    82.5 Adding a Broadcast Receiver
    82.6 Adding the PiP Action
    82.7 Testing the Picture-in-Picture Action
    82.8 Summary
83. Making Runtime Permission Requests in Android
    83.1 Understanding Normal and Dangerous Permissions
    83.2 Creating the Permissions Example Project
    83.3 Checking for a Permission
    83.4 Requesting Permission at Runtime
    83.5 Providing a Rationale for the Permission Request
    83.6 Testing the Permissions App
    83.7 Summary
84. Android Audio Recording and Playback using MediaPlayer and MediaRecorder
    84.1 Playing Audio
    84.2 Recording Audio and Video using the MediaRecorder Class
    84.3 About the Example Project
    84.4 Creating the AudioApp Project
    84.5 Designing the User Interface
    84.6 Checking for Microphone Availability
    84.7 Performing the Activity Initialization
    84.8 Implementing the recordAudio() Method
    84.9 Implementing the stopAudio() Method
    84.10 Implementing the playAudio() method
    84.11 Configuring and Requesting Permissions
    84.12 Testing the Application
    84.13 Summary
85. Working with the Google Maps Android API in Android Studio
    85.1 The Elements of the Google Maps Android API
    85.2 Creating the Google Maps Project
    85.3 Obtaining Your Developer Signature
    85.4 Adding the Apache HTTP Legacy Library Requirement
    85.5 Testing the Application
    85.6 Understanding Geocoding and Reverse Geocoding
    85.7 Adding a Map to an Application
    85.8 Requesting Current Location Permission
    85.9 Displaying the User’s Current Location
    85.10 Changing the Map Type
    85.11 Displaying Map Controls to the User
    85.12 Handling Map Gesture Interaction
    85.12.1 Map Zooming Gestures
    85.12.2 Map Scrolling/Panning Gestures
    85.12.3 Map Tilt Gestures
    85.12.4 Map Rotation Gestures
    85.13 Creating Map Markers
    85.14 Controlling the Map Camera
    85.15 Summary
86. Printing with the Android Printing Framework
    86.1 The Android Printing Architecture
    86.2 The Print Service Plugins
    86.3 Google Cloud Print
    86.4 Printing to Google Drive
    86.5 Save as PDF
    86.6 Printing from Android Devices
    86.7 Options for Building Print Support into Android Apps
    86.7.1 Image Printing
    86.7.2 Creating and Printing HTML Content
    86.7.3 Printing a Web Page
    86.7.4 Printing a Custom Document
    86.8 Summary
87. An Android HTML and Web Content Printing Example
    87.1 Creating the HTML Printing Example Application
    87.2 Printing Dynamic HTML Content
    87.3 Creating the Web Page Printing Example
    87.4 Removing the Floating Action Button
    87.5 Removing Navigation Features
    87.6 Designing the User Interface Layout
    87.7 Loading the Web Page into the WebView
    87.8 Adding the Print Menu Option
    87.9 Summary
88. A Guide to Android Custom Document Printing
    88.1 An Overview of Android Custom Document Printing
    88.1.1 Custom Print Adapters
    88.2 Preparing the Custom Document Printing Project
    88.3 Creating the Custom Print Adapter
    88.4 Implementing the onLayout() Callback Method
    88.5 Implementing the onWrite() Callback Method
    88.6 Checking a Page is in Range
    88.7 Drawing the Content on the Page Canvas
    88.8 Starting the Print Job
    88.9 Testing the Application
    88.10 Summary
89. An Introduction to Android App Links
    89.1 An Overview of Android App Links
    89.2 App Link Intent Filters
    89.3 Handling App Link Intents
    89.4 Associating the App with a Website
    89.5 Summary
90. An Android Studio App Links Tutorial
    90.1 About the Example App
    90.2 The Database Schema
    90.3 Loading and Running the Project
    90.4 Adding the URL Mapping
    90.5 Adding the Intent Filter
    90.6 Adding Intent Handling Code
    90.7 Testing the App Link
    90.8 Associating an App Link with a Web Site
    90.9 Summary
91. A Guide to the Android Studio Profiler
    91.1 Accessing the Android Profiler
    91.2 Enabling Advanced Profiling
    91.3 The Android Profiler Tool Window
    91.4 The Sessions Panel
    91.5 The CPU Profiler
    91.6 Memory Profiler
    91.7 Network Profiler
    91.8 Energy Profiler
    91.9 Summary
92. An Android Biometric Authentication Tutorial
    92.1 An Overview of Biometric Authentication
    92.2 Creating the Biometric Authentication Project
    92.3 Configuring Device Fingerprint Authentication
    92.4 Adding the Biometric Permission to the Manifest File
    92.5 Designing the User Interface
    92.6 Adding a Toast Convenience Method
    92.7 Checking the Security Settings
    92.8 Configuring the Authentication Callbacks
    92.9 Adding the CancellationSignal
    92.10 Starting the Biometric Prompt
    92.11 Testing the Project
    92.12 Summary
93. Creating, Testing and Uploading an Android App Bundle
    93.1 The Release Preparation Process
    93.2 Android App Bundles
    93.3 Register for a Google Play Developer Console Account
    93.4 Configuring the App in the Console
    93.5 Enabling Google Play App Signing
    93.6 Creating a Keystore File
    93.7 Creating the Android App Bundle
    93.8 Generating Test APK Files
    93.9 Uploading the App Bundle to the Google Play Developer Console
    93.10 Exploring the App Bundle
    93.11 Managing Testers
    93.12 Uploading New App Bundle Revisions
    93.13 Analyzing the App Bundle File
    93.14 Enabling Google Play Signing for an Existing App
    93.15 Summary
94. An Overview of Android Dynamic Feature Modules
    94.1 An Overview of Dynamic Feature Modules
    94.2 Dynamic Feature Module Architecture
    94.3 Creating a Dynamic Feature Module
    94.4 Converting an Existing Module for Dynamic Delivery
    94.5 Working with Dynamic Feature Modules
    94.6 Handling Large Dynamic Feature Modules
    94.7 Summary
95. An Android Studio Dynamic Feature Tutorial
    95.1 Creating the DynamicFeature Project
    95.2 Adding Dynamic Feature Support to the Project
    95.3 Designing the Base Activity User Interface
    95.4 Adding the Dynamic Feature Module
    95.5 Reviewing the Dynamic Feature Module
    95.6 Adding the Dynamic Feature Activity
    95.7 Implementing the launchIntent() Method
    95.8 Uploading the App Bundle for Testing
    95.9 Implementing the installFeature() Method
    95.10 Adding the Update Listener
    95.11 Handling Large Downloads
    95.12 Using Deferred Installation
    95.13 Removing a Dynamic Module
    95.14 Summary
96. An Overview of Gradle in Android Studio
    96.1 An Overview of Gradle
    96.2 Gradle and Android Studio
    96.2.1 Sensible Defaults
    96.2.2 Dependencies
    96.2.3 Build Variants
    96.2.4 Manifest Entries
    96.2.5 APK Signing
    96.2.6 ProGuard Support
    96.3 The Top-level Gradle Build File
    96.4 Module Level Gradle Build Files
    96.5 Configuring Signing Settings in the Build File
    96.6 Running Gradle Tasks from the Command-line
    96.7 Summary
    Index
    _GoBack
    _Ref381951250
    _Ref381951280
    _Ref381877478
    _Ref382489559
    _Ref382490730
    _GoBack
    _GoBack
    _Ref384718331
    _Ref324774345