54. Android Explicit Intents – A Worked Example | Android Studio 4.1 Development Essentials

Book Overview & Buying
Table Of Contents
Feedback & Rating

Android Studio 4.1 Development Essentials – Java Edition

By : Neil Smyth

Buy this Book

Android Studio 4.1 Development Essentials – Java Edition

By: Neil Smyth

Buy this Book

Overview of this book

For developers, Android 11 has a ton of new capabilities. The goal of this book is to teach the skills necessary to develop Android-based applications using the Java programming language. This book begins with the steps necessary to set up an Android development and testing environment. An overview of Android Studio along with the architecture of Android is covered next, followed by an in-depth look at the design of Android applications and user interfaces using the Android Studio environment. You will also learn about the Android architecture components along with some advanced topics such as touch screen handling, gesture recognition, the recording and playback of audio, app links, dynamic delivery, the AndroidStudio profiler, Gradle build configuration, and submitting apps to the Google Play Developer Console. The concepts of material design, including the use of floating action buttons, Snackbars, tabbed interfaces, card views, navigation drawers, and collapsing toolbars are a highlight of this book. This edition of the book also covers printing, transitions, and cloud-based file storage; the foldable device support is the cherry on the cake. By the end of this course, you will be able to develop Android 11 Apps using Android Studio 4.1, Java, and Android Jetpack. The code files for the book can be found here: https://www.ebookfrenzy.com/retail/androidstudio41/index.php

1. Introduction

1.1 Downloading the Code Samples

1.2 Feedback

1.3 Errata

Free Chapter

2. Setting up an Android Studio Development Environment

2.1 System Requirements

2.2 Downloading the Android Studio Package

2.3 Installing Android Studio

2.4 The Android Studio Setup Wizard

2.5 Installing Additional Android SDK Packages

2.6 Making the Android SDK Tools Command-line Accessible

2.7 Android Studio Memory Management

2.8 Updating Android Studio and the SDK

2.9 Summary

3. Creating an Example Android App in Android Studio

3.1 About the Project

3.2 Creating a New Android Project

3.3 Creating an Activity

3.4 Defining the Project and SDK Settings

3.5 Modifying the Example Application

3.6 Modifying the User Interface

3.7 Reviewing the Layout and Resource Files

3.8 Adding Interaction

3.9 Summary

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

4.1 About Android Virtual Devices

4.2 Creating a New AVD

4.3 Starting the Emulator

4.4 Running the Application in the AVD

4.5 Running on Multiple Devices

4.6 Stopping a Running Application

4.7 Supporting Dark Theme

4.8 Running the Emulator in a Tool Window

4.9 AVD Command-line Creation

4.10 Android Virtual Device Configuration Files

4.11 Moving and Renaming an Android Virtual Device

4.12 Summary

5. Using and Configuring the Android Studio AVD Emulator

5.1 The Emulator Environment

5.2 The Emulator Toolbar Options

5.3 Working in Zoom Mode

5.4 Resizing the Emulator Window

5.5 Extended Control Options

5.6 Working with Snapshots

5.7 Configuring Fingerprint Emulation

5.8 The Emulator in Tool Window Mode

5.9 Summary

6. A Tour of the Android Studio User Interface

6.1 The Welcome Screen

6.2 The Main Window

6.3 The Tool Windows

6.4 Android Studio Keyboard Shortcuts

6.5 Switcher and Recent Files Navigation

6.6 Changing the Android Studio Theme

6.7 Summary

7. Testing Android Studio Apps on a Physical Android Device

7.1 An Overview of the Android Debug Bridge (ADB)

7.2 Enabling ADB on Android based Devices

7.3 Testing the adb Connection

7.4 Summary

8. The Basics of the Android Studio Code Editor

8.1 The Android Studio Editor

8.2 Splitting the Editor Window

8.3 Code Completion

8.4 Statement Completion

8.5 Parameter Information

8.6 Parameter Name Hints

8.7 Code Generation

8.8 Code Folding

8.9 Quick Documentation Lookup

8.10 Code Reformatting

8.11 Finding Sample Code

8.12 Live Templates

8.13 Summary

9. An Overview of the Android Architecture

9.1 The Android Software Stack

9.2 The Linux Kernel

9.3 Android Runtime – ART

9.4 Android Libraries

9.5 Application Framework

9.6 Applications

9.7 Summary

10. The Anatomy of an Android Application

10.1 Android Activities

10.2 Android Fragments

10.3 Android Intents

10.4 Broadcast Intents

10.5 Broadcast Receivers

10.6 Android Services

10.7 Content Providers

10.8 The Application Manifest

10.9 Application Resources

10.10 Application Context

10.11 Summary

11. An Overview of Android View Binding

11.1 Find View by ID

11.2 View Bindings

11.3 Converting the AndroidSample Project

11.4 Enabling View Binding

11.5 Using View Bindings

11.6 Choosing an Option

11.7 Summary

12. Understanding Android Application and Activity Lifecycles

12.1 Android Applications and Resource Management

12.2 Android Process States

12.3 Inter-Process Dependencies

12.4 The Activity Lifecycle

12.5 The Activity Stack

12.6 Activity States

12.7 Configuration Changes

12.8 Handling State Change

12.9 Summary

13. Handling Android Activity State Changes

13.1 New vs. Old Lifecycle Techniques

13.2 The Activity and Fragment Classes

13.3 Dynamic State vs. Persistent State

13.4 The Android Lifecycle Methods

13.5 Lifetimes

13.6 Foldable Devices and Multi-Resume

13.7 Disabling Configuration Change Restarts

13.8 Lifecycle Method Limitations

13.9 Summary

14. Android Activity State Changes by Example

14.1 Creating the State Change Example Project

14.2 Designing the User Interface

14.3 Overriding the Activity Lifecycle Methods

14.4 Filtering the Logcat Panel

14.5 Running the Application

14.6 Experimenting with the Activity

14.7 Summary

15. Saving and Restoring the State of an Android Activity

15.1 Saving Dynamic State

15.2 Default Saving of User Interface State

15.3 The Bundle Class

15.4 Saving the State

15.5 Restoring the State

15.6 Testing the Application

15.7 Summary

16. Understanding Android Views, View Groups and Layouts

16.1 Designing for Different Android Devices

16.2 Views and View Groups

16.3 Android Layout Managers

16.4 The View Hierarchy

16.5 Creating User Interfaces

16.6 Summary

17. A Guide to the Android Studio Layout Editor Tool

17.1 Basic vs. Empty Activity Templates

17.2 The Android Studio Layout Editor

17.3 Design Mode

17.4 The Palette

17.5 Design Mode and Layout Views

17.6 Code Mode

17.7 Split Mode

17.8 Setting Attributes

17.9 Transforms

17.10 Tools Visibility Toggles

17.11 Converting Views

17.12 Displaying Sample Data

17.13 Creating a Custom Device Definition

17.14 Changing the Current Device

17.15 Layout Validation (Multi Preview)

17.16 Summary

18. A Guide to the Android ConstraintLayout

18.1 How ConstraintLayout Works

18.2 Baseline Alignment

18.3 Configuring Widget Dimensions

18.4 Guideline Helper

18.5 Group Helper

18.6 Barrier Helper

18.7 Flow Helper

18.8 Ratios

18.9 ConstraintLayout Advantages

18.10 ConstraintLayout Availability

18.11 Summary

19. A Guide to using ConstraintLayout in Android Studio

19.1 Design and Layout Views

19.2 Autoconnect Mode

19.3 Inference Mode

19.4 Manipulating Constraints Manually

19.5 Adding Constraints in the Inspector

19.6 Viewing Constraints in the Attributes Window

19.7 Deleting Constraints

19.8 Adjusting Constraint Bias

19.9 Understanding ConstraintLayout Margins

19.10 The Importance of Opposing Constraints and Bias

19.11 Configuring Widget Dimensions

19.12 Design Time Tools Positioning

19.13 Adding Guidelines

19.14 Adding Barriers

19.15 Adding a Group

19.16 Working with the Flow Helper

19.17 Widget Group Alignment and Distribution

19.18 Converting other Layouts to ConstraintLayout

19.19 Summary

20. Working with ConstraintLayout Chains and Ratios in Android Studio

20.1 Creating a Chain

20.2 Changing the Chain Style

20.3 Spread Inside Chain Style

20.4 Packed Chain Style

20.5 Packed Chain Style with Bias

20.6 Weighted Chain

20.7 Working with Ratios

20.8 Summary

21. An Android Studio Layout Editor ConstraintLayout Tutorial

21.1 An Android Studio Layout Editor Tool Example

21.2 Creating a New Activity

21.3 Preparing the Layout Editor Environment

21.4 Adding the Widgets to the User Interface

21.5 Adding the Constraints

21.6 Testing the Layout

21.7 Using the Layout Inspector

21.8 Summary

22. Manual XML Layout Design in Android Studio

22.1 Manually Creating an XML Layout

22.2 Manual XML vs. Visual Layout Design

22.3 Summary

23. Managing Constraints using Constraint Sets

23.1 Java Code vs. XML Layout Files

23.2 Creating Views

23.3 View Attributes

23.4 Constraint Sets

23.5 Summary

24. An Android ConstraintSet Tutorial

24.1 Creating the Example Project in Android Studio

24.2 Adding Views to an Activity

24.3 Setting View Attributes

24.4 Creating View IDs

24.5 Configuring the Constraint Set

24.6 Adding the EditText View

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

24.8 Summary

25. A Guide to using Apply Changes in Android Studio

25.1 Introducing Apply Changes

25.2 Understanding Apply Changes Options

25.3 Using Apply Changes

25.4 Configuring Apply Changes Fallback Settings

25.5 An Apply Changes Tutorial

25.6 Using Apply Code Changes

25.7 Using Apply Changes and Restart Activity

25.8 Using Run App

25.9 Summary

26. An Overview and Example of Android Event Handling

26.1 Understanding Android Events

26.2 Using the android:onClick Resource

26.3 Event Listeners and Callback Methods

26.4 An Event Handling Example

26.5 The Event Listener and Callback Method

26.6 Consuming Events

26.7 Summary

27. Android Touch and Multi-touch Event Handling

27.1 Intercepting Touch Events

27.2 The MotionEvent Object

27.3 Understanding Touch Actions

27.4 Handling Multiple Touches

27.5 An Example Multi-Touch Application

27.6 Implementing the Touch Event Listener

27.7 Running the Example Application

27.8 Summary

28. Detecting Common Gestures using the Android Gesture Detector Class

28.1 Implementing Common Gesture Detection

28.2 Creating an Example Gesture Detection Project

28.3 Creating the GestureDetectorCompat Instance

28.4 Implementing the onTouchEvent() Method

28.5 Testing the Application

28.6 Summary

29. Implementing Custom Gesture and Pinch Recognition on Android

29.1 The Android Gesture Builder Application

29.2 The GestureOverlayView Class

29.3 Detecting Gestures

29.4 Identifying Specific Gestures

29.5 Installing and Running the Gesture Builder Application

29.6 Creating a Gestures File

29.7 Creating the Example Project

29.8 Adding the Gestures File to the Project

29.9 Designing the User Interface

29.10 Loading the Gestures File

29.11 Registering the Event Listener

29.12 Implementing the onGesturePerformed Method

29.13 Testing the Application

29.14 Configuring the GestureOverlayView

29.15 Intercepting Gestures

29.16 Detecting Pinch Gestures

29.17 A Pinch Gesture Example Project

29.18 Summary

30. An Introduction to Android Fragments

30.1 What is a Fragment?

30.2 Creating a Fragment

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

30.4 Adding and Managing Fragments in Code

30.5 Handling Fragment Events

30.6 Implementing Fragment Communication

30.7 Summary

31. Using Fragments in Android Studio - An Example

31.1 About the Example Fragment Application

31.2 Creating the Example Project

31.3 Creating the First Fragment Layout

31.4 Adding the Second Fragment

31.5 Adding the Fragments to the Activity

31.6 Making the Toolbar Fragment Talk to the Activity

31.7 Making the Activity Talk to the Text Fragment

31.8 Testing the Application

31.9 Summary

32. Modern Android App Architecture with Jetpack

32.1 What is Android Jetpack?

32.2 The “Old” Architecture

32.3 Modern Android Architecture

32.4 The ViewModel Component

32.5 The LiveData Component

32.6 ViewModel Saved State

32.7 LiveData and Data Binding

32.8 Android Lifecycles

32.9 Repository Modules

32.10 Summary

33. An Android Jetpack ViewModel Tutorial

33.1 About the Project

33.2 Creating the ViewModel Example Project

33.3 Designing the Fragment Layout

33.4 Implementing the View Model

33.5 Associating the Fragment with the View Model

33.6 Modifying the Fragment

33.7 Accessing the ViewModel Data

33.8 Testing the Project

33.9 Summary

34. An Android Jetpack LiveData Tutorial

34.1 LiveData - A Recap

34.2 Adding LiveData to the ViewModel

34.3 Implementing the Observer

34.4 Summary

35. An Overview of Android Jetpack Data Binding

35.1 An Overview of Data Binding

35.2 The Key Components of Data Binding

35.3 Summary

36. An Android Jetpack Data Binding Tutorial

36.1 Removing the Redundant Code

36.2 Enabling Data Binding

36.3 Adding the Layout Element

36.4 Adding the Data Element to Layout File

36.5 Working with the Binding Class

36.6 Assigning the ViewModel Instance to the Data Binding Variable

36.7 Adding Binding Expressions

36.8 Adding the Conversion Method

36.9 Adding a Listener Binding

36.10 Testing the App

36.11 Summary

37. An Android ViewModel Saved State Tutorial

37.1 Understanding ViewModel State Saving

37.2 Implementing ViewModel State Saving

37.3 Saving and Restoring State

37.4 Adding Saved State Support to the ViewModelDemo Project

37.5 Summary

38. Working with Android Lifecycle-Aware Components

38.1 Lifecycle Awareness

38.2 Lifecycle Owners

38.3 Lifecycle Observers

38.4 Lifecycle States and Events

38.5 Summary

39. An Android Jetpack Lifecycle Awareness Tutorial

39.1 Creating the Example Lifecycle Project

39.2 Creating a Lifecycle Observer

39.3 Adding the Observer

39.4 Testing the Observer

39.5 Creating a Lifecycle Owner

39.6 Testing the Custom Lifecycle Owner

39.7 Summary

40. An Overview of the Navigation Architecture Component

40.1 Understanding Navigation

40.2 Declaring a Navigation Host

40.3 The Navigation Graph

40.4 Accessing the Navigation Controller

40.5 Triggering a Navigation Action

40.6 Passing Arguments

40.7 Summary

41. An Android Jetpack Navigation Component Tutorial

41.1 Creating the NavigationDemo Project

41.2 Adding Navigation to the Build Configuration

41.3 Creating the Navigation Graph Resource File

41.4 Declaring a Navigation Host

41.5 Adding Navigation Destinations

41.6 Designing the Destination Fragment Layouts

41.7 Adding an Action to the Navigation Graph

41.8 Implement the OnFragmentInteractionListener

41.9 Triggering the Action

41.10 Passing Data Using Safeargs

41.11 Summary

42. Creating and Managing Overflow Menus on Android

42.1 The Overflow Menu

42.2 Creating an Overflow Menu

42.3 Displaying an Overflow Menu

42.4 Responding to Menu Item Selections

42.5 Creating Checkable Item Groups

42.6 Menus and the Android Studio Menu Editor

42.7 Creating the Example Project

42.8 Designing the Menu

42.9 Modifying the onOptionsItemSelected() Method

42.10 Testing the Application

42.11 Summary

43. An Introduction to MotionLayout

43.1 An Overview of MotionLayout

43.2 MotionLayout

43.3 MotionScene

43.4 Configuring ConstraintSets

43.5 Custom Attributes

43.6 Triggering an Animation

43.7 Arc Motion

43.8 Keyframes

43.9 Time Linearity

43.10 KeyTrigger

43.11 Cycle and Time Cycle Keyframes

43.12 Starting an Animation from Code

44. An Android MotionLayout Editor Tutorial

44.1 Creating the MotionLayoutDemo Project

44.2 ConstraintLayout to MotionLayout Conversion

44.3 Configuring Start and End Constraints

44.4 Previewing the MotionLayout Animation

44.5 Adding an OnClick Gesture

44.6 Adding an Attribute Keyframe to the Transition

44.7 Adding a CustomAttribute to a Transition

44.8 Adding Position Keyframes

44.9 Summary

45. A MotionLayout KeyCycle Tutorial

45.1 An Overview of Cycle Keyframes

45.2 Using the Cycle Editor

45.3 Creating the KeyCycleDemo Project

45.4 Configuring the Start and End Constraints

45.5 Creating the Cycles

45.6 Previewing the Animation

45.7 Adding the KeyFrameSet to the MotionScene

45.8 Summary

46. Working with the Floating Action Button and Snackbar

46.1 The Material Design

46.2 The Design Library

46.3 The Floating Action Button (FAB)

46.4 The Snackbar

46.5 Creating the Example Project

46.6 Removing Navigation Features

46.7 Changing the Floating Action Button

46.8 Adding the ListView to the Content Layout

46.9 Adding Items to the ListView

46.10 Adding an Action to the Snackbar

46.11 Summary

47. Creating a Tabbed Interface using the TabLayout Component

47.1 An Introduction to the ViewPager

47.2 An Overview of the TabLayout Component

47.3 Creating the TabLayoutDemo Project

47.4 Creating the First Fragment

47.5 Duplicating the Fragments

47.6 Adding the TabLayout and ViewPager

47.7 Creating the Pager Adapter

47.8 Performing the Initialization Tasks

47.9 Testing the Application

47.10 Customizing the TabLayout

47.11 Displaying Icon Tab Items

47.12 Summary

48. Working with the RecyclerView and CardView Widgets

48.1 An Overview of the RecyclerView

48.2 An Overview of the CardView

48.3 Summary

49. An Android RecyclerView and CardView Tutorial

49.1 Creating the CardDemo Project

49.2 Designing the CardView Layout

49.3 Adding the RecyclerView

49.4 Adding the Image Files

49.5 Creating the RecyclerView Adapter

49.6 Initializing the RecyclerView Component

49.7 Testing the Application

49.8 Responding to Card Selections

49.9 Summary

50. A Layout Editor Sample Data Tutorial

50.1 Adding Sample Data to a Project

50.2 Using Custom Sample Data

50.3 Summary

51. Working with the AppBar and Collapsing Toolbar Layouts

51.1 The Anatomy of an AppBar

51.2 The Example Project

51.3 Coordinating the RecyclerView and Toolbar

51.4 Introducing the Collapsing Toolbar Layout

51.5 Changing the Title and Scrim Color

51.6 Summary

52. An Android Studio Master/Detail Flow Tutorial

52.1 The Master/Detail Flow

52.2 Creating a Master/Detail Flow Activity

52.3 The Anatomy of the Master/Detail Flow Template

52.4 Modifying the Master/Detail Flow Template

52.5 Changing the Content Model

52.6 Changing the Detail Pane

52.7 Modifying the WebsiteDetailFragment Class

52.8 Modifying the WebsiteListActivity Class

52.9 Adding Manifest Permissions

52.10 Running the Application

52.11 Summary

53. An Overview of Android Intents

53.1 An Overview of Intents

53.2 Explicit Intents

53.3 Returning Data from an Activity

53.4 Implicit Intents

53.5 Using Intent Filters

53.6 Checking Intent Availability

53.7 Summary

54. Android Explicit Intents – A Worked Example

54.1 Creating the Explicit Intent Example Application

54.2 Creating the Second Activity Class

54.3 Designing the User Interface Layout for ActivityB

54.4 Reviewing the Application Manifest File

54.5 Creating the Intent

54.6 Extracting Intent Data

54.7 Launching ActivityB as a Sub-Activity

54.8 Returning Data from a Sub-Activity

54.9 Testing the Application

54.10 Summary

55. Android Implicit Intents – A Worked Example

55.1 Creating the Android Studio Implicit Intent Example Project

55.2 Creating the Implicit Intent

55.3 Adding a Second Matching Activity

55.4 Adding the Web View to the UI

55.5 Obtaining the Intent URL

55.6 Modifying the MyWebView Project Manifest File

55.7 Installing the MyWebView Package on a Device

55.8 Testing the Application

55.9 Summary

56. Android Broadcast Intents and Broadcast Receivers

56.1 An Overview of Broadcast Intents

56.2 An Overview of Broadcast Receivers

56.3 Obtaining Results from a Broadcast

56.4 Sticky Broadcast Intents

56.5 The Broadcast Intent Example

56.6 Creating the Example Application

56.7 Creating and Sending the Broadcast Intent

56.8 Creating the Broadcast Receiver

56.9 Registering the Broadcast Receiver

56.10 Testing the Broadcast Example

56.11 Listening for System Broadcasts

56.12 Summary

57. A Basic Overview of Threads and AsyncTasks

57.1 An Overview of Threads

57.2 The Application Main Thread

57.3 Thread Handlers

57.4 A Basic AsyncTask Example

57.5 Subclassing AsyncTask

57.6 Testing the App

57.7 Canceling a Task

57.8 Summary

58. An Overview of Android Started and Bound Services

58.1 Started Services

58.2 Intent Service

58.3 Bound Service

58.4 The Anatomy of a Service

58.5 Controlling Destroyed Service Restart Options

58.6 Declaring a Service in the Manifest File

58.7 Starting a Service Running on System Startup

58.8 Summary

59. Implementing an Android Started Service – A Worked Example

59.1 Creating the Example Project

59.2 Creating the Service Class

59.3 Adding the Service to the Manifest File

59.4 Starting the Service

59.5 Testing the IntentService Example

59.6 Using the Service Class

59.7 Creating the New Service

59.8 Modifying the User Interface

59.9 Running the Application

59.10 Creating an AsyncTask for Service Tasks

59.11 Summary

60. Android Local Bound Services – A Worked Example

60.1 Understanding Bound Services

60.2 Bound Service Interaction Options

60.3 An Android Studio Local Bound Service Example

60.4 Adding a Bound Service to the Project

60.5 Implementing the Binder

60.6 Binding the Client to the Service

60.7 Completing the Example

60.8 Testing the Application

60.9 Summary

61. Android Remote Bound Services – A Worked Example

61.1 Client to Remote Service Communication

61.2 Creating the Example Application

61.3 Designing the User Interface

61.4 Implementing the Remote Bound Service

61.5 Configuring a Remote Service in the Manifest File

61.6 Launching and Binding to the Remote Service

61.7 Sending a Message to the Remote Service

61.8 Summary

62. An Android Notifications Tutorial

62.1 An Overview of Notifications

62.2 Creating the NotifyDemo Project

62.3 Designing the User Interface

62.4 Creating the Second Activity

62.5 Creating a Notification Channel

62.6 Creating and Issuing a Basic Notification

62.7 Launching an Activity from a Notification

62.8 Adding Actions to a Notification

62.9 Bundled Notifications

62.10 Summary

63. An Android Direct Reply Notification Tutorial

63.1 Creating the DirectReply Project

63.2 Creating the Notification Channel

63.3 Building the RemoteInput Object

63.4 Creating the PendingIntent

63.5 Creating the Reply Action

63.6 Receiving Direct Reply Input

63.7 Updating the Notification

63.8 Summary

64. Foldable Devices and Multi-Window Support

64.1 Foldables and Multi-Window Support

64.2 Using a Foldable Emulator

64.3 Entering Multi-Window Mode

64.4 Enabling and using Freeform Support

64.5 Checking for Freeform Support

64.6 Enabling Multi-Window Support in an App

64.7 Specifying Multi-Window Attributes

64.8 Detecting Multi-Window Mode in an Activity

64.9 Receiving Multi-Window Notifications

64.10 Launching an Activity in Multi-Window Mode

64.11 Configuring Freeform Activity Size and Position

64.12 Summary

65. An Overview of Android SQLite Databases

65.1 Understanding Database Tables

65.2 Introducing Database Schema

65.3 Columns and Data Types

65.4 Database Rows

65.5 Introducing Primary Keys

65.6 What is SQLite?

65.7 Structured Query Language (SQL)

65.8 Trying SQLite on an Android Virtual Device (AVD)

65.9 The Android Room Persistence Library

65.10 Summary

66. The Android Room Persistence Library

66.1 Revisiting Modern App Architecture

66.2 Key Elements of Room Database Persistence

66.3 Understanding Entities

66.4 Data Access Objects

66.5 The Room Database

66.6 The Repository

66.7 In-Memory Databases

66.8 Database Inspector

66.9 Summary

67. An Android TableLayout and TableRow Tutorial

67.1 The TableLayout and TableRow Layout Views

67.2 Creating the Room Database Project

67.3 Converting to a LinearLayout

67.4 Adding the TableLayout to the User Interface

67.5 Configuring the TableRows

67.6 Adding the Button Bar to the Layout

67.7 Adding the RecyclerView

67.8 Adjusting the Layout Margins

67.9 Summary

68. An Android Room Database and Repository Tutorial

68.1 About the RoomDemo Project

68.2 Modifying the Build Configuration

68.3 Building the Entity

68.4 Creating the Data Access Object

68.5 Adding the Room Database

68.6 Adding the Repository

68.7 Modifying the ViewModel

68.8 Creating the Product Item Layout

68.9 Adding the RecyclerView Adapter

68.10 Preparing the Main Fragment

68.11 Adding the Button Listeners

68.12 Adding LiveData Observers

68.13 Initializing the RecyclerView

68.14 Testing the RoomDemo App

68.15 Using the Database Inspector

68.16 Summary

69. Accessing Cloud Storage using the Android Storage Access Framework

69.1 The Storage Access Framework

69.2 Working with the Storage Access Framework

69.3 Filtering Picker File Listings

69.4 Handling Intent Results

69.5 Reading the Content of a File

69.6 Writing Content to a File

69.7 Deleting a File

69.8 Gaining Persistent Access to a File

69.9 Summary

70. An Android Storage Access Framework Example

70.1 About the Storage Access Framework Example

70.2 Creating the Storage Access Framework Example

70.3 Declaring Request Codes

70.4 Creating a New Storage File

70.5 The onActivityResult() Method

70.6 Saving to a Storage File

70.7 Opening and Reading a Storage File

70.8 Testing the Storage Access Application

70.9 Summary

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

71.1 Introducing the Android VideoView Class

71.2 Introducing the Android MediaController Class

71.3 Creating the Video Playback Example

71.4 Downloading the Video File

71.5 Configuring the VideoView

71.6 Adding the MediaController to the Video View

71.7 Setting up the onPreparedListener

71.8 Summary

72. Android Picture-in-Picture Mode

72.1 Picture-in-Picture Features

72.2 Enabling Picture-in-Picture Mode

72.3 Configuring Picture-in-Picture Parameters

72.4 Entering Picture-in-Picture Mode

72.5 Detecting Picture-in-Picture Mode Changes

72.6 Adding Picture-in-Picture Actions

72.7 Summary

73. An Android Picture-in-Picture Tutorial

73.1 Adding Picture-in-Picture Support to the Manifest

73.2 Adding a Picture-in-Picture Button

73.3 Entering Picture-in-Picture Mode

73.4 Detecting Picture-in-Picture Mode Changes

73.5 Adding a Broadcast Receiver

73.6 Adding the PiP Action

73.7 Testing the Picture-in-Picture Action

73.8 Summary

74. Making Runtime Permission Requests in Android

74.1 Understanding Normal and Dangerous Permissions

74.2 Creating the Permissions Example Project

74.3 Checking for a Permission

74.4 Requesting Permission at Runtime

74.5 Providing a Rationale for the Permission Request

74.6 Testing the Permissions App

74.7 Summary

75. Android Audio Recording and Playback using MediaPlayer and MediaRecorder

75.1 Playing Audio

75.2 Recording Audio and Video using the MediaRecorder Class

75.3 About the Example Project

75.4 Creating the AudioApp Project

75.5 Checking for Microphone Availability

75.6 Performing the Activity Initialization

75.7 Implementing the recordAudio() Method

75.8 Implementing the stopAudio() Method

75.9 Implementing the playAudio() method

75.10 Configuring and Requesting Permissions

75.11 Testing the Application

75.12 Summary

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

76.1 The Elements of the Google Maps Android API

76.2 Creating the Google Maps Project

76.3 Obtaining Your Developer Signature

76.4 Adding the Apache HTTP Legacy Library Requirement

76.5 Testing the Application

76.6 Understanding Geocoding and Reverse Geocoding

76.7 Adding a Map to an Application

76.8 Requesting Current Location Permission

76.9 Displaying the User’s Current Location

76.10 Changing the Map Type

76.11 Displaying Map Controls to the User

76.12 Handling Map Gesture Interaction

76.13 Creating Map Markers

76.14 Controlling the Map Camera

76.15 Summary

77. Printing with the Android Printing Framework

77.1 The Android Printing Architecture

77.2 The Print Service Plugins

77.3 Google Cloud Print

77.4 Printing to Google Drive

77.5 Save as PDF

77.6 Printing from Android Devices

77.7 Options for Building Print Support into Android Apps

77.8 Summary

78. An Android HTML and Web Content Printing Example

78.1 Creating the HTML Printing Example Application

78.2 Printing Dynamic HTML Content

78.3 Creating the Web Page Printing Example

78.4 Removing Navigation Features

78.5 Designing the User Interface Layout

78.6 Loading the Web Page into the WebView

78.7 Adding the Print Menu Option

78.8 Summary

79. A Guide to Android Custom Document Printing

79.1 An Overview of Android Custom Document Printing

79.2 Preparing the Custom Document Printing Project

79.3 Creating the Custom Print Adapter

79.4 Implementing the onLayout() Callback Method

79.5 Implementing the onWrite() Callback Method

79.6 Checking a Page is in Range

79.7 Drawing the Content on the Page Canvas

79.8 Starting the Print Job

79.9 Testing the Application

79.10 Summary

80. An Introduction to Android App Links

80.1 An Overview of Android App Links

80.2 App Link Intent Filters

80.3 Handling App Link Intents

80.4 Associating the App with a Website

80.5 Summary

81. An Android Studio App Links Tutorial

81.1 About the Example App

81.2 The Database Schema

81.3 Loading and Running the Project

81.4 Adding the URL Mapping

81.5 Adding the Intent Filter

81.6 Adding Intent Handling Code

81.7 Testing the App Link

81.8 Associating an App Link with a Web Site

81.9 Summary

82. A Guide to the Android Studio Profiler

82.1 Accessing the Android Profiler

82.2 Enabling Advanced Profiling

82.3 The Android Profiler Tool Window

82.4 The Sessions Panel

82.5 The CPU Profiler

82.6 Memory Profiler

82.7 Network Profiler

82.8 Energy Profiler

82.9 Summary

83. An Android Biometric Authentication Tutorial

83.1 An Overview of Biometric Authentication

83.2 Creating the Biometric Authentication Project

83.3 Configuring Device Fingerprint Authentication

83.4 Adding the Biometric Permission to the Manifest File

83.5 Designing the User Interface

83.6 Adding a Toast Convenience Method

83.7 Checking the Security Settings

83.8 Configuring the Authentication Callbacks

83.9 Adding the CancellationSignal

83.10 Starting the Biometric Prompt

83.11 Testing the Project

83.12 Summary

84. Creating, Testing and Uploading an Android App Bundle

84.1 The Release Preparation Process

84.2 Android App Bundles

84.3 Register for a Google Play Developer Console Account

84.4 Configuring the App in the Console

84.5 Enabling Google Play App Signing

84.6 Creating a Keystore File

84.7 Creating the Android App Bundle

84.8 Generating Test APK Files

84.9 Uploading the App Bundle to the Google Play Developer Console

84.10 Exploring the App Bundle

84.11 Managing Testers

84.12 Rolling the App Out for Testing

84.13 Uploading New App Bundle Revisions

84.14 Analyzing the App Bundle File

84.15 Summary

85. An Overview of Android Dynamic Feature Modules

85.1 An Overview of Dynamic Feature Modules

85.2 Dynamic Feature Module Architecture

85.3 Creating a Dynamic Feature Module

85.4 Converting an Existing Module for Dynamic Delivery

85.5 Working with Dynamic Feature Modules

85.6 Handling Large Dynamic Feature Modules

85.7 Summary

86. An Android Studio Dynamic Feature Tutorial

86.1 Creating the DynamicFeature Project

86.2 Adding Dynamic Feature Support to the Project

86.3 Designing the Base Activity User Interface

86.4 Adding the Dynamic Feature Module

86.5 Reviewing the Dynamic Feature Module

86.6 Adding the Dynamic Feature Activity

86.7 Implementing the launchIntent() Method

86.8 Uploading the App Bundle for Testing

86.9 Implementing the installFeature() Method

86.10 Adding the Update Listener

86.11 Handling Large Downloads

86.12 Using Deferred Installation

86.13 Removing a Dynamic Module

86.14 Summary

87. An Overview of Gradle in Android Studio

87.1 An Overview of Gradle

87.2 Gradle and Android Studio

87.3 The Top-level Gradle Build File

87.4 Module Level Gradle Build Files

87.5 Configuring Signing Settings in the Build File

87.6 Running Gradle Tasks from the Command-line

87.7 Summary

Index

Customer Reviews

5 star

4 star

3 star

2 star

1 star

Android Studio 4.1 Development Essentials – Java Edition

By : Neil Smyth

Android Studio 4.1 Development Essentials – Java Edition

By: Neil Smyth

Overview of this book

Unlock full access

Continue reading for free

Android Studio 4.1 Development Essentials – Java Edition

By : Neil Smyth

Android Studio 4.1 Development Essentials – Java Edition

By: Neil Smyth

Overview of this book

Unlock full access

Continue reading for free

Delete Bookmark

Confirmation

Buy this book with your credits?