95 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 the Kotlin Extensions Plugin

3.9 Adding Interaction

3.10 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 Running on Multiple Devices

4.6 Stopping a Running Application

4.7 Supporting Dark Theme

4.8 Running the Emulator in a Tool Window

4.9 AVD Command-line Creation

4.10 Android Virtual Device Configuration Files

4.11 Moving and Renaming an Android Virtual Device

4.12 Summary

5. Using and Configuring the Android Studio AVD Emulator

5.1 The Emulator Environment

5.2 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 The Emulator in Tool Window Mode

5.9 Summary

6. A Tour of the Android Studio User Interface

6.1 The Welcome Screen

6.2 The Main Window

6.3 The Tool Windows

6.4 Android Studio Keyboard Shortcuts

6.5 Switcher and Recent Files Navigation

6.6 Changing the Android Studio Theme

6.7 Summary

7. Testing Android Studio Apps on a Physical Android Device

7.1 An Overview of the Android Debug Bridge (ADB)

7.2 Enabling 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 Transforms

24.10 Tools Visibility Toggles

24.11 Converting Views

24.12 Displaying Sample Data

24.13 Creating a Custom Device Definition

24.14 Changing the Current Device

24.15 Layout Validation (Multi Preview)

24.16 Summary

25. A Guide to the Android ConstraintLayout

25.1 How ConstraintLayout Works

25.2 Baseline Alignment

25.3 Configuring Widget Dimensions

25.4 Guideline Helper

25.9 ConstraintLayout Advantages

25.10 ConstraintLayout Availability

25.11 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 Design Time Tools Positioning

26.13 Adding Guidelines

26.14 Adding Barriers

26.15 Adding a Group

26.16 Working with the Flow Helper

26.17 Widget Group Alignment and Distribution

26.18 Converting other Layouts to ConstraintLayout

26.19 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. An Introduction to MotionLayout

49.1 An Overview of MotionLayout

49.2 MotionLayout

49.3 MotionScene

49.4 Configuring ConstraintSets

49.5 Custom Attributes

49.6 Triggering an Animation

49.11 Cycle and Time Cycle Keyframes

49.12 Starting an Animation from Code

50. An Android MotionLayout Editor Tutorial

50.1 Creating the MotionLayoutDemo Project

50.2 ConstraintLayout to MotionLayout Conversion

50.3 Configuring Start and End Constraints

50.4 Previewing the MotionLayout Animation

50.5 Adding an OnClick Gesture

50.6 Adding an Attribute Keyframe to the Transition

50.7 Adding a CustomAttribute to a Transition

50.8 Adding Position Keyframes

50.9 Summary

51. A MotionLayout KeyCycle Tutorial

51.1 An Overview of Cycle Keyframes

51.2 Using the Cycle Editor

51.3 Creating the KeyCycleDemo Project

51.4 Configuring the Start and End Constraints

51.5 Creating the Cycles

51.6 Previewing the Animation

51.7 Adding the KeyFrameSet to the MotionScene

51.8 Summary

52. Working with the Floating Action Button and Snackbar

52.1 The Material Design

52.2 The Design Library

52.3 The Floating Action Button (FAB)

52.4 The Snackbar

52.5 Creating the Example Project

52.6 Reviewing the Project

52.7 Removing Navigation Features

52.8 Changing the Floating Action Button

52.9 Adding the ListView to the Content Layout

52.10 Adding Items to the ListView

52.11 Adding an Action to the Snackbar

52.12 Summary

53. Creating a Tabbed Interface using the TabLayout Component

53.1 An Introduction to the ViewPager

53.2 An Overview of the TabLayout Component

53.3 Creating the TabLayoutDemo Project

53.4 Creating the First Fragment

53.5 Duplicating the Fragments

53.6 Adding the TabLayout and ViewPager

53.7 Creating the Pager Adapter

53.8 Performing the Initialization Tasks

53.9 Testing the Application

53.10 Customizing the TabLayout

53.11 Displaying Icon Tab Items

53.12 Summary

54. Working with the RecyclerView and CardView Widgets

54.1 An Overview of the RecyclerView

54.2 An Overview of the CardView

54.3 Summary

55. An Android RecyclerView and CardView Tutorial

55.1 Creating the CardDemo Project

55.2 Modifying the Basic Activity Project

55.3 Designing the CardView Layout

55.4 Adding the RecyclerView

55.5 Adding the Image Files

55.6 Creating the RecyclerView Adapter

55.7 Initializing the RecyclerView Component

55.8 Testing the Application

55.9 Responding to Card Selections

55.10 Summary

56. A Layout Editor Sample Data Tutorial

56.1 Adding Sample Data to a Project

56.2 Using Custom Sample Data

56.3 Summary

57. Working with the AppBar and Collapsing Toolbar Layouts

57.1 The Anatomy of an AppBar

57.2 The Example Project

57.3 Coordinating the RecyclerView and Toolbar

57.4 Introducing the Collapsing Toolbar Layout

57.5 Changing the Title and Scrim Color

57.6 Summary

58. An Android Studio Master/Detail Flow Tutorial

58.1 The Master/Detail Flow

58.2 Creating a Master/Detail Flow Activity

58.3 The Anatomy of the Master/Detail Flow Template

58.4 Modifying the Master/Detail Flow Template

58.5 Changing the Content Model

58.6 Changing the Detail Pane

58.7 Modifying the WebsiteDetailFragment Class

58.8 Modifying the WebsiteListActivity Class

58.9 Adding Manifest Permissions

58.10 Running the Application

58.11 Summary

59. An Overview of Android Intents

59.1 An Overview of Intents

59.2 Explicit Intents

59.3 Returning Data from an Activity

59.4 Implicit Intents

59.5 Using Intent Filters

59.6 Checking Intent Availability

59.7 Summary

60. Android Explicit Intents – A Worked Example

60.1 Creating the Explicit Intent Example Application

60.2 Designing the User Interface Layout for MainActivity

60.3 Creating the Second Activity Class

60.4 Designing the User Interface Layout for ActivityB

60.5 Reviewing the Application Manifest File

60.6 Creating the Intent

60.7 Extracting Intent Data

60.8 Launching ActivityB as a Sub-Activity

60.9 Returning Data from a Sub-Activity

60.10 Testing the Application

60.11 Summary

61. Android Implicit Intents – A Worked Example

61.1 Creating the Android Studio Implicit Intent Example Project

61.2 Designing the User Interface

61.3 Creating the Implicit Intent

61.4 Adding a Second Matching Activity

61.5 Adding the Web View to the UI

61.6 Obtaining the Intent URL

61.7 Modifying the MyWebView Project Manifest File

61.8 Installing the MyWebView Package on a Device

61.9 Testing the Application

61.10 Summary

62. Android Broadcast Intents and Broadcast Receivers

62.1 An Overview of Broadcast Intents

62.2 An Overview of Broadcast Receivers

62.3 Obtaining Results from a Broadcast

62.4 Sticky Broadcast Intents

62.5 The Broadcast Intent Example

62.6 Creating the Example Application

62.7 Creating and Sending the Broadcast Intent

62.8 Creating the Broadcast Receiver

62.9 Registering the Broadcast Receiver

62.10 Testing the Broadcast Example

62.11 Listening for System Broadcasts

62.12 Summary

63. A Basic Overview of Threads and AsyncTasks

63.1 An Overview of Threads

63.2 The Application Main Thread

63.3 Thread Handlers

63.4 A Basic AsyncTask Example

63.5 Subclassing AsyncTask

63.6 Testing the App

63.7 Canceling a Task

63.8 Summary

64. An Introduction to Kotlin Coroutines

64.1 What are Coroutines?

64.2 Threads vs Coroutines

64.3 Coroutine Scope

64.4 Suspend Functions

64.5 Coroutine Dispatchers

64.6 Coroutine Builders

64.7 Jobs

64.8 Coroutines – Suspending and Resuming

64.9 Returning Results from a Coroutine

64.10 Using withContext

64.11 Coroutine Channel Communication

64.12 Summary

65. An Android Kotlin Coroutines Tutorial

65.1 Creating the Coroutine Example Application

65.2 Adding Coroutine Support to the Project

65.3 Designing the User Interface

65.4 Implementing the SeekBar

65.5 Adding the Suspend Function

65.6 Implementing the launchCoroutines Method

65.7 Testing the App

65.8 Summary

66. An Overview of Android Started and Bound Services

66.1 Started Services

66.2 Intent Service

66.3 Bound Service

66.4 The Anatomy of a Service

66.5 Controlling Destroyed Service Restart Options

66.6 Declaring a Service in the Manifest File

66.7 Starting a Service Running on System Startup

66.8 Summary

67. Implementing an Android Started Service – A Worked Example

67.1 Creating the Example Project

67.2 Creating the Service Class

67.3 Adding the Service to the Manifest File

67.4 Starting the Service

67.5 Testing the IntentService Example

67.6 Using the Service Class

67.7 Creating the New Service

67.8 Modifying the User Interface

67.9 Running the Application

67.10 Using a Coroutine for the Service Task

67.11 Summary

68. Android Local Bound Services – A Worked Example

68.1 Understanding Bound Services

68.2 Bound Service Interaction Options

68.3 An Android Studio Local Bound Service Example

68.4 Adding a Bound Service to the Project

68.5 Implementing the Binder

68.6 Binding the Client to the Service

68.7 Completing the Example

68.8 Testing the Application

68.9 Summary

69. Android Remote Bound Services – A Worked Example

69.1 Client to Remote Service Communication

69.2 Creating the Example Application

69.3 Designing the User Interface

69.4 Implementing the Remote Bound Service

69.5 Configuring a Remote Service in the Manifest File

69.6 Launching and Binding to the Remote Service

69.7 Sending a Message to the Remote Service

69.8 Summary

70. An Android Notifications Tutorial

70.1 An Overview of Notifications

70.2 Creating the NotifyDemo Project

70.3 Designing the User Interface

70.4 Creating the Second Activity

70.5 Creating a Notification Channel

70.6 Creating and Issuing a Basic Notification

70.7 Launching an Activity from a Notification

70.8 Adding Actions to a Notification

70.9 Bundled Notifications

70.10 Summary

71. An Android Direct Reply Notification Tutorial

71.1 Creating the DirectReply Project

71.2 Designing the User Interface

71.3 Creating the Notification Channel

71.4 Building the RemoteInput Object

71.5 Creating the PendingIntent

71.6 Creating the Reply Action

71.7 Receiving Direct Reply Input

71.8 Updating the Notification

71.9 Summary

72. Foldable Devices and Multi-Window Support

72.1 Foldables and Multi-Window Support

72.2 Using a Foldable Emulator

72.3 Entering Multi-Window Mode

72.4 Enabling and using Freeform Support

72.5 Checking for Freeform Support

72.6 Enabling Multi-Window Support in an App

72.7 Specifying Multi-Window Attributes

72.8 Detecting Multi-Window Mode in an Activity

72.9 Receiving Multi-Window Notifications

72.10 Launching an Activity in Multi-Window Mode

72.11 Configuring Freeform Activity Size and Position

72.12 Summary

73. An Overview of Android SQLite Databases

73.1 Understanding Database Tables

73.2 Introducing Database Schema

73.3 Columns and Data Types

73.4 Database Rows

73.5 Introducing Primary Keys

73.6 What is SQLite?

73.7 Structured Query Language (SQL)

73.8 Trying SQLite on an Android Virtual Device (AVD)

73.9 The Android Room Persistence Library

73.10 Summary

74. The Android Room Persistence Library

74.1 Revisiting Modern App Architecture

74.2 Key Elements of Room Database Persistence

74.3 Understanding Entities

74.4 Data Access Objects

74.5 The Room Database

74.6 The Repository

74.7 In-Memory Databases

74.8 Database Inspector

74.9 Summary

75. An Android TableLayout and TableRow Tutorial

75.1 The TableLayout and TableRow Layout Views

75.2 Creating the Room Database Project

75.3 Converting to a LinearLayout

75.4 Adding the TableLayout to the User Interface

75.5 Configuring the TableRows

75.6 Adding the Button Bar to the Layout

75.7 Adding the RecyclerView

75.8 Adjusting the Layout Margins

75.9 Summary

76. An Android Room Database and Repository Tutorial

76.1 About the RoomDemo Project

76.2 Modifying the Build Configuration

76.3 Building the Entity

76.4 Creating the Data Access Object

76.5 Adding the Room Database

76.6 Adding the Repository

76.7 Modifying the ViewModel

76.8 Creating the Product Item Layout

76.9 Adding the RecyclerView Adapter

76.10 Preparing the Main Fragment

76.11 Adding the Button Listeners

76.12 Adding LiveData Observers

76.13 Initializing the RecyclerView

76.14 Testing the RoomDemo App

76.15 Using the Database Inspector

76.16 Summary

77. Accessing Cloud Storage using the Android Storage Access Framework

77.1 The Storage Access Framework

77.2 Working with the Storage Access Framework

77.3 Filtering Picker File Listings

77.4 Handling Intent Results

77.5 Reading the Content of a File

77.6 Writing Content to a File

77.7 Deleting a File

77.8 Gaining Persistent Access to a File

77.9 Summary

78. An Android Storage Access Framework Example

78.1 About the Storage Access Framework Example

78.2 Creating the Storage Access Framework Example

78.3 Designing the User Interface

78.4 Declaring Request Codes

78.5 Creating a New Storage File

78.6 The onActivityResult() Method

78.7 Saving to a Storage File

78.8 Opening and Reading a Storage File

78.9 Testing the Storage Access Application

78.10 Summary

79. Video Playback on Android using the VideoView and MediaController Classes

79.1 Introducing the Android VideoView Class

79.2 Introducing the Android MediaController Class

79.3 Creating the Video Playback Example

79.4 Designing the VideoPlayer Layout

79.5 Downloading the Video File

79.6 Configuring the VideoView

79.7 Adding the MediaController to the Video View

79.8 Setting up the onPreparedListener

79.9 Summary

80. Android Picture-in-Picture Mode

80.1 Picture-in-Picture Features

80.2 Enabling Picture-in-Picture Mode

80.3 Configuring Picture-in-Picture Parameters

80.4 Entering Picture-in-Picture Mode

80.5 Detecting Picture-in-Picture Mode Changes

80.6 Adding Picture-in-Picture Actions

80.7 Summary

81. An Android Picture-in-Picture Tutorial

81.1 Adding Picture-in-Picture Support to the Manifest

81.2 Adding a Picture-in-Picture Button

81.3 Entering Picture-in-Picture Mode

81.4 Detecting Picture-in-Picture Mode Changes

81.5 Adding a Broadcast Receiver

81.6 Adding the PiP Action

81.7 Testing the Picture-in-Picture Action

81.8 Summary

82. Making Runtime Permission Requests in Android

82.1 Understanding Normal and Dangerous Permissions

82.2 Creating the Permissions Example Project

82.3 Checking for a Permission

82.4 Requesting Permission at Runtime

82.5 Providing a Rationale for the Permission Request

82.6 Testing the Permissions App

82.7 Summary

83. Android Audio Recording and Playback using MediaPlayer and MediaRecorder

83.1 Playing Audio

83.2 Recording Audio and Video using the MediaRecorder Class

83.3 About the Example Project

83.4 Creating the AudioApp Project

83.5 Designing the User Interface

83.6 Checking for Microphone Availability

83.7 Performing the Activity Initialization

83.8 Implementing the recordAudio() Method

83.9 Implementing the stopAudio() Method

83.10 Implementing the playAudio() method

83.11 Configuring and Requesting Permissions

83.12 Testing the Application

83.13 Summary

84. Printing with the Android Printing Framework

84.1 The Android Printing Architecture

84.2 The Print Service Plugins

84.3 Google Cloud Print

84.4 Printing to Google Drive

84.5 Save as PDF

84.6 Printing from Android Devices

84.7 Options for Building Print Support into Android Apps

84.8 Summary

85. An Android HTML and Web Content Printing Example

85.1 Creating the HTML Printing Example Application

85.2 Printing Dynamic HTML Content

85.3 Creating the Web Page Printing Example

85.4 Removing the Floating Action Button

85.5 Removing Navigation Features

85.6 Designing the User Interface Layout

85.7 Loading the Web Page into the WebView

85.8 Adding the Print Menu Option

85.9 Summary

86. A Guide to Android Custom Document Printing

86.1 An Overview of Android Custom Document Printing

86.2 Preparing the Custom Document Printing Project

86.3 Creating the Custom Print Adapter

86.4 Implementing the onLayout() Callback Method

86.5 Implementing the onWrite() Callback Method

86.6 Checking a Page is in Range

86.7 Drawing the Content on the Page Canvas

86.8 Starting the Print Job

86.9 Testing the Application

86.10 Summary

87. An Introduction to Android App Links

87.1 An Overview of Android App Links

87.2 App Link Intent Filters

87.3 Handling App Link Intents

87.4 Associating the App with a Website

87.5 Summary

88. An Android Studio App Links Tutorial

88.1 About the Example App

88.2 The Database Schema

88.3 Loading and Running the Project

88.4 Adding the URL Mapping

88.5 Adding the Intent Filter

88.6 Adding Intent Handling Code

88.7 Testing the App Link

88.8 Associating an App Link with a Web Site

88.9 Summary

89. A Guide to the Android Studio Profiler

89.1 Accessing the Android Profiler

89.2 Enabling Advanced Profiling

89.3 The Android Profiler Tool Window

89.4 The Sessions Panel

89.5 The CPU Profiler

89.6 Memory Profiler

89.7 Network Profiler

89.8 Energy Profiler

89.9 Summary

90. An Android Biometric Authentication Tutorial

90.1 An Overview of Biometric Authentication

90.2 Creating the Biometric Authentication Project

90.3 Configuring Device Fingerprint Authentication

90.4 Adding the Biometric Permission to the Manifest File

90.5 Designing the User Interface

90.6 Adding a Toast Convenience Method

90.7 Checking the Security Settings

90.8 Configuring the Authentication Callbacks

90.9 Adding the CancellationSignal

90.10 Starting the Biometric Prompt

90.11 Testing the Project

90.12 Summary

91. Creating, Testing and Uploading an Android App Bundle

91.1 The Release Preparation Process

91.2 Android App Bundles

91.3 Register for a Google Play Developer Console Account

91.4 Configuring the App in the Console

91.5 Enabling Google Play App Signing

91.6 Creating a Keystore File

91.7 Creating the Android App Bundle

91.8 Generating Test APK Files

91.9 Uploading the App Bundle to the Google Play Developer Console

91.10 Exploring the App Bundle

91.11 Managing Testers

91.12 Rolling the App Out for Testing

91.13 Uploading New App Bundle Revisions

91.14 Analyzing the App Bundle File

91.15 Summary

92. An Overview of Android Dynamic Feature Modules

92.1 An Overview of Dynamic Feature Modules

92.2 Dynamic Feature Module Architecture

92.3 Creating a Dynamic Feature Module

92.4 Converting an Existing Module for Dynamic Delivery

92.5 Working with Dynamic Feature Modules

92.6 Handling Large Dynamic Feature Modules

92.7 Summary

93. An Android Studio Dynamic Feature Tutorial

93.1 Creating the DynamicFeature Project

93.2 Adding Dynamic Feature Support to the Project

93.3 Designing the Base Activity User Interface

93.4 Adding the Dynamic Feature Module

93.5 Reviewing the Dynamic Feature Module

93.6 Adding the Dynamic Feature Activity

93.7 Implementing the launchIntent() Method

93.8 Uploading the App Bundle for Testing

93.9 Implementing the installFeature() Method

93.10 Adding the Update Listener

93.11 Handling Large Downloads

93.12 Using Deferred Installation

93.13 Removing a Dynamic Module

93.14 Summary

94. An Overview of Gradle in Android Studio

94.1 An Overview of Gradle

94.2 Gradle and Android Studio

94.3 The Top-level Gradle Build File

94.4 Module Level Gradle Build Files

94.5 Configuring Signing Settings in the Build File

94.6 Running Gradle Tasks from the Command-line

94.7 Summary

Index

Android Studio 4.1 Development Essentials – Kotlin Edition: Developing Android 11 Apps Using Android Studio 4.1, Kotlin, and Android Jetpack

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.1 Development Essentials – Kotlin Edition: Developing Android 11 Apps Using Android Studio 4.1, Kotlin, and Android Jetpack

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