Android Studio Electric Eel Essentials Kotlin Edition Developing Android Apps Using Android Studio 2022 1 1 and Kotlin 1st edition Neil Smyth 1951442571 9781951442576

Android Studio Electric Eel Essentials Kotlin Edition Developing Android Apps Using Android Studio 2022 1 1 and Kotlin 1st edition Neil Smyth – Ebook PDF Instant Download/Delivery: 1951442571, 9781951442576

Full download Android Studio Electric Eel Essentials Kotlin Edition Developing Android Apps Using Android Studio 2022 1 1 and Kotlin 1st Edition after payment

Product details:

ISBN 10: 1951442571 

ISBN 13: 9781951442576

Author: Neil Smyth

Android Studio Electric Eel Essentials Kotlin Edition Developing Android Apps Using Android Studio 2022 1 1 and Kotlin 1st 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 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

67.4 Implementing the Remote Bound Service

67.5 Configuring a Remote Service in the Manifest File

67.6 Launching and Binding to the Remote Service

67.7 Sending a Message to the Remote Service

67.8 Summary

68. An Introduction to Kotlin Flow

68.1 Understanding Flows

68.2 Creating the Sample Project

68.3 Adding the Kotlin Lifecycle Library

68.4 Declaring a Flow

68.5 Emitting Flow Data

68.6 Collecting Flow Data

68.7 Adding a Flow Buffer

68.8 Transforming Data with Intermediaries

68.9 Terminal Flow Operators

68.10 Flow Flattening

68.11 Combining Multiple Flows

68.12 Hot and Cold Flows

68.13 StateFlow

68.14 SharedFlow

68.15 Summary

69. An Android SharedFlow Tutorial

69.1 About the Project

69.2 Creating the SharedFlowDemo Project

69.3 Adding the Lifecycle Libraries

69.4 Designing the User Interface Layout

69.5 Adding the List Row Layout

69.6 Adding the RecyclerView Adapter

69.7 Adding the ViewModel

69.8 Configuring the ViewModelProvider

69.9 Collecting the Flow Values

69.10 Testing the SharedFlowDemo App

69.11 Handling Flows in the Background

69.12 Summary

70. An Overview of Android SQLite Databases

70.1 Understanding Database Tables

70.2 Introducing Database Schema

70.3 Columns and Data Types

70.4 Database Rows

70.5 Introducing Primary Keys

70.6 What is SQLite?

70.7 Structured Query Language (SQL)

70.8 Trying SQLite on an Android Virtual Device (AVD)

70.9 Android SQLite Classes

70.9.1 Cursor

70.9.2 SQLiteDatabase

70.9.3 SQLiteOpenHelper

70.9.4 ContentValues

70.10 The Android Room Persistence Library

70.11 Summary

71. An Android SQLite Database Tutorial

71.1 About the Database Example

71.2 Creating the SQLDemo Project

71.3 Designing the User interface

71.4 Creating the Data Model

71.5 Implementing the Data Handler

71.6 The Add Handler Method

71.7 The Query Handler Method

71.8 The Delete Handler Method

71.9 Implementing the Activity Event Methods

71.10 Testing the Application

71.11 Summary

72. Understanding Android Content Providers

72.1 What is a Content Provider?

72.2 The Content Provider

72.2.1 onCreate()

72.2.2 query()

72.2.3 insert()

72.2.4 update()

72.2.5 delete()

72.2.6 getType()

72.3 The Content URI

72.4 The Content Resolver

72.5 The Manifest Element

72.6 Summary

73. An Android Content Provider Tutorial

73.1 Copying the SQLDemo Project

73.2 Adding the Content Provider Package

73.3 Creating the Content Provider Class

73.4 Constructing the Authority and Content URI

73.5 Implementing URI Matching in the Content Provider

73.6 Implementing the Content Provider onCreate() Method

73.7 Implementing the Content Provider insert() Method

73.8 Implementing the Content Provider query() Method

73.9 Implementing the Content Provider update() Method

73.10 Implementing the Content Provider delete() Method

73.11 Declaring the Content Provider in the Manifest File

73.12 Modifying the Database Handler

73.13 Summary

74. An Android Content Provider Client Tutorial

74.1 Creating the SQLDemoClient Project

74.2 Designing the User interface

74.3 Accessing the Content Provider

74.4 Adding the Query Permission

74.5 Testing the Project

74.6 Summary

75. The Android Room Persistence Library

75.1 Revisiting Modern App Architecture

75.2 Key Elements of Room Database Persistence

75.2.1 Repository

75.2.2 Room Database

75.2.3 Data Access Object (DAO)

75.2.4 Entities

75.2.5 SQLite Database

75.3 Understanding Entities

75.4 Data Access Objects

75.5 The Room Database

75.6 The Repository

75.7 In-Memory Databases

75.8 Database Inspector

75.9 Summary

76. An Android TableLayout and TableRow Tutorial

76.1 The TableLayout and TableRow Layout Views

76.2 Creating the Room Database Project

76.3 Converting to a LinearLayout

76.4 Adding the TableLayout to the User Interface

76.5 Configuring the TableRows

76.6 Adding the Button Bar to the Layout

76.7 Adding the RecyclerView

76.8 Adjusting the Layout Margins

76.9 Summary

77. An Android Room Database and Repository Tutorial

77.1 About the RoomDemo Project

77.2 Modifying the Build Configuration

77.3 Building the Entity

77.4 Creating the Data Access Object

77.5 Adding the Room Database

77.6 Adding the Repository

77.7 Adding the ViewModel

77.8 Creating the Product Item Layout

77.9 Adding the RecyclerView Adapter

77.10 Preparing the Main Activity

77.11 Adding the Button Listeners

77.12 Adding LiveData Observers

77.13 Initializing the RecyclerView

77.14 Testing the RoomDemo App

77.15 Using the Database Inspector

77.16 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. An Android Notifications Tutorial

83.1 An Overview of Notifications

83.2 Creating the NotifyDemo Project

83.3 Designing the User Interface

83.4 Creating the Second Activity

83.5 Creating a Notification Channel

83.6 Requesting Notification Permission

83.7 Creating and Issuing a Notification

83.8 Launching an Activity from a Notification

83.9 Adding Actions to a Notification

83.10 Bundled Notifications

83.11 Summary

84. An Android Direct Reply Notification Tutorial

84.1 Creating the DirectReply Project

84.2 Designing the User Interface

84.3 Requesting Notification Permission

84.4 Creating the Notification Channel

84.5 Building the RemoteInput Object

84.6 Creating the PendingIntent

84.7 Creating the Reply Action

84.8 Receiving Direct Reply Input

84.9 Updating the Notification

84.10 Summary

85. Working with the Google Maps Android API in Android Studio

85.1 The Elements of the Google Maps Android API

85.2 Creating the Google Maps Project

85.3 Creating a Google Cloud Billing Account

85.4 Creating a New Google Cloud Project

85.5 Enabling the Google Maps SDK

85.6 Generating a Google Maps API Key

85.7 Adding the API Key to the Android Studio Project

85.8 Testing the Application

85.9 Understanding Geocoding and Reverse Geocoding

85.10 Adding a Map to an Application

85.11 Requesting Current Location Permission

85.12 Displaying the User’s Current Location

85.13 Changing the Map Type

85.14 Displaying Map Controls to the User

85.15 Handling Map Gesture Interaction

85.15.1 Map Zooming Gestures

85.15.2 Map Scrolling/Panning Gestures

85.15.3 Map Tilt Gestures

85.15.4 Map Rotation Gestures

85.16 Creating Map Markers

85.17 Controlling the Map Camera

85.18 Summary

86. Printing with the Android Printing Framework

86.1 The Android Printing Architecture

86.2 The Print Service Plugins

86.3 Google Cloud Print

86.4 Printing to Google Drive

86.5 Save as PDF

86.6 Printing from Android Devices

86.7 Options for Building Print Support into Android Apps

86.7.1 Image Printing

86.7.2 Creating and Printing HTML Content

86.7.3 Printing a Web Page

86.7.4 Printing a Custom Document

86.8 Summary

87. An Android HTML and Web Content Printing Example

87.1 Creating the HTML Printing Example Application

87.2 Printing Dynamic HTML Content

87.3 Creating the Web Page Printing Example

87.4 Removing the Floating Action Button

87.5 Removing Navigation Features

87.6 Designing the User Interface Layout

87.7 Accessing the WebView from the Main Activity

87.8 Loading the Web Page into the WebView

87.9 Adding the Print Menu Option

87.10 Summary

88. A Guide to Android Custom Document Printing

88.1 An Overview of Android Custom Document Printing

88.1.1 Custom Print Adapters

88.2 Preparing the Custom Document Printing Project

88.3 Designing the UI

88.4 Creating the Custom Print Adapter

88.5 Implementing the onLayout() Callback Method

88.6 Implementing the onWrite() Callback Method

88.7 Checking a Page is in Range

88.8 Drawing the Content on the Page Canvas

88.9 Starting the Print Job

88.10 Testing the Application

88.11 Summary

89. An Introduction to Android App Links

89.1 An Overview of Android App Links

89.2 App Link Intent Filters

89.3 Handling App Link Intents

89.4 Associating the App with a Website

89.5 Summary

90. An Android Studio App Links Tutorial

90.1 About the Example App

90.2 The Database Schema

90.3 Loading and Running the Project

90.4 Adding the URL Mapping

90.5 Adding the Intent Filter

90.6 Adding Intent Handling Code

90.7 Testing the App

90.8 Creating the Digital Asset Links File

90.9 Testing the App Link

90.10 Summary

91. An Android Biometric Authentication Tutorial

91.1 An Overview of Biometric Authentication

91.2 Creating the Biometric Authentication Project

91.3 Configuring Device Fingerprint Authentication

91.4 Adding the Biometric Permission to the Manifest File

91.5 Designing the User Interface

91.6 Adding a Toast Convenience Method

91.7 Checking the Security Settings

91.8 Configuring the Authentication Callbacks

91.9 Adding the CancellationSignal

91.10 Starting the Biometric Prompt

91.11 Testing the Project

91.12 Summary

92. Creating, Testing, and Uploading an Android App Bundle

92.1 The Release Preparation Process

92.2 Android App Bundles

92.3 Register for a Google Play Developer Console Account

92.4 Configuring the App in the Console

92.5 Enabling Google Play App Signing

92.6 Creating a Keystore File

92.7 Creating the Android App Bundle

92.8 Generating Test APK Files

92.9 Uploading the App Bundle to the Google Play Developer Console

92.10 Exploring the App Bundle

92.11 Managing Testers

92.12 Rolling the App Out for Testing

92.13 Uploading New App Bundle Revisions

92.14 Analyzing the App Bundle File

92.15 Summary

93. An Overview of Android In-App Billing

93.1 Preparing a Project for In-App Purchasing

93.2 Creating In-App Products and Subscriptions

93.3 Billing Client Initialization

93.4 Connecting to the Google Play Billing Library

93.5 Querying Available Products

93.6 Starting the Purchase Process

93.7 Completing the Purchase

93.8 Querying Previous Purchases

93.9 Summary

94. An Android In-App Purchasing Tutorial

94.1 About the In-App Purchasing Example Project

94.2 Creating the InAppPurchase Project

94.3 Adding Libraries to the Project

94.4 Designing the User Interface

94.5 Adding the App to the Google Play Store

94.6 Creating an In-App Product

94.7 Enabling License Testers

94.8 Initializing the Billing Client

94.9 Querying the Product

94.10 Launching the Purchase Flow

94.11 Handling Purchase Updates

94.12 Consuming the Product

94.13 Restoring a Previous Purchase

94.14 Testing the App

94.15 Troubleshooting

94.16 Summary

95. Accessing Cloud Storage using the Android Storage Access Framework

95.1 The Storage Access Framework

95.2 Working with the Storage Access Framework

95.3 Filtering Picker File Listings

95.4 Handling Intent Results

95.5 Reading the Content of a File

95.6 Writing Content to a File

95.7 Deleting a File

95.8 Gaining Persistent Access to a File

95.9 Summary

96. An Android Storage Access Framework Example

96.1 About the Storage Access Framework Example

96.2 Creating the Storage Access Framework Example

96.3 Designing the User Interface

96.4 Adding the Activity Launchers

96.5 Creating a New Storage File

96.6 Saving to a Storage File

96.7 Opening and Reading a Storage File

96.8 Testing the Storage Access Application

96.9 Summary

97. An Android Studio Primary/Detail Flow Tutorial

97.1 The Primary/Detail Flow

97.2 Creating a Primary/Detail Flow Activity

97.3 Adding the Primary/Detail Flow Activity

97.4 Modifying the Primary/Detail Flow Template

97.5 Changing the Content Model

97.6 Changing the Detail Pane

97.7 Modifying the ItemDetailFragment Class

97.8 Modifying the ItemListFragment Class

97.9 Adding Manifest Permissions

97.10 Running the Application

97.11 Summary

98. Working with Material Design 3 Theming

98.1 Material Design 2 vs. Material Design 3

98.2 Understanding Material Design Theming

98.3 Material Design 3 Theming

98.4 Building a custom theme

98.5 Summary

99. A Material Design 3 Theming and Dynamic Color Tutorial

99.1 Creating the ThemeDemo Project

99.2 Designing the User Interface

99.3 Building a new theme

99.4 Adding the Theme to the Project

99.5 Enabling Dynamic Color Support

99.6 Summary

100. An Overview of Gradle in Android Studio

100.1 An Overview of Gradle

100.2 Gradle and Android Studio

100.2.1 Sensible Defaults

100.2.2 Dependencies

100.2.3 Build Variants

100.2.4 Manifest Entries

100.2.5 APK Signing

100.2.6 ProGuard Support

100.3 The Property and Settings Gradle Build File

100.4 The Top-level Gradle Build File

100.5 Module Level Gradle Build Files

100.6 Configuring Signing Settings in the Build File

100.7 Running Gradle Tasks from the Command Line

100.8 Summary

People also search for Android Studio Electric Eel Essentials Kotlin Edition Developing Android Apps Using Android Studio 2022 1 1 and Kotlin 1st:

electric eel information

are electric eels legal to own

can you keep electric eels as pets

 android studio electric eel

 

Tags:

Kotlin Neil Smyth,Android,Studio,Electric