Android Studio 4.2 Development Essentials - Java Edition
by
Android Studio 4.2 Development Essentials - Java Edition
- 1. Introduction
- 2. Setting up an Android Studio Development Environment
- 2.1 System Requirements
- 2.2 Downloading the Android Studio Package
- 2.3 Installing Android Studio
- 2.3.1 Installation on Windows
- 2.3.2 Installation on macOS
- 2.3.3 Installation on Linux
- 2.4 The Android Studio Setup Wizard
- 2.5 Installing Additional Android SDK Packages
- 2.6 Making the Android SDK Tools Command-line Accessible
- 2.6.1 Windows 7
- 2.6.2 Windows 8.1
- 2.6.3 Windows 10
- 2.6.4 Linux
- 2.6.5 macOS
- 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
- 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.5.1 Location
- 5.5.2 Displays
- 5.5.3 Cellular
- 5.5.4 Battery
- 5.5.5 Camera
- 5.5.6 Phone
- 5.5.7 Directional Pad
- 5.5.8 Microphone
- 5.5.9 Fingerprint
- 5.5.10 Virtual Sensors
- 5.5.11 Snapshots
- 5.5.12 Record and Playback
- 5.5.13 Google Play
- 5.5.14 Settings
- 5.5.15 Help
- 5.6 Working with Snapshots
- 5.7 Configuring Fingerprint Emulation
- 5.8 The Emulator in Tool Window Mode
- 5.9 Summary
- 6. A Tour of the Android Studio User Interface
- 7. Testing Android Studio Apps on a Physical Android Device
- 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
- 10. The Anatomy of an Android Application
- 11. An Overview of Android View Binding
- 12. Understanding Android Application and Activity Lifecycles
- 12.1 Android Applications and Resource Management
- 12.2 Android Process States
- 12.2.1 Foreground Process
- 12.2.2 Visible Process
- 12.2.3 Service Process
- 12.2.4 Background Process
- 12.2.5 Empty Process
- 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
- 14. Android Activity State Changes by Example
- 15. Saving and Restoring the State of an Android Activity
- 16. Understanding Android Views, View Groups and Layouts
- 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.7 Code 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)
- 17.17 Summary
- 18. A Guide to the Android ConstraintLayout
- 18.1 How ConstraintLayout Works
- 18.1.1 Constraints
- 18.1.2 Margins
- 18.1.3 Opposing Constraints
- 18.1.4 Constraint Bias
- 18.1.5 Chains
- 18.1.6 Chain Styles
- 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
- 21. An Android Studio Layout Editor ConstraintLayout Tutorial
- 22. Manual XML Layout Design in Android Studio
- 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.4.1 Establishing Connections
- 23.4.2 Applying Constraints to a Layout
- 23.4.3 Parent Constraint Connections
- 23.4.4 Sizing Constraints
- 23.4.5 Constraint Bias
- 23.4.6 Alignment Constraints
- 23.4.7 Copying and Applying Constraint Sets
- 23.4.8 ConstraintLayout Chains
- 23.4.9 Guidelines
- 23.4.10 Removing Constraints
- 23.4.11 Scaling
- 23.4.12 Rotation
- 23.5 Summary
- 24. An Android ConstraintSet Tutorial
- 25. A Guide to using Apply Changes in Android Studio
- 26. An Overview and Example of Android Event Handling
- 27. Android Touch and Multi-touch Event Handling
- 28. Detecting Common Gestures Using the Android Gesture Detector Class
- 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
- 29.19 Summary
- 30. An Introduction to Android Fragments
- 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
- 31.10 Summary
- 32. Modern Android App Architecture with Jetpack
- 33. An Android Jetpack ViewModel Tutorial
- 33.1 About the Project
- 33.2 Creating the ViewModel Example Project
- 33.3 Reviewing the Project
- 33.3.1 The Main Activity
- 33.3.2 The Content Fragment
- 33.3.3 The ViewModel
- 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
- 33.10 Summary
- 34. An Android Jetpack LiveData Tutorial
- 35. An Overview of Android Jetpack Data Binding
- 35.1 An Overview of Data Binding
- 35.2 The Key Components of Data Binding
- 35.2.1 The Project Build Configuration
- 35.2.2 The Data Binding Layout File
- 35.2.3 The Layout File Data Element
- 35.2.4 The Binding Classes
- 35.2.5 Data Binding Variable Configuration
- 35.2.6 Binding Expressions (One-Way)
- 35.2.7 Binding Expressions (Two-Way)
- 35.2.8 Event and Listener Bindings
- 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
- 38. Working with Android Lifecycle-Aware Components
- 39. An Android Jetpack Lifecycle Awareness Tutorial
- 40. An Overview of the Navigation Architecture Component
- 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
- 41.12 Summary
- 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.8 Keyframes
- 42.8.1 Attribute Keyframes
- 42.8.2 Position Keyframes
- 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.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
- 43.9 Summary
- 44. A MotionLayout KeyCycle Tutorial
- 45. Working with the Floating Action Button and Snackbar
- 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
- 46.11 Summary
- 47. Working with the RecyclerView and CardView Widgets
- 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
- 48.10 Summary
- 49. A Layout Editor Sample Data Tutorial
- 50. Working with the AppBar and Collapsing Toolbar Layouts
- 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
- 51.10 Summary
- 52. An Overview of Android Intents
- 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
- 53.11 Summary
- 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
- 54.10 Summary
- 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
- 55.12 Summary
- 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
- 56.15 Summary
- 57. An Overview of Android Services
- 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
- 58.12 Summary
- 59. Android Local 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
- 60.8 Summary
- 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
- 61.10 Summary
- 62. An Android Direct Reply Notification Tutorial
- 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
- 63.12 Summary
- 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
- 64.10 Summary
- 65. The Android Room Persistence Library
- 65.1 Revisiting Modern App Architecture
- 65.2 Key Elements of Room Database Persistence
- 65.2.1 Repository
- 65.2.2 Room Database
- 65.2.3 Data Access Object (DAO)
- 65.2.4 Entities
- 65.2.5 SQLite Database
- 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
- 65.9 Summary
- 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
- 66.9 Summary
- 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
- 67.16 Summary
- 68. Accessing Cloud Storage using the Android Storage Access Framework
- 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
- 69.10 Summary
- 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
- 70.9 Summary
- 71. Android Picture-in-Picture Mode
- 72. An Android Picture-in-Picture Tutorial
- 73. Making Runtime Permission Requests in Android
- 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
- 74.13 Summary
- 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.12.1 Map Zooming Gestures
- 75.12.2 Map Scrolling/Panning Gestures
- 75.12.3 Map Tilt Gestures
- 75.12.4 Map Rotation Gestures
- 75.13 Creating Map Markers
- 75.14 Controlling the Map Camera
- 75.15 Summary
- 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
- 76.7.1 Image Printing
- 76.7.2 Creating and Printing HTML Content
- 76.7.3 Printing a Web Page
- 76.7.4 Printing a Custom Document
- 76.8 Summary
- 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
- 77.10 Summary
- 78. A Guide to Android Custom Document Printing
- 78.1 An Overview of Android Custom Document Printing
- 78.1.1 Custom Print Adapters
- 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
- 78.10 Summary
- 79. An Introduction to Android App Links
- 80. An Android Studio App Links Tutorial
- 81. A Guide to the Android Studio Profiler
- 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
- 82.12 Summary
- 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
- 83.15 Summary
- 84. An Overview of Android Dynamic Feature Modules
- 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
- 85.14 Summary
- 86. An Overview of Gradle in Android Studio
- 86.1 An Overview of Gradle
- 86.2 Gradle and Android Studio
- 86.2.1 Sensible Defaults
- 86.2.2 Dependencies
- 86.2.3 Build Variants
- 86.2.4 Manifest Entries
- 86.2.5 APK Signing
- 86.2.6 ProGuard Support
- 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
- 86.7 Summary
- Index
-
No Comment
..................Content has been hidden....................
You can't read the all page of ebook, please click here login for view all page.