8. The Basics of the Android Studio Code Editor | Android Studio 3.5 Development Essentials

Book Overview & Buying
Table Of Contents

Android Studio 3.5 Development Essentials - Java Edition

By : Neil Smyth

4.6 (5)

Buy this Book

Android Studio 3.5 Development Essentials - Java Edition

4.6 (5)

By: Neil Smyth

Buy this Book

Overview of this book

Android applications have become an important part of our daily lives and lots of effort goes into developing an Android application. This book will help you to build you own Android applications using Java. Android Studio 3.5 Development Essentials – Java 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 emulator. You will test apps on physical Android devices, then study Android Studio code editor and constraint layout, Android architecture, the anatomy of an Android app, and Android activity state changes. The book then covers advanced topics such as views and widgets implementation, multi-window support integration, and biometric authentication, and finally, you will learn to upload your app to 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 Java.

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

11.1 Android Applications and Resource Management

11.2 Android Process States

11.3 Inter-Process Dependencies

11.4 The Activity Lifecycle

11.5 The Activity Stack

11.6 Activity States

11.7 Configuration Changes

11.8 Handling State Change

11.9 Summary

12. Handling Android Activity State Changes

12.1 New vs. Old Lifecycle Techniques

12.2 The Activity and Fragment Classes

12.3 Dynamic State vs. Persistent State

12.4 The Android Lifecycle Methods

12.5 Lifetimes

12.6 Foldable Devices and Multi-Resume

12.7 Disabling Configuration Change Restarts

12.8 Lifecycle Method Limitations

12.9 Summary

13. Android Activity State Changes by Example

13.1 Creating the State Change Example Project

13.2 Designing the User Interface

13.3 Overriding the Activity Lifecycle Methods

13.4 Filtering the Logcat Panel

13.5 Running the Application

13.6 Experimenting with the Activity

13.7 Summary

14. Saving and Restoring the State of an Android Activity

14.1 Saving Dynamic State

14.2 Default Saving of User Interface State

14.3 The Bundle Class

14.4 Saving the State

14.5 Restoring the State

14.6 Testing the Application

14.7 Summary

15. Understanding Android Views, View Groups and Layouts

15.1 Designing for Different Android Devices

15.2 Views and View Groups

15.3 Android Layout Managers

15.4 The View Hierarchy

15.5 Creating User Interfaces

15.6 Summary

16. A Guide to the Android Studio Layout Editor Tool

16.1 Basic vs. Empty Activity Templates

16.2 The Android Studio Layout Editor

16.3 Design Mode

16.4 The Palette

16.5 Design and Layout Views

16.6 Text Mode

16.7 Setting Attributes

16.8 Converting Views

16.9 Displaying Sample Data

16.10 Creating a Custom Device Definition

16.11 Changing the Current Device

16.12 Summary

17. A Guide to the Android ConstraintLayout

17.1 How ConstraintLayout Works

17.2 Baseline Alignment

17.3 Working with Guidelines

17.4 Configuring Widget Dimensions

17.5 Working with Barriers

17.6 Ratios

17.7 ConstraintLayout Advantages

17.8 ConstraintLayout Availability

17.9 Summary

18. A Guide to using ConstraintLayout in Android Studio

18.1 Design and Layout Views

18.2 Autoconnect Mode

18.3 Inference Mode

18.4 Manipulating Constraints Manually

18.5 Adding Constraints in the Inspector

18.6 Viewing Constraints in the Attributes Window

18.7 Deleting Constraints

18.8 Adjusting Constraint Bias

18.9 Understanding ConstraintLayout Margins

18.10 The Importance of Opposing Constraints and Bias

18.11 Configuring Widget Dimensions

18.12 Adding Guidelines

18.13 Adding Barriers

18.14 Widget Group Alignment and Distribution

18.15 Converting other Layouts to ConstraintLayout

18.16 Summary

19. Working with ConstraintLayout Chains and Ratios in Android Studio

19.1 Creating a Chain

19.2 Changing the Chain Style

19.3 Spread Inside Chain Style

19.4 Packed Chain Style

19.5 Packed Chain Style with Bias

19.6 Weighted Chain

19.7 Working with Ratios

19.8 Summary

20. An Android Studio Layout Editor ConstraintLayout Tutorial

20.1 An Android Studio Layout Editor Tool Example

20.2 Creating a New Activity

20.3 Preparing the Layout Editor Environment

20.4 Adding the Widgets to the User Interface

20.5 Adding the Constraints

20.6 Testing the Layout

20.7 Using the Layout Inspector

20.8 Summary

21. Manual XML Layout Design in Android Studio

21.1 Manually Creating an XML Layout

21.2 Manual XML vs. Visual Layout Design

21.3 Summary

22. Managing Constraints using Constraint Sets

22.1 Java Code vs. XML Layout Files

22.2 Creating Views

22.3 View Attributes

22.4 Constraint Sets

22.5 Summary

23. An Android ConstraintSet Tutorial

23.1 Creating the Example Project in Android Studio

23.2 Adding Views to an Activity

23.3 Setting View Attributes

23.4 Creating View IDs

23.5 Configuring the Constraint Set

23.6 Adding the EditText View

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

23.8 Summary

24. A Guide to using Apply Changes in Android Studio

24.1 Introducing Apply Changes

24.2 Understanding Apply Changes Options

24.3 Using Apply Changes

24.4 Configuring Apply Changes Fallback Settings

24.5 An Apply Changes Tutorial

24.6 Using Apply Code Changes

24.7 Using Apply Changes and Restart Activity

24.8 Using Run App

24.9 Summary

25. An Overview and Example of Android Event Handling

25.1 Understanding Android Events

25.2 Using the android:onClick Resource

25.3 Event Listeners and Callback Methods

25.4 An Event Handling Example

25.5 Designing the User Interface

25.6 The Event Listener and Callback Method

25.7 Consuming Events

25.8 Summary

26. Android Touch and Multi-touch Event Handling

26.1 Intercepting Touch Events

26.2 The MotionEvent Object

26.3 Understanding Touch Actions

26.4 Handling Multiple Touches

26.5 An Example Multi-Touch Application

26.6 Designing the Activity User Interface

26.7 Implementing the Touch Event Listener

26.8 Running the Example Application

26.9 Summary

27. Detecting Common Gestures using the Android Gesture Detector Class

27.1 Implementing Common Gesture Detection

27.2 Creating an Example Gesture Detection Project

27.3 Implementing the Listener Class

27.4 Creating the GestureDetectorCompat Instance

27.5 Implementing the onTouchEvent() Method

27.6 Testing the Application

27.7 Summary

28. Implementing Custom Gesture and Pinch Recognition on Android

28.1 The Android Gesture Builder Application

28.2 The GestureOverlayView Class

28.3 Detecting Gestures

28.4 Identifying Specific Gestures

28.5 Installing and Running the Gesture Builder Application

28.6 Creating a Gestures File

28.7 Creating the Example Project

28.8 Extracting the Gestures File from the SD Card

28.9 Adding the Gestures File to the Project

28.10 Designing the User Interface

28.11 Loading the Gestures File

28.12 Registering the Event Listener

28.13 Implementing the onGesturePerformed Method

28.14 Testing the Application

28.15 Configuring the GestureOverlayView

28.16 Intercepting Gestures

28.17 Detecting Pinch Gestures

28.18 A Pinch Gesture Example Project

28.19 Summary

29. An Introduction to Android Fragments

29.1 What is a Fragment?

29.2 Creating a Fragment

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

29.4 Adding and Managing Fragments in Code

29.5 Handling Fragment Events

29.6 Implementing Fragment Communication

29.7 Summary

30. Using Fragments in Android Studio - An Example

30.1 About the Example Fragment Application

30.2 Creating the Example Project

30.3 Creating the First Fragment Layout

30.4 Creating the First Fragment Class

30.5 Creating the Second Fragment Layout

30.6 Adding the Fragments to the Activity

30.7 Making the Toolbar Fragment Talk to the Activity

30.8 Making the Activity Talk to the Text Fragment

30.9 Testing the Application

30.10 Summary

31. Modern Android App Architecture with Jetpack

31.1 What is Android Jetpack?

31.2 The “Old” Architecture

31.3 Modern Android Architecture

31.4 The ViewModel Component

31.5 The LiveData Component

31.6 LiveData and Data Binding

31.7 Android Lifecycles

31.8 Repository Modules

31.9 Summary

32. An Android Jetpack ViewModel Tutorial

32.1 About the Project

32.2 Creating the ViewModel Example Project

32.3 Reviewing the Project

32.4 Designing the Fragment Layout

32.5 Implementing the View Model

32.6 Associating the Fragment with the View Model

32.7 Modifying the Fragment

32.8 Accessing the ViewModel Data

32.9 Testing the Project

32.10 Summary

33. An Android Jetpack LiveData Tutorial

33.1 LiveData - A Recap

33.2 Adding LiveData to the ViewModel

33.3 Implementing the Observer

33.4 Summary

34. An Overview of Android Jetpack Data Binding

34.1 An Overview of Data Binding

34.2 The Key Components of Data Binding

34.3 Summary

35. An Android Jetpack Data Binding Tutorial

35.1 Removing the Redundant Code

35.2 Enabling Data Binding

35.3 Adding the Layout Element

35.4 Adding the Data Element to Layout File

35.5 Working with the Binding Class

35.6 Assigning the ViewModel Instance to the Data Binding Variable

35.7 Adding Binding Expressions

35.8 Adding the Conversion Method

35.9 Adding a Listener Binding

35.10 Testing the App

35.11 Summary

36. Working with Android Lifecycle-Aware Components

36.1 Lifecycle Awareness

36.2 Lifecycle Owners

36.3 Lifecycle Observers

36.4 Lifecycle States and Events

36.5 Summary

37. An Android Jetpack Lifecycle Awareness Tutorial

37.1 Creating the Example Lifecycle Project

37.2 Creating a Lifecycle Observer

37.3 Adding the Observer

37.4 Testing the Observer

37.5 Creating a Lifecycle Owner

37.6 Testing the Custom Lifecycle Owner

37.7 Summary

38. An Overview of the Navigation Architecture Component

38.1 Understanding Navigation

38.2 Declaring a Navigation Host

38.3 The Navigation Graph

38.4 Accessing the Navigation Controller

38.5 Triggering a Navigation Action

38.6 Passing Arguments

38.7 Summary

39. An Android Jetpack Navigation Component Tutorial

39.1 Creating the NavigationDemo Project

39.2 Adding Navigation to the Build Configuration

39.3 Creating the Navigation Graph Resource File

39.4 Declaring a Navigation Host

39.5 Adding Navigation Destinations

39.6 Designing the Destination Fragment Layouts

39.7 Adding an Action to the Navigation Graph

39.8 Implement the OnFragmentInteractionListener

39.9 Triggering the Action

39.10 Passing Data Using Safeargs

39.11 Summary

40. Creating and Managing Overflow Menus on Android

40.1 The Overflow Menu

40.2 Creating an Overflow Menu

40.3 Displaying an Overflow Menu

40.4 Responding to Menu Item Selections

40.5 Creating Checkable Item Groups

40.6 Menus and the Android Studio Menu Editor

40.7 Creating the Example Project

40.8 Designing the Menu

40.9 Modifying the onOptionsItemSelected() Method

40.10 Testing the Application

40.11 Summary

41. Animating User Interfaces with the Android Transitions Framework

41.1 Introducing Android Transitions and Scenes

41.2 Using Interpolators with Transitions

41.3 Working with Scene Transitions

41.4 Custom Transitions and TransitionSets in Code

41.5 Custom Transitions and TransitionSets in XML

41.6 Working with Interpolators

41.7 Creating a Custom Interpolator

41.8 Using the beginDelayedTransition Method

41.9 Summary

42. An Android Transition Tutorial using beginDelayedTransition

42.1 Creating the Android Studio TransitionDemo Project

42.2 Preparing the Project Files

42.3 Implementing beginDelayedTransition Animation

42.4 Customizing the Transition

42.5 Summary

43. Implementing Android Scene Transitions – A Tutorial

43.1 An Overview of the Scene Transition Project

43.2 Creating the Android Studio SceneTransitions Project

43.3 Identifying and Preparing the Root Container

43.4 Designing the First Scene

43.5 Designing the Second Scene

43.6 Entering the First Scene

43.7 Loading Scene 2

43.8 Implementing the Transitions

43.9 Adding the Transition File

43.10 Loading and Using the Transition Set

43.11 Configuring Additional Transitions

43.12 Summary

44. Working with the Floating Action Button and Snackbar

44.1 The Material Design

44.2 The Design Library

44.3 The Floating Action Button (FAB)

44.4 The Snackbar

44.5 Creating the Example Project

44.6 Reviewing the Project

44.7 Changing the Floating Action Button

44.8 Adding the ListView to the Content Layout

44.9 Adding Items to the ListView

44.10 Adding an Action to the Snackbar

44.11 Summary

45. Creating a Tabbed Interface using the TabLayout Component

45.1 An Introduction to the ViewPager

45.2 An Overview of the TabLayout Component

45.3 Creating the TabLayoutDemo Project

45.4 Creating the First Fragment

45.5 Duplicating the Fragments

45.6 Adding the TabLayout and ViewPager

45.7 Creating the Pager Adapter

45.8 Performing the Initialization Tasks

45.9 Testing the Application

45.10 Customizing the TabLayout

45.11 Displaying Icon Tab Items

45.12 Summary

46. Working with the RecyclerView and CardView Widgets

46.1 An Overview of the RecyclerView

46.2 An Overview of the CardView

46.3 Summary

47. An Android RecyclerView and CardView Tutorial

47.1 Creating the CardDemo Project

47.2 Removing the Floating Action Button

47.3 Designing the CardView Layout

47.4 Adding the RecyclerView

47.5 Creating the RecyclerView Adapter

47.6 Adding the Image Files

47.7 Initializing the RecyclerView Component

47.8 Testing the Application

47.9 Responding to Card Selections

47.10 Summary

48. A Layout Editor Sample Data Tutorial

48.1 Adding Sample Data to a Project

48.2 Using Custom Sample Data

48.3 Summary

49. Working with the AppBar and Collapsing Toolbar Layouts

49.1 The Anatomy of an AppBar

49.2 The Example Project

49.3 Coordinating the RecyclerView and Toolbar

49.4 Introducing the Collapsing Toolbar Layout

49.5 Changing the Title and Scrim Color

49.6 Summary

50. An Android Studio Master/Detail Flow Tutorial

50.1 The Master/Detail Flow

50.2 Creating a Master/Detail Flow Activity

50.3 The Anatomy of the Master/Detail Flow Template

50.4 Modifying the Master/Detail Flow Template

50.5 Changing the Content Model

50.6 Changing the Detail Pane

50.7 Modifying the WebsiteDetailFragment Class

50.8 Modifying the WebsiteListActivity Class

50.9 Adding Manifest Permissions

50.10 Running the Application

50.11 Summary

51. An Overview of Android Intents

51.1 An Overview of Intents

51.2 Explicit Intents

51.3 Returning Data from an Activity

51.4 Implicit Intents

51.5 Using Intent Filters

51.6 Checking Intent Availability

51.7 Summary

52. Android Explicit Intents – A Worked Example

52.1 Creating the Explicit Intent Example Application

52.2 Designing the User Interface Layout for MainActivity

52.3 Creating the Second Activity Class

52.4 Designing the User Interface Layout for ActivityB

52.5 Reviewing the Application Manifest File

52.6 Creating the Intent

52.7 Extracting Intent Data

52.8 Launching ActivityB as a Sub-Activity

52.9 Returning Data from a Sub-Activity

52.10 Testing the Application

52.11 Summary

53. Android Implicit Intents – A Worked Example

53.1 Creating the Android Studio Implicit Intent Example Project

53.2 Designing the User Interface

53.3 Creating the Implicit Intent

53.4 Adding a Second Matching Activity

53.5 Adding the Web View to the UI

53.6 Obtaining the Intent URL

53.7 Modifying the MyWebView Project Manifest File

53.8 Installing the MyWebView Package on a Device

53.9 Testing the Application

53.10 Summary

54. Android Broadcast Intents and Broadcast Receivers

54.1 An Overview of Broadcast Intents

54.2 An Overview of Broadcast Receivers

54.3 Obtaining Results from a Broadcast

54.4 Sticky Broadcast Intents

54.5 The Broadcast Intent Example

54.6 Creating the Example Application

54.7 Creating and Sending the Broadcast Intent

54.8 Creating the Broadcast Receiver

54.9 Registering the Broadcast Receiver

54.10 Testing the Broadcast Example

54.11 Listening for System Broadcasts

54.12 Summary

55. A Basic Overview of Threads and AsyncTasks

55.1 An Overview of Threads

55.2 The Application Main Thread

55.3 Thread Handlers

55.4 A Basic AsyncTask Example

55.5 Subclassing AsyncTask

55.6 Testing the App

55.7 Canceling a Task

55.8 Summary

56. An Overview of Android Started and Bound Services

56.1 Started Services

56.2 Intent Service

56.3 Bound Service

56.4 The Anatomy of a Service

56.5 Controlling Destroyed Service Restart Options

56.6 Declaring a Service in the Manifest File

56.7 Starting a Service Running on System Startup

56.8 Summary

57. Implementing an Android Started Service – A Worked Example

57.1 Creating the Example Project

57.2 Creating the Service Class

57.3 Adding the Service to the Manifest File

57.4 Starting the Service

57.5 Testing the IntentService Example

57.6 Using the Service Class

57.7 Creating the New Service

57.8 Modifying the User Interface

57.9 Running the Application

57.10 Creating an AsyncTask for Service Tasks

57.11 Summary

58. Android Local Bound Services – A Worked Example

58.1 Understanding Bound Services

58.2 Bound Service Interaction Options

58.3 An Android Studio Local Bound Service Example

58.4 Adding a Bound Service to the Project

58.5 Implementing the Binder

58.6 Binding the Client to the Service

58.7 Completing the Example

58.8 Testing the Application

58.9 Summary

59. Android Remote Bound Services – A Worked Example

59.1 Client to Remote Service Communication

59.2 Creating the Example Application

59.3 Designing the User Interface

59.4 Implementing the Remote Bound Service

59.5 Configuring a Remote Service in the Manifest File

59.6 Launching and Binding to the Remote Service

59.7 Sending a Message to the Remote Service

59.8 Summary

60. An Android Notifications Tutorial

60.1 An Overview of Notifications

60.2 Creating the NotifyDemo Project

60.3 Designing the User Interface

60.4 Creating the Second Activity

60.5 Creating a Notification Channel

60.6 Creating and Issuing a Basic Notification

60.7 Launching an Activity from a Notification

60.8 Adding Actions to a Notification

60.9 Bundled Notifications

60.10 Summary

61. An Android Direct Reply Notification Tutorial

61.1 Creating the DirectReply Project

61.2 Designing the User Interface

61.3 Creating the Notification Channel

61.4 Building the RemoteInput Object

61.5 Creating the PendingIntent

61.6 Creating the Reply Action

61.7 Receiving Direct Reply Input

61.8 Updating the Notification

61.9 Summary

62. Foldable Devices and Multi-Window Support

62.1 Foldables and Multi-Window Support

62.2 Using a Foldable Emulator

62.3 Entering Multi-Window Mode

62.4 Enabling and using Freeform Support

62.5 Checking for Freeform Support

62.6 Enabling Multi-Window Support in an App

62.7 Specifying Multi-Window Attributes

62.8 Detecting Multi-Window Mode in an Activity

62.9 Receiving Multi-Window Notifications

62.10 Launching an Activity in Multi-Window Mode

62.11 Configuring Freeform Activity Size and Position

62.12 Summary

63. An Overview of Android SQLite Databases

63.1 Understanding Database Tables

63.2 Introducing Database Schema

63.3 Columns and Data Types

63.4 Database Rows

63.5 Introducing Primary Keys

63.6 What is SQLite?

63.7 Structured Query Language (SQL)

63.8 Trying SQLite on an Android Virtual Device (AVD)

63.9 The Android Room Persistence Library

63.10 Summary

64. The Android Room Persistence Library

64.1 Revisiting Modern App Architecture

64.2 Key Elements of Room Database Persistence

64.3 Understanding Entities

64.4 Data Access Objects

64.5 The Room Database

64.6 The Repository

64.7 In-Memory Databases

64.8 Summary

65. An Android TableLayout and TableRow Tutorial

65.1 The TableLayout and TableRow Layout Views

65.2 Creating the Room Database Project

65.3 Converting to a LinearLayout

65.4 Adding the TableLayout to the User Interface

65.5 Configuring the TableRows

65.6 Adding the Button Bar to the Layout

65.7 Adding the RecyclerView

65.8 Adjusting the Layout Margins

65.9 Summary

66. An Android Room Database and Repository Tutorial

66.1 About the RoomDemo Project

66.2 Modifying the Build Configuration

66.3 Building the Entity

66.4 Creating the Data Access Object

66.5 Adding the Room Database

66.6 Adding the Repository

66.7 Modifying the ViewModel

66.8 Creating the Product Item Layout

66.9 Adding the RecyclerView Adapter

66.10 Preparing the Main Fragment

66.11 Adding the Button Listeners

66.12 Adding LiveData Observers

66.13 Initializing the RecyclerView

66.14 Testing the RoomDemo App

66.15 Summary

67. Accessing Cloud Storage using the Android Storage Access Framework

67.1 The Storage Access Framework

67.2 Working with the Storage Access Framework

67.3 Filtering Picker File Listings

67.4 Handling Intent Results

67.5 Reading the Content of a File

67.6 Writing Content to a File

67.7 Deleting a File

67.8 Gaining Persistent Access to a File

67.9 Summary

68. An Android Storage Access Framework Example

68.1 About the Storage Access Framework Example

68.2 Creating the Storage Access Framework Example

68.3 Designing the User Interface

68.4 Declaring Request Codes

68.5 Creating a New Storage File

68.6 The onActivityResult() Method

68.7 Saving to a Storage File

68.8 Opening and Reading a Storage File

68.9 Testing the Storage Access Application

68.10 Summary

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

69.1 Introducing the Android VideoView Class

69.2 Introducing the Android MediaController Class

69.3 Creating the Video Playback Example

69.4 Designing the VideoPlayer Layout

69.5 Configuring the VideoView

69.6 Adding Internet Permission

69.7 Adding the MediaController to the Video View

69.8 Setting up the onPreparedListener

69.9 Summary

70. Android Picture-in-Picture Mode

70.1 Picture-in-Picture Features

70.2 Enabling Picture-in-Picture Mode

70.3 Configuring Picture-in-Picture Parameters

70.4 Entering Picture-in-Picture Mode

70.5 Detecting Picture-in-Picture Mode Changes

70.6 Adding Picture-in-Picture Actions

70.7 Summary

71. An Android Picture-in-Picture Tutorial

71.1 Adding Picture-in-Picture Support to the Manifest

71.2 Adding a Picture-in-Picture Button

71.3 Entering Picture-in-Picture Mode

71.4 Detecting Picture-in-Picture Mode Changes

71.5 Adding a Broadcast Receiver

71.6 Adding the PiP Action

71.7 Testing the Picture-in-Picture Action

71.8 Summary

72. Making Runtime Permission Requests in Android

72.1 Understanding Normal and Dangerous Permissions

72.2 Creating the Permissions Example Project

72.3 Checking for a Permission

72.4 Requesting Permission at Runtime

72.5 Providing a Rationale for the Permission Request

72.6 Testing the Permissions App

72.7 Summary

73. Android Audio Recording and Playback using MediaPlayer and MediaRecorder

73.1 Playing Audio

73.2 Recording Audio and Video using the MediaRecorder Class

73.3 About the Example Project

73.4 Creating the AudioApp Project

73.5 Designing the User Interface

73.6 Checking for Microphone Availability

73.7 Performing the Activity Initialization

73.8 Implementing the recordAudio() Method

73.9 Implementing the stopAudio() Method

73.10 Implementing the playAudio() method

73.11 Configuring and Requesting Permissions

73.12 Testing the Application

73.13 Summary

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

74.1 The Elements of the Google Maps Android API

74.2 Creating the Google Maps Project

74.3 Obtaining Your Developer Signature

74.4 Adding the Apache HTTP Legacy Library Requirement

74.5 Testing the Application

74.6 Understanding Geocoding and Reverse Geocoding

74.7 Adding a Map to an Application

74.8 Requesting Current Location Permission

74.9 Displaying the User’s Current Location

74.10 Changing the Map Type

74.11 Displaying Map Controls to the User

74.12 Handling Map Gesture Interaction

74.13 Creating Map Markers

74.14 Controlling the Map Camera

74.15 Summary

75. Printing with the Android Printing Framework

75.1 The Android Printing Architecture

75.2 The Print Service Plugins

75.3 Google Cloud Print

75.4 Printing to Google Drive

75.5 Save as PDF

75.6 Printing from Android Devices

75.7 Options for Building Print Support into Android Apps

75.8 Summary

76. An Android HTML and Web Content Printing Example

76.1 Creating the HTML Printing Example Application

76.2 Printing Dynamic HTML Content

76.3 Creating the Web Page Printing Example

76.4 Removing the Floating Action Button

76.5 Designing the User Interface Layout

76.6 Loading the Web Page into the WebView

76.7 Adding the Print Menu Option

76.8 Summary

77. A Guide to Android Custom Document Printing

77.1 An Overview of Android Custom Document Printing

77.2 Preparing the Custom Document Printing Project

77.3 Creating the Custom Print Adapter

77.4 Implementing the onLayout() Callback Method

77.5 Implementing the onWrite() Callback Method

77.6 Checking a Page is in Range

77.7 Drawing the Content on the Page Canvas

77.8 Starting the Print Job

77.9 Testing the Application

77.10 Summary

78. An Introduction to Android App Links

78.1 An Overview of Android App Links

78.2 App Link Intent Filters

78.3 Handling App Link Intents

78.4 Associating the App with a Website

78.5 Summary

79. An Android Studio App Links Tutorial

79.1 About the Example App

79.2 The Database Schema

79.3 Loading and Running the Project

79.4 Adding the URL Mapping

79.5 Adding the Intent Filter

79.6 Adding Intent Handling Code

79.7 Testing the App Link

79.8 Associating an App Link with a Web Site

79.9 Summary

80. A Guide to the Android Studio Profiler

80.1 Accessing the Android Profiler

80.2 Enabling Advanced Profiling

80.3 The Android Profiler Tool Window

80.4 The Sessions Panel

80.5 The CPU Profiler

80.6 Memory Profiler

80.7 Network Profiler

80.8 Energy Profiler

80.9 Summary

81. An Android Biometric Authentication Tutorial

81.1 An Overview of Biometric Authentication

81.2 Creating the Biometric Authentication Project

81.3 Configuring Device Fingerprint Authentication

81.4 Adding the Biometric Permission to the Manifest File

81.5 Designing the User Interface

81.6 Adding a Toast Convenience Method

81.7 Checking the Security Settings

81.8 Configuring the Authentication Callbacks

81.9 Adding the CancellationSignal

81.10 Starting the Biometric Prompt

81.11 Testing the Project

81.12 Summary

82. Creating, Testing and Uploading an Android App Bundle

82.1 The Release Preparation Process

82.2 Android App Bundles

82.3 Register for a Google Play Developer Console Account

82.4 Configuring the App in the Console

82.5 Enabling Google Play App Signing

82.6 Creating a Keystore File

82.7 Creating the Android App Bundle

82.8 Generating Test APK Files

82.9 Uploading the App Bundle to the Google Play Developer Console

82.10 Exploring the App Bundle

82.11 Managing Testers

82.12 Uploading New App Bundle Revisions

82.13 Analyzing the App Bundle File

82.14 Enabling Google Play Signing for an Existing App

82.15 Summary

83. An Overview of Android Dynamic Feature Modules

83.1 An Overview of Dynamic Feature Modules

83.2 Dynamic Feature Module Architecture

83.3 Creating a Dynamic Feature Module

83.4 Converting an Existing Module for Dynamic Delivery

83.5 Working with Dynamic Feature Modules

83.6 Handling Large Dynamic Feature Modules

83.7 Summary

84. An Android Studio Dynamic Feature Tutorial

84.1 Creating the DynamicFeature Project

84.2 Adding Dynamic Feature Support to the Project

84.3 Designing the Base Activity User Interface

84.4 Adding the Dynamic Feature Module

84.5 Reviewing the Dynamic Feature Module

84.6 Adding the Dynamic Feature Activity

84.7 Implementing the launchIntent() Method

84.8 Uploading the App Bundle for Testing

84.9 Implementing the installFeature() Method

84.10 Adding the Update Listener

84.11 Handling Large Downloads

84.12 Using Deferred Installation

84.13 Removing a Dynamic Module

84.14 Summary

85. An Overview of Gradle in Android Studio

85.1 An Overview of Gradle

85.2 Gradle and Android Studio

85.3 The Top-level Gradle Build File

85.4 Module Level Gradle Build Files

85.5 Configuring Signing Settings in the Build File

85.6 Running Gradle Tasks from the Command-line

85.7 Summary

Index

Android Studio 3.5 Development Essentials - Java Edition

By : Neil Smyth

Android Studio 3.5 Development Essentials - Java 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