87. An Android Studio App Links Tutorial | Android Studio 4.2 Development Essentials

Book Overview & Buying
Table Of Contents
Feedback & Rating

Android Studio 4.2 Development Essentials - Kotlin Edition

By : Neil Smyth

3.5 (2)

Buy this Book

Android Studio 4.2 Development Essentials - Kotlin Edition

3.5 (2)

By: Neil Smyth

Buy this Book

Overview of this book

Android Studio is an Integrated Development Environment that is based on the JetBrains IntelliJ IDEA. It provides developers with a unique platform to design and develop Android apps using various developer tools. The new Android Studio 4.2 has an upgraded IntelliJ platform and a variety of new features designed to improve the productivity of Android app developers. Fully updated for Android Studio 4.2, the objective of this book is to help you master the skills necessary to develop Android applications using Kotlin as the programming language. This book begins by outlining the steps necessary to set up an Android development and testing environment and introduces programming in Kotlin, addressing data types, flow control, functions, lambdas, and object-oriented programming. It includes an overview of Android Studio, covering areas such as tool windows, the code editor, and the Layout Editor tool. An introduction to Android architecture is followed by an in-depth explanation of the design of Android applications and user interfaces using the Android Studio environment. Early chapters detail Android Architecture components like view models, lifecycle management, Room database access, the Database Inspector, app navigation, live data, and data binding. Advanced topics such as intents are also covered, as are touch screen handling, gesture recognition, and the recording and playback of audio. You will also explore printing, transitions, cloud-based file storage, and foldable device support. Detailed descriptions of material design concepts are provided, including the use of floating action buttons, Snackbars, tabbed interfaces, card views, navigation drawers, and collapsing toolbars. Some key features of Android Studio 4.2 and Android discussed in-depth include the Layout Editor, the ConstraintLayout and ConstraintSet classes, MotionLayout Editor, view binding, constraint chains, barriers, and direct reply notifications. Later chapters cover advanced features of Android Studio such as App links, Dynamic Delivery, the Android Studio Profiler, Gradle build configuration, and submitting apps to the Google Play Developer Console.

1. Introduction

1.1 Downloading the Code Samples

1.2 Feedback

1.3 Errata

Free Chapter

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 Binding

18.3 Converting the AndroidSample project

18.4 Enabling View Binding

18.5 Using View Binding

18.6 Choosing an Option

18.7 View Binding in the Book Examples

18.8 Migrating a Project to View Binding

18.9 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 Night Mode

24.7 Code Mode

24.8 Split Mode

24.9 Setting Attributes

24.10 Transforms

24.11 Tools Visibility Toggles

24.12 Converting Views

24.13 Displaying Sample Data

24.14 Creating a Custom Device Definition

24.15 Changing the Current Device

24.16 Layout Validation (Multi Preview)

24.17 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.5 Group Helper

25.6 Barrier Helper

25.7 Flow Helper

25.8 Ratios

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

30.2 Creating Views

30.3 View Attributes

30.4 Constraint Sets

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 Migrating a Fragment to View Binding

38.5 Adding the Second Fragment

38.6 Adding the Fragments to the Activity

38.7 Making the Toolbar Fragment Talk to the Activity

38.8 Making the Activity Talk to the Text Fragment

38.9 Testing the Application

38.10 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 Adding View Binding Support to the Destination Fragments

48.10 Triggering the Action

48.11 Passing Data Using Safeargs

48.12 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.7 Arc Motion

49.8 Keyframes

49.9 Time Linearity

49.10 KeyTrigger

49.11 Cycle and Time Cycle Keyframes

49.12 Starting an Animation from Code

49.13 Summary

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 an Action to the Snackbar

52.10 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 Primary/Detail Flow Tutorial

58.1 The Primary/Detail Flow

58.2 Creating a Primary/Detail Flow Activity

58.3 Modifying the Primary/Detail Flow Template

58.4 Changing the Content Model

58.5 Changing the Detail Pane

58.6 Modifying the WebsiteDetailFragment Class

58.7 Modifying the WebsiteListFragment Class

58.8 Adding Manifest Permissions

58.9 Running the Application

58.10 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 SecondActivity

60.5 Reviewing the Application Manifest File

60.6 Creating the Intent

60.7 Extracting Intent Data

60.8 Launching SecondActivity 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. An Introduction to Kotlin Coroutines

63.1 What are Coroutines?

63.2 Threads vs Coroutines

63.3 Coroutine Scope

63.4 Suspend Functions

63.5 Coroutine Dispatchers

63.6 Coroutine Builders

63.7 Jobs

63.8 Coroutines – Suspending and Resuming

63.9 Returning Results from a Coroutine

63.10 Using withContext

63.11 Coroutine Channel Communication

63.12 Summary

64. An Android Kotlin Coroutines Tutorial

64.1 Creating the Coroutine Example Application

64.2 Adding Coroutine Support to the Project

64.3 Designing the User Interface

64.4 Implementing the SeekBar

64.5 Adding the Suspend Function

64.6 Implementing the launchCoroutines Method

64.7 Testing the App

64.8 Summary

65. An Overview of Android Services

65.1 Started Services

65.2 Intent Service

65.3 Bound Service

65.4 The Anatomy of a Service

65.5 Controlling Destroyed Service Restart Options

65.6 Declaring a Service in the Manifest File

65.7 Starting a Service Running on System Startup

65.8 Summary

66. Implementing an Android Started Service – A Worked Example

66.1 Creating the Example Project

66.2 Designing the User Interface

66.3 Creating the Service Class

66.4 Adding the Service to the Manifest File

66.5 Starting the Service

66.6 Testing the IntentService Example

66.7 Using the Service Class

66.8 Creating the New Service

66.9 Launching the Service

66.10 Running the Application

66.11 Using a Coroutine for the Service Task

66.12 Summary

67. Android Local Bound Services – A Worked Example

67.1 Understanding Bound Services

67.2 Bound Service Interaction Options

67.3 A Local Bound Service Example

67.4 Adding a Bound Service to the Project

67.5 Implementing the Binder

67.6 Binding the Client to the Service

67.7 Completing the Example

67.8 Testing the Application

67.9 Summary

68. Android Remote Bound Services – A Worked Example

68.1 Client to Remote Service Communication

68.2 Creating the Example Application

68.3 Designing the User Interface

68.4 Implementing the Remote Bound Service

68.5 Configuring a Remote Service in the Manifest File

68.6 Launching and Binding to the Remote Service

68.7 Sending a Message to the Remote Service

68.8 Summary

69. An Android Notifications Tutorial

69.1 An Overview of Notifications

69.2 Creating the NotifyDemo Project

69.3 Designing the User Interface

69.4 Creating the Second Activity

69.5 Creating a Notification Channel

69.6 Creating and Issuing a Notification

69.7 Launching an Activity from a Notification

69.8 Adding Actions to a Notification

69.9 Bundled Notifications

69.10 Summary

70. An Android Direct Reply Notification Tutorial

70.1 Creating the DirectReply Project

70.2 Designing the User Interface

70.3 Creating the Notification Channel

70.4 Building the RemoteInput Object

70.5 Creating the PendingIntent

70.6 Creating the Reply Action

70.7 Receiving Direct Reply Input

70.8 Updating the Notification

70.9 Summary

71. Foldable Devices and Multi-Window Support

71.1 Foldables and Multi-Window Support

71.2 Using a Foldable Emulator

71.3 Entering Multi-Window Mode

71.4 Enabling and using Freeform Support

71.5 Checking for Freeform Support

71.6 Enabling Multi-Window Support in an App

71.7 Specifying Multi-Window Attributes

71.8 Detecting Multi-Window Mode in an Activity

71.9 Receiving Multi-Window Notifications

71.10 Launching an Activity in Multi-Window Mode

71.11 Configuring Freeform Activity Size and Position

71.12 Summary

72. An Overview of Android SQLite Databases

72.1 Understanding Database Tables

72.2 Introducing Database Schema

72.3 Columns and Data Types

72.4 Database Rows

72.5 Introducing Primary Keys

72.6 What is SQLite?

72.7 Structured Query Language (SQL)

72.8 Trying SQLite on an Android Virtual Device (AVD)

72.9 The Android Room Persistence Library

72.10 Summary

73. The Android Room Persistence Library

73.1 Revisiting Modern App Architecture

73.2 Key Elements of Room Database Persistence

73.3 Understanding Entities

73.4 Data Access Objects

73.5 The Room Database

73.6 The Repository

73.7 In-Memory Databases

73.8 Database Inspector

73.9 Summary

74. An Android TableLayout and TableRow Tutorial

74.1 The TableLayout and TableRow Layout Views

74.2 Creating the Room Database Project

74.3 Converting to a LinearLayout

74.4 Adding the TableLayout to the User Interface

74.5 Configuring the TableRows

74.6 Adding the Button Bar to the Layout

74.7 Adding the RecyclerView

74.8 Adjusting the Layout Margins

74.9 Summary

75. An Android Room Database and Repository Tutorial

75.1 About the RoomDemo Project

75.2 Modifying the Build Configuration

75.3 Building the Entity

75.4 Creating the Data Access Object

75.5 Adding the Room Database

75.6 Adding the Repository

75.7 Modifying the ViewModel

75.8 Creating the Product Item Layout

75.9 Adding the RecyclerView Adapter

75.10 Preparing the Main Fragment

75.11 Adding the Button Listeners

75.12 Adding LiveData Observers

75.13 Initializing the RecyclerView

75.14 Testing the RoomDemo App

75.15 Using the Database Inspector

75.16 Summary

76. Accessing Cloud Storage using the Android Storage Access Framework

76.1 The Storage Access Framework

76.2 Working with the Storage Access Framework

76.3 Filtering Picker File Listings

76.4 Handling Intent Results

76.5 Reading the Content of a File

76.6 Writing Content to a File

76.7 Deleting a File

76.8 Gaining Persistent Access to a File

76.9 Summary

77. An Android Storage Access Framework Example

77.1 About the Storage Access Framework Example

77.2 Creating the Storage Access Framework Example

77.3 Designing the User Interface

77.4 Declaring Request Codes

77.5 Creating a New Storage File

77.6 The onActivityResult() Method

77.7 Saving to a Storage File

77.8 Opening and Reading a Storage File

77.9 Testing the Storage Access Application

77.10 Summary

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

78.1 Introducing the Android VideoView Class

78.2 Introducing the Android MediaController Class

78.3 Creating the Video Playback Example

78.4 Designing the VideoPlayer Layout

78.5 Downloading the Video File

78.6 Configuring the VideoView

78.7 Adding the MediaController to the Video View

78.8 Setting up the onPreparedListener

78.9 Summary

79. Android Picture-in-Picture Mode

79.1 Picture-in-Picture Features

79.2 Enabling Picture-in-Picture Mode

79.3 Configuring Picture-in-Picture Parameters

79.4 Entering Picture-in-Picture Mode

79.5 Detecting Picture-in-Picture Mode Changes

79.6 Adding Picture-in-Picture Actions

79.7 Summary

80. An Android Picture-in-Picture Tutorial

80.1 Adding Picture-in-Picture Support to the Manifest

80.2 Adding a Picture-in-Picture Button

80.3 Entering Picture-in-Picture Mode

80.4 Detecting Picture-in-Picture Mode Changes

80.5 Adding a Broadcast Receiver

80.6 Adding the PiP Action

80.7 Testing the Picture-in-Picture Action

80.8 Summary

81. Making Runtime Permission Requests in Android

81.1 Understanding Normal and Dangerous Permissions

81.2 Creating the Permissions Example Project

81.3 Checking for a Permission

81.4 Requesting Permission at Runtime

81.5 Providing a Rationale for the Permission Request

81.6 Testing the Permissions App

81.7 Summary

82. Android Audio Recording and Playback using MediaPlayer and MediaRecorder

82.1 Playing Audio

82.2 Recording Audio and Video using the MediaRecorder Class

82.3 About the Example Project

82.4 Creating the AudioApp Project

82.5 Designing the User Interface

82.6 Checking for Microphone Availability

82.7 Initializing the Activity

82.8 Implementing the recordAudio() Method

82.9 Implementing the stopAudio() Method

82.10 Implementing the playAudio() method

82.11 Configuring and Requesting Permissions

82.12 Testing the Application

82.13 Summary

83. Printing with the Android Printing Framework

83.1 The Android Printing Architecture

83.2 The Print Service Plugins

83.3 Google Cloud Print

83.4 Printing to Google Drive

83.5 Save as PDF

83.6 Printing from Android Devices

83.7 Options for Building Print Support into Android Apps

83.8 Summary

84. An Android HTML and Web Content Printing Example

84.1 Creating the HTML Printing Example Application

84.2 Printing Dynamic HTML Content

84.3 Creating the Web Page Printing Example

84.4 Removing the Floating Action Button

84.5 Removing Navigation Features

84.6 Designing the User Interface Layout

84.7 Accessing the WebView from the Main Activity

84.8 Loading the Web Page into the WebView

84.9 Adding the Print Menu Option

84.10 Summary

85. A Guide to Android Custom Document Printing

85.1 An Overview of Android Custom Document Printing

85.2 Preparing the Custom Document Printing Project

85.3 Creating the Custom Print Adapter

85.4 Implementing the onLayout() Callback Method

85.5 Implementing the onWrite() Callback Method

85.6 Checking a Page is in Range

85.7 Drawing the Content on the Page Canvas

85.8 Starting the Print Job

85.9 Testing the Application

85.10 Summary

86. An Introduction to Android App Links

86.1 An Overview of Android App Links

86.2 App Link Intent Filters

86.3 Handling App Link Intents

86.4 Associating the App with a Website

86.5 Summary

87. An Android Studio App Links Tutorial

87.1 About the Example App

87.2 The Database Schema

87.3 Loading and Running the Project

87.4 Adding the URL Mapping

87.5 Adding the Intent Filter

87.6 Adding Intent Handling Code

87.7 Testing the App Link

87.8 Associating an App Link with a Web Site

87.9 Summary

88. A Guide to the Android Studio Profiler

88.1 Accessing the Android Profiler

88.2 Enabling Advanced Profiling

88.3 The Android Profiler Tool Window

88.4 The Sessions Panel

88.5 The CPU Profiler

88.6 Memory Profiler

88.7 Network Profiler

88.8 Energy Profiler

88.9 Summary

89. An Android Biometric Authentication Tutorial

89.1 An Overview of Biometric Authentication

89.2 Creating the Biometric Authentication Project

89.3 Configuring Device Fingerprint Authentication

89.4 Adding the Biometric Permission to the Manifest File

89.5 Designing the User Interface

89.6 Adding a Toast Convenience Method

89.7 Checking the Security Settings

89.8 Configuring the Authentication Callbacks

89.9 Adding the CancellationSignal

89.10 Starting the Biometric Prompt

89.11 Testing the Project

89.12 Summary

90. Creating, Testing and Uploading an Android App Bundle

90.1 The Release Preparation Process

90.2 Android App Bundles

90.3 Register for a Google Play Developer Console Account

90.4 Configuring the App in the Console

90.5 Enabling Google Play App Signing

90.6 Creating a Keystore File

90.7 Creating the Android App Bundle

90.8 Generating Test APK Files

90.9 Uploading the App Bundle to the Google Play Developer Console

90.10 Exploring the App Bundle

90.11 Managing Testers

90.12 Rolling the App Out for Testing

90.13 Uploading New App Bundle Revisions

90.14 Analyzing the App Bundle File

90.15 Summary

91. An Overview of Android Dynamic Feature Modules

91.1 An Overview of Dynamic Feature Modules

91.2 Dynamic Feature Module Architecture

91.3 Creating a Dynamic Feature Module

91.4 Converting an Existing Module for Dynamic Delivery

91.5 Working with Dynamic Feature Modules

91.6 Handling Large Dynamic Feature Modules

91.7 Summary

92. An Android Studio Dynamic Feature Tutorial

92.1 Creating the DynamicFeature Project

92.2 Adding Dynamic Feature Support to the Project

92.3 Designing the Base Activity User Interface

92.4 Adding the Dynamic Feature Module

92.5 Reviewing the Dynamic Feature Module

92.6 Adding the Dynamic Feature Activity

92.7 Implementing the launchIntent() Method

92.8 Uploading the App Bundle for Testing

92.9 Implementing the installFeature() Method

92.10 Adding the Update Listener

92.11 Handling Large Downloads

92.12 Using Deferred Installation

92.13 Removing a Dynamic Module

92.14 Summary

93. An Overview of Gradle in Android Studio

93.1 An Overview of Gradle

93.2 Gradle and Android Studio

93.3 The Top-level Gradle Build File

93.4 Module Level Gradle Build Files

93.5 Configuring Signing Settings in the Build File

93.6 Running Gradle Tasks from the Command-line

93.7 Summary

Index

Customer Reviews

3.5 (2)

5 star

4 star

50%

3 star

50%

2 star

1 star

Android Studio 4.2 Development Essentials - Kotlin Edition

By : Neil Smyth

Android Studio 4.2 Development Essentials - Kotlin Edition

By: Neil Smyth

Overview of this book

Unlock full access

Continue reading for free

Android Studio 4.2 Development Essentials - Kotlin Edition

By : Neil Smyth

Android Studio 4.2 Development Essentials - Kotlin Edition

By: Neil Smyth

Overview of this book

Unlock full access

Continue reading for free

Create a Note

Delete Bookmark

Delete Note

Edit Note

Confirmation

Buy this book with your credits?