7. Testing Android Studio Apps on a Physical Android Device | Android Studio 3.5 Development Essentials

Book Overview & Buying
Table Of Contents

Android Studio 3.5 Development Essentials - Kotlin Edition

By : Neil Smyth

3.7 (6)

Buy this Book

Android Studio 3.5 Development Essentials - Kotlin Edition

3.7 (6)

By: Neil Smyth

Buy this Book

Overview of this book

Popularity of Kotlin as an Android-compatible language keeps growing every day. This book will help you to build your own Android applications using Kotlin. Android Studio 3.5 Development Essentials Kotlin Edition first teaches you to install Android development and test environment on different operating systems. Next, you will create an Android app and a virtual device in Android studio, and install an Android application on emulators. You will test apps on physical android devices, then study Android Studio code editor, Android architecture, and the anatomy of an Android app. The focus then shifts to Kotlin language. You’ll get an overview of Kotlin language and practice converting code from Java to Kotlin. You’ll also explore Kotlin data types, operators, expressions, loops, functions, and the basics of OOP concept in Kotlin. This book will then cover Android Jetpack and how to create an example app project using ViewModel component, as well as advanced topics such as views and widgets implementation, multi-window support integration, and biometric authentication. Finally, you will learn to upload your app to the Google Play Console and handle the build process with Gradle. By the end of this book, you will have gained enough knowledge to develop powerful Android applications using Kotlin.

Free Chapter

1. Introduction

1.1 Downloading the Code Samples

1.2 Feedback

1.3 Errata

2. Setting up an Android Studio Development Environment

2.1 System Requirements

2.2 Downloading the Android Studio Package

2.3 Installing Android Studio

2.4 The Android Studio Setup Wizard

2.5 Installing Additional Android SDK Packages

2.6 Making the Android SDK Tools Command-line Accessible

2.7 Android Studio Memory Management

2.8 Updating Android Studio and the SDK

2.9 Summary

3. Creating an Example Android App in Android Studio

3.1 About the Project

3.2 Creating a New Android Project

3.3 Creating an Activity

3.4 Defining the Project and SDK Settings

3.5 Modifying the Example Application

3.6 Reviewing the Layout and Resource Files

3.7 Adding Interaction

3.8 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 Stopping a Running Application

4.6 Supporting Dark Theme

4.7 AVD Command-line Creation

4.8 Android Virtual Device Configuration Files

4.9 Moving and Renaming an Android Virtual Device

4.10 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 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 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. Understanding Android Application and Activity Lifecycles

18.1 Android Applications and Resource Management

18.2 Android Process States

18.3 Inter-Process Dependencies

18.4 The Activity Lifecycle

18.5 The Activity Stack

18.6 Activity States

18.7 Configuration Changes

18.8 Handling State Change

18.9 Summary

19. Handling Android Activity State Changes

19.1 New vs. Old Lifecycle Techniques

19.2 The Activity and Fragment Classes

19.3 Dynamic State vs. Persistent State

19.4 The Android Lifecycle Methods

19.5 Lifetimes

19.6 Foldable Devices and Multi-Resume

19.7 Disabling Configuration Change Restarts

19.8 Lifecycle Method Limitations

19.9 Summary

20. Android Activity State Changes by Example

20.1 Creating the State Change Example Project

20.2 Designing the User Interface

20.3 Overriding the Activity Lifecycle Methods

20.4 Filtering the Logcat Panel

20.5 Running the Application

20.6 Experimenting with the Activity

20.7 Summary

21. Saving and Restoring the State of an Android Activity

21.1 Saving Dynamic State

21.2 Default Saving of User Interface State

21.3 The Bundle Class

21.4 Saving the State

21.5 Restoring the State

21.6 Testing the Application

21.7 Summary

22. Understanding Android Views, View Groups and Layouts

22.1 Designing for Different Android Devices

22.2 Views and View Groups

22.3 Android Layout Managers

22.4 The View Hierarchy

22.5 Creating User Interfaces

22.6 Summary

23. A Guide to the Android Studio Layout Editor Tool

23.1 Basic vs. Empty Activity Templates

23.2 The Android Studio Layout Editor

23.3 Design Mode

23.4 The Palette

23.5 Design and Layout Views

23.6 Text Mode

23.7 Setting Attributes

23.8 Converting Views

23.9 Displaying Sample Data

23.10 Creating a Custom Device Definition

23.11 Changing the Current Device

23.12 Summary

24. A Guide to the Android ConstraintLayout

24.1 How ConstraintLayout Works

24.2 Baseline Alignment

24.3 Working with Guidelines

24.4 Configuring Widget Dimensions

24.5 Working with Barriers

24.6 Ratios

24.7 ConstraintLayout Advantages

24.8 ConstraintLayout Availability

24.9 Summary

25. A Guide to using ConstraintLayout in Android Studio

25.1 Design and Layout Views

25.2 Autoconnect Mode

25.3 Inference Mode

25.4 Manipulating Constraints Manually

25.5 Adding Constraints in the Inspector

25.6 Viewing Constraints in the Attributes Window

25.7 Deleting Constraints

25.8 Adjusting Constraint Bias

25.9 Understanding ConstraintLayout Margins

25.10 The Importance of Opposing Constraints and Bias

25.11 Configuring Widget Dimensions

25.12 Adding Guidelines

25.13 Adding Barriers

25.14 Widget Group Alignment and Distribution

25.15 Converting other Layouts to ConstraintLayout

25.16 Summary

26. Working with ConstraintLayout Chains and Ratios in Android Studio

26.1 Creating a Chain

26.2 Changing the Chain Style

26.3 Spread Inside Chain Style

26.4 Packed Chain Style

26.5 Packed Chain Style with Bias

26.6 Weighted Chain

26.7 Working with Ratios

26.8 Summary

27. An Android Studio Layout Editor ConstraintLayout Tutorial

27.1 An Android Studio Layout Editor Tool Example

27.2 Creating a New Activity

27.3 Preparing the Layout Editor Environment

27.4 Adding the Widgets to the User Interface

27.5 Adding the Constraints

27.6 Testing the Layout

27.7 Using the Layout Inspector

27.8 Summary

28. Manual XML Layout Design in Android Studio

28.1 Manually Creating an XML Layout

28.2 Manual XML vs. Visual Layout Design

28.3 Summary

29. Managing Constraints using Constraint Sets

29.1 Kotlin Code vs. XML Layout Files

29.2 Creating Views

29.3 View Attributes

29.4 Constraint Sets

29.5 Summary

30. An Android ConstraintSet Tutorial

30.1 Creating the Example Project in Android Studio

30.2 Adding Views to an Activity

30.3 Setting View Attributes

30.4 Creating View IDs

30.5 Configuring the Constraint Set

30.6 Adding the EditText View

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

30.8 Summary

31. A Guide to using Apply Changes in Android Studio

31.1 Introducing Apply Changes

31.2 Understanding Apply Changes Options

31.3 Using Apply Changes

31.4 Configuring Apply Changes Fallback Settings

31.5 An Apply Changes Tutorial

31.6 Using Apply Code Changes

31.7 Using Apply Changes and Restart Activity

31.8 Using Run App

31.9 Summary

32. An Overview and Example of Android Event Handling

32.1 Understanding Android Events

32.2 Using the android:onClick Resource

32.3 Event Listeners and Callback Methods

32.4 An Event Handling Example

32.5 Designing the User Interface

32.6 The Event Listener and Callback Method

32.7 Consuming Events

32.8 Summary

33. Android Touch and Multi-touch Event Handling

33.1 Intercepting Touch Events

33.2 The MotionEvent Object

33.3 Understanding Touch Actions

33.4 Handling Multiple Touches

33.5 An Example Multi-Touch Application

33.6 Designing the Activity User Interface

33.7 Implementing the Touch Event Listener

33.8 Running the Example Application

33.9 Summary

34. Detecting Common Gestures using the Android Gesture Detector Class

34.1 Implementing Common Gesture Detection

34.2 Creating an Example Gesture Detection Project

34.3 Implementing the Listener Class

34.4 Creating the GestureDetectorCompat Instance

34.5 Implementing the onTouchEvent() Method

34.6 Testing the Application

34.7 Summary

35. Implementing Custom Gesture and Pinch Recognition on Android

35.1 The Android Gesture Builder Application

35.2 The GestureOverlayView Class

35.3 Detecting Gestures

35.4 Identifying Specific Gestures

35.5 Installing and Running the Gesture Builder Application

35.6 Creating a Gestures File

35.7 Creating the Example Project

35.8 Extracting the Gestures File from the SD Card

35.9 Adding the Gestures File to the Project

35.10 Designing the User Interface

35.11 Loading the Gestures File

35.12 Registering the Event Listener

35.13 Implementing the onGesturePerformed Method

35.14 Testing the Application

35.15 Configuring the GestureOverlayView

35.16 Intercepting Gestures

35.17 Detecting Pinch Gestures

35.18 A Pinch Gesture Example Project

35.19 Summary

36. An Introduction to Android Fragments

36.1 What is a Fragment?

36.2 Creating a Fragment

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

36.4 Adding and Managing Fragments in Code

36.5 Handling Fragment Events

36.6 Implementing Fragment Communication

36.7 Summary

37. Using Fragments in Android Studio - An Example

37.1 About the Example Fragment Application

37.2 Creating the Example Project

37.3 Creating the First Fragment Layout

37.4 Creating the First Fragment Class

37.5 Creating the Second Fragment Layout

37.6 Adding the Fragments to the Activity

37.7 Making the Toolbar Fragment Talk to the Activity

37.8 Making the Activity Talk to the Text Fragment

37.9 Testing the Application

37.10 Summary

38. Modern Android App Architecture with Jetpack

38.1 What is Android Jetpack?

38.2 The “Old” Architecture

38.3 Modern Android Architecture

38.4 The ViewModel Component

38.5 The LiveData Component

38.6 LiveData and Data Binding

38.7 Android Lifecycles

38.8 Repository Modules

38.9 Summary

39. An Android Jetpack ViewModel Tutorial

39.1 About the Project

39.2 Creating the ViewModel Example Project

39.3 Reviewing the Project

39.4 Designing the Fragment Layout

39.5 Implementing the View Model

39.6 Associating the Fragment with the View Model

39.7 Modifying the Fragment

39.8 Accessing the ViewModel Data

39.9 Testing the Project

39.10 Summary

40. An Android Jetpack LiveData Tutorial

40.1 LiveData - A Recap

40.2 Adding LiveData to the ViewModel

40.3 Implementing the Observer

40.4 Summary

41. An Overview of Android Jetpack Data Binding

41.1 An Overview of Data Binding

41.2 The Key Components of Data Binding

41.3 Summary

42. An Android Jetpack Data Binding Tutorial

42.1 Removing the Redundant Code

42.2 Enabling Data Binding

42.3 Adding the Layout Element

42.4 Adding the Data Element to Layout File

42.5 Working with the Binding Class

42.6 Assigning the ViewModel Instance to the Data Binding Variable

42.7 Adding Binding Expressions

42.8 Adding the Conversion Method

42.9 Adding a Listener Binding

42.10 Testing the App

42.11 Summary

43. Working with Android Lifecycle-Aware Components

43.1 Lifecycle Awareness

43.2 Lifecycle Owners

43.3 Lifecycle Observers

43.4 Lifecycle States and Events

43.5 Summary

44. An Android Jetpack Lifecycle Awareness Tutorial

44.1 Creating the Example Lifecycle Project

44.2 Creating a Lifecycle Observer

44.3 Adding the Observer

44.4 Testing the Observer

44.5 Creating a Lifecycle Owner

44.6 Testing the Custom Lifecycle Owner

44.7 Summary

45. An Overview of the Navigation Architecture Component

45.1 Understanding Navigation

45.2 Declaring a Navigation Host

45.3 The Navigation Graph

45.4 Accessing the Navigation Controller

45.5 Triggering a Navigation Action

45.6 Passing Arguments

45.7 Summary

46. An Android Jetpack Navigation Component Tutorial

46.1 Creating the NavigationDemo Project

46.2 Adding Navigation to the Build Configuration

46.3 Creating the Navigation Graph Resource File

46.4 Declaring a Navigation Host

46.5 Adding Navigation Destinations

46.6 Designing the Destination Fragment Layouts

46.7 Adding an Action to the Navigation Graph

46.8 Implement the OnFragmentInteractionListener

46.9 Triggering the Action

46.10 Passing Data Using Safeargs

46.11 Summary

47. Creating and Managing Overflow Menus on Android

47.1 The Overflow Menu

47.2 Creating an Overflow Menu

47.3 Displaying an Overflow Menu

47.4 Responding to Menu Item Selections

47.5 Creating Checkable Item Groups

47.6 Menus and the Android Studio Menu Editor

47.7 Creating the Example Project

47.8 Designing the Menu

47.9 Modifying the onOptionsItemSelected() Method

47.10 Testing the Application

47.11 Summary

48. Animating User Interfaces with the Android Transitions Framework

48.1 Introducing Android Transitions and Scenes

48.2 Using Interpolators with Transitions

48.3 Working with Scene Transitions

48.4 Custom Transitions and TransitionSets in Code

48.5 Custom Transitions and TransitionSets in XML

48.6 Working with Interpolators

48.7 Creating a Custom Interpolator

48.8 Using the beginDelayedTransition Method

48.9 Summary

49. An Android Transition Tutorial using beginDelayedTransition

49.1 Creating the Android Studio TransitionDemo Project

49.2 Preparing the Project Files

49.3 Implementing beginDelayedTransition Animation

49.4 Customizing the Transition

49.5 Summary

50. Implementing Android Scene Transitions – A Tutorial

50.1 An Overview of the Scene Transition Project

50.2 Creating the Android Studio SceneTransitions Project

50.3 Identifying and Preparing the Root Container

50.4 Designing the First Scene

50.5 Designing the Second Scene

50.6 Entering the First Scene

50.7 Loading Scene 2

50.8 Implementing the Transitions

50.9 Adding the Transition File

50.10 Loading and Using the Transition Set

50.11 Configuring Additional Transitions

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 Changing the Floating Action Button

51.8 Adding the ListView to the Content Layout

51.9 Adding Items to the ListView

51.10 Adding an Action to the Snackbar

51.11 Summary

52. Creating a Tabbed Interface using the TabLayout Component

52.1 An Introduction to the ViewPager

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 ViewPager

52.7 Creating the Pager Adapter

52.8 Performing the Initialization Tasks

52.9 Testing the Application

52.10 Customizing the TabLayout

52.11 Displaying Icon Tab Items

52.12 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 Removing the Floating Action Button

54.3 Designing the CardView Layout

54.4 Adding the RecyclerView

54.5 Creating the RecyclerView Adapter

54.6 Adding the Image Files

54.7 Initializing the RecyclerView Component

54.8 Testing the Application

54.9 Responding to Card Selections

54.10 Summary

55. A Layout Editor Sample Data Tutorial

55.1 Adding Sample Data to a Project

55.2 Using Custom Sample Data

55.3 Summary

56. Working with the AppBar and Collapsing Toolbar Layouts

56.1 The Anatomy of an AppBar

56.2 The Example Project

56.3 Coordinating the RecyclerView and Toolbar

56.4 Introducing the Collapsing Toolbar Layout

56.5 Changing the Title and Scrim Color

56.6 Summary

57. An Android Studio Master/Detail Flow Tutorial

57.1 The Master/Detail Flow

57.2 Creating a Master/Detail Flow Activity

57.3 The Anatomy of the Master/Detail Flow Template

57.4 Modifying the Master/Detail Flow Template

57.5 Changing the Content Model

57.6 Changing the Detail Pane

57.7 Modifying the WebsiteDetailFragment Class

57.8 Modifying the WebsiteListActivity Class

57.9 Adding Manifest Permissions

57.10 Running the Application

57.11 Summary

58. An Overview of Android Intents

58.1 An Overview of Intents

58.2 Explicit Intents

58.3 Returning Data from an Activity

58.4 Implicit Intents

58.5 Using Intent Filters

58.6 Checking Intent Availability

58.7 Summary

59. Android Explicit Intents – A Worked Example

59.1 Creating the Explicit Intent Example Application

59.2 Designing the User Interface Layout for MainActivity

59.3 Creating the Second Activity Class

59.4 Designing the User Interface Layout for ActivityB

59.5 Reviewing the Application Manifest File

59.6 Creating the Intent

59.7 Extracting Intent Data

59.8 Launching ActivityB as a Sub-Activity

59.9 Returning Data from a Sub-Activity

59.10 Testing the Application

59.11 Summary

60. Android Implicit Intents – A Worked Example

60.1 Creating the Android Studio Implicit Intent Example Project

60.2 Designing the User Interface

60.3 Creating the Implicit Intent

60.4 Adding a Second Matching Activity

60.5 Adding the Web View to the UI

60.6 Obtaining the Intent URL

60.7 Modifying the MyWebView Project Manifest File

60.8 Installing the MyWebView Package on a Device

60.9 Testing the Application

60.10 Summary

61. Android Broadcast Intents and Broadcast Receivers

61.1 An Overview of Broadcast Intents

61.2 An Overview of Broadcast Receivers

61.3 Obtaining Results from a Broadcast

61.4 Sticky Broadcast Intents

61.5 The Broadcast Intent Example

61.6 Creating the Example Application

61.7 Creating and Sending the Broadcast Intent

61.8 Creating the Broadcast Receiver

61.9 Registering the Broadcast Receiver

61.10 Testing the Broadcast Example

61.11 Listening for System Broadcasts

61.12 Summary

62. A Basic Overview of Threads and AsyncTasks

62.1 An Overview of Threads

62.2 The Application Main Thread

62.3 Thread Handlers

62.4 A Basic AsyncTask Example

62.5 Subclassing AsyncTask

62.6 Testing the App

62.7 Canceling a Task

62.8 Summary

63. An Overview of Android Started and Bound Services

63.1 Started Services

63.2 Intent Service

63.3 Bound Service

63.4 The Anatomy of a Service

63.5 Controlling Destroyed Service Restart Options

63.6 Declaring a Service in the Manifest File

63.7 Starting a Service Running on System Startup

63.8 Summary

64. Implementing an Android Started Service – A Worked Example

64.1 Creating the Example Project

64.2 Creating the Service Class

64.3 Adding the Service to the Manifest File

64.4 Starting the Service

64.5 Testing the IntentService Example

64.6 Using the Service Class

64.7 Creating the New Service

64.8 Modifying the User Interface

64.9 Running the Application

64.10 Creating an AsyncTask for Service Tasks

64.11 Summary

65. Android Local Bound Services – A Worked Example

65.1 Understanding Bound Services

65.2 Bound Service Interaction Options

65.3 An Android Studio Local Bound Service Example

65.4 Adding a Bound Service to the Project

65.5 Implementing the Binder

65.6 Binding the Client to the Service

65.7 Completing the Example

65.8 Testing the Application

65.9 Summary

66. Android Remote Bound Services – A Worked Example

66.1 Client to Remote Service Communication

66.2 Creating the Example Application

66.3 Designing the User Interface

66.4 Implementing the Remote Bound Service

66.5 Configuring a Remote Service in the Manifest File

66.6 Launching and Binding to the Remote Service

66.7 Sending a Message to the Remote Service

66.8 Summary

67. An Android Notifications Tutorial

67.1 An Overview of Notifications

67.2 Creating the NotifyDemo Project

67.3 Designing the User Interface

67.4 Creating the Second Activity

67.5 Creating a Notification Channel

67.6 Creating and Issuing a Basic Notification

67.7 Launching an Activity from a Notification

67.8 Adding Actions to a Notification

67.9 Bundled Notifications

67.10 Summary

68. An Android Direct Reply Notification Tutorial

68.1 Creating the DirectReply Project

68.2 Designing the User Interface

68.3 Creating the Notification Channel

68.4 Building the RemoteInput Object

68.5 Creating the PendingIntent

68.6 Creating the Reply Action

68.7 Receiving Direct Reply Input

68.8 Updating the Notification

68.9 Summary

69. Foldable Devices and Multi-Window Support

69.1 Foldables and Multi-Window Support

69.2 Using a Foldable Emulator

69.3 Entering Multi-Window Mode

69.4 Enabling and using Freeform Support

69.5 Checking for Freeform Support

69.6 Enabling Multi-Window Support in an App

69.7 Specifying Multi-Window Attributes

69.8 Detecting Multi-Window Mode in an Activity

69.9 Receiving Multi-Window Notifications

69.10 Launching an Activity in Multi-Window Mode

69.11 Configuring Freeform Activity Size and Position

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 The Android Room Persistence Library

70.10 Summary

71. The Android Room Persistence Library

71.1 Revisiting Modern App Architecture

71.2 Key Elements of Room Database Persistence

71.3 Understanding Entities

71.4 Data Access Objects

71.5 The Room Database

71.6 The Repository

71.7 In-Memory Databases

71.8 Summary

72. An Android TableLayout and TableRow Tutorial

72.1 The TableLayout and TableRow Layout Views

72.2 Creating the Room Database Project

72.3 Converting to a LinearLayout

72.4 Adding the TableLayout to the User Interface

72.5 Configuring the TableRows

72.6 Adding the Button Bar to the Layout

72.7 Adding the RecyclerView

72.8 Adjusting the Layout Margins

72.9 Summary

73. An Android Room Database and Repository Tutorial

73.1 About the RoomDemo Project

73.2 Modifying the Build Configuration

73.3 Building the Entity

73.4 Creating the Data Access Object

73.5 Adding the Room Database

73.6 Adding the Repository

73.7 Modifying the ViewModel

73.8 Creating the Product Item Layout

73.9 Adding the RecyclerView Adapter

73.10 Preparing the Main Fragment

73.11 Adding the Button Listeners

73.12 Adding LiveData Observers

73.13 Initializing the RecyclerView

73.14 Testing the RoomDemo App

73.15 Summary

74. Accessing Cloud Storage using the Android Storage Access Framework

74.1 The Storage Access Framework

74.2 Working with the Storage Access Framework

74.3 Filtering Picker File Listings

74.4 Handling Intent Results

74.5 Reading the Content of a File

74.6 Writing Content to a File

74.7 Deleting a File

74.8 Gaining Persistent Access to a File

74.9 Summary

75. An Android Storage Access Framework Example

75.1 About the Storage Access Framework Example

75.2 Creating the Storage Access Framework Example

75.3 Designing the User Interface

75.4 Declaring Request Codes

75.5 Creating a New Storage File

75.6 The onActivityResult() Method

75.7 Saving to a Storage File

75.8 Opening and Reading a Storage File

75.9 Testing the Storage Access Application

75.10 Summary

76. Implementing Video Playback on Android using the VideoView and MediaController Classes

76.1 Introducing the Android VideoView Class

76.2 Introducing the Android MediaController Class

76.3 Creating the Video Playback Example

76.4 Designing the VideoPlayer Layout

76.5 Configuring the VideoView

76.6 Adding Internet Permission

76.7 Adding the MediaController to the Video View

76.8 Setting up the onPreparedListener

76.9 Summary

77. Android Picture-in-Picture Mode

77.1 Picture-in-Picture Features

77.2 Enabling Picture-in-Picture Mode

77.3 Configuring Picture-in-Picture Parameters

77.4 Entering Picture-in-Picture Mode

77.5 Detecting Picture-in-Picture Mode Changes

77.6 Adding Picture-in-Picture Actions

77.7 Summary

78. An Android Picture-in-Picture Tutorial

78.1 Adding Picture-in-Picture Support to the Manifest

78.2 Adding a Picture-in-Picture Button

78.3 Entering Picture-in-Picture Mode

78.4 Detecting Picture-in-Picture Mode Changes

78.5 Adding a Broadcast Receiver

78.6 Adding the PiP Action

78.7 Testing the Picture-in-Picture Action

78.8 Summary

79. Making Runtime Permission Requests in Android

79.1 Understanding Normal and Dangerous Permissions

79.2 Creating the Permissions Example Project

79.3 Checking for a Permission

79.4 Requesting Permission at Runtime

79.5 Providing a Rationale for the Permission Request

79.6 Testing the Permissions App

79.7 Summary

80. Android Audio Recording and Playback using MediaPlayer and MediaRecorder

80.1 Playing Audio

80.2 Recording Audio and Video using the MediaRecorder Class

80.3 About the Example Project

80.4 Creating the AudioApp Project

80.5 Designing the User Interface

80.6 Checking for Microphone Availability

80.7 Performing the Activity Initialization

80.8 Implementing the recordAudio() Method

80.9 Implementing the stopAudio() Method

80.10 Implementing the playAudio() method

80.11 Configuring and Requesting Permissions

80.12 Testing the Application

80.13 Summary

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

81.1 The Elements of the Google Maps Android API

81.2 Creating the Google Maps Project

81.3 Obtaining Your Developer Signature

81.4 Adding the Apache HTTP Legacy Library Requirement

81.5 Testing the Application

81.6 Understanding Geocoding and Reverse Geocoding

81.7 Adding a Map to an Application

81.8 Requesting Current Location Permission

81.9 Displaying the User’s Current Location

81.10 Changing the Map Type

81.11 Displaying Map Controls to the User

81.12 Handling Map Gesture Interaction

81.13 Creating Map Markers

81.14 Controlling the Map Camera

81.15 Summary

82. Printing with the Android Printing Framework

82.1 The Android Printing Architecture

82.2 The Print Service Plugins

82.3 Google Cloud Print

82.4 Printing to Google Drive

82.5 Save as PDF

82.6 Printing from Android Devices

82.7 Options for Building Print Support into Android Apps

82.8 Summary

83. An Android HTML and Web Content Printing Example

83.1 Creating the HTML Printing Example Application

83.2 Printing Dynamic HTML Content

83.3 Creating the Web Page Printing Example

83.4 Removing the Floating Action Button

83.5 Designing the User Interface Layout

83.6 Loading the Web Page into the WebView

83.7 Adding the Print Menu Option

83.8 Summary

84. A Guide to Android Custom Document Printing

84.1 An Overview of Android Custom Document Printing

84.2 Preparing the Custom Document Printing Project

84.3 Creating the Custom Print Adapter

84.4 Implementing the onLayout() Callback Method

84.5 Implementing the onWrite() Callback Method

84.6 Checking a Page is in Range

84.7 Drawing the Content on the Page Canvas

84.8 Starting the Print Job

84.9 Testing the Application

84.10 Summary

85. An Introduction to Android App Links

85.1 An Overview of Android App Links

85.2 App Link Intent Filters

85.3 Handling App Link Intents

85.4 Associating the App with a Website

85.5 Summary

86. An Android Studio App Links Tutorial

86.1 About the Example App

86.2 The Database Schema

86.3 Loading and Running the Project

86.4 Adding the URL Mapping

86.5 Adding the Intent Filter

86.6 Adding Intent Handling Code

86.7 Testing the App Link

86.8 Associating an App Link with a Web Site

86.9 Summary

87. A Guide to the Android Studio Profiler

87.1 Accessing the Android Profiler

87.2 Enabling Advanced Profiling

87.3 The Android Profiler Tool Window

87.4 The Sessions Panel

87.5 The CPU Profiler

87.6 Memory Profiler

87.7 Network Profiler

87.8 Energy Profiler

87.9 Summary

88. An Android Biometric Authentication Tutorial

88.1 An Overview of Biometric Authentication

88.2 Creating the Biometric Authentication Project

88.3 Configuring Device Fingerprint Authentication

88.4 Adding the Biometric Permission to the Manifest File

88.5 Designing the User Interface

88.6 Adding a Toast Convenience Method

88.7 Checking the Security Settings

88.8 Configuring the Authentication Callbacks

88.9 Adding the CancellationSignal

88.10 Starting the Biometric Prompt

88.11 Testing the Project

88.12 Summary

89. Creating, Testing and Uploading an Android App Bundle

89.1 The Release Preparation Process

89.2 Android App Bundles

89.3 Register for a Google Play Developer Console Account

89.4 Configuring the App in the Console

89.5 Enabling Google Play App Signing

89.6 Creating a Keystore File

89.7 Creating the Android App Bundle

89.8 Generating Test APK Files

89.9 Uploading the App Bundle to the Google Play Developer Console

89.10 Exploring the App Bundle

89.11 Managing Testers

89.12 Uploading New App Bundle Revisions

89.13 Analyzing the App Bundle File

89.14 Enabling Google Play Signing for an Existing App

89.15 Summary

90. An Overview of Android Dynamic Feature Modules

90.1 An Overview of Dynamic Feature Modules

90.2 Dynamic Feature Module Architecture

90.3 Creating a Dynamic Feature Module

90.4 Converting an Existing Module for Dynamic Delivery

90.5 Working with Dynamic Feature Modules

90.6 Handling Large Dynamic Feature Modules

90.7 Summary

91. An Android Studio Dynamic Feature Tutorial

91.1 Creating the DynamicFeature Project

91.2 Adding Dynamic Feature Support to the Project

91.3 Designing the Base Activity User Interface

91.4 Adding the Dynamic Feature Module

91.5 Reviewing the Dynamic Feature Module

91.6 Adding the Dynamic Feature Activity

91.7 Implementing the launchIntent() Method

91.8 Uploading the App Bundle for Testing

91.9 Implementing the installFeature() Method

91.10 Adding the Update Listener

91.11 Handling Large Downloads

91.12 Using Deferred Installation

91.13 Removing a Dynamic Module

91.14 Summary

92. An Overview of Gradle in Android Studio

92.1 An Overview of Gradle

92.2 Gradle and Android Studio

92.3 The Top-level Gradle Build File

92.4 Module Level Gradle Build Files

92.5 Configuring Signing Settings in the Build File

92.6 Running Gradle Tasks from the Command-line

92.7 Summary

Index

Android Studio 3.5 Development Essentials - Kotlin Edition

By : Neil Smyth

Android Studio 3.5 Development Essentials - Kotlin Edition

By: Neil Smyth

Overview of this book

Confirmation

Buy this book with your credits?

Submit Your Feedback

Create a Free Account To Continue Reading

Sign in to activate your 7-day free access