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

Android Studio Ladybug

Essentials

Kotlin Edition

Android Studio Ladybug Essentials – Kotlin Edition

ISBN: 978-1-965764-05-3

© 2024 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 Installing additional Android SDK packages

2.5 Installing the Android SDK Command-line Tools

2.5.1 Windows 8.1

2.5.2 Windows 10

2.5.3 Windows 11

2.5.4 Linux

2.5.5 macOS

2.6 Android Studio memory management

2.7 Updating Android Studio and the SDK

2.8 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 Location

5.5.2 Displays

5.5.3 Cellular

5.5.4 Battery

5.5.5 Camera

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

51.1 An Overview of MotionLayout

51.2 MotionLayout

51.3 MotionScene

51.4 Configuring ConstraintSets

51.5 Custom Attributes

51.6 Triggering an Animation

51.7 Arc Motion

51.8 Keyframes

51.8.1 Attribute Keyframes

51.8.2 Position Keyframes

51.9 Time Linearity

51.10 KeyTrigger

51.11 Cycle and Time Cycle Keyframes

51.12 Starting an Animation from Code

51.13 Summary

52. An Android MotionLayout Editor Tutorial

52.1 Creating the MotionLayoutDemo Project

52.2 ConstraintLayout to MotionLayout Conversion

52.3 Configuring Start and End Constraints

52.4 Previewing the MotionLayout Animation

52.5 Adding an OnClick Gesture

52.6 Adding an Attribute Keyframe to the Transition

52.7 Adding a CustomAttribute to a Transition

52.8 Adding Position Keyframes

52.9 Summary

53. A MotionLayout KeyCycle Tutorial

53.1 An Overview of Cycle Keyframes

53.2 Using the Cycle Editor

53.3 Creating the KeyCycleDemo Project

53.4 Configuring the Start and End Constraints

53.5 Creating the Cycles

53.6 Previewing the Animation

53.7 Adding the KeyFrameSet to the MotionScene

53.8 Summary

54. Working with the Floating Action Button and Snackbar

54.1 The Material Design

54.2 The Design Library

54.3 The Floating Action Button (FAB)

54.4 The Snackbar

54.5 Creating the Example Project

54.6 Reviewing the Project

54.7 Removing Navigation Features

54.8 Changing the Floating Action Button

54.9 Adding an Action to the Snackbar

54.10 Summary

55. Creating a Tabbed Interface using the TabLayout Component

55.1 An Introduction to the ViewPager2

55.2 An Overview of the TabLayout Component

55.3 Creating the TabLayoutDemo Project

55.4 Creating the First Fragment

55.5 Duplicating the Fragments

55.6 Adding the TabLayout and ViewPager2

55.7 Creating the Pager Adapter

55.8 Performing the Initialization Tasks

55.9 Testing the Application

55.10 Customizing the TabLayout

55.11 Summary

56. Working with the RecyclerView and CardView Widgets

56.1 An Overview of the RecyclerView

56.2 An Overview of the CardView

56.3 Summary

57. An Android RecyclerView and CardView Tutorial

57.1 Creating the CardDemo Project

57.2 Modifying the Basic Views Activity Project

57.3 Designing the CardView Layout

57.4 Adding the RecyclerView

57.5 Adding the Image Files

57.6 Creating the RecyclerView Adapter

57.7 Initializing the RecyclerView Component

57.8 Testing the Application

57.9 Responding to Card Selections

57.10 Summary

58. Working with the AppBar and Collapsing Toolbar Layouts

58.1 The Anatomy of an AppBar

58.2 The Example Project

58.3 Coordinating the RecyclerView and Toolbar

58.4 Introducing the Collapsing Toolbar Layout

58.5 Changing the Title and Scrim Color

58.6 Summary

59. An 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 Automatic Link Verification

59.7 Manually Enabling Links

59.8 Checking Intent Availability

59.9 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 Manually Enabling the Link

61.11 Automatic Link Verification

61.12 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 Designing the User Interface

64.3 Implementing the SeekBar

64.4 Adding the Suspend Function

64.5 Implementing the launchCoroutines Method

64.6 Testing the App

64.7 Summary

65. An Overview of Android Services

65.1 Intent Service

65.2 Bound Service

65.3 The Anatomy of a Service

65.4 Controlling Destroyed Service Restart Options

65.5 Declaring a Service in the Manifest File

65.6 Starting a Service Running on System Startup

65.7 Summary

66. Android Local Bound Services – A Worked Example

66.1 Understanding Bound Services

66.2 Bound Service Interaction Options

66.3 A Local Bound Service Example

66.4 Adding a Bound Service to the Project

66.5 Implementing the Binder

66.6 Binding the Client to the Service

66.7 Completing the Example

66.8 Testing the Application

66.9 Summary

67. Android Remote Bound Services – A Worked Example

67.1 Client to Remote Service Communication

67.2 Creating the Example Application

67.3 Designing the User Interface