97 Chapters

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.4 The Android Studio Setup Wizard

2.5 Installing Additional Android SDK Packages

2.6 Making the Android SDK Tools Command-line Accessible

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.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.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.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.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.10 Summary

14. Kotlin Flow Control

14.1 Looping Flow Control

14.2 Conditional Flow Control

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.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.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

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.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.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.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.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.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.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.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.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

Android Studio 4.0 Development Essentials - Kotlin Edition: Build Android Apps with Android Studio 4.0 and Kotlin

What do you get with eBook?

Key benefits

Description

Who is this book for?

What you will learn

Product Details

What do you get with eBook?

Product Details

Frequently bought together

Table of Contents

Recommendations for you

People who bought this also bought

About the author

FAQs

Android Studio 4.0 Development Essentials - Kotlin Edition: Build Android Apps with Android Studio 4.0 and Kotlin

What do you get with eBook?

Contact Details

Billing Address

Key benefits

Description

Who is this book for?

What you will learn

Product Details

What do you get with eBook?

Contact Details

Billing Address

Product Details

Packt Subscriptions

Frequently bought together

Table of Contents

Recommendations for you

People who bought this also bought

About the author

FAQs