Android Studio Meerkat Essentials - Kotlin Edition: Developing Android Apps Using Android Studio Meerkat and Kotlin

Android Studio Meerkat

Essentials

Kotlin Edition

Android Studio Meerkat Essentials – Kotlin Edition

© 2025 Neil Smyth / Payload Media, Inc. All Rights Reserved.

This book is provided for personal use only. Unauthorized use, reproduction and/or distribution strictly prohibited. All rights reserved.

The content of this book is provided for informational purposes only. Neither the publisher nor the author offers any warranties or representation, express or implied, with regard to the accuracy of information contained in this book, nor do they accept any liability for any loss or damage arising from any errors or omissions.

This book contains trademarked terms that are used solely for editorial purposes and to the benefit of the respective trademark owner. The terms used within this book are not intended as infringement of any trademarks.

Rev: 1.0

https://www.payloadbooks.com

Copyright

"

Table of Contents

1. Introduction

1.1 Downloading the Code Samples

1.2 Feedback

1.3 Errata

2. Setting up an Android Studio Development Environment

2.1 System requirements

2.2 Downloading the Android Studio package

2.3 Installing Android Studio

2.3.1 Installation on Windows

2.3.2 Installation on macOS

2.3.3 Installation on Linux

2.4 The Android Studio setup wizard

2.5 Installing additional Android SDK packages

2.6 Installing the Android SDK Command-line Tools

2.6.1 Windows 8.1

2.6.2 Windows 10

2.6.3 Windows 11

2.6.4 Linux

2.6.5 macOS

2.7 Android Studio memory management

2.8 Updating Android Studio and the SDK

2.9 Summary

3. Creating an Example Android App in Android Studio

3.1 About the Project

3.2 Creating a New Android Project

3.3 Creating an Activity

3.4 Defining the Project and SDK Settings

3.5 Modifying the Example Application

3.6 Modifying the User Interface

3.7 Reviewing the Layout and Resource Files

3.8 Adding Interaction

3.9 Summary

4. Creating an Android Virtual Device (AVD) in Android Studio

4.1 About Android Virtual Devices

4.2 Starting the Emulator

4.3 Running the Application in the AVD

4.4 Running on Multiple Devices

4.5 Stopping a Running Application

4.6 Running the Emulator in a Separate Window

4.7 Removing the Device Frame

4.8 Summary

5. Using and Configuring the Android Studio AVD Emulator

5.1 The Emulator Environment

5.2 Emulator Toolbar Options

5.3 Working in Zoom Mode

5.4 Resizing the Emulator Window

5.5 Extended Control Options

5.5.1 Displays

5.5.2 Cellular

5.5.3 Battery

5.5.4 Camera

5.5.5 Location

5.5.6 Phone

5.5.7 Directional Pad

5.5.8 Microphone

5.5.9 Fingerprint

5.5.10 Virtual Sensors

5.5.11 Snapshots

5.5.12 Record and Playback

5.5.13 Google Play

5.5.14 Settings

5.5.15 Help

5.6 Working with Snapshots

5.7 Configuring Fingerprint Emulation

5.8 The Emulator in Tool Window Mode

5.9 Common Android Settings

5.10 Creating a Resizable Emulator

5.11 Summary

6. A Tour of the Android Studio User Interface

6.1 The Welcome Screen

6.2 The Menu Bar

6.3 The Main Window

6.4 The Tool Windows

6.5 The Tool Window Menus

6.6 Android Studio Keyboard Shortcuts

6.7 Switcher and Recent Files Navigation

6.8 Changing the Android Studio Theme

6.9 Summary

7. Testing Android Studio Apps on a Physical Android Device

7.1 An Overview of the Android Debug Bridge (ADB)

7.2 Enabling USB Debugging ADB on Android Devices

7.2.1 macOS ADB Configuration

7.2.2 Windows ADB Configuration

7.2.3 Linux adb Configuration

7.3 Resolving USB Connection Issues

7.4 Enabling Wireless Debugging on Android Devices

7.5 Testing the adb Connection

7.6 Device Mirroring

7.7 Summary

8. The Basics of the Android Studio Code Editor

8.1 The Android Studio Editor

8.2 The Floating Code Toolbar

8.3 Splitting the Editor Window

8.4 Code Completion

8.5 Statement Completion

8.6 Parameter Information

8.7 Parameter Name Hints

8.8 Code Generation

8.9 Code Folding

8.10 Quick Documentation Lookup

8.11 Code Reformatting

8.12 Finding Sample Code

8.13 Live Templates

8.14 Summary

9. An Overview of the Android Architecture

9.1 The Android Software Stack

9.2 The Linux Kernel

9.3 Hardware Abstraction Layer

9.4 Android Runtime – ART

9.5 Android Libraries

9.5.1 C/C++ Libraries

9.6 Application Framework

9.7 Applications

9.8 Summary

10. The Anatomy of an Android App

10.1 Android Activities

10.2 Android Fragments

10.3 Android Intents

10.4 Broadcast Intents

10.5 Broadcast Receivers

10.6 Android Services

10.7 Content Providers

10.8 The Application Manifest

10.9 Application Resources

10.10 Application Context

10.11 Summary

11. An Introduction to Kotlin

11.1 What is Kotlin?

11.2 Kotlin and Java

11.3 Converting from Java to Kotlin

11.4 Kotlin and Android Studio

11.5 Experimenting with Kotlin

11.6 Semi-colons in Kotlin

11.7 Summary

12. Kotlin Data Types, Variables, and Nullability

12.1 Kotlin Data Types

12.1.1 Integer Data Types

12.1.2 Floating-Point Data Types

12.1.3 Boolean Data Type

12.1.4 Character Data Type

12.1.5 String Data Type

12.1.6 Escape Sequences

12.2 Mutable Variables

12.3 Immutable Variables

12.4 Declaring Mutable and Immutable Variables

12.5 Data Types are Objects

12.6 Type Annotations and Type Inference

12.7 Nullable Type

12.8 The Safe Call Operator

12.9 Not-Null Assertion

12.10 Nullable Types and the let Function

12.11 Late Initialization (lateinit)

12.12 The Elvis Operator

12.13 Type Casting and Type Checking

12.14 Summary

13. Kotlin Operators and Expressions

13.1 Expression Syntax in Kotlin

13.2 The Basic Assignment Operator

13.3 Kotlin Arithmetic Operators

13.4 Augmented Assignment Operators

13.5 Increment and Decrement Operators

13.6 Equality Operators

13.7 Boolean Logical Operators

13.8 Range Operator

13.9 Bitwise Operators

13.9.1 Bitwise Inversion

13.9.2 Bitwise AND

13.9.3 Bitwise OR

13.9.4 Bitwise XOR

13.9.5 Bitwise Left Shift

13.9.6 Bitwise Right Shift

13.10 Summary

14. Kotlin Control Flow

14.1 Looping Control flow

14.1.1 The Kotlin for-in Statement

14.1.2 The while Loop

14.1.3 The do ... while loop

14.1.4 Breaking from Loops

14.1.5 The continue Statement

14.1.6 Break and Continue Labels

14.2 Conditional Control Flow

14.2.1 Using the if Expressions

14.2.2 Using if ... else … Expressions

14.2.3 Using if ... else if ... Expressions

14.2.4 Using the when Statement

14.3 Summary

15. An Overview of Kotlin Functions and Lambdas

15.1 What is a Function?

15.2 How to Declare a Kotlin Function

15.3 Calling a Kotlin Function

15.4 Single Expression Functions

15.5 Local Functions

15.6 Handling Return Values

15.7 Declaring Default Function Parameters

15.8 Variable Number of Function Parameters

15.9 Lambda Expressions

15.10 Higher-order Functions

15.11 Summary

16. The Basics of Object Oriented Programming in Kotlin

16.1 What is an Object?

16.2 What is a Class?

16.3 Declaring a Kotlin Class

16.4 Adding Properties to a Class

16.5 Defining Methods

16.6 Declaring and Initializing a Class Instance

16.7 Primary and Secondary Constructors

16.8 Initializer Blocks

16.9 Calling Methods and Accessing Properties

16.10 Custom Accessors

16.11 Nested and Inner Classes

16.12 Companion Objects

16.13 Summary

17. An Introduction to Kotlin Inheritance and Subclassing

17.1 Inheritance, Classes and Subclasses

17.2 Subclassing Syntax

17.3 A Kotlin Inheritance Example

17.4 Extending the Functionality of a Subclass

17.5 Overriding Inherited Methods

17.6 Adding a Custom Secondary Constructor

17.7 Using the SavingsAccount Class

17.8 Summary

18. An Overview of Android View Binding

18.1 Find View by Id

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. Introducing Gemini in Android Studio

19.1 Introducing Gemini AI

19.2 Enabling Gemini in Android Studio

19.3 Gemini configuration

19.4 Asking Gemini questions

19.5 Question contexts

19.6 Inline code completion

19.7 Transforming and documenting code

19.8 Smart renaming

19.9 Summary

20. Understanding Android Application and Activity Lifecycles

20.1 Android Applications and Resource Management

20.2 Android Process States

20.2.1 Foreground Process

20.2.2 Visible Process

20.2.3 Service Process

20.2.4 Background Process

20.2.5 Empty Process

20.3 Inter-Process Dependencies

20.4 The Activity Lifecycle

20.5 The Activity Stack

20.6 Activity States

20.7 Configuration Changes

20.8 Handling State Change

20.9 Summary

21. Handling Android Activity State Changes

21.1 New vs. Old Lifecycle Techniques

21.2 The Activity and Fragment Classes

21.3 Dynamic State vs. Persistent State

21.4 The Android Lifecycle Methods

21.5 Lifetimes

21.6 Foldable Devices and Multi-Resume

21.7 Disabling Configuration Change Restarts

21.8 Lifecycle Method Limitations

21.9 Summary

22. Android Activity State Changes by Example

22.1 Creating the State Change Example Project

22.2 Designing the User Interface

22.3 Overriding the Activity Lifecycle Methods

22.4 Filtering the Logcat Panel

22.5 Running the Application

22.6 Experimenting with the Activity

22.7 Summary

23. Saving and Restoring the State of an Android Activity

23.1 Saving Dynamic State

23.2 Default Saving of User Interface State

23.3 The Bundle Class

23.4 Saving the State

23.5 Restoring the State

23.6 Testing the Application

23.7 Summary

24. Understanding Android Views, View Groups and Layouts

24.1 Designing for Different Android Devices

24.2 Views and View Groups

24.3 Android Layout Managers

24.4 The View Hierarchy

24.5 Creating User Interfaces

24.6 Summary

25. A Guide to the Android Studio Layout Editor Tool

25.1 Basic vs. Empty Views Activity Templates

25.2 The Android Studio Layout Editor

25.3 Design Mode

25.4 The Palette

25.5 Design Mode and Layout Views

25.6 Night Mode

25.7 Code Mode

25.8 Split Mode

25.9 Setting Attributes

25.10 Transforms

25.11 Tools Visibility Toggles

25.12 Converting Views

25.13 Displaying Sample Data

25.14 Creating a Custom Device Definition

25.15 Changing the Current Device

25.16 Layout Validation

25.17 Summary

26. A Guide to the Android ConstraintLayout

26.1 How ConstraintLayout Works

26.1.1 Constraints

26.1.2 Margins

26.1.3 Opposing Constraints

26.1.4 Constraint Bias

26.1.5 Chains

26.1.6 Chain Styles

26.2 Baseline Alignment

26.3 Configuring Widget Dimensions

26.4 Guideline Helper

26.5 Group Helper

26.6 Barrier Helper

26.7 Flow Helper

26.8 Ratios

26.9 ConstraintLayout Advantages

26.10 ConstraintLayout Availability

26.11 Summary

27. A Guide to Using ConstraintLayout in Android Studio

27.1 Design and Layout Views

27.2 Autoconnect Mode

27.3 Inference Mode

27.4 Manipulating Constraints Manually

27.5 Adding Constraints in the Inspector

27.6 Viewing Constraints in the Attributes Window

27.7 Deleting Constraints

27.8 Adjusting Constraint Bias

27.9 Understanding ConstraintLayout Margins

27.10 The Importance of Opposing Constraints and Bias

27.11 Configuring Widget Dimensions

27.12 Design Time Tools Positioning

27.13 Adding Guidelines

27.14 Adding Barriers

27.15 Adding a Group

27.16 Working with the Flow Helper

27.17 Widget Group Alignment and Distribution

27.18 Converting other Layouts to ConstraintLayout

27.19 Summary

28. Working with ConstraintLayout Chains and Ratios in Android Studio

28.1 Creating a Chain

28.2 Changing the Chain Style

28.3 Spread Inside Chain Style

28.4 Packed Chain Style

28.5 Packed Chain Style with Bias

28.6 Weighted Chain

28.7 Working with Ratios

28.8 Summary

29. An Android Studio Layout Editor ConstraintLayout Tutorial

29.1 An Android Studio Layout Editor Tool Example

29.2 Preparing the Layout Editor Environment

29.3 Adding the Widgets to the User Interface

29.4 Adding the Constraints

29.5 Testing the Layout

29.6 Using the Layout Inspector

29.7 Summary

30. Manual XML Layout Design in Android Studio

30.1 Manually Creating an XML Layout

30.2 Manual XML vs. Visual Layout Design

30.3 Summary

31. Managing Constraints using Constraint Sets

31.1 Kotlin Code vs. XML Layout Files

31.2 Creating Views

31.3 View Attributes

31.4 Constraint Sets

31.4.1 Establishing Connections

31.4.2 Applying Constraints to a Layout

31.4.3 Parent Constraint Connections

31.4.4 Sizing Constraints

31.4.5 Constraint Bias

31.4.6 Alignment Constraints

31.4.7 Copying and Applying Constraint Sets

31.4.8 ConstraintLayout Chains

31.4.9 Guidelines

31.4.10 Removing Constraints

31.4.11 Scaling

31.4.12 Rotation

31.5 Summary

32. An Android ConstraintSet Tutorial

32.1 Creating the Example Project in Android Studio

32.2 Adding Views to an Activity

32.3 Setting View Attributes

32.4 Creating View IDs

32.5 Configuring the Constraint Set

32.6 Adding the EditText View

32.7 Converting Density Independent Pixels (dp) to Pixels (px)

32.8 Summary

33. A Guide to Using Apply Changes in Android Studio

33.1 Introducing Apply Changes

33.2 Understanding Apply Changes Options

33.3 Using Apply Changes

33.4 Configuring Apply Changes Fallback Settings

33.5 An Apply Changes Tutorial

33.6 Using Apply Code Changes

33.7 Using Apply Changes and Restart Activity

33.8 Using Run App

33.9 Summary

34. A Guide to Gradle Version Catalogs

34.1 Library and Plugin Dependencies

34.2 Project Gradle Build File

34.3 Module Gradle Build Files

34.4 Version Catalog File

34.5 Adding Dependencies

34.6 Library Updates

34.7 Summary

35. An Overview and Example of Android Event Handling

35.1 Understanding Android Events

35.2 Using the android:onClick Resource

35.3 Event Listeners and Callback Methods

35.4 An Event Handling Example

35.5 Designing the User Interface

35.6 The Event Listener and Callback Method

35.7 Consuming Events

35.8 Summary

36. Android Touch and Multi-touch Event Handling

36.1 Intercepting Touch Events

36.2 The MotionEvent Object

36.3 Understanding Touch Actions

36.4 Handling Multiple Touches

36.5 An Example Multi-Touch Application

36.6 Designing the Activity User Interface

36.7 Implementing the Touch Event Listener

36.8 Running the Example Application

36.9 Summary

37. Detecting Common Gestures Using the Android Gesture Detector Class

37.1 Implementing Common Gesture Detection

37.2 Creating an Example Gesture Detection Project

37.3 Implementing the Listener Class

37.4 Creating the GestureDetector Instance

37.5 Implementing the onTouchEvent() Method

37.6 Testing the Application

37.7 Summary

38. Implementing Custom Gesture and Pinch Recognition on Android

38.1 The Android Gesture Builder Application

38.2 The GestureOverlayView Class

38.3 Detecting Gestures

38.4 Identifying Specific Gestures

38.5 Installing and Running the Gesture Builder Application

38.6 Creating a Gestures File

38.7 Creating the Example Project

38.8 Extracting the Gestures File from the SD Card

38.9 Adding the Gestures File to the Project

38.10 Designing the User Interface

38.11 Loading the Gestures File

38.12 Registering the Event Listener

38.13 Implementing the onGesturePerformed Method

38.14 Testing the Application

38.15 Configuring the GestureOverlayView

38.16 Intercepting Gestures

38.17 Detecting Pinch Gestures

38.18 A Pinch Gesture Example Project

38.19 Summary

39. An Introduction to Android Fragments

39.1 What is a Fragment?

39.2 Creating a Fragment

39.3 Adding a Fragment to an Activity using the Layout XML File

39.4 Adding and Managing Fragments in Code

39.5 Handling Fragment Events

39.6 Implementing Fragment Communication

39.7 Summary

40. Using Fragments in Android Studio - An Example

40.1 About the Example Fragment Application

40.2 Creating the Example Project

40.3 Creating the First Fragment Layout

40.4 Migrating a Fragment to View Binding

40.5 Adding the Second Fragment

40.6 Adding the Fragments to the Activity

40.7 Making the Toolbar Fragment Talk to the Activity

40.8 Making the Activity Talk to the Text Fragment

40.9 Testing the Application

40.10 Summary

41. Modern Android App Architecture with Jetpack

41.1 What is Android Jetpack?

41.2 The Old Architecture

41.3 Modern Android Architecture

41.4 The ViewModel Component

41.5 The LiveData Component

41.6 ViewModel Saved State

41.7 LiveData and Data Binding

41.8 Android Lifecycles

41.9 Repository Modules

41.10 Summary

42. An Android ViewModel Tutorial

42.1 About the Project

42.2 Creating the ViewModel Example Project

42.3 Removing Unwanted Project Elements

42.4 Designing the Fragment Layout

42.5 Implementing the View Model

42.6 Associating the Fragment with the View Model

42.7 Modifying the Fragment

42.8 Accessing the ViewModel Data

42.9 Testing the Project

42.10 Summary

43. An Android Jetpack LiveData Tutorial

43.1 LiveData - A Recap

43.2 Adding LiveData to the ViewModel

43.3 Implementing the Observer

43.4 Summary

44. An Overview of Android Jetpack Data Binding

44.1 An Overview of Data Binding

44.2 The Key Components of Data Binding

44.2.1 The Project Build Configuration

44.2.2 The Data Binding Layout File

44.2.3 The Layout File Data Element

44.2.4 The Binding Classes

44.2.5 Data Binding Variable Configuration

44.2.6 Binding Expressions (One-Way)

44.2.7 Binding Expressions (Two-Way)

44.2.8 Event and Listener Bindings

44.3 Summary

45. An Android Jetpack Data Binding Tutorial

45.1 Removing the Redundant Code

45.2 Enabling Data Binding

45.3 Adding the Layout Element

45.4 Adding the Data Element to Layout File

45.5 Working with the Binding Class

45.6 Assigning the ViewModel Instance to the Data Binding Variable

45.7 Adding Binding Expressions

45.8 Adding the Conversion Method

45.9 Adding a Listener Binding

45.10 Testing the App

45.11 Summary

46. An Android ViewModel Saved State Tutorial

46.1 Understanding ViewModel State Saving

46.2 Implementing ViewModel State Saving

46.3 Saving and Restoring State

46.4 Adding Saved State Support to the ViewModelDemo Project

46.5 Summary

47. Working with Android Lifecycle-Aware Components

47.1 Lifecycle Awareness

47.2 Lifecycle Owners

47.3 Lifecycle Observers

47.4 Lifecycle States and Events

47.5 Summary

48. An Android Jetpack Lifecycle Awareness Tutorial

48.1 Creating the Example Lifecycle Project

48.2 Creating a Lifecycle Observer

48.3 Adding the Observer

48.4 Testing the Observer

48.5 Creating a Lifecycle Owner

48.6 Testing the Custom Lifecycle Owner

48.7 Summary

49. An Overview of the Navigation Architecture Component

49.1 Understanding Navigation

49.2 Declaring a Navigation Host

49.3 The Navigation Graph

49.4 Accessing the Navigation Controller

49.5 Triggering a Navigation Action

49.6 Passing Arguments

49.7 Summary

50. An Android Jetpack Navigation Component Tutorial

50.1 Creating the NavigationDemo Project

50.2 Adding Navigation to the Build Configuration

50.3 Creating the Navigation Graph Resource File

50.4 Declaring a Navigation Host

50.5 Adding Navigation Destinations

50.6 Designing the Destination Fragment Layouts

50.7 Adding an Action to the Navigation Graph

50.8 Implement the OnFragmentInteractionListener

50.9 Adding View Binding Support to the Destination Fragments

50.10 Triggering the Action

50.11 Passing Data Using Safeargs

50.12 Summary

51. Working with the Floating Action Button and Snackbar

51.1 The Material Design

51.2 The Design Library

51.3 The Floating Action Button (FAB)

51.4 The Snackbar

51.5 Creating the Example Project

51.6 Reviewing the Project

51.7 Removing Navigation Features

51.8 Changing the Floating Action Button

51.9 Adding an Action to the Snackbar

51.10 Summary

52. Creating a Tabbed Interface using the TabLayout Component

52.1 An Introduction to the ViewPager2

52.2 An Overview of the TabLayout Component

52.3 Creating the TabLayoutDemo Project

52.4 Creating the First Fragment

52.5 Duplicating the Fragments

52.6 Adding the TabLayout and ViewPager2

52.7 Performing the Initialization Tasks

52.8 Testing the Application

52.9 Customizing the TabLayout

52.10 Summary

53. Working with the RecyclerView and CardView Widgets

53.1 An Overview of the RecyclerView

53.2 An Overview of the CardView

53.3 Summary

54. An Android RecyclerView and CardView Tutorial

54.1 Creating the CardDemo Project

54.2 Modifying the Basic Views Activity Project

54.3 Designing the CardView Layout

54.4 Adding the RecyclerView

54.5 Adding the Image Files

54.6 Creating the RecyclerView Adapter

54.7 Initializing the RecyclerView Component

54.8 Testing the Application

54.9 Responding to Card Selections

54.10 Summary

55. Working with the AppBar and Collapsing Toolbar Layouts

55.1 The Anatomy of an AppBar

55.2 The Example Project

55.3 Coordinating the RecyclerView and Toolbar

55.4 Introducing the Collapsing Toolbar Layout

55.5 Changing the Title and Scrim Color

55.6 Summary

56. An Overview of Android Intents

56.1 An Overview of Intents

56.2 Explicit Intents

56.3 Returning Data from an Activity

56.4 Implicit Intents

56.5 Using Intent Filters

56.6 Automatic Link Verification

56.7 Manually Enabling Links

56.8 Checking Intent Availability

56.9 Summary

57. Android Explicit Intents – A Worked Example

57.1 Creating the Explicit Intent Example Application

57.2 Designing the User Interface Layout for MainActivity

57.3 Creating the Second Activity Class

57.4 Designing the User Interface Layout for SecondActivity

57.5 Reviewing the Application Manifest File

57.6 Creating the Intent

57.7 Extracting Intent Data

57.8 Launching SecondActivity as a Sub-Activity

57.9 Returning Data from a Sub-Activity

57.10 Testing the Application

57.11 Summary

58. Android Implicit Intents – A Worked Example

58.1 Creating the Android Studio Implicit Intent Example Project

58.2 Designing the User Interface

58.3 Creating the Implicit Intent

58.4 Adding a Second Matching Activity

58.5 Adding the Web View to the UI

58.6 Obtaining the Intent URL

58.7 Modifying the MyWebView Project Manifest File

58.8 Installing the MyWebView Package on a Device

58.9 Testing the Application

58.10 Manually Enabling the Link

58.11 Automatic Link Verification

58.12 Summary

59. Android Broadcast Intents and Broadcast Receivers

59.1 An Overview of Broadcast Intents

59.2 An Overview of Broadcast Receivers

59.3 Obtaining Results from a Broadcast

59.4 Sticky Broadcast Intents

59.5 The Broadcast Intent Example

59.6 Creating the Example Application

59.7 Creating and Sending the Broadcast Intent

59.8 Creating the Broadcast Receiver

59.9 Registering the Broadcast Receiver

59.10 Testing the Broadcast Example

59.11 Listening for System Broadcasts

59.12 Summary

60. An Introduction to Kotlin Coroutines

60.1 What are Coroutines?

60.2 Threads vs. Coroutines

60.3 Coroutine Scope

60.4 Suspend Functions

60.5 Coroutine Dispatchers

60.6 Coroutine Builders

60.7 Jobs

60.8 Coroutines – Suspending and Resuming

60.9 Returning Results from a Coroutine

60.10 Using withContext

60.11 Coroutine Channel Communication

60.12 Summary

61. An Android Kotlin Coroutines Tutorial

61.1 Creating the Coroutine Example Application

61.2 Designing the User Interface

61.3 Implementing the SeekBar

61.4 Adding the Suspend Function

61.5 Implementing the launchCoroutines Method

61.6 Testing the App

61.7 Summary

62. An Overview of Android Services

62.1 Intent Service

62.2 Bound Service

62.3 The Anatomy of a Service

62.4 Controlling Destroyed Service Restart Options

62.5 Declaring a Service in the Manifest File

62.6 Starting a Service Running on System Startup

62.7 Summary

63. Android Local Bound Services – A Worked Example

63.1 Understanding Bound Services

63.2 Bound Service Interaction Options

63.3 A Local Bound Service Example

63.4 Adding a Bound Service to the Project

63.5 Implementing the Binder

63.6 Binding the Client to the Service

63.7 Completing the Example

63.8 Testing the Application

63.9 Summary

64. Android Remote Bound Services – A Worked Example

64.1 Client to Remote Service Communication

64.2 Creating the Example Application

64.3 Designing the User Interface

64.4 Implementing the Remote Bound Service

64.5 Configuring a Remote Service in the Manifest File

64.6 Launching and Binding to the Remote Service

64.7 Sending a Message to the Remote Service

64.8 Summary

65. An Introduction to Kotlin Flow

65.1 Understanding Flows

65.2 Creating the Sample Project

65.3 Adding the Kotlin Lifecycle Library

65.4 Declaring a Flow

65.5 Emitting Flow Data

65.6 Collecting Flow Data

65.7 Adding a Flow Buffer

65.8 Transforming Data with Intermediaries

65.9 Terminal Flow Operators

65.10 Flow Flattening

65.11 Combining Multiple Flows

65.12 Hot and Cold Flows

65.13 StateFlow

65.14 SharedFlow

65.15 Summary

66. An Android SharedFlow Tutorial

66.1 About the Project

66.2 Creating the SharedFlowDemo Project

66.3 Adding the Lifecycle Libraries

66.4 Designing the User Interface Layout

66.5 Adding the List Row Layout

66.6 Adding the RecyclerView Adapter

66.7 Adding the ViewModel