Android Studio 4.2 Development Essentials - Java Edition

Book Image

Android Studio 4.2 Development Essentials - Java Edition

By : Neil Smyth

Book Image

Android Studio 4.2 Development Essentials - Java Edition

By: Neil Smyth

Overview of this book

Android Studio is an Integrated Development Environment based on the JetBrains IntelliJ IDEA. It provides developers with a unique platform to design and develop Android apps using various developer tools. The new Android Studio 4.2 has an upgraded IntelliJ platform and a variety of new features designed to improve the productivity of Android app developers. Fully updated for Android Studio 4.2, the objective of this book is to help you master the skills necessary to develop Android applications using Java as the programming language. This book begins by outlining the steps necessary to set up an Android development and testing environment and introducing programming in Java, describing data types, flow control, functions, lambdas, and object-oriented programming. It includes an overview of Android Studio, covering areas such as tool windows, the code editor, and the Layout Editor tool. An introduction to Android architecture is followed by an in-depth explanation of the design of Android applications and user interfaces using the Android Studio environment. Early chapters detail Android Architecture components like view models, lifecycle management, Room database access, the Database Inspector, app navigation, live data, and data binding. Advanced topics such as intents are also covered, as are touch screen handling, gesture recognition, and the recording and playback of audio. You will also explore printing, transitions, cloud-based file storage, and foldable device support. Detailed descriptions of the concepts of material design are provided, including the use of floating action buttons, Snackbars, tabbed interfaces, card views, navigation drawers, and collapsing toolbars. Some key features of Android Studio 4.2 and Android discussed in-depth include the Layout Editor, the ConstraintLayout and ConstraintSet classes, MotionLayout Editor, view binding, constraint chains, barriers, and direct reply notifications. Later chapters cover advanced features of Android Studio such as App Links, Dynamic Delivery, the Android Studio Profiler, Gradle build configuration, and submitting apps to the Google Play Developer Console.

1. Introduction

1. Introduction

1.1 Downloading the Code Samples

Free Chapter

2. Setting up an Android Studio Development Environment

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

3. Creating an Example Android App in Android Studio

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

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

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

5. Using and Configuring the Android Studio AVD Emulator

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

6. A Tour of the Android Studio User Interface

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

7. Testing Android Studio Apps on a Physical Android Device

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

8. The Basics of the Android Studio Code Editor

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

9. An Overview of the Android Architecture

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

10. The Anatomy of an Android Application

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

11. An Overview of Android View Binding

11. An Overview of Android View Binding

11.1 Find View by Id

11.2 View Binding

11.3 Converting the AndroidSample project

11.4 Enabling View Binding

11.5 Using View Binding

11.6 Choosing an Option

11.7 View Binding in the Book Examples

11.8 Migrating a Project to View Binding

12. Understanding Android Application and Activity Lifecycles

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

13. Handling Android Activity State Changes

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.6 Foldable Devices and Multi-Resume

13.7 Disabling Configuration Change Restarts

13.8 Lifecycle Method Limitations

14. Android Activity State Changes by Example

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

15. Saving and Restoring the State of an Android Activity

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

16. Understanding Android Views, View Groups and Layouts

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

17. A Guide to the Android Studio Layout Editor Tool

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 Night Mode

17.8 Split Mode

17.9 Setting Attributes

17.10 Transforms

17.11 Tools Visibility Toggles

17.12 Converting Views

17.13 Displaying Sample Data

17.14 Creating a Custom Device Definition

17.15 Changing the Current Device

17.16 Layout Validation (Multi Preview)

18. A Guide to the Android ConstraintLayout

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.9 ConstraintLayout Advantages

18.10 ConstraintLayout Availability

19. A Guide to Using ConstraintLayout in Android Studio

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

20. Working with ConstraintLayout Chains and Ratios in Android Studio

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

21. An Android Studio Layout Editor ConstraintLayout Tutorial

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

22. Manual XML Layout Design in Android Studio

22. Manual XML Layout Design in Android Studio

22.1 Manually Creating an XML Layout

22.2 Manual XML vs. Visual Layout Design

23. Managing Constraints using Constraint Sets

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

24. An Android ConstraintSet Tutorial

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)

25. A Guide to using Apply Changes in Android Studio

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

26. An Overview and Example of Android Event Handling

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

26.6 The Event Listener and Callback Method

26.7 Consuming Events

27. Android Touch and Multi-touch Event Handling

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

27.7 Implementing the Touch Event Listener

27.8 Running the Example Application

28. Detecting Common Gestures Using the Android Gesture Detector Class

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 Implementing the Listener Class

28.4 Creating the GestureDetectorCompat Instance

28.5 Implementing the onTouchEvent() Method

28.6 Testing the Application

29. Implementing Custom Gesture and Pinch Recognition on Android

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 Extracting the Gestures File from the SD Card

29.9 Adding the Gestures File to the Project

29.10 Designing the User Interface

29.11 Loading the Gestures File

29.12 Registering the Event Listener

29.13 Implementing the onGesturePerformed Method

29.14 Testing the Application

29.15 Configuring the GestureOverlayView

29.16 Intercepting Gestures

29.17 Detecting Pinch Gestures

29.18 A Pinch Gesture Example Project

30. An Introduction to Android Fragments

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

31. Using Fragments in Android Studio - An Example

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 Migrating a Fragment to View Binding

31.5 Adding the Second Fragment

31.6 Adding the Fragments to the Activity

31.7 Making the Toolbar Fragment Talk to the Activity

31.8 Making the Activity Talk to the Text Fragment

31.9 Testing the Application

32. Modern Android App Architecture with Jetpack

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

33. An Android Jetpack ViewModel Tutorial

33. An Android Jetpack ViewModel Tutorial

33.1 About the Project

33.2 Creating the ViewModel Example Project

33.3 Reviewing the Project

33.4 Designing the Fragment Layout

33.5 Implementing the View Model

33.6 Associating the Fragment with the View Model

33.7 Modifying the Fragment

33.8 Accessing the ViewModel Data

33.9 Testing the Project

34. An Android Jetpack LiveData Tutorial

34. An Android Jetpack LiveData Tutorial

34.1 LiveData - A Recap

34.2 Adding LiveData to the ViewModel

34.3 Implementing the Observer

35. An Overview of Android Jetpack Data Binding

35. An Overview of Android Jetpack Data Binding

35.1 An Overview of Data Binding

35.2 The Key Components of Data Binding

36. An Android Jetpack Data Binding Tutorial

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

37. An Android ViewModel Saved State Tutorial

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

38. Working with Android Lifecycle-Aware Components

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

39. An Android Jetpack Lifecycle Awareness Tutorial

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

40. An Overview of the Navigation Architecture Component

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

41. An Android Jetpack Navigation Component Tutorial

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 Adding View Binding Support to the Destination Fragments

41.10 Triggering the Action

41.11 Passing Data Using Safeargs

42. An Introduction to MotionLayout

42. An Introduction to MotionLayout

42.1 An Overview of MotionLayout

42.2 MotionLayout

42.3 MotionScene

42.4 Configuring ConstraintSets

42.5 Custom Attributes

42.6 Triggering an Animation

42.7 Arc Motion

42.9 Time Linearity

42.10 KeyTrigger

42.11 Cycle and Time Cycle Keyframes

42.12 Starting an Animation from Code

43. An Android MotionLayout Editor Tutorial

43. An Android MotionLayout Editor Tutorial

43.1 Creating the MotionLayoutDemo Project

43.2 ConstraintLayout to MotionLayout Conversion

43.3 Configuring Start and End Constraints

43.4 Previewing the MotionLayout Animation

43.5 Adding an OnClick Gesture

43.6 Adding an Attribute Keyframe to the Transition

43.7 Adding a CustomAttribute to a Transition

43.8 Adding Position Keyframes

44. A MotionLayout KeyCycle Tutorial

44. A MotionLayout KeyCycle Tutorial

44.1 An Overview of Cycle Keyframes

44.2 Using the Cycle Editor

44.3 Creating the KeyCycleDemo Project

44.4 Configuring the Start and End Constraints

44.5 Creating the Cycles

44.6 Previewing the Animation

44.7 Adding the KeyFrameSet to the MotionScene

45. Working with the Floating Action Button and Snackbar

45. Working with the Floating Action Button and Snackbar

45.1 The Material Design

45.2 The Design Library

45.3 The Floating Action Button (FAB)

45.4 The Snackbar

45.5 Creating the Example Project

45.6 Reviewing the Project

45.7 Removing Navigation Features

45.8 Changing the Floating Action Button

45.9 Adding an Action to the Snackbar

46. Creating a Tabbed Interface using the TabLayout Component

46. Creating a Tabbed Interface using the TabLayout Component

46.1 An Introduction to the ViewPager2 Class

46.2 An Overview of the TabLayout Component

46.3 Creating the TabLayoutDemo Project

46.4 Creating the First Fragment

46.5 Duplicating the Fragments

46.6 Adding the TabLayout and ViewPager2

46.7 Creating the Fragment State Adapter

46.8 Performing the Initialization Tasks

46.9 Testing the Application

46.10 Customizing the TabLayout

47. Working with the RecyclerView and CardView Widgets

47. Working with the RecyclerView and CardView Widgets

47.1 An Overview of the RecyclerView

47.2 An Overview of the CardView

48. An Android RecyclerView and CardView Tutorial

48. An Android RecyclerView and CardView Tutorial

48.1 Creating the CardDemo Project

48.2 Modifying the Basic Activity Project

48.3 Designing the CardView Layout

48.4 Adding the RecyclerView

48.5 Adding the Image Files

48.6 Creating the RecyclerView Adapter

48.7 Initializing the RecyclerView Component

48.8 Testing the Application

48.9 Responding to Card Selections

49. A Layout Editor Sample Data Tutorial

49. A Layout Editor Sample Data Tutorial

49.1 Adding Sample Data to a Project

49.2 Using Custom Sample Data

50. Working with the AppBar and Collapsing Toolbar Layouts

50. Working with the AppBar and Collapsing Toolbar Layouts

50.1 The Anatomy of an AppBar

50.2 The Example Project

50.3 Coordinating the RecyclerView and Toolbar

50.4 Introducing the Collapsing Toolbar Layout

50.5 Changing the Title and Scrim Color

51. An Android Studio Primary/Detail Flow Tutorial

51. An Android Studio Primary/Detail Flow Tutorial

51.1 The Primary/Detail Flow

51.2 Creating a Primary/Detail Flow Activity

51.3 Modifying the Primary/Detail Flow Template

51.4 Changing the Content Model

51.5 Changing the Detail Pane

51.6 Modifying the WebsiteDetailFragment Class

51.7 Modifying the WebsiteListFragment Class

51.8 Adding Manifest Permissions

51.9 Running the Application

52. An Overview of Android Intents

52. An Overview of Android Intents

52.1 An Overview of Intents

52.2 Explicit Intents

52.3 Returning Data from an Activity

52.4 Implicit Intents

52.5 Using Intent Filters

52.6 Checking Intent Availability

53. Android Explicit Intents – A Worked Example

53. Android Explicit Intents – A Worked Example

53.1 Creating the Explicit Intent Example Application

53.2 Designing the User Interface Layout for MainActivity

53.3 Creating the Second Activity Class

53.4 Designing the User Interface Layout for SecondActivity

53.5 Reviewing the Application Manifest File

53.6 Creating the Intent

53.7 Extracting Intent Data

53.8 Launching SecondActivity as a Sub-Activity

53.9 Returning Data from a Sub-Activity

53.10 Testing the Application

54. Android Implicit Intents – A Worked Example

54. Android Implicit Intents – A Worked Example

54.1 Creating the Android Studio Implicit Intent Example Project

54.2 Designing the User Interface

54.3 Creating the Implicit Intent

54.4 Adding a Second Matching Activity

54.5 Adding the Web View to the UI

54.6 Obtaining the Intent URL

54.7 Modifying the MyWebView Project Manifest File

54.8 Installing the MyWebView Package on a Device

54.9 Testing the Application

55. Android Broadcast Intents and Broadcast Receivers

55. Android Broadcast Intents and Broadcast Receivers

55.1 An Overview of Broadcast Intents

55.2 An Overview of Broadcast Receivers

55.3 Obtaining Results from a Broadcast

55.4 Sticky Broadcast Intents

55.5 The Broadcast Intent Example

55.6 Creating the Example Application

55.7 Creating and Sending the Broadcast Intent

55.8 Creating the Broadcast Receiver

55.9 Registering the Broadcast Receiver

55.10 Testing the Broadcast Example

55.11 Listening for System Broadcasts

56. A Basic Overview of Java Threads, Handlers and Executors

56. A Basic Overview of Java Threads, Handlers and Executors

56.1 An Overview of Threads

56.2 The Application Main Thread

56.3 Thread Handlers

56.4 A Threading Example

56.5 Building the App

56.6 Creating a New Thread

56.7 Implementing a Thread Handler

56.8 Passing a Message to the Handler

56.9 Java Executor Concurrency

56.10 Working with Runnable Tasks

56.11 Shutting down an Executor Service

56.12 Working with Callable Tasks and Futures

56.13 Handling a Future Result

56.14 Scheduling Tasks

57. An Overview of Android Services

57. An Overview of Android Services

57.1 Started Services

57.2 Intent Service

57.3 Bound Service

57.4 The Anatomy of a Service

57.5 Controlling Destroyed Service Restart Options

57.6 Declaring a Service in the Manifest File

57.7 Starting a Service Running on System Startup

58. Implementing an Android Started Service – A Worked Example

58. Implementing an Android Started Service – A Worked Example

58.1 Creating the Example Project

58.2 Designing the User Interface

58.3 Creating the Service Class

58.4 Adding the Service to the Manifest File

58.5 Starting the Service

58.6 Testing the IntentService Example

58.7 Using the Service Class

58.8 Creating the New Service

58.9 Launching the Service

58.10 Running the Application

58.11 Adding Threading to the Service

59. Android Local Bound Services – A Worked Example

59. Android Local Bound Services – A Worked Example

59.1 Understanding Bound Services

59.2 Bound Service Interaction Options

59.3 A Local Bound Service Example

59.4 Adding a Bound Service to the Project

59.5 Implementing the Binder

59.6 Binding the Client to the Service

59.7 Completing the Example

59.8 Testing the Application

60. Android Remote Bound Services – A Worked Example

60. Android Remote Bound Services – A Worked Example

60.1 Client to Remote Service Communication

60.2 Creating the Example Application

60.3 Designing the User Interface

60.4 Implementing the Remote Bound Service

60.5 Configuring a Remote Service in the Manifest File

60.6 Launching and Binding to the Remote Service

60.7 Sending a Message to the Remote Service

61. An Android Notifications Tutorial

61. An Android Notifications Tutorial

61.1 An Overview of Notifications

61.2 Creating the NotifyDemo Project

61.3 Designing the User Interface

61.4 Creating the Second Activity

61.5 Creating a Notification Channel

61.6 Creating and Issuing a Notification

61.7 Launching an Activity from a Notification

61.8 Adding Actions to a Notification

61.9 Bundled Notifications

62. An Android Direct Reply Notification Tutorial

62. An Android Direct Reply Notification Tutorial

62.1 Creating the DirectReply Project

62.2 Designing the User Interface

62.3 Creating the Notification Channel

62.4 Building the RemoteInput Object

62.5 Creating the PendingIntent

62.6 Creating the Reply Action

62.7 Receiving Direct Reply Input

62.8 Updating the Notification

63. Foldable Devices and Multi-Window Support

63. Foldable Devices and Multi-Window Support

63.1 Foldables and Multi-Window Support

63.2 Using a Foldable Emulator

63.3 Entering Multi-Window Mode

63.4 Enabling and using Freeform Support

63.5 Checking for Freeform Support

63.6 Enabling Multi-Window Support in an App

63.7 Specifying Multi-Window Attributes

63.8 Detecting Multi-Window Mode in an Activity

63.9 Receiving Multi-Window Notifications

63.10 Launching an Activity in Multi-Window Mode

63.11 Configuring Freeform Activity Size and Position

64. An Overview of Android SQLite Databases

64. An Overview of Android SQLite Databases

64.1 Understanding Database Tables

64.2 Introducing Database Schema

64.3 Columns and Data Types

64.4 Database Rows

64.5 Introducing Primary Keys

64.6 What is SQLite?

64.7 Structured Query Language (SQL)

64.8 Trying SQLite on an Android Virtual Device (AVD)

64.9 The Android Room Persistence Library

65. The Android Room Persistence Library

65. The Android Room Persistence Library

65.1 Revisiting Modern App Architecture

65.2 Key Elements of Room Database Persistence

65.3 Understanding Entities

65.4 Data Access Objects

65.5 The Room Database

65.6 The Repository

65.7 In-Memory Databases

65.8 Database Inspector

66. An Android TableLayout and TableRow Tutorial

66. An Android TableLayout and TableRow Tutorial

66.1 The TableLayout and TableRow Layout Views

66.2 Creating the Room Database Project

66.3 Converting to a LinearLayout

66.4 Adding the TableLayout to the User Interface

66.5 Configuring the TableRows

66.6 Adding the Button Bar to the Layout

66.7 Adding the RecyclerView

66.8 Adjusting the Layout Margins

67. An Android Room Database and Repository Tutorial

67. An Android Room Database and Repository Tutorial

67.1 About the RoomDemo Project

67.2 Modifying the Build Configuration

67.3 Building the Entity

67.4 Creating the Data Access Object

67.5 Adding the Room Database

67.6 Adding the Repository

67.7 Modifying the ViewModel

67.8 Creating the Product Item Layout

67.9 Adding the RecyclerView Adapter

67.10 Preparing the Main Fragment

67.11 Adding the Button Listeners

67.12 Adding LiveData Observers

67.13 Initializing the RecyclerView

67.14 Testing the RoomDemo App

67.15 Using the Database Inspector

68. Accessing Cloud Storage using the Android Storage Access Framework

68. Accessing Cloud Storage using the Android Storage Access Framework

68.1 The Storage Access Framework

68.2 Working with the Storage Access Framework

68.3 Filtering Picker File Listings

68.4 Handling Intent Results

68.5 Reading the Content of a File

68.6 Writing Content to a File

68.7 Deleting a File

68.8 Gaining Persistent Access to a File

69. An Android Storage Access Framework Example

69. An Android Storage Access Framework Example

69.1 About the Storage Access Framework Example

69.2 Creating the Storage Access Framework Example

69.3 Designing the User Interface

69.4 Declaring Request Codes

69.5 Creating a New Storage File

69.6 The onActivityResult() Method

69.7 Saving to a Storage File

69.8 Opening and Reading a Storage File

69.9 Testing the Storage Access Application

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

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

70.1 Introducing the Android VideoView Class

70.2 Introducing the Android MediaController Class

70.3 Creating the Video Playback Example

70.4 Designing the VideoPlayer Layout

70.5 Downloading the Video File

70.6 Configuring the VideoView

70.7 Adding the MediaController to the Video View

70.8 Setting up the onPreparedListener

71. Android Picture-in-Picture Mode

71. Android Picture-in-Picture Mode

71.1 Picture-in-Picture Features

71.2 Enabling Picture-in-Picture Mode

71.3 Configuring Picture-in-Picture Parameters

71.4 Entering Picture-in-Picture Mode

71.5 Detecting Picture-in-Picture Mode Changes

71.6 Adding Picture-in-Picture Actions

72. An Android Picture-in-Picture Tutorial

72. An Android Picture-in-Picture Tutorial

72.1 Adding Picture-in-Picture Support to the Manifest

72.2 Adding a Picture-in-Picture Button

72.3 Entering Picture-in-Picture Mode

72.4 Detecting Picture-in-Picture Mode Changes

72.5 Adding a Broadcast Receiver

72.6 Adding the PiP Action

72.7 Testing the Picture-in-Picture Action

73. Making Runtime Permission Requests in Android

73. Making Runtime Permission Requests in Android

73.1 Understanding Normal and Dangerous Permissions

73.2 Creating the Permissions Example Project

73.3 Checking for a Permission

73.4 Requesting Permission at Runtime

73.5 Providing a Rationale for the Permission Request

73.6 Testing the Permissions App

74. Android Audio Recording and Playback using MediaPlayer and MediaRecorder

74. Android Audio Recording and Playback using MediaPlayer and MediaRecorder

74.1 Playing Audio

74.2 Recording Audio and Video using the MediaRecorder Class

74.3 About the Example Project

74.4 Creating the AudioApp Project

74.5 Designing the User Interface

74.6 Checking for Microphone Availability

74.7 Initializing the Activity

74.8 Implementing the recordAudio() Method

74.9 Implementing the stopAudio() Method

74.10 Implementing the playAudio() method

74.11 Configuring and Requesting Permissions

74.12 Testing the Application

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

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

75.1 The Elements of the Google Maps Android API

75.2 Creating the Google Maps Project

75.3 Obtaining Your Developer Signature

75.4 Adding the Apache HTTP Legacy Library Requirement

75.5 Testing the Application

75.6 Understanding Geocoding and Reverse Geocoding

75.7 Adding a Map to an Application

75.8 Requesting Current Location Permission

75.9 Displaying the User’s Current Location

75.10 Changing the Map Type

75.11 Displaying Map Controls to the User

75.12 Handling Map Gesture Interaction

75.13 Creating Map Markers

75.14 Controlling the Map Camera

76. Printing with the Android Printing Framework

76. Printing with the Android Printing Framework

76.1 The Android Printing Architecture

76.2 The Print Service Plugins

76.3 Google Cloud Print

76.4 Printing to Google Drive

76.5 Save as PDF

76.6 Printing from Android Devices

76.7 Options for Building Print Support into Android Apps

77. An Android HTML and Web Content Printing Example

77. An Android HTML and Web Content Printing Example

77.1 Creating the HTML Printing Example Application

77.2 Printing Dynamic HTML Content

77.3 Creating the Web Page Printing Example

77.4 Removing the Floating Action Button

77.5 Removing Navigation Features

77.6 Designing the User Interface Layout

77.7 Accessing the WebView from the Main Activity

77.8 Loading the Web Page into the WebView

77.9 Adding the Print Menu Option

78. A Guide to Android Custom Document Printing

78. A Guide to Android Custom Document Printing

78.1 An Overview of Android Custom Document Printing

78.2 Preparing the Custom Document Printing Project

78.3 Creating the Custom Print Adapter

78.4 Implementing the onLayout() Callback Method

78.5 Implementing the onWrite() Callback Method

78.6 Checking a Page is in Range

78.7 Drawing the Content on the Page Canvas

78.8 Starting the Print Job

78.9 Testing the Application

79. An Introduction to Android App Links

79. An Introduction to Android App Links

79.1 An Overview of Android App Links

79.2 App Link Intent Filters

79.3 Handling App Link Intents

79.4 Associating the App with a Website

80. An Android Studio App Links Tutorial

80. An Android Studio App Links Tutorial

80.1 About the Example App

80.2 The Database Schema

80.3 Loading and Running the Project

80.4 Adding the URL Mapping

80.5 Adding the Intent Filter

80.6 Adding Intent Handling Code

80.7 Testing the App Link

80.8 Associating an App Link with a Web Site

81. A Guide to the Android Studio Profiler

81. A Guide to the Android Studio Profiler

81.1 Accessing the Android Profiler

81.2 Enabling Advanced Profiling

81.3 The Android Profiler Tool Window

81.4 The Sessions Panel

81.5 The CPU Profiler

81.6 Memory Profiler

81.7 Network Profiler

81.8 Energy Profiler

82. An Android Biometric Authentication Tutorial

82. An Android Biometric Authentication Tutorial

82.1 An Overview of Biometric Authentication

82.2 Creating the Biometric Authentication Project

82.3 Configuring Device Fingerprint Authentication

82.4 Adding the Biometric Permission to the Manifest File

82.5 Designing the User Interface

82.6 Adding a Toast Convenience Method

82.7 Checking the Security Settings

82.8 Configuring the Authentication Callbacks

82.9 Adding the CancellationSignal

82.10 Starting the Biometric Prompt

82.11 Testing the Project

83. Creating, Testing and Uploading an Android App Bundle

83. Creating, Testing and Uploading an Android App Bundle

83.1 The Release Preparation Process

83.2 Android App Bundles

83.3 Register for a Google Play Developer Console Account

83.4 Configuring the App in the Console

83.5 Enabling Google Play App Signing

83.6 Creating a Keystore File

83.7 Creating the Android App Bundle

83.8 Generating Test APK Files

83.9 Uploading the App Bundle to the Google Play Developer Console

83.10 Exploring the App Bundle

83.11 Managing Testers

83.12 Rolling the App Out for Testing

83.13 Uploading New App Bundle Revisions

83.14 Analyzing the App Bundle File

84. An Overview of Android Dynamic Feature Modules

84. An Overview of Android Dynamic Feature Modules

84.1 An Overview of Dynamic Feature Modules

84.2 Dynamic Feature Module Architecture

84.3 Creating a Dynamic Feature Module

84.4 Converting an Existing Module for Dynamic Delivery

84.5 Working with Dynamic Feature Modules

84.6 Handling Large Dynamic Feature Modules

85. An Android Studio Dynamic Feature Tutorial

85. An Android Studio Dynamic Feature Tutorial

85.1 Creating the DynamicFeature Project

85.2 Adding Dynamic Feature Support to the Project

85.3 Designing the Base Activity User Interface

85.4 Adding the Dynamic Feature Module

85.5 Reviewing the Dynamic Feature Module

85.6 Adding the Dynamic Feature Activity

85.7 Implementing the launchIntent() Method

85.8 Uploading the App Bundle for Testing

85.9 Implementing the installFeature() Method

85.10 Adding the Update Listener

85.11 Handling Large Downloads

85.12 Using Deferred Installation

85.13 Removing a Dynamic Module

86. An Overview of Gradle in Android Studio

86. An Overview of Gradle in Android Studio

86.1 An Overview of Gradle

86.2 Gradle and Android Studio

86.3 The Top-level Gradle Build File

86.4 Module Level Gradle Build Files

86.5 Configuring Signing Settings in the Build File

86.6 Running Gradle Tasks from the Command-line

Index

Customer Reviews

5 star

0

4 star

0

3 star

0

2 star

0

1 star

0

Index

Symbols

<application> 461

<fragment> 235

<fragment> element 235

<receiver> 440

<service> 461, 474, 481

<uses-permission> 420

Code Reformatting 67

@layout/toolbar_fragment 245

.well-known folder 661

A

AbsoluteLayout 112

ACCESS_COARSE_LOCATION permission 596

ACCESS_FINE_LOCATION permission 596

ACTION_CREATE_DOCUMENT 564

ACTION_CREATE_INTENT 565

ACTION_DOWN 210

ACTION_MOVE 210

ACTION_OPEN_DOCUMENT 559

ACTION_OPEN_DOCUMENT intent 558

ACTION_POINTER_DOWN 210

ACTION_POINTER_UP 210

ACTION_UP 210

ACTION_VIEW 435

Active / Running state 86

Activity 73, 89

adding to a project 169

adding views in Java code 189

class 89

creation 14

Entire Lifetime 93

Foreground Lifetime 93

lifecycle methods 92

lifecycles 83

returning data from 418

state change example 97

state changes 89

states 86

Visible Lifetime 93

...