Android Studio Arctic Fox Essentials - Kotlin Edition

Android Studio Arctic Fox Essentials - Kotlin Edition

by Neil Smyth
Released October 2021
Publisher(s): Packt Publishing
ISBN: 9781803247458

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

A simple approach to developing Android applications using Android Studio Arctic Fox Essentials and Kotlin

Key Features

  • The latest Material Design components to build modern user interface designs
  • Step-by-step instruction to building view model-based apps and modern user interface designs using the Jetpack architecture and the latest material design components
  • Coding practice with the Kotlin programming language, including multi-threaded Kotlin code using Coroutines

Book Description

Android Studio is an Integrated Development Environment based on the JetBrains IntelliJ IDEA. It offers developers a unique platform to design and develop Android apps using various developer tools. Fully updated for Android Studio Arctic Fox, the goal of this book is to teach the skills necessary to develop Android-based applications using the Kotlin programming language.

This book begins with an outline of the steps necessary to set up an Android development and testing environment, followed by an introduction to programming in Kotlin which includes data types, control flow, functions, lambdas, and object-oriented programming. An overview of Android Studio covers areas such as tool windows, the code editor, and the layout editor tool. An introduction to the architecture of Android is followed by an in-depth look at the design of Android applications and user interfaces using the Android Studio environment.

Early chapters detail Android architecture components such as view models, lifecycle management, Room database access, the Database Inspector, app navigation, live data, and data binding. More advanced topics such as intents are also covered, as are touch screen handling, gesture recognition, and the recording and playback of audio. This edition of the book also covers printing, transitions, cloud-based file storage, and foldable device support.

The concepts of material design are also discussed in detail, including the use of floating action buttons, Snackbars, tabbed interfaces, card views, navigation drawers, and collapsing toolbars. Other key features of Android Studio Arctic Fox and Android taught in this book include the Layout Editor, the ConstraintLayout and ConstraintSet classes, MotionLayout Editor, view binding, constraint chains, barriers, and direct reply to notifications. Chapters also explore more advanced features of Android Studio such as app links, dynamic delivery, Gradle build configuration, and submitting apps to the Google Play developer console.

What you will learn

  • Install and configure Android Studio on Windows, macOS, and Linux
  • Design complex, responsive user interface layouts
  • Understand Android architecture and app lifecycle
  • Integrate SQLite databases and the Android Room persistence library
  • Divide large apps into dynamic feature modules
  • Monitor app performances using the Android studio profiler tool

Who this book is for

This book is for anyone who wants to learn Android application development, such as existing Android developers who want to upgrade their skills and step into the Kotlin ecosystem. To get the most from this book, you should have some previous programming experience. You will be required to download Android Studio and the Android SDK for this course, so make sure you have access to a Windows, Mac, or Linux system and some creative app ideas to develop.

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 8.1
      2. 2.6.2 Windows 10
      3. 2.6.3 Linux
      4. 2.6.4 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 Battery
      5. 5.5.5 Camera
      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 Control flow
    1. 14.1 Looping Control flow
      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 Control flow
      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 Binding
    3. 18.3 Converting the AndroidSample project
    4. 18.4 Enabling View Binding
    5. 18.5 Using View Binding
    6. 18.6 Choosing an Option
    7. 18.7 View Binding in the Book Examples
    8. 18.8 Migrating a Project to View Binding
    9. 18.9 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 Night Mode
    7. 24.7 Code Mode
    8. 24.8 Split Mode
    9. 24.9 Setting Attributes
    10. 24.10 Transforms
    11. 24.11 Tools Visibility Toggles
    12. 24.12 Converting Views
    13. 24.13 Displaying Sample Data
    14. 24.14 Creating a Custom Device Definition
    15. 24.15 Changing the Current Device
    16. 24.16 Layout Validation (Multi Preview)
    17. 24.17 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 Migrating a Fragment to View Binding
    5. 38.5 Adding the Second Fragment
    6. 38.6 Adding the Fragments to the Activity
    7. 38.7 Making the Toolbar Fragment Talk to the Activity
    8. 38.8 Making the Activity Talk to the Text Fragment
    9. 38.9 Testing the Application
    10. 38.10 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 Adding View Binding Support to the Destination Fragments
    10. 48.10 Triggering the Action
    11. 48.11 Passing Data Using Safeargs
    12. 48.12 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
    13. 49.13 Summary
  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 an Action to the Snackbar
    10. 52.10 Summary
  53. 53. Creating a Tabbed Interface using the TabLayout Component
    1. 53.1 An Introduction to the ViewPager2
    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 ViewPager2
    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 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 Primary/Detail Flow Tutorial
    1. 58.1 The Primary/Detail Flow
    2. 58.2 Creating a Primary/Detail Flow Activity
    3. 58.3 Modifying the Primary/Detail Flow Template
    4. 58.4 Changing the Content Model
    5. 58.5 Changing the Detail Pane
    6. 58.6 Modifying the WebsiteDetailFragment Class
    7. 58.7 Modifying the WebsiteListFragment Class
    8. 58.8 Adding Manifest Permissions
    9. 58.9 Running the Application
    10. 58.10 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 SecondActivity
    5. 60.5 Reviewing the Application Manifest File
    6. 60.6 Creating the Intent
    7. 60.7 Extracting Intent Data
    8. 60.8 Launching SecondActivity 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. An Introduction to Kotlin Coroutines
    1. 63.1 What are Coroutines?
    2. 63.2 Threads vs Coroutines
    3. 63.3 Coroutine Scope
    4. 63.4 Suspend Functions
    5. 63.5 Coroutine Dispatchers
    6. 63.6 Coroutine Builders
    7. 63.7 Jobs
    8. 63.8 Coroutines – Suspending and Resuming
    9. 63.9 Returning Results from a Coroutine
    10. 63.10 Using withContext
    11. 63.11 Coroutine Channel Communication
    12. 63.12 Summary
  64. 64. An Android Kotlin Coroutines Tutorial
    1. 64.1 Creating the Coroutine Example Application
    2. 64.2 Adding Coroutine Support to the Project
    3. 64.3 Designing the User Interface
    4. 64.4 Implementing the SeekBar
    5. 64.5 Adding the Suspend Function
    6. 64.6 Implementing the launchCoroutines Method
    7. 64.7 Testing the App
    8. 64.8 Summary
  65. 65. An Overview of Android Services
    1. 65.1 Started Services
    2. 65.2 Intent Service
    3. 65.3 Bound Service
    4. 65.4 The Anatomy of a Service
    5. 65.5 Controlling Destroyed Service Restart Options
    6. 65.6 Declaring a Service in the Manifest File
    7. 65.7 Starting a Service Running on System Startup
    8. 65.8 Summary
  66. 66. Implementing an Android Started Service – A Worked Example
    1. 66.1 Creating the Example Project
    2. 66.2 Designing the User Interface
    3. 66.3 Creating the Service Class
    4. 66.4 Adding the Service to the Manifest File
    5. 66.5 Starting the Service
    6. 66.6 Testing the IntentService Example
    7. 66.7 Using the Service Class
    8. 66.8 Creating the New Service
    9. 66.9 Launching the Service
    10. 66.10 Running the Application
    11. 66.11 Using a Coroutine for the Service Task
    12. 66.12 Summary
  67. 67. Android Local Bound Services – A Worked Example
    1. 67.1 Understanding Bound Services
    2. 67.2 Bound Service Interaction Options
    3. 67.3 A Local Bound Service Example
    4. 67.4 Adding a Bound Service to the Project
    5. 67.5 Implementing the Binder
    6. 67.6 Binding the Client to the Service
    7. 67.7 Completing the Example
    8. 67.8 Testing the Application
    9. 67.9 Summary
  68. 68. Android Remote Bound Services – A Worked Example
    1. 68.1 Client to Remote Service Communication
    2. 68.2 Creating the Example Application
    3. 68.3 Designing the User Interface
    4. 68.4 Implementing the Remote Bound Service
    5. 68.5 Configuring a Remote Service in the Manifest File
    6. 68.6 Launching and Binding to the Remote Service
    7. 68.7 Sending a Message to the Remote Service
    8. 68.8 Summary
  69. 69. An Android Notifications Tutorial
    1. 69.1 An Overview of Notifications
    2. 69.2 Creating the NotifyDemo Project
    3. 69.3 Designing the User Interface
    4. 69.4 Creating the Second Activity
    5. 69.5 Creating a Notification Channel
    6. 69.6 Creating and Issuing a Notification
    7. 69.7 Launching an Activity from a Notification
    8. 69.8 Adding Actions to a Notification
    9. 69.9 Bundled Notifications
    10. 69.10 Summary
  70. 70. An Android Direct Reply Notification Tutorial
    1. 70.1 Creating the DirectReply Project
    2. 70.2 Designing the User Interface
    3. 70.3 Creating the Notification Channel
    4. 70.4 Building the RemoteInput Object
    5. 70.5 Creating the PendingIntent
    6. 70.6 Creating the Reply Action
    7. 70.7 Receiving Direct Reply Input
    8. 70.8 Updating the Notification
    9. 70.9 Summary
  71. 71. Foldable Devices and Multi-Window Support
    1. 71.1 Foldables and Multi-Window Support
    2. 71.2 Using a Foldable Emulator
    3. 71.3 Entering Multi-Window Mode
    4. 71.4 Enabling and using Freeform Support
    5. 71.5 Checking for Freeform Support
    6. 71.6 Enabling Multi-Window Support in an App
    7. 71.7 Specifying Multi-Window Attributes
    8. 71.8 Detecting Multi-Window Mode in an Activity
    9. 71.9 Receiving Multi-Window Notifications
    10. 71.10 Launching an Activity in Multi-Window Mode
    11. 71.11 Configuring Freeform Activity Size and Position
    12. 71.12 Summary
  72. 72. An Overview of Android SQLite Databases
    1. 72.1 Understanding Database Tables
    2. 72.2 Introducing Database Schema
    3. 72.3 Columns and Data Types
    4. 72.4 Database Rows
    5. 72.5 Introducing Primary Keys
    6. 72.6 What is SQLite?
    7. 72.7 Structured Query Language (SQL)
    8. 72.8 Trying SQLite on an Android Virtual Device (AVD)
    9. 72.9 The Android Room Persistence Library
    10. 72.10 Summary
  73. 73. The Android Room Persistence Library
    1. 73.1 Revisiting Modern App Architecture
    2. 73.2 Key Elements of Room Database Persistence
      1. 73.2.1 Repository
      2. 73.2.2 Room Database
      3. 73.2.3 Data Access Object (DAO)
      4. 73.2.4 Entities
      5. 73.2.5 SQLite Database
    3. 73.3 Understanding Entities
    4. 73.4 Data Access Objects
    5. 73.5 The Room Database
    6. 73.6 The Repository
    7. 73.7 In-Memory Databases
    8. 73.8 Database Inspector
    9. 73.9 Summary
  74. 74. An Android TableLayout and TableRow Tutorial
    1. 74.1 The TableLayout and TableRow Layout Views
    2. 74.2 Creating the Room Database Project
    3. 74.3 Converting to a LinearLayout
    4. 74.4 Adding the TableLayout to the User Interface
    5. 74.5 Configuring the TableRows
    6. 74.6 Adding the Button Bar to the Layout
    7. 74.7 Adding the RecyclerView
    8. 74.8 Adjusting the Layout Margins
    9. 74.9 Summary
  75. 75. An Android Room Database and Repository Tutorial
    1. 75.1 About the RoomDemo Project
    2. 75.2 Modifying the Build Configuration
    3. 75.3 Building the Entity
    4. 75.4 Creating the Data Access Object
    5. 75.5 Adding the Room Database
    6. 75.6 Adding the Repository
    7. 75.7 Modifying the ViewModel
    8. 75.8 Creating the Product Item Layout
    9. 75.9 Adding the RecyclerView Adapter
    10. 75.10 Preparing the Main Fragment
    11. 75.11 Adding the Button Listeners
    12. 75.12 Adding LiveData Observers
    13. 75.13 Initializing the RecyclerView
    14. 75.14 Testing the RoomDemo App
    15. 75.15 Using the Database Inspector
    16. 75.16 Summary
  76. 76. Accessing Cloud Storage using the Android Storage Access Framework
    1. 76.1 The Storage Access Framework
    2. 76.2 Working with the Storage Access Framework
    3. 76.3 Filtering Picker File Listings
    4. 76.4 Handling Intent Results
    5. 76.5 Reading the Content of a File
    6. 76.6 Writing Content to a File
    7. 76.7 Deleting a File
    8. 76.8 Gaining Persistent Access to a File
    9. 76.9 Summary
  77. 77. An Android Storage Access Framework Example
    1. 77.1 About the Storage Access Framework Example
    2. 77.2 Creating the Storage Access Framework Example
    3. 77.3 Designing the User Interface
    4. 77.4 Adding the Activity Launchers
    5. 77.5 Creating a New Storage File
    6. 77.6 Saving to a Storage File
    7. 77.7 Opening and Reading a Storage File
    8. 77.8 Testing the Storage Access Application
    9. 77.9 Summary
  78. 78. Video Playback on Android using the VideoView and MediaController Classes
    1. 78.1 Introducing the Android VideoView Class
    2. 78.2 Introducing the Android MediaController Class
    3. 78.3 Creating the Video Playback Example
    4. 78.4 Designing the VideoPlayer Layout
    5. 78.5 Downloading the Video File
    6. 78.6 Configuring the VideoView
    7. 78.7 Adding the MediaController to the Video View
    8. 78.8 Setting up the onPreparedListener
    9. 78.9 Summary
  79. 79. Android Picture-in-Picture Mode
    1. 79.1 Picture-in-Picture Features
    2. 79.2 Enabling Picture-in-Picture Mode
    3. 79.3 Configuring Picture-in-Picture Parameters
    4. 79.4 Entering Picture-in-Picture Mode
    5. 79.5 Detecting Picture-in-Picture Mode Changes
    6. 79.6 Adding Picture-in-Picture Actions
    7. 79.7 Summary
  80. 80. An Android Picture-in-Picture Tutorial
    1. 80.1 Adding Picture-in-Picture Support to the Manifest
    2. 80.2 Adding a Picture-in-Picture Button
    3. 80.3 Entering Picture-in-Picture Mode
    4. 80.4 Detecting Picture-in-Picture Mode Changes
    5. 80.5 Adding a Broadcast Receiver
    6. 80.6 Adding the PiP Action
    7. 80.7 Testing the Picture-in-Picture Action
    8. 80.8 Summary
  81. 81. Making Runtime Permission Requests in Android
    1. 81.1 Understanding Normal and Dangerous Permissions
    2. 81.2 Creating the Permissions Example Project
    3. 81.3 Checking for a Permission
    4. 81.4 Requesting Permission at Runtime
    5. 81.5 Providing a Rationale for the Permission Request
    6. 81.6 Testing the Permissions App
    7. 81.7 Summary
  82. 82. Android Audio Recording and Playback using MediaPlayer and MediaRecorder
    1. 82.1 Playing Audio
    2. 82.2 Recording Audio and Video using the MediaRecorder Class
    3. 82.3 About the Example Project
    4. 82.4 Creating the AudioApp Project
    5. 82.5 Designing the User Interface
    6. 82.6 Checking for Microphone Availability
    7. 82.7 Initializing the Activity
    8. 82.8 Implementing the recordAudio() Method
    9. 82.9 Implementing the stopAudio() Method
    10. 82.10 Implementing the playAudio() method
    11. 82.11 Configuring and Requesting Permissions
    12. 82.12 Testing the Application
    13. 82.13 Summary
  83. 83. Printing with the Android Printing Framework
    1. 83.1 The Android Printing Architecture
    2. 83.2 The Print Service Plugins
    3. 83.3 Google Cloud Print
    4. 83.4 Printing to Google Drive
    5. 83.5 Save as PDF
    6. 83.6 Printing from Android Devices
    7. 83.7 Options for Building Print Support into Android Apps
      1. 83.7.1 Image Printing
      2. 83.7.2 Creating and Printing HTML Content
      3. 83.7.3 Printing a Web Page
      4. 83.7.4 Printing a Custom Document
    8. 83.8 Summary
  84. 84. An Android HTML and Web Content Printing Example
    1. 84.1 Creating the HTML Printing Example Application
    2. 84.2 Printing Dynamic HTML Content
    3. 84.3 Creating the Web Page Printing Example
    4. 84.4 Removing the Floating Action Button
    5. 84.5 Removing Navigation Features
    6. 84.6 Designing the User Interface Layout
    7. 84.7 Accessing the WebView from the Main Activity
    8. 84.8 Loading the Web Page into the WebView
    9. 84.9 Adding the Print Menu Option
    10. 84.10 Summary
  85. 85. A Guide to Android Custom Document Printing
    1. 85.1 An Overview of Android Custom Document Printing
      1. 85.1.1 Custom Print Adapters
    2. 85.2 Preparing the Custom Document Printing Project
    3. 85.3 Creating the Custom Print Adapter
    4. 85.4 Implementing the onLayout() Callback Method
    5. 85.5 Implementing the onWrite() Callback Method
    6. 85.6 Checking a Page is in Range
    7. 85.7 Drawing the Content on the Page Canvas
    8. 85.8 Starting the Print Job
    9. 85.9 Testing the Application
    10. 85.10 Summary
  86. 86. An Introduction to Android App Links
    1. 86.1 An Overview of Android App Links
    2. 86.2 App Link Intent Filters
    3. 86.3 Handling App Link Intents
    4. 86.4 Associating the App with a Website
    5. 86.5 Summary
  87. 87. An Android Studio App Links Tutorial
    1. 87.1 About the Example App
    2. 87.2 The Database Schema
    3. 87.3 Loading and Running the Project
    4. 87.4 Adding the URL Mapping
    5. 87.5 Adding the Intent Filter
    6. 87.6 Adding Intent Handling Code
    7. 87.7 Testing the App Link
    8. 87.8 Associating an App Link with a Web Site
    9. 87.9 Summary
  88. 88. An Android Biometric Authentication Tutorial
    1. 88.1 An Overview of Biometric Authentication
    2. 88.2 Creating the Biometric Authentication Project
    3. 88.3 Configuring Device Fingerprint Authentication
    4. 88.4 Adding the Biometric Permission to the Manifest File
    5. 88.5 Designing the User Interface
    6. 88.6 Adding a Toast Convenience Method
    7. 88.7 Checking the Security Settings
    8. 88.8 Configuring the Authentication Callbacks
    9. 88.9 Adding the CancellationSignal
    10. 88.10 Starting the Biometric Prompt
    11. 88.11 Testing the Project
    12. 88.12 Summary
  89. 89. Creating, Testing and Uploading an Android App Bundle
    1. 89.1 The Release Preparation Process
    2. 89.2 Android App Bundles
    3. 89.3 Register for a Google Play Developer Console Account
    4. 89.4 Configuring the App in the Console
    5. 89.5 Enabling Google Play App Signing
    6. 89.6 Creating a Keystore File
    7. 89.7 Creating the Android App Bundle
    8. 89.8 Generating Test APK Files
    9. 89.9 Uploading the App Bundle to the Google Play Developer Console
    10. 89.10 Exploring the App Bundle
    11. 89.11 Managing Testers
    12. 89.12 Rolling the App Out for Testing
    13. 89.13 Uploading New App Bundle Revisions
    14. 89.14 Analyzing the App Bundle File
    15. 89.15 Summary
  90. 90. An Overview of Android Dynamic Feature Modules
    1. 90.1 An Overview of Dynamic Feature Modules
    2. 90.2 Dynamic Feature Module Architecture
    3. 90.3 Creating a Dynamic Feature Module
    4. 90.4 Converting an Existing Module for Dynamic Delivery
    5. 90.5 Working with Dynamic Feature Modules
    6. 90.6 Handling Large Dynamic Feature Modules
    7. 90.7 Summary
  91. 91. An Android Studio Dynamic Feature Tutorial
    1. 91.1 Creating the DynamicFeature Project
    2. 91.2 Adding Dynamic Feature Support to the Project
    3. 91.3 Designing the Base Activity User Interface
    4. 91.4 Adding the Dynamic Feature Module
    5. 91.5 Reviewing the Dynamic Feature Module
    6. 91.6 Adding the Dynamic Feature Activity
    7. 91.7 Implementing the launchIntent() Method
    8. 91.8 Uploading the App Bundle for Testing
    9. 91.9 Implementing the installFeature() Method
    10. 91.10 Adding the Update Listener
    11. 91.11 Using Deferred Installation
    12. 91.12 Removing a Dynamic Module
    13. 91.13 Summary
  92. 92. An Overview of Gradle in Android Studio
    1. 92.1 An Overview of Gradle
    2. 92.2 Gradle and Android Studio
      1. 92.2.1 Sensible Defaults
      2. 92.2.2 Dependencies
      3. 92.2.3 Build Variants
      4. 92.2.4 Manifest Entries
      5. 92.2.5 APK Signing
      6. 92.2.6 ProGuard Support
    3. 92.3 The Top-level Gradle Build File
    4. 92.4 Module Level Gradle Build Files
    5. 92.5 Configuring Signing Settings in the Build File
    6. 92.6 Running Gradle Tasks from the Command-line
    7. 92.7 Summary
  93. Index

Product information

  • Title: Android Studio Arctic Fox Essentials - Kotlin Edition
  • Author(s): Neil Smyth
  • Release date: October 2021
  • Publisher(s): Packt Publishing
  • ISBN: 9781803247458