Android Studio 4.1 Development Essentials – Kotlin Edition

Android Studio 4.1 Development Essentials – Kotlin Edition

by Neil Smyth
Released May 2021
Publisher(s): Packt Publishing
ISBN: 9781801815987

Read it now on the O’Reilly learning platform with a 10-day free trial.

O’Reilly members get unlimited access to books, live events, courses curated by job role, and more from O’Reilly and nearly 200 top publishers.

Start your free trial

Book description

Acquire the skills necessary to develop Android apps using the Android Studio integrated development environment and the Kotlin programming language

Key Features

  • Learn to code using the Kotlin programming language
  • Use the latest Material Design components to build modern user interface designs
  • Integrate with SQLite databases and the Android Room Persistence Library

Book Description

Android 11 has a ton of new capabilities. It comes up with three foci: a people-centric approach to communication, controls to let users quickly access and manage all of their smart devices, and privacy to give users more ways to control how data on devices is shared.

This book starts off with the steps necessary to set up an Android development and testing environment, followed by an introduction to programming in Kotlin. An overview of Android Studio and its architecture is provided, followed by an in-depth look at the design of Android applications and user interfaces using the Android Studio environment. You will also learn about the Android architecture components along with some advanced topics such as touch screen handling, gesture recognition, the recording and playback of audio, app links, dynamic delivery, the AndroidStudio profiler, Gradle build configuration, and submitting apps to the Google Play Developer Console.

The concepts of material design are also covered in detail. This edition of the book also covers printing, transitions, and cloud-based file storage; foldable device support is the cherry on the cake.

By the end of this course, you will be able to develop Android 11 Apps using Android Studio 4.1, Kotlin, and Android Jetpack.

What you will learn

  • Install and configure Android Studio on Windows, macOS, and Linux
  • Write multi-threaded Kotlin code using Coroutines
  • Understand Android architecture and app lifecycle
  • Build view model-based apps using the Jetpack architecture
  • Integrate your apps with Google cloud storage
  • Add printing support from within your own apps

Who this book is for

This book is for Kotlin developers who want to learn essential skills to work with Android Studio 4.1 to build applications. The book also covers important topics about Android architecture essential for anyone looking to become an Android application developer.

Assuming you already have some programming experience, are ready to download Android Studio and the Android SDK, have access to a Windows, Mac, or Linux system, and have ideas for some apps to develop, then you are ready to get started. Some Kotlin programming experience is also required to understand certain concepts in this book.

Table of contents

  1. 1. Introduction
    1. 1.1 Downloading the Code Samples
    2. 1.2 Feedback
    3. 1.3 Errata
  2. 2. Setting up an Android Studio Development Environment
    1. 2.1 System Requirements
    2. 2.2 Downloading the Android Studio Package
    3. 2.3 Installing Android Studio
      1. 2.3.1 Installation on Windows
      2. 2.3.2 Installation on macOS
      3. 2.3.3 Installation on Linux
    4. 2.4 The Android Studio Setup Wizard
    5. 2.5 Installing Additional Android SDK Packages
    6. 2.6 Making the Android SDK Tools Command-line Accessible
      1. 2.6.1 Windows 7
      2. 2.6.2 Windows 8.1
      3. 2.6.3 Windows 10
      4. 2.6.4 Linux
      5. 2.6.5 macOS
    7. 2.7 Android Studio Memory Management
    8. 2.8 Updating Android Studio and the SDK
    9. 2.9 Summary
  3. 3. Creating an Example Android App in Android Studio
    1. 3.1 About the Project
    2. 3.2 Creating a New Android Project
    3. 3.3 Creating an Activity
    4. 3.4 Defining the Project and SDK Settings
    5. 3.5 Modifying the Example Application
    6. 3.6 Modifying the User Interface
    7. 3.7 Reviewing the Layout and Resource Files
    8. 3.8 Adding the Kotlin Extensions Plugin
    9. 3.9 Adding Interaction
    10. 3.10 Summary
  4. 4. Creating an Android Virtual Device (AVD) in Android Studio
    1. 4.1 About Android Virtual Devices
    2. 4.2 Creating a New AVD
    3. 4.3 Starting the Emulator
    4. 4.4 Running the Application in the AVD
    5. 4.5 Running on Multiple Devices
    6. 4.6 Stopping a Running Application
    7. 4.7 Supporting Dark Theme
    8. 4.8 Running the Emulator in a Tool Window
    9. 4.9 AVD Command-line Creation
    10. 4.10 Android Virtual Device Configuration Files
    11. 4.11 Moving and Renaming an Android Virtual Device
    12. 4.12 Summary
  5. 5. Using and Configuring the Android Studio AVD Emulator
    1. 5.1 The Emulator Environment
    2. 5.2 The Emulator Toolbar Options
    3. 5.3 Working in Zoom Mode
    4. 5.4 Resizing the Emulator Window
    5. 5.5 Extended Control Options
      1. 5.5.1 Location
      2. 5.5.2 Displays
      3. 5.5.3 Cellular
      4. 5.5.4 Camera
      5. 5.5.5 Battery
      6. 5.5.6 Phone
      7. 5.5.7 Directional Pad
      8. 5.5.8 Microphone
      9. 5.5.9 Fingerprint
      10. 5.5.10 Virtual Sensors
      11. 5.5.11 Snapshots
      12. 5.5.12 Record and Playback
      13. 5.5.13 Google Play
      14. 5.5.14 Settings
      15. 5.5.15 Help
    6. 5.6 Working with Snapshots
    7. 5.7 Configuring Fingerprint Emulation
    8. 5.8 The Emulator in Tool Window Mode
    9. 5.9 Summary
  6. 6. A Tour of the Android Studio User Interface
    1. 6.1 The Welcome Screen
    2. 6.2 The Main Window
    3. 6.3 The Tool Windows
    4. 6.4 Android Studio Keyboard Shortcuts
    5. 6.5 Switcher and Recent Files Navigation
    6. 6.6 Changing the Android Studio Theme
    7. 6.7 Summary
  7. 7. Testing Android Studio Apps on a Physical Android Device
    1. 7.1 An Overview of the Android Debug Bridge (ADB)
    2. 7.2 Enabling ADB on Android based Devices
      1. 7.2.1 macOS ADB Configuration
      2. 7.2.2 Windows ADB Configuration
      3. 7.2.3 Linux adb Configuration
    3. 7.3 Testing the adb Connection
    4. 7.4 Summary
  8. 8. The Basics of the Android Studio Code Editor
    1. 8.1 The Android Studio Editor
    2. 8.2 Splitting the Editor Window
    3. 8.3 Code Completion
    4. 8.4 Statement Completion
    5. 8.5 Parameter Information
    6. 8.6 Parameter Name Hints
    7. 8.7 Code Generation
    8. 8.8 Code Folding
    9. 8.9 Quick Documentation Lookup
    10. 8.10 Code Reformatting
    11. 8.11 Finding Sample Code
    12. 8.12 Live Templates
    13. 8.13 Summary
  9. 9. An Overview of the Android Architecture
    1. 9.1 The Android Software Stack
    2. 9.2 The Linux Kernel
    3. 9.3 Android Runtime – ART
    4. 9.4 Android Libraries
      1. 9.4.1 C/C++ Libraries
    5. 9.5 Application Framework
    6. 9.6 Applications
    7. 9.7 Summary
  10. 10. The Anatomy of an Android Application
    1. 10.1 Android Activities
    2. 10.2 Android Fragments
    3. 10.3 Android Intents
    4. 10.4 Broadcast Intents
    5. 10.5 Broadcast Receivers
    6. 10.6 Android Services
    7. 10.7 Content Providers
    8. 10.8 The Application Manifest
    9. 10.9 Application Resources
    10. 10.10 Application Context
    11. 10.11 Summary
  11. 11. An Introduction to Kotlin
    1. 11.1 What is Kotlin?
    2. 11.2 Kotlin and Java
    3. 11.3 Converting from Java to Kotlin
    4. 11.4 Kotlin and Android Studio
    5. 11.5 Experimenting with Kotlin
    6. 11.6 Semi-colons in Kotlin
    7. 11.7 Summary
  12. 12. Kotlin Data Types,Variables and Nullability
    1. 12.1 Kotlin Data Types
      1. 12.1.1 Integer Data Types
      2. 12.1.2 Floating Point Data Types
      3. 12.1.3 Boolean Data Type
      4. 12.1.4 Character Data Type
      5. 12.1.5 String Data Type
      6. 12.1.6 Escape Sequences
    2. 12.2 Mutable Variables
    3. 12.3 Immutable Variables
    4. 12.4 Declaring Mutable and Immutable Variables
    5. 12.5 Data Types are Objects
    6. 12.6 Type Annotations and Type Inference
    7. 12.7 Nullable Type
    8. 12.8 The Safe Call Operator
    9. 12.9 Not-Null Assertion
    10. 12.10 Nullable Types and the let Function
    11. 12.11 Late Initialization (lateinit)
    12. 12.12 The Elvis Operator
    13. 12.13 Type Casting and Type Checking
    14. 12.14 Summary
  13. 13. Kotlin Operators and Expressions
    1. 13.1 Expression Syntax in Kotlin
    2. 13.2 The Basic Assignment Operator
    3. 13.3 Kotlin Arithmetic Operators
    4. 13.4 Augmented Assignment Operators
    5. 13.5 Increment and Decrement Operators
    6. 13.6 Equality Operators
    7. 13.7 Boolean Logical Operators
    8. 13.8 Range Operator
    9. 13.9 Bitwise Operators
      1. 13.9.1 Bitwise Inversion
      2. 13.9.2 Bitwise AND
      3. 13.9.3 Bitwise OR
      4. 13.9.4 Bitwise XOR
      5. 13.9.5 Bitwise Left Shift
      6. 13.9.6 Bitwise Right Shift
    10. 13.10 Summary
  14. 14. Kotlin Flow Control
    1. 14.1 Looping Flow Control
      1. 14.1.1 The Kotlin for-in Statement
      2. 14.1.2 The while Loop
      3. 14.1.3 The do ... while loop
      4. 14.1.4 Breaking from Loops
      5. 14.1.5 The continue Statement
      6. 14.1.6 Break and Continue Labels
    2. 14.2 Conditional Flow Control
      1. 14.2.1 Using the if Expressions
      2. 14.2.2 Using if ... else … Expressions
      3. 14.2.3 Using if ... else if ... Expressions
      4. 14.2.4 Using the when Statement
    3. 14.3 Summary
  15. 15. An Overview of Kotlin Functions and Lambdas
    1. 15.1 What is a Function?
    2. 15.2 How to Declare a Kotlin Function
    3. 15.3 Calling a Kotlin Function
    4. 15.4 Single Expression Functions
    5. 15.5 Local Functions
    6. 15.6 Handling Return Values
    7. 15.7 Declaring Default Function Parameters
    8. 15.8 Variable Number of Function Parameters
    9. 15.9 Lambda Expressions
    10. 15.10 Higher-order Functions
    11. 15.11 Summary
  16. 16. The Basics of Object Oriented Programming in Kotlin
    1. 16.1 What is an Object?
    2. 16.2 What is a Class?
    3. 16.3 Declaring a Kotlin Class
    4. 16.4 Adding Properties to a Class
    5. 16.5 Defining Methods
    6. 16.6 Declaring and Initializing a Class Instance
    7. 16.7 Primary and Secondary Constructors
    8. 16.8 Initializer Blocks
    9. 16.9 Calling Methods and Accessing Properties
    10. 16.10 Custom Accessors
    11. 16.11 Nested and Inner Classes
    12. 16.12 Companion Objects
    13. 16.13 Summary
  17. 17. An Introduction to Kotlin Inheritance and Subclassing
    1. 17.1 Inheritance, Classes and Subclasses
    2. 17.2 Subclassing Syntax
    3. 17.3 A Kotlin Inheritance Example
    4. 17.4 Extending the Functionality of a Subclass
    5. 17.5 Overriding Inherited Methods
    6. 17.6 Adding a Custom Secondary Constructor
    7. 17.7 Using the SavingsAccount Class
    8. 17.8 Summary
  18. 18. An Overview of Android View Binding
    1. 18.1 Find View by ID and Synthetic Properties
    2. 18.2 View Bindings
    3. 18.3 Converting the AndroidSample Project
    4. 18.4 Enabling View Binding
    5. 18.5 Using View Bindings
    6. 18.6 Choosing an Option
    7. 18.7 Summary
  19. 19. Understanding Android Application and Activity Lifecycles
    1. 19.1 Android Applications and Resource Management
    2. 19.2 Android Process States
      1. 19.2.1 Foreground Process
      2. 19.2.2 Visible Process
      3. 19.2.3 Service Process
      4. 19.2.4 Background Process
      5. 19.2.5 Empty Process
    3. 19.3 Inter-Process Dependencies
    4. 19.4 The Activity Lifecycle
    5. 19.5 The Activity Stack
    6. 19.6 Activity States
    7. 19.7 Configuration Changes
    8. 19.8 Handling State Change
    9. 19.9 Summary
  20. 20. Handling Android Activity State Changes
    1. 20.1 New vs. Old Lifecycle Techniques
    2. 20.2 The Activity and Fragment Classes
    3. 20.3 Dynamic State vs. Persistent State
    4. 20.4 The Android Lifecycle Methods
    5. 20.5 Lifetimes
    6. 20.6 Foldable Devices and Multi-Resume
    7. 20.7 Disabling Configuration Change Restarts
    8. 20.8 Lifecycle Method Limitations
    9. 20.9 Summary
  21. 21. Android Activity State Changes by Example
    1. 21.1 Creating the State Change Example Project
    2. 21.2 Designing the User Interface
    3. 21.3 Overriding the Activity Lifecycle Methods
    4. 21.4 Filtering the Logcat Panel
    5. 21.5 Running the Application
    6. 21.6 Experimenting with the Activity
    7. 21.7 Summary
  22. 22. Saving and Restoring the State of an Android Activity
    1. 22.1 Saving Dynamic State
    2. 22.2 Default Saving of User Interface State
    3. 22.3 The Bundle Class
    4. 22.4 Saving the State
    5. 22.5 Restoring the State
    6. 22.6 Testing the Application
    7. 22.7 Summary
  23. 23. Understanding Android Views, View Groups and Layouts
    1. 23.1 Designing for Different Android Devices
    2. 23.2 Views and View Groups
    3. 23.3 Android Layout Managers
    4. 23.4 The View Hierarchy
    5. 23.5 Creating User Interfaces
    6. 23.6 Summary
  24. 24. A Guide to the Android Studio Layout Editor Tool
    1. 24.1 Basic vs. Empty Activity Templates
    2. 24.2 The Android Studio Layout Editor
    3. 24.3 Design Mode
    4. 24.4 The Palette
    5. 24.5 Design Mode and Layout Views
    6. 24.6 Code Mode
    7. 24.7 Split Mode
    8. 24.8 Setting Attributes
    9. 24.9 Transforms
    10. 24.10 Tools Visibility Toggles
    11. 24.11 Converting Views
    12. 24.12 Displaying Sample Data
    13. 24.13 Creating a Custom Device Definition
    14. 24.14 Changing the Current Device
    15. 24.15 Layout Validation (Multi Preview)
    16. 24.16 Summary
  25. 25. A Guide to the Android ConstraintLayout
    1. 25.1 How ConstraintLayout Works
      1. 25.1.1 Constraints
      2. 25.1.2 Margins
      3. 25.1.3 Opposing Constraints
      4. 25.1.4 Constraint Bias
      5. 25.1.5 Chains
      6. 25.1.6 Chain Styles
    2. 25.2 Baseline Alignment
    3. 25.3 Configuring Widget Dimensions
    4. 25.4 Guideline Helper
    5. 25.5 Group Helper
    6. 25.6 Barrier Helper
    7. 25.7 Flow Helper
    8. 25.8 Ratios
    9. 25.9 ConstraintLayout Advantages
    10. 25.10 ConstraintLayout Availability
    11. 25.11 Summary
  26. 26. A Guide to using ConstraintLayout in Android Studio
    1. 26.1 Design and Layout Views
    2. 26.2 Autoconnect Mode
    3. 26.3 Inference Mode
    4. 26.4 Manipulating Constraints Manually
    5. 26.5 Adding Constraints in the Inspector
    6. 26.6 Viewing Constraints in the Attributes Window
    7. 26.7 Deleting Constraints
    8. 26.8 Adjusting Constraint Bias
    9. 26.9 Understanding ConstraintLayout Margins
    10. 26.10 The Importance of Opposing Constraints and Bias
    11. 26.11 Configuring Widget Dimensions
    12. 26.12 Design Time Tools Positioning
    13. 26.13 Adding Guidelines
    14. 26.14 Adding Barriers
    15. 26.15 Adding a Group
    16. 26.16 Working with the Flow Helper
    17. 26.17 Widget Group Alignment and Distribution
    18. 26.18 Converting other Layouts to ConstraintLayout
    19. 26.19 Summary
  27. 27. Working with ConstraintLayout Chains and Ratios in Android Studio
    1. 27.1 Creating a Chain
    2. 27.2 Changing the Chain Style
    3. 27.3 Spread Inside Chain Style
    4. 27.4 Packed Chain Style
    5. 27.5 Packed Chain Style with Bias
    6. 27.6 Weighted Chain
    7. 27.7 Working with Ratios
    8. 27.8 Summary
  28. 28. An Android Studio Layout Editor ConstraintLayout Tutorial
    1. 28.1 An Android Studio Layout Editor Tool Example
    2. 28.2 Creating a New Activity
    3. 28.3 Preparing the Layout Editor Environment
    4. 28.4 Adding the Widgets to the User Interface
    5. 28.5 Adding the Constraints
    6. 28.6 Testing the Layout
    7. 28.7 Using the Layout Inspector
    8. 28.8 Summary
  29. 29. Manual XML Layout Design in Android Studio
    1. 29.1 Manually Creating an XML Layout
    2. 29.2 Manual XML vs. Visual Layout Design
    3. 29.3 Summary
  30. 30. Managing Constraints using Constraint Sets
    1. 30.1 Kotlin Code vs. XML Layout Files
    2. 30.2 Creating Views
    3. 30.3 View Attributes
    4. 30.4 Constraint Sets
      1. 30.4.1 Establishing Connections
      2. 30.4.2 Applying Constraints to a Layout
      3. 30.4.3 Parent Constraint Connections
      4. 30.4.4 Sizing Constraints
      5. 30.4.5 Constraint Bias
      6. 30.4.6 Alignment Constraints
      7. 30.4.7 Copying and Applying Constraint Sets
      8. 30.4.8 ConstraintLayout Chains
      9. 30.4.9 Guidelines
      10. 30.4.10 Removing Constraints
      11. 30.4.11 Scaling
      12. 30.4.12 Rotation
    5. 30.5 Summary
  31. 31. An Android ConstraintSet Tutorial
    1. 31.1 Creating the Example Project in Android Studio
    2. 31.2 Adding Views to an Activity
    3. 31.3 Setting View Attributes
    4. 31.4 Creating View IDs
    5. 31.5 Configuring the Constraint Set
    6. 31.6 Adding the EditText View
    7. 31.7 Converting Density Independent Pixels (dp) to Pixels (px)
    8. 31.8 Summary
  32. 32. A Guide to using Apply Changes in Android Studio
    1. 32.1 Introducing Apply Changes
    2. 32.2 Understanding Apply Changes Options
    3. 32.3 Using Apply Changes
    4. 32.4 Configuring Apply Changes Fallback Settings
    5. 32.5 An Apply Changes Tutorial
    6. 32.6 Using Apply Code Changes
    7. 32.7 Using Apply Changes and Restart Activity
    8. 32.8 Using Run App
    9. 32.9 Summary
  33. 33. An Overview and Example of Android Event Handling
    1. 33.1 Understanding Android Events
    2. 33.2 Using the android:onClick Resource
    3. 33.3 Event Listeners and Callback Methods
    4. 33.4 An Event Handling Example
    5. 33.5 Designing the User Interface
    6. 33.6 The Event Listener and Callback Method
    7. 33.7 Consuming Events
    8. 33.8 Summary
  34. 34. Android Touch and Multi-touch Event Handling
    1. 34.1 Intercepting Touch Events
    2. 34.2 The MotionEvent Object
    3. 34.3 Understanding Touch Actions
    4. 34.4 Handling Multiple Touches
    5. 34.5 An Example Multi-Touch Application
    6. 34.6 Designing the Activity User Interface
    7. 34.7 Implementing the Touch Event Listener
    8. 34.8 Running the Example Application
    9. 34.9 Summary
  35. 35. Detecting Common Gestures using the Android Gesture Detector Class
    1. 35.1 Implementing Common Gesture Detection
    2. 35.2 Creating an Example Gesture Detection Project
    3. 35.3 Implementing the Listener Class
    4. 35.4 Creating the GestureDetectorCompat Instance
    5. 35.5 Implementing the onTouchEvent() Method
    6. 35.6 Testing the Application
    7. 35.7 Summary
  36. 36. Implementing Custom Gesture and Pinch Recognition on Android
    1. 36.1 The Android Gesture Builder Application
    2. 36.2 The GestureOverlayView Class
    3. 36.3 Detecting Gestures
    4. 36.4 Identifying Specific Gestures
    5. 36.5 Installing and Running the Gesture Builder Application
    6. 36.6 Creating a Gestures File
    7. 36.7 Creating the Example Project
    8. 36.8 Extracting the Gestures File from the SD Card
    9. 36.9 Adding the Gestures File to the Project
    10. 36.10 Designing the User Interface
    11. 36.11 Loading the Gestures File
    12. 36.12 Registering the Event Listener
    13. 36.13 Implementing the onGesturePerformed Method
    14. 36.14 Testing the Application
    15. 36.15 Configuring the GestureOverlayView
    16. 36.16 Intercepting Gestures
    17. 36.17 Detecting Pinch Gestures
    18. 36.18 A Pinch Gesture Example Project
    19. 36.19 Summary
  37. 37. An Introduction to Android Fragments
    1. 37.1 What is a Fragment?
    2. 37.2 Creating a Fragment
    3. 37.3 Adding a Fragment to an Activity using the Layout XML File
    4. 37.4 Adding and Managing Fragments in Code
    5. 37.5 Handling Fragment Events
    6. 37.6 Implementing Fragment Communication
    7. 37.7 Summary
  38. 38. Using Fragments in Android Studio - An Example
    1. 38.1 About the Example Fragment Application
    2. 38.2 Creating the Example Project
    3. 38.3 Creating the First Fragment Layout
    4. 38.4 Adding the Second Fragment
    5. 38.5 Adding the Fragments to the Activity
    6. 38.6 Making the Toolbar Fragment Talk to the Activity
    7. 38.7 Making the Activity Talk to the Text Fragment
    8. 38.8 Testing the Application
    9. 38.9 Summary
  39. 39. Modern Android App Architecture with Jetpack
    1. 39.1 What is Android Jetpack?
    2. 39.2 The “Old” Architecture
    3. 39.3 Modern Android Architecture
    4. 39.4 The ViewModel Component
    5. 39.5 The LiveData Component
    6. 39.6 ViewModel Saved State
    7. 39.7 LiveData and Data Binding
    8. 39.8 Android Lifecycles
    9. 39.9 Repository Modules
    10. 39.10 Summary
  40. 40. An Android Jetpack ViewModel Tutorial
    1. 40.1 About the Project
    2. 40.2 Creating the ViewModel Example Project
    3. 40.3 Reviewing the Project
      1. 40.3.1 The Main Activity
      2. 40.3.2 The Content Fragment
      3. 40.3.3 The ViewModel
    4. 40.4 Designing the Fragment Layout
    5. 40.5 Implementing the View Model
    6. 40.6 Associating the Fragment with the View Model
    7. 40.7 Modifying the Fragment
    8. 40.8 Accessing the ViewModel Data
    9. 40.9 Testing the Project
    10. 40.10 Summary
  41. 41. An Android Jetpack LiveData Tutorial
    1. 41.1 LiveData - A Recap
    2. 41.2 Adding LiveData to the ViewModel
    3. 41.3 Implementing the Observer
    4. 41.4 Summary
  42. 42. An Overview of Android Jetpack Data Binding
    1. 42.1 An Overview of Data Binding
    2. 42.2 The Key Components of Data Binding
      1. 42.2.1 The Project Build Configuration
      2. 42.2.2 The Data Binding Layout File
      3. 42.2.3 The Layout File Data Element
      4. 42.2.4 The Binding Classes
      5. 42.2.5 Data Binding Variable Configuration
      6. 42.2.6 Binding Expressions (One-Way)
      7. 42.2.7 Binding Expressions (Two-Way)
      8. 42.2.8 Event and Listener Bindings
    3. 42.3 Summary
  43. 43. An Android Jetpack Data Binding Tutorial
    1. 43.1 Removing the Redundant Code
    2. 43.2 Enabling Data Binding
    3. 43.3 Adding the Layout Element
    4. 43.4 Adding the Data Element to Layout File
    5. 43.5 Working with the Binding Class
    6. 43.6 Assigning the ViewModel Instance to the Data Binding Variable
    7. 43.7 Adding Binding Expressions
    8. 43.8 Adding the Conversion Method
    9. 43.9 Adding a Listener Binding
    10. 43.10 Testing the App
    11. 43.11 Summary
  44. 44. An Android ViewModel Saved State Tutorial
    1. 44.1 Understanding ViewModel State Saving
    2. 44.2 Implementing ViewModel State Saving
    3. 44.3 Saving and Restoring State
    4. 44.4 Adding Saved State Support to the ViewModelDemo Project
    5. 44.5 Summary
  45. 45. Working with Android Lifecycle-Aware Components
    1. 45.1 Lifecycle Awareness
    2. 45.2 Lifecycle Owners
    3. 45.3 Lifecycle Observers
    4. 45.4 Lifecycle States and Events
    5. 45.5 Summary
  46. 46. An Android Jetpack Lifecycle Awareness Tutorial
    1. 46.1 Creating the Example Lifecycle Project
    2. 46.2 Creating a Lifecycle Observer
    3. 46.3 Adding the Observer
    4. 46.4 Testing the Observer
    5. 46.5 Creating a Lifecycle Owner
    6. 46.6 Testing the Custom Lifecycle Owner
    7. 46.7 Summary
  47. 47. An Overview of the Navigation Architecture Component
    1. 47.1 Understanding Navigation
    2. 47.2 Declaring a Navigation Host
    3. 47.3 The Navigation Graph
    4. 47.4 Accessing the Navigation Controller
    5. 47.5 Triggering a Navigation Action
    6. 47.6 Passing Arguments
    7. 47.7 Summary
  48. 48. An Android Jetpack Navigation Component Tutorial
    1. 48.1 Creating the NavigationDemo Project
    2. 48.2 Adding Navigation to the Build Configuration
    3. 48.3 Creating the Navigation Graph Resource File
    4. 48.4 Declaring a Navigation Host
    5. 48.5 Adding Navigation Destinations
    6. 48.6 Designing the Destination Fragment Layouts
    7. 48.7 Adding an Action to the Navigation Graph
    8. 48.8 Implement the OnFragmentInteractionListener
    9. 48.9 Triggering the Action
    10. 48.10 Passing Data Using Safeargs
    11. 48.11 Summary
  49. 49. An Introduction to MotionLayout
    1. 49.1 An Overview of MotionLayout
    2. 49.2 MotionLayout
    3. 49.3 MotionScene
    4. 49.4 Configuring ConstraintSets
    5. 49.5 Custom Attributes
    6. 49.6 Triggering an Animation
    7. 49.7 Arc Motion
    8. 49.8 Keyframes
      1. 49.8.1 Attribute Keyframes
      2. 49.8.2 Position Keyframes
    9. 49.9 Time Linearity
    10. 49.10 KeyTrigger
    11. 49.11 Cycle and Time Cycle Keyframes
    12. 49.12 Starting an Animation from Code
  50. 50. An Android MotionLayout Editor Tutorial
    1. 50.1 Creating the MotionLayoutDemo Project
    2. 50.2 ConstraintLayout to MotionLayout Conversion
    3. 50.3 Configuring Start and End Constraints
    4. 50.4 Previewing the MotionLayout Animation
    5. 50.5 Adding an OnClick Gesture
    6. 50.6 Adding an Attribute Keyframe to the Transition
    7. 50.7 Adding a CustomAttribute to a Transition
    8. 50.8 Adding Position Keyframes
    9. 50.9 Summary
  51. 51. A MotionLayout KeyCycle Tutorial
    1. 51.1 An Overview of Cycle Keyframes
    2. 51.2 Using the Cycle Editor
    3. 51.3 Creating the KeyCycleDemo Project
    4. 51.4 Configuring the Start and End Constraints
    5. 51.5 Creating the Cycles
    6. 51.6 Previewing the Animation
    7. 51.7 Adding the KeyFrameSet to the MotionScene
    8. 51.8 Summary
  52. 52. Working with the Floating Action Button and Snackbar
    1. 52.1 The Material Design
    2. 52.2 The Design Library
    3. 52.3 The Floating Action Button (FAB)
    4. 52.4 The Snackbar
    5. 52.5 Creating the Example Project
    6. 52.6 Reviewing the Project
    7. 52.7 Removing Navigation Features
    8. 52.8 Changing the Floating Action Button
    9. 52.9 Adding the ListView to the Content Layout
    10. 52.10 Adding Items to the ListView
    11. 52.11 Adding an Action to the Snackbar
    12. 52.12 Summary
  53. 53. Creating a Tabbed Interface using the TabLayout Component
    1. 53.1 An Introduction to the ViewPager
    2. 53.2 An Overview of the TabLayout Component
    3. 53.3 Creating the TabLayoutDemo Project
    4. 53.4 Creating the First Fragment
    5. 53.5 Duplicating the Fragments
    6. 53.6 Adding the TabLayout and ViewPager
    7. 53.7 Creating the Pager Adapter
    8. 53.8 Performing the Initialization Tasks
    9. 53.9 Testing the Application
    10. 53.10 Customizing the TabLayout
    11. 53.11 Displaying Icon Tab Items
    12. 53.12 Summary
  54. 54. Working with the RecyclerView and CardView Widgets
    1. 54.1 An Overview of the RecyclerView
    2. 54.2 An Overview of the CardView
    3. 54.3 Summary
  55. 55. An Android RecyclerView and CardView Tutorial
    1. 55.1 Creating the CardDemo Project
    2. 55.2 Modifying the Basic Activity Project
    3. 55.3 Designing the CardView Layout
    4. 55.4 Adding the RecyclerView
    5. 55.5 Adding the Image Files
    6. 55.6 Creating the RecyclerView Adapter
    7. 55.7 Initializing the RecyclerView Component
    8. 55.8 Testing the Application
    9. 55.9 Responding to Card Selections
    10. 55.10 Summary
  56. 56. A Layout Editor Sample Data Tutorial
    1. 56.1 Adding Sample Data to a Project
    2. 56.2 Using Custom Sample Data
    3. 56.3 Summary
  57. 57. Working with the AppBar and Collapsing Toolbar Layouts
    1. 57.1 The Anatomy of an AppBar
    2. 57.2 The Example Project
    3. 57.3 Coordinating the RecyclerView and Toolbar
    4. 57.4 Introducing the Collapsing Toolbar Layout
    5. 57.5 Changing the Title and Scrim Color
    6. 57.6 Summary
  58. 58. An Android Studio Master/Detail Flow Tutorial
    1. 58.1 The Master/Detail Flow
    2. 58.2 Creating a Master/Detail Flow Activity
    3. 58.3 The Anatomy of the Master/Detail Flow Template
    4. 58.4 Modifying the Master/Detail Flow Template
    5. 58.5 Changing the Content Model
    6. 58.6 Changing the Detail Pane
    7. 58.7 Modifying the WebsiteDetailFragment Class
    8. 58.8 Modifying the WebsiteListActivity Class
    9. 58.9 Adding Manifest Permissions
    10. 58.10 Running the Application
    11. 58.11 Summary
  59. 59. An Overview of Android Intents
    1. 59.1 An Overview of Intents
    2. 59.2 Explicit Intents
    3. 59.3 Returning Data from an Activity
    4. 59.4 Implicit Intents
    5. 59.5 Using Intent Filters
    6. 59.6 Checking Intent Availability
    7. 59.7 Summary
  60. 60. Android Explicit Intents – A Worked Example
    1. 60.1 Creating the Explicit Intent Example Application
    2. 60.2 Designing the User Interface Layout for MainActivity
    3. 60.3 Creating the Second Activity Class
    4. 60.4 Designing the User Interface Layout for ActivityB
    5. 60.5 Reviewing the Application Manifest File
    6. 60.6 Creating the Intent
    7. 60.7 Extracting Intent Data
    8. 60.8 Launching ActivityB as a Sub-Activity
    9. 60.9 Returning Data from a Sub-Activity
    10. 60.10 Testing the Application
    11. 60.11 Summary
  61. 61. Android Implicit Intents – A Worked Example
    1. 61.1 Creating the Android Studio Implicit Intent Example Project
    2. 61.2 Designing the User Interface
    3. 61.3 Creating the Implicit Intent
    4. 61.4 Adding a Second Matching Activity
    5. 61.5 Adding the Web View to the UI
    6. 61.6 Obtaining the Intent URL
    7. 61.7 Modifying the MyWebView Project Manifest File
    8. 61.8 Installing the MyWebView Package on a Device
    9. 61.9 Testing the Application
    10. 61.10 Summary
  62. 62. Android Broadcast Intents and Broadcast Receivers
    1. 62.1 An Overview of Broadcast Intents
    2. 62.2 An Overview of Broadcast Receivers
    3. 62.3 Obtaining Results from a Broadcast
    4. 62.4 Sticky Broadcast Intents
    5. 62.5 The Broadcast Intent Example
    6. 62.6 Creating the Example Application
    7. 62.7 Creating and Sending the Broadcast Intent
    8. 62.8 Creating the Broadcast Receiver
    9. 62.9 Registering the Broadcast Receiver
    10. 62.10 Testing the Broadcast Example
    11. 62.11 Listening for System Broadcasts
    12. 62.12 Summary
  63. 63. A Basic Overview of Threads and AsyncTasks
    1. 63.1 An Overview of Threads
    2. 63.2 The Application Main Thread
    3. 63.3 Thread Handlers
    4. 63.4 A Basic AsyncTask Example
    5. 63.5 Subclassing AsyncTask
    6. 63.6 Testing the App
    7. 63.7 Canceling a Task
    8. 63.8 Summary
  64. 64. An Introduction to Kotlin Coroutines
    1. 64.1 What are Coroutines?
    2. 64.2 Threads vs Coroutines
    3. 64.3 Coroutine Scope
    4. 64.4 Suspend Functions
    5. 64.5 Coroutine Dispatchers
    6. 64.6 Coroutine Builders
    7. 64.7 Jobs
    8. 64.8 Coroutines – Suspending and Resuming
    9. 64.9 Returning Results from a Coroutine
    10. 64.10 Using withContext
    11. 64.11 Coroutine Channel Communication
    12. 64.12 Summary
  65. 65. An Android Kotlin Coroutines Tutorial
    1. 65.1 Creating the Coroutine Example Application
    2. 65.2 Adding Coroutine Support to the Project
    3. 65.3 Designing the User Interface
    4. 65.4 Implementing the SeekBar
    5. 65.5 Adding the Suspend Function
    6. 65.6 Implementing the launchCoroutines Method
    7. 65.7 Testing the App
    8. 65.8 Summary
  66. 66. An Overview of Android Started and Bound Services
    1. 66.1 Started Services
    2. 66.2 Intent Service
    3. 66.3 Bound Service
    4. 66.4 The Anatomy of a Service
    5. 66.5 Controlling Destroyed Service Restart Options
    6. 66.6 Declaring a Service in the Manifest File
    7. 66.7 Starting a Service Running on System Startup
    8. 66.8 Summary
  67. 67. Implementing an Android Started Service – A Worked Example
    1. 67.1 Creating the Example Project
    2. 67.2 Creating the Service Class
    3. 67.3 Adding the Service to the Manifest File
    4. 67.4 Starting the Service
    5. 67.5 Testing the IntentService Example
    6. 67.6 Using the Service Class
    7. 67.7 Creating the New Service
    8. 67.8 Modifying the User Interface
    9. 67.9 Running the Application
    10. 67.10 Using a Coroutine for the Service Task
    11. 67.11 Summary
  68. 68. Android Local Bound Services – A Worked Example
    1. 68.1 Understanding Bound Services
    2. 68.2 Bound Service Interaction Options
    3. 68.3 An Android Studio Local Bound Service Example
    4. 68.4 Adding a Bound Service to the Project
    5. 68.5 Implementing the Binder
    6. 68.6 Binding the Client to the Service
    7. 68.7 Completing the Example
    8. 68.8 Testing the Application
    9. 68.9 Summary
  69. 69. Android Remote Bound Services – A Worked Example
    1. 69.1 Client to Remote Service Communication
    2. 69.2 Creating the Example Application
    3. 69.3 Designing the User Interface
    4. 69.4 Implementing the Remote Bound Service
    5. 69.5 Configuring a Remote Service in the Manifest File
    6. 69.6 Launching and Binding to the Remote Service
    7. 69.7 Sending a Message to the Remote Service
    8. 69.8 Summary
  70. 70. An Android Notifications Tutorial
    1. 70.1 An Overview of Notifications
    2. 70.2 Creating the NotifyDemo Project
    3. 70.3 Designing the User Interface
    4. 70.4 Creating the Second Activity
    5. 70.5 Creating a Notification Channel
    6. 70.6 Creating and Issuing a Basic Notification
    7. 70.7 Launching an Activity from a Notification
    8. 70.8 Adding Actions to a Notification
    9. 70.9 Bundled Notifications
    10. 70.10 Summary
  71. 71. An Android Direct Reply Notification Tutorial
    1. 71.1 Creating the DirectReply Project
    2. 71.2 Designing the User Interface
    3. 71.3 Creating the Notification Channel
    4. 71.4 Building the RemoteInput Object
    5. 71.5 Creating the PendingIntent
    6. 71.6 Creating the Reply Action
    7. 71.7 Receiving Direct Reply Input
    8. 71.8 Updating the Notification
    9. 71.9 Summary
  72. 72. Foldable Devices and Multi-Window Support
    1. 72.1 Foldables and Multi-Window Support
    2. 72.2 Using a Foldable Emulator
    3. 72.3 Entering Multi-Window Mode
    4. 72.4 Enabling and using Freeform Support
    5. 72.5 Checking for Freeform Support
    6. 72.6 Enabling Multi-Window Support in an App
    7. 72.7 Specifying Multi-Window Attributes
    8. 72.8 Detecting Multi-Window Mode in an Activity
    9. 72.9 Receiving Multi-Window Notifications
    10. 72.10 Launching an Activity in Multi-Window Mode
    11. 72.11 Configuring Freeform Activity Size and Position
    12. 72.12 Summary
  73. 73. An Overview of Android SQLite Databases
    1. 73.1 Understanding Database Tables
    2. 73.2 Introducing Database Schema
    3. 73.3 Columns and Data Types
    4. 73.4 Database Rows
    5. 73.5 Introducing Primary Keys
    6. 73.6 What is SQLite?
    7. 73.7 Structured Query Language (SQL)
    8. 73.8 Trying SQLite on an Android Virtual Device (AVD)
    9. 73.9 The Android Room Persistence Library
    10. 73.10 Summary
  74. 74. The Android Room Persistence Library
    1. 74.1 Revisiting Modern App Architecture
    2. 74.2 Key Elements of Room Database Persistence
      1. 74.2.1 Repository
      2. 74.2.2 Room Database
      3. 74.2.3 Data Access Object (DAO)
      4. 74.2.4 Entities
      5. 74.2.5 SQLite Database
    3. 74.3 Understanding Entities
    4. 74.4 Data Access Objects
    5. 74.5 The Room Database
    6. 74.6 The Repository
    7. 74.7 In-Memory Databases
    8. 74.8 Database Inspector
    9. 74.9 Summary
  75. 75. An Android TableLayout and TableRow Tutorial
    1. 75.1 The TableLayout and TableRow Layout Views
    2. 75.2 Creating the Room Database Project
    3. 75.3 Converting to a LinearLayout
    4. 75.4 Adding the TableLayout to the User Interface
    5. 75.5 Configuring the TableRows
    6. 75.6 Adding the Button Bar to the Layout
    7. 75.7 Adding the RecyclerView
    8. 75.8 Adjusting the Layout Margins
    9. 75.9 Summary
  76. 76. An Android Room Database and Repository Tutorial
    1. 76.1 About the RoomDemo Project
    2. 76.2 Modifying the Build Configuration
    3. 76.3 Building the Entity
    4. 76.4 Creating the Data Access Object
    5. 76.5 Adding the Room Database
    6. 76.6 Adding the Repository
    7. 76.7 Modifying the ViewModel
    8. 76.8 Creating the Product Item Layout
    9. 76.9 Adding the RecyclerView Adapter
    10. 76.10 Preparing the Main Fragment
    11. 76.11 Adding the Button Listeners
    12. 76.12 Adding LiveData Observers
    13. 76.13 Initializing the RecyclerView
    14. 76.14 Testing the RoomDemo App
    15. 76.15 Using the Database Inspector
    16. 76.16 Summary
  77. 77. Accessing Cloud Storage using the Android Storage Access Framework
    1. 77.1 The Storage Access Framework
    2. 77.2 Working with the Storage Access Framework
    3. 77.3 Filtering Picker File Listings
    4. 77.4 Handling Intent Results
    5. 77.5 Reading the Content of a File
    6. 77.6 Writing Content to a File
    7. 77.7 Deleting a File
    8. 77.8 Gaining Persistent Access to a File
    9. 77.9 Summary
  78. 78. An Android Storage Access Framework Example
    1. 78.1 About the Storage Access Framework Example
    2. 78.2 Creating the Storage Access Framework Example
    3. 78.3 Designing the User Interface
    4. 78.4 Declaring Request Codes
    5. 78.5 Creating a New Storage File
    6. 78.6 The onActivityResult() Method
    7. 78.7 Saving to a Storage File
    8. 78.8 Opening and Reading a Storage File
    9. 78.9 Testing the Storage Access Application
    10. 78.10 Summary
  79. 79. Video Playback on Android using the VideoView and MediaController Classes
    1. 79.1 Introducing the Android VideoView Class
    2. 79.2 Introducing the Android MediaController Class
    3. 79.3 Creating the Video Playback Example
    4. 79.4 Designing the VideoPlayer Layout
    5. 79.5 Downloading the Video File
    6. 79.6 Configuring the VideoView
    7. 79.7 Adding the MediaController to the Video View
    8. 79.8 Setting up the onPreparedListener
    9. 79.9 Summary
  80. 80. Android Picture-in-Picture Mode
    1. 80.1 Picture-in-Picture Features
    2. 80.2 Enabling Picture-in-Picture Mode
    3. 80.3 Configuring Picture-in-Picture Parameters
    4. 80.4 Entering Picture-in-Picture Mode
    5. 80.5 Detecting Picture-in-Picture Mode Changes
    6. 80.6 Adding Picture-in-Picture Actions
    7. 80.7 Summary
  81. 81. An Android Picture-in-Picture Tutorial
    1. 81.1 Adding Picture-in-Picture Support to the Manifest
    2. 81.2 Adding a Picture-in-Picture Button
    3. 81.3 Entering Picture-in-Picture Mode
    4. 81.4 Detecting Picture-in-Picture Mode Changes
    5. 81.5 Adding a Broadcast Receiver
    6. 81.6 Adding the PiP Action
    7. 81.7 Testing the Picture-in-Picture Action
    8. 81.8 Summary
  82. 82. Making Runtime Permission Requests in Android
    1. 82.1 Understanding Normal and Dangerous Permissions
    2. 82.2 Creating the Permissions Example Project
    3. 82.3 Checking for a Permission
    4. 82.4 Requesting Permission at Runtime
    5. 82.5 Providing a Rationale for the Permission Request
    6. 82.6 Testing the Permissions App
    7. 82.7 Summary
  83. 83. Android Audio Recording and Playback using MediaPlayer and MediaRecorder
    1. 83.1 Playing Audio
    2. 83.2 Recording Audio and Video using the MediaRecorder Class
    3. 83.3 About the Example Project
    4. 83.4 Creating the AudioApp Project
    5. 83.5 Designing the User Interface
    6. 83.6 Checking for Microphone Availability
    7. 83.7 Performing the Activity Initialization
    8. 83.8 Implementing the recordAudio() Method
    9. 83.9 Implementing the stopAudio() Method
    10. 83.10 Implementing the playAudio() method
    11. 83.11 Configuring and Requesting Permissions
    12. 83.12 Testing the Application
    13. 83.13 Summary
  84. 84. Printing with the Android Printing Framework
    1. 84.1 The Android Printing Architecture
    2. 84.2 The Print Service Plugins
    3. 84.3 Google Cloud Print
    4. 84.4 Printing to Google Drive
    5. 84.5 Save as PDF
    6. 84.6 Printing from Android Devices
    7. 84.7 Options for Building Print Support into Android Apps
      1. 84.7.1 Image Printing
      2. 84.7.2 Creating and Printing HTML Content
      3. 84.7.3 Printing a Web Page
      4. 84.7.4 Printing a Custom Document
    8. 84.8 Summary
  85. 85. An Android HTML and Web Content Printing Example
    1. 85.1 Creating the HTML Printing Example Application
    2. 85.2 Printing Dynamic HTML Content
    3. 85.3 Creating the Web Page Printing Example
    4. 85.4 Removing the Floating Action Button
    5. 85.5 Removing Navigation Features
    6. 85.6 Designing the User Interface Layout
    7. 85.7 Loading the Web Page into the WebView
    8. 85.8 Adding the Print Menu Option
    9. 85.9 Summary
  86. 86. A Guide to Android Custom Document Printing
    1. 86.1 An Overview of Android Custom Document Printing
      1. 86.1.1 Custom Print Adapters
    2. 86.2 Preparing the Custom Document Printing Project
    3. 86.3 Creating the Custom Print Adapter
    4. 86.4 Implementing the onLayout() Callback Method
    5. 86.5 Implementing the onWrite() Callback Method
    6. 86.6 Checking a Page is in Range
    7. 86.7 Drawing the Content on the Page Canvas
    8. 86.8 Starting the Print Job
    9. 86.9 Testing the Application
    10. 86.10 Summary
  87. 87. An Introduction to Android App Links
    1. 87.1 An Overview of Android App Links
    2. 87.2 App Link Intent Filters
    3. 87.3 Handling App Link Intents
    4. 87.4 Associating the App with a Website
    5. 87.5 Summary
  88. 88. An Android Studio App Links Tutorial
    1. 88.1 About the Example App
    2. 88.2 The Database Schema
    3. 88.3 Loading and Running the Project
    4. 88.4 Adding the URL Mapping
    5. 88.5 Adding the Intent Filter
    6. 88.6 Adding Intent Handling Code
    7. 88.7 Testing the App Link
    8. 88.8 Associating an App Link with a Web Site
    9. 88.9 Summary
  89. 89. A Guide to the Android Studio Profiler
    1. 89.1 Accessing the Android Profiler
    2. 89.2 Enabling Advanced Profiling
    3. 89.3 The Android Profiler Tool Window
    4. 89.4 The Sessions Panel
    5. 89.5 The CPU Profiler
    6. 89.6 Memory Profiler
    7. 89.7 Network Profiler
    8. 89.8 Energy Profiler
    9. 89.9 Summary
  90. 90. An Android Biometric Authentication Tutorial
    1. 90.1 An Overview of Biometric Authentication
    2. 90.2 Creating the Biometric Authentication Project
    3. 90.3 Configuring Device Fingerprint Authentication
    4. 90.4 Adding the Biometric Permission to the Manifest File
    5. 90.5 Designing the User Interface
    6. 90.6 Adding a Toast Convenience Method
    7. 90.7 Checking the Security Settings
    8. 90.8 Configuring the Authentication Callbacks
    9. 90.9 Adding the CancellationSignal
    10. 90.10 Starting the Biometric Prompt
    11. 90.11 Testing the Project
    12. 90.12 Summary
  91. 91. Creating, Testing and Uploading an Android App Bundle
    1. 91.1 The Release Preparation Process
    2. 91.2 Android App Bundles
    3. 91.3 Register for a Google Play Developer Console Account
    4. 91.4 Configuring the App in the Console
    5. 91.5 Enabling Google Play App Signing
    6. 91.6 Creating a Keystore File
    7. 91.7 Creating the Android App Bundle
    8. 91.8 Generating Test APK Files
    9. 91.9 Uploading the App Bundle to the Google Play Developer Console
    10. 91.10 Exploring the App Bundle
    11. 91.11 Managing Testers
    12. 91.12 Rolling the App Out for Testing
    13. 91.13 Uploading New App Bundle Revisions
    14. 91.14 Analyzing the App Bundle File
    15. 91.15 Summary
  92. 92. An Overview of Android Dynamic Feature Modules
    1. 92.1 An Overview of Dynamic Feature Modules
    2. 92.2 Dynamic Feature Module Architecture
    3. 92.3 Creating a Dynamic Feature Module
    4. 92.4 Converting an Existing Module for Dynamic Delivery
    5. 92.5 Working with Dynamic Feature Modules
    6. 92.6 Handling Large Dynamic Feature Modules
    7. 92.7 Summary
  93. 93. An Android Studio Dynamic Feature Tutorial
    1. 93.1 Creating the DynamicFeature Project
    2. 93.2 Adding Dynamic Feature Support to the Project
    3. 93.3 Designing the Base Activity User Interface
    4. 93.4 Adding the Dynamic Feature Module
    5. 93.5 Reviewing the Dynamic Feature Module
    6. 93.6 Adding the Dynamic Feature Activity
    7. 93.7 Implementing the launchIntent() Method
    8. 93.8 Uploading the App Bundle for Testing
    9. 93.9 Implementing the installFeature() Method
    10. 93.10 Adding the Update Listener
    11. 93.11 Handling Large Downloads
    12. 93.12 Using Deferred Installation
    13. 93.13 Removing a Dynamic Module
    14. 93.14 Summary
  94. 94. An Overview of Gradle in Android Studio
    1. 94.1 An Overview of Gradle
    2. 94.2 Gradle and Android Studio
      1. 94.2.1 Sensible Defaults
      2. 94.2.2 Dependencies
      3. 94.2.3 Build Variants
      4. 94.2.4 Manifest Entries
      5. 94.2.5 APK Signing
      6. 94.2.6 ProGuard Support
    3. 94.3 The Top-level Gradle Build File
    4. 94.4 Module Level Gradle Build Files
    5. 94.5 Configuring Signing Settings in the Build File
    6. 94.6 Running Gradle Tasks from the Command-line
    7. 94.7 Summary
  95. Index

Product information

  • Title: Android Studio 4.1 Development Essentials – Kotlin Edition
  • Author(s): Neil Smyth
  • Release date: May 2021
  • Publisher(s): Packt Publishing
  • ISBN: 9781801815987