Android Studio 3.6 Development Essentials - Kotlin Edition

Android Studio 3.6 Development Essentials - Kotlin Edition

by Neil Smyth
Released April 2020
Publisher(s): Packt Publishing
ISBN: 9781800567665

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

Update your Android Studio skills and build modern Android applications using Kotlin

Key Features

  • Set up Android development and testing environments
  • Gain core knowledge of the Kotlin programming language
  • Study the design of Android applications and its user interfaces in-depth

Book Description

The popularity of Kotlin as an Android-compatible language keeps growing every day. This book will help you build your own Android applications using Kotlin.

Android Studio 3.6 Development Essentials – Kotlin Edition first shows you how to install Android development and test environments on different operating systems. Next, you will create an Android app and a virtual device in Android Studio and install an Android application on an emulator. You will test apps on emulators and on physical Android devices. Next, you'll explore the features of Android Studio 3.6, Android 10, and Android architecture. The focus then shifts to the Kotlin language. You'll be given an overview of Kotlin, and practice converting code from Java to Kotlin. You'll also explore data types, operators, expressions, loops, functions, and the basics of OOP in Kotlin. The book will then cover Android Jetpack and how to create an example app project using the ViewModel component. You'll study advanced topics such as views and widget implementation, multi-window support integration, and biometric authentication. Finally, you will learn to upload your app to the Google Play Console and handle the build process with Gradle.

By the end of this book, you will have gained the knowledge and skills required to develop powerful Android applications using Kotlin.

What you will learn

  • Build reliable apps with less error-prone code using Kotlin
  • Use Java-based Android libraries in Kotlin
  • Reduce the amount of code using Android Jetpack
  • Explore unique ways to handle single and multi-touch events
  • Use Gesture libraries to implement gesture and pinch recognition systems
  • Increase your app visibility with app links

Who this book is for

This book is ideal for anyone who wants to learn how to develop powerful Android Applications using Kotlin and Android Studio 3.6. A basic understanding of Kotlin and Android SDK is recommended.

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 Interaction
    9. 3.9 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 Stopping a Running Application
    6. 4.6 Supporting Dark Theme
    7. 4.7 AVD Command-line Creation
    8. 4.8 Android Virtual Device Configuration Files
    9. 4.9 Moving and Renaming an Android Virtual Device
    10. 4.10 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 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 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 By View 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 Converting Views
    10. 24.10 Displaying Sample Data
    11. 24.11 Creating a Custom Device Definition
    12. 24.12 Changing the Current Device
    13. 24.13 Multi Preview
    14. 24.14 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 Working with Guidelines
    4. 25.4 Configuring Widget Dimensions
    5. 25.5 Working with Barriers
    6. 25.6 Ratios
    7. 25.7 ConstraintLayout Advantages
    8. 25.8 ConstraintLayout Availability
    9. 25.9 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 Adding Guidelines
    13. 26.13 Adding Barriers
    14. 26.14 Widget Group Alignment and Distribution
    15. 26.15 Converting other Layouts to ConstraintLayout
    16. 26.16 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 Creating the First Fragment Class
    5. 38.5 Creating the Second Fragment Layout
    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 Triggering the Action
    10. 48.10 Passing Data Using Safeargs
    11. 48.11 Summary
  49. 49. Creating and Managing Overflow Menus on Android
    1. 49.1 The Overflow Menu
    2. 49.2 Creating an Overflow Menu
    3. 49.3 Displaying an Overflow Menu
    4. 49.4 Responding to Menu Item Selections
    5. 49.5 Creating Checkable Item Groups
    6. 49.6 Menus and the Android Studio Menu Editor
    7. 49.7 Creating the Example Project
    8. 49.8 Designing the Menu
    9. 49.9 Modifying the onOptionsItemSelected() Method
    10. 49.10 Testing the Application
    11. 49.11 Summary
  50. 50. Animating User Interfaces with the Android Transitions Framework
    1. 50.1 Introducing Android Transitions and Scenes
    2. 50.2 Using Interpolators with Transitions
    3. 50.3 Working with Scene Transitions
    4. 50.4 Custom Transitions and TransitionSets in Code
    5. 50.5 Custom Transitions and TransitionSets in XML
    6. 50.6 Working with Interpolators
    7. 50.7 Creating a Custom Interpolator
    8. 50.8 Using the beginDelayedTransition Method
    9. 50.9 Summary
  51. 51. An Android Transition Tutorial using beginDelayedTransition
    1. 51.1 Creating the Android Studio TransitionDemo Project
    2. 51.2 Preparing the Project Files
    3. 51.3 Implementing beginDelayedTransition Animation
    4. 51.4 Customizing the Transition
    5. 51.5 Summary
  52. 52. Implementing Android Scene Transitions – A Tutorial
    1. 52.1 An Overview of the Scene Transition Project
    2. 52.2 Creating the Android Studio SceneTransitions Project
    3. 52.3 Identifying and Preparing the Root Container
    4. 52.4 Designing the First Scene
    5. 52.5 Designing the Second Scene
    6. 52.6 Entering the First Scene
    7. 52.7 Loading Scene 2
    8. 52.8 Implementing the Transitions
    9. 52.9 Adding the Transition File
    10. 52.10 Loading and Using the Transition Set
    11. 52.11 Configuring Additional Transitions
    12. 52.12 Summary
  53. 53. Working with the Floating Action Button and Snackbar
    1. 53.1 The Material Design
    2. 53.2 The Design Library
    3. 53.3 The Floating Action Button (FAB)
    4. 53.4 The Snackbar
    5. 53.5 Creating the Example Project
    6. 53.6 Reviewing the Project
    7. 53.7 Removing Navigation Features
    8. 53.8 Changing the Floating Action Button
    9. 53.9 Adding the ListView to the Content Layout
    10. 53.10 Adding Items to the ListView
    11. 53.11 Adding an Action to the Snackbar
    12. 53.12 Summary
  54. 54. Creating a Tabbed Interface using the TabLayout Component
    1. 54.1 An Introduction to the ViewPager
    2. 54.2 An Overview of the TabLayout Component
    3. 54.3 Creating the TabLayoutDemo Project
    4. 54.4 Creating the First Fragment
    5. 54.5 Duplicating the Fragments
    6. 54.6 Adding the TabLayout and ViewPager
    7. 54.7 Creating the Pager Adapter
    8. 54.8 Performing the Initialization Tasks
    9. 54.9 Testing the Application
    10. 54.10 Customizing the TabLayout
    11. 54.11 Displaying Icon Tab Items
    12. 54.12 Summary
  55. 55. Working with the RecyclerView and CardView Widgets
    1. 55.1 An Overview of the RecyclerView
    2. 55.2 An Overview of the CardView
    3. 55.3 Summary
  56. 56. An Android RecyclerView and CardView Tutorial
    1. 56.1 Creating the CardDemo Project
    2. 56.2 Modifying the Basic Activity Project
    3. 56.3 Designing the CardView Layout
    4. 56.4 Adding the RecyclerView
    5. 56.5 Creating the RecyclerView Adapter
    6. 56.6 Adding the Image Files
    7. 56.7 Initializing the RecyclerView Component
    8. 56.8 Testing the Application
    9. 56.9 Responding to Card Selections
    10. 56.10 Summary
  57. 57. A Layout Editor Sample Data Tutorial
    1. 57.1 Adding Sample Data to a Project
    2. 57.2 Using Custom Sample Data
    3. 57.3 Summary
  58. 58. Working with the AppBar and Collapsing Toolbar Layouts
    1. 58.1 The Anatomy of an AppBar
    2. 58.2 The Example Project
    3. 58.3 Coordinating the RecyclerView and Toolbar
    4. 58.4 Introducing the Collapsing Toolbar Layout
    5. 58.5 Changing the Title and Scrim Color
    6. 58.6 Summary
  59. 59. An Android Studio Master/Detail Flow Tutorial
    1. 59.1 The Master/Detail Flow
    2. 59.2 Creating a Master/Detail Flow Activity
    3. 59.3 The Anatomy of the Master/Detail Flow Template
    4. 59.4 Modifying the Master/Detail Flow Template
    5. 59.5 Changing the Content Model
    6. 59.6 Changing the Detail Pane
    7. 59.7 Modifying the WebsiteDetailFragment Class
    8. 59.8 Modifying the WebsiteListActivity Class
    9. 59.9 Adding Manifest Permissions
    10. 59.10 Running the Application
    11. 59.11 Summary
  60. 60. An Overview of Android Intents
    1. 60.1 An Overview of Intents
    2. 60.2 Explicit Intents
    3. 60.3 Returning Data from an Activity
    4. 60.4 Implicit Intents
    5. 60.5 Using Intent Filters
    6. 60.6 Checking Intent Availability
    7. 60.7 Summary
  61. 61. Android Explicit Intents – A Worked Example
    1. 61.1 Creating the Explicit Intent Example Application
    2. 61.2 Designing the User Interface Layout for MainActivity
    3. 61.3 Creating the Second Activity Class
    4. 61.4 Designing the User Interface Layout for ActivityB
    5. 61.5 Reviewing the Application Manifest File
    6. 61.6 Creating the Intent
    7. 61.7 Extracting Intent Data
    8. 61.8 Launching ActivityB as a Sub-Activity
    9. 61.9 Returning Data from a Sub-Activity
    10. 61.10 Testing the Application
    11. 61.11 Summary
  62. 62. Android Implicit Intents – A Worked Example
    1. 62.1 Creating the Android Studio Implicit Intent Example Project
    2. 62.2 Designing the User Interface
    3. 62.3 Creating the Implicit Intent
    4. 62.4 Adding a Second Matching Activity
    5. 62.5 Adding the Web View to the UI
    6. 62.6 Obtaining the Intent URL
    7. 62.7 Modifying the MyWebView Project Manifest File
    8. 62.8 Installing the MyWebView Package on a Device
    9. 62.9 Testing the Application
    10. 62.10 Summary
  63. 63. Android Broadcast Intents and Broadcast Receivers
    1. 63.1 An Overview of Broadcast Intents
    2. 63.2 An Overview of Broadcast Receivers
    3. 63.3 Obtaining Results from a Broadcast
    4. 63.4 Sticky Broadcast Intents
    5. 63.5 The Broadcast Intent Example
    6. 63.6 Creating the Example Application
    7. 63.7 Creating and Sending the Broadcast Intent
    8. 63.8 Creating the Broadcast Receiver
    9. 63.9 Registering the Broadcast Receiver
    10. 63.10 Testing the Broadcast Example
    11. 63.11 Listening for System Broadcasts
    12. 63.12 Summary
  64. 64. A Basic Overview of Threads and AsyncTasks
    1. 64.1 An Overview of Threads
    2. 64.2 The Application Main Thread
    3. 64.3 Thread Handlers
    4. 64.4 A Basic AsyncTask Example
    5. 64.5 Subclassing AsyncTask
    6. 64.6 Testing the App
    7. 64.7 Canceling a Task
    8. 64.8 Summary
  65. 65. An Introduction to Kotlin Coroutines
    1. 65.1 What are Coroutines?
    2. 65.2 Threads vs Coroutines
    3. 65.3 Coroutine Scope
    4. 65.4 Suspend Functions
    5. 65.5 Coroutine Dispatchers
    6. 65.6 Coroutine Builders
    7. 65.7 Jobs
    8. 65.8 Coroutines – Suspending and Resuming
    9. 65.9 Returning Results from a Coroutine
    10. 65.10 Using withContext
    11. 65.11 Coroutine Channel Communication
    12. 65.12 Summary
  66. 66. An Android Kotlin Coroutines Tutorial
    1. 66.1 Creating the Coroutine Example Application
    2. 66.2 Adding Coroutine Support to the Project
    3. 66.3 Designing the User Interface
    4. 66.4 Implementing the SeekBar
    5. 66.5 Adding the Suspend Function
    6. 66.6 Implementing the launchCoroutines Method
    7. 66.7 Testing the App
    8. 66.8 Summary
  67. 67. An Overview of Android Started and Bound Services
    1. 67.1 Started Services
    2. 67.2 Intent Service
    3. 67.3 Bound Service
    4. 67.4 The Anatomy of a Service
    5. 67.5 Controlling Destroyed Service Restart Options
    6. 67.6 Declaring a Service in the Manifest File
    7. 67.7 Starting a Service Running on System Startup
    8. 67.8 Summary
  68. 68. Implementing an Android Started Service – A Worked Example
    1. 68.1 Creating the Example Project
    2. 68.2 Creating the Service Class
    3. 68.3 Adding the Service to the Manifest File
    4. 68.4 Starting the Service
    5. 68.5 Testing the IntentService Example
    6. 68.6 Using the Service Class
    7. 68.7 Creating the New Service
    8. 68.8 Modifying the User Interface
    9. 68.9 Running the Application
    10. 68.10 Using a Coroutine for the Service Task
    11. 68.11 Summary
  69. 69. Android Local Bound Services – A Worked Example
    1. 69.1 Understanding Bound Services
    2. 69.2 Bound Service Interaction Options
    3. 69.3 An Android Studio Local Bound Service Example
    4. 69.4 Adding a Bound Service to the Project
    5. 69.5 Implementing the Binder
    6. 69.6 Binding the Client to the Service
    7. 69.7 Completing the Example
    8. 69.8 Testing the Application
    9. 69.9 Summary
  70. 70. Android Remote Bound Services – A Worked Example
    1. 70.1 Client to Remote Service Communication
    2. 70.2 Creating the Example Application
    3. 70.3 Designing the User Interface
    4. 70.4 Implementing the Remote Bound Service
    5. 70.5 Configuring a Remote Service in the Manifest File
    6. 70.6 Launching and Binding to the Remote Service
    7. 70.7 Sending a Message to the Remote Service
    8. 70.8 Summary
  71. 71. An Android Notifications Tutorial
    1. 71.1 An Overview of Notifications
    2. 71.2 Creating the NotifyDemo Project
    3. 71.3 Designing the User Interface
    4. 71.4 Creating the Second Activity
    5. 71.5 Creating a Notification Channel
    6. 71.6 Creating and Issuing a Basic Notification
    7. 71.7 Launching an Activity from a Notification
    8. 71.8 Adding Actions to a Notification
    9. 71.9 Bundled Notifications
    10. 71.10 Summary
  72. 72. An Android Direct Reply Notification Tutorial
    1. 72.1 Creating the DirectReply Project
    2. 72.2 Designing the User Interface
    3. 72.3 Creating the Notification Channel
    4. 72.4 Building the RemoteInput Object
    5. 72.5 Creating the PendingIntent
    6. 72.6 Creating the Reply Action
    7. 72.7 Receiving Direct Reply Input
    8. 72.8 Updating the Notification
    9. 72.9 Summary
  73. 73. Foldable Devices and Multi-Window Support
    1. 73.1 Foldables and Multi-Window Support
    2. 73.2 Using a Foldable Emulator
    3. 73.3 Entering Multi-Window Mode
    4. 73.4 Enabling and using Freeform Support
    5. 73.5 Checking for Freeform Support
    6. 73.6 Enabling Multi-Window Support in an App
    7. 73.7 Specifying Multi-Window Attributes
    8. 73.8 Detecting Multi-Window Mode in an Activity
    9. 73.9 Receiving Multi-Window Notifications
    10. 73.10 Launching an Activity in Multi-Window Mode
    11. 73.11 Configuring Freeform Activity Size and Position
    12. 73.12 Summary
  74. 74. An Overview of Android SQLite Databases
    1. 74.1 Understanding Database Tables
    2. 74.2 Introducing Database Schema
    3. 74.3 Columns and Data Types
    4. 74.4 Database Rows
    5. 74.5 Introducing Primary Keys
    6. 74.6 What is SQLite?
    7. 74.7 Structured Query Language (SQL)
    8. 74.8 Trying SQLite on an Android Virtual Device (AVD)
    9. 74.9 The Android Room Persistence Library
    10. 74.10 Summary
  75. 75. The Android Room Persistence Library
    1. 75.1 Revisiting Modern App Architecture
    2. 75.2 Key Elements of Room Database Persistence
      1. 75.2.1 Repository
      2. 75.2.2 Room Database
      3. 75.2.3 Data Access Object (DAO)
      4. 75.2.4 Entities
      5. 75.2.5 SQLite Database
    3. 75.3 Understanding Entities
    4. 75.4 Data Access Objects
    5. 75.5 The Room Database
    6. 75.6 The Repository
    7. 75.7 In-Memory Databases
    8. 75.8 Summary
  76. 76. An Android TableLayout and TableRow Tutorial
    1. 76.1 The TableLayout and TableRow Layout Views
    2. 76.2 Creating the Room Database Project
    3. 76.3 Converting to a LinearLayout
    4. 76.4 Adding the TableLayout to the User Interface
    5. 76.5 Configuring the TableRows
    6. 76.6 Adding the Button Bar to the Layout
    7. 76.7 Adding the RecyclerView
    8. 76.8 Adjusting the Layout Margins
    9. 76.9 Summary
  77. 77. An Android Room Database and Repository Tutorial
    1. 77.1 About the RoomDemo Project
    2. 77.2 Modifying the Build Configuration
    3. 77.3 Building the Entity
    4. 77.4 Creating the Data Access Object
    5. 77.5 Adding the Room Database
    6. 77.6 Adding the Repository
    7. 77.7 Modifying the ViewModel
    8. 77.8 Creating the Product Item Layout
    9. 77.9 Adding the RecyclerView Adapter
    10. 77.10 Preparing the Main Fragment
    11. 77.11 Adding the Button Listeners
    12. 77.12 Adding LiveData Observers
    13. 77.13 Initializing the RecyclerView
    14. 77.14 Testing the RoomDemo App
    15. 77.15 Summary
  78. 78. Accessing Cloud Storage using the Android Storage Access Framework
    1. 78.1 The Storage Access Framework
    2. 78.2 Working with the Storage Access Framework
    3. 78.3 Filtering Picker File Listings
    4. 78.4 Handling Intent Results
    5. 78.5 Reading the Content of a File
    6. 78.6 Writing Content to a File
    7. 78.7 Deleting a File
    8. 78.8 Gaining Persistent Access to a File
    9. 78.9 Summary
  79. 79. An Android Storage Access Framework Example
    1. 79.1 About the Storage Access Framework Example
    2. 79.2 Creating the Storage Access Framework Example
    3. 79.3 Designing the User Interface
    4. 79.4 Declaring Request Codes
    5. 79.5 Creating a New Storage File
    6. 79.6 The onActivityResult() Method
    7. 79.7 Saving to a Storage File
    8. 79.8 Opening and Reading a Storage File
    9. 79.9 Testing the Storage Access Application
    10. 79.10 Summary
  80. 80. Implementing Video Playback on Android using the VideoView and MediaController Classes
    1. 80.1 Introducing the Android VideoView Class
    2. 80.2 Introducing the Android MediaController Class
    3. 80.3 Creating the Video Playback Example
    4. 80.4 Designing the VideoPlayer Layout
    5. 80.5 Downloading the Video File
    6. 80.6 Configuring the VideoView
    7. 80.7 Adding the MediaController to the Video View
    8. 80.8 Setting up the onPreparedListener
    9. 80.9 Summary
  81. 81. Android Picture-in-Picture Mode
    1. 81.1 Picture-in-Picture Features
    2. 81.2 Enabling Picture-in-Picture Mode
    3. 81.3 Configuring Picture-in-Picture Parameters
    4. 81.4 Entering Picture-in-Picture Mode
    5. 81.5 Detecting Picture-in-Picture Mode Changes
    6. 81.6 Adding Picture-in-Picture Actions
    7. 81.7 Summary
  82. 82. An Android Picture-in-Picture Tutorial
    1. 82.1 Adding Picture-in-Picture Support to the Manifest
    2. 82.2 Adding a Picture-in-Picture Button
    3. 82.3 Entering Picture-in-Picture Mode
    4. 82.4 Detecting Picture-in-Picture Mode Changes
    5. 82.5 Adding a Broadcast Receiver
    6. 82.6 Adding the PiP Action
    7. 82.7 Testing the Picture-in-Picture Action
    8. 82.8 Summary
  83. 83. Making Runtime Permission Requests in Android
    1. 83.1 Understanding Normal and Dangerous Permissions
    2. 83.2 Creating the Permissions Example Project
    3. 83.3 Checking for a Permission
    4. 83.4 Requesting Permission at Runtime
    5. 83.5 Providing a Rationale for the Permission Request
    6. 83.6 Testing the Permissions App
    7. 83.7 Summary
  84. 84. Android Audio Recording and Playback using MediaPlayer and MediaRecorder
    1. 84.1 Playing Audio
    2. 84.2 Recording Audio and Video using the MediaRecorder Class
    3. 84.3 About the Example Project
    4. 84.4 Creating the AudioApp Project
    5. 84.5 Designing the User Interface
    6. 84.6 Checking for Microphone Availability
    7. 84.7 Performing the Activity Initialization
    8. 84.8 Implementing the recordAudio() Method
    9. 84.9 Implementing the stopAudio() Method
    10. 84.10 Implementing the playAudio() method
    11. 84.11 Configuring and Requesting Permissions
    12. 84.12 Testing the Application
    13. 84.13 Summary
  85. 85. Working with the Google Maps Android API in Android Studio
    1. 85.1 The Elements of the Google Maps Android API
    2. 85.2 Creating the Google Maps Project
    3. 85.3 Obtaining Your Developer Signature
    4. 85.4 Adding the Apache HTTP Legacy Library Requirement
    5. 85.5 Testing the Application
    6. 85.6 Understanding Geocoding and Reverse Geocoding
    7. 85.7 Adding a Map to an Application
    8. 85.8 Requesting Current Location Permission
    9. 85.9 Displaying the User’s Current Location
    10. 85.10 Changing the Map Type
    11. 85.11 Displaying Map Controls to the User
    12. 85.12 Handling Map Gesture Interaction
      1. 85.12.1 Map Zooming Gestures
      2. 85.12.2 Map Scrolling/Panning Gestures
      3. 85.12.3 Map Tilt Gestures
      4. 85.12.4 Map Rotation Gestures
    13. 85.13 Creating Map Markers
    14. 85.14 Controlling the Map Camera
    15. 85.15 Summary
  86. 86. Printing with the Android Printing Framework
    1. 86.1 The Android Printing Architecture
    2. 86.2 The Print Service Plugins
    3. 86.3 Google Cloud Print
    4. 86.4 Printing to Google Drive
    5. 86.5 Save as PDF
    6. 86.6 Printing from Android Devices
    7. 86.7 Options for Building Print Support into Android Apps
      1. 86.7.1 Image Printing
      2. 86.7.2 Creating and Printing HTML Content
      3. 86.7.3 Printing a Web Page
      4. 86.7.4 Printing a Custom Document
    8. 86.8 Summary
  87. 87. An Android HTML and Web Content Printing Example
    1. 87.1 Creating the HTML Printing Example Application
    2. 87.2 Printing Dynamic HTML Content
    3. 87.3 Creating the Web Page Printing Example
    4. 87.4 Removing the Floating Action Button
    5. 87.5 Removing Navigation Features
    6. 87.6 Designing the User Interface Layout
    7. 87.7 Loading the Web Page into the WebView
    8. 87.8 Adding the Print Menu Option
    9. 87.9 Summary
  88. 88. A Guide to Android Custom Document Printing
    1. 88.1 An Overview of Android Custom Document Printing
      1. 88.1.1 Custom Print Adapters
    2. 88.2 Preparing the Custom Document Printing Project
    3. 88.3 Creating the Custom Print Adapter
    4. 88.4 Implementing the onLayout() Callback Method
    5. 88.5 Implementing the onWrite() Callback Method
    6. 88.6 Checking a Page is in Range
    7. 88.7 Drawing the Content on the Page Canvas
    8. 88.8 Starting the Print Job
    9. 88.9 Testing the Application
    10. 88.10 Summary
  89. 89. An Introduction to Android App Links
    1. 89.1 An Overview of Android App Links
    2. 89.2 App Link Intent Filters
    3. 89.3 Handling App Link Intents
    4. 89.4 Associating the App with a Website
    5. 89.5 Summary
  90. 90. An Android Studio App Links Tutorial
    1. 90.1 About the Example App
    2. 90.2 The Database Schema
    3. 90.3 Loading and Running the Project
    4. 90.4 Adding the URL Mapping
    5. 90.5 Adding the Intent Filter
    6. 90.6 Adding Intent Handling Code
    7. 90.7 Testing the App Link
    8. 90.8 Associating an App Link with a Web Site
    9. 90.9 Summary
  91. 91. A Guide to the Android Studio Profiler
    1. 91.1 Accessing the Android Profiler
    2. 91.2 Enabling Advanced Profiling
    3. 91.3 The Android Profiler Tool Window
    4. 91.4 The Sessions Panel
    5. 91.5 The CPU Profiler
    6. 91.6 Memory Profiler
    7. 91.7 Network Profiler
    8. 91.8 Energy Profiler
    9. 91.9 Summary
  92. 92. An Android Biometric Authentication Tutorial
    1. 92.1 An Overview of Biometric Authentication
    2. 92.2 Creating the Biometric Authentication Project
    3. 92.3 Configuring Device Fingerprint Authentication
    4. 92.4 Adding the Biometric Permission to the Manifest File
    5. 92.5 Designing the User Interface
    6. 92.6 Adding a Toast Convenience Method
    7. 92.7 Checking the Security Settings
    8. 92.8 Configuring the Authentication Callbacks
    9. 92.9 Adding the CancellationSignal
    10. 92.10 Starting the Biometric Prompt
    11. 92.11 Testing the Project
    12. 92.12 Summary
  93. 93. Creating, Testing and Uploading an Android App Bundle
    1. 93.1 The Release Preparation Process
    2. 93.2 Android App Bundles
    3. 93.3 Register for a Google Play Developer Console Account
    4. 93.4 Configuring the App in the Console
    5. 93.5 Enabling Google Play App Signing
    6. 93.6 Creating a Keystore File
    7. 93.7 Creating the Android App Bundle
    8. 93.8 Generating Test APK Files
    9. 93.9 Uploading the App Bundle to the Google Play Developer Console
    10. 93.10 Exploring the App Bundle
    11. 93.11 Managing Testers
    12. 93.12 Uploading New App Bundle Revisions
    13. 93.13 Analyzing the App Bundle File
    14. 93.14 Enabling Google Play Signing for an Existing App
    15. 93.15 Summary
  94. 94. An Overview of Android Dynamic Feature Modules
    1. 94.1 An Overview of Dynamic Feature Modules
    2. 94.2 Dynamic Feature Module Architecture
    3. 94.3 Creating a Dynamic Feature Module
    4. 94.4 Converting an Existing Module for Dynamic Delivery
    5. 94.5 Working with Dynamic Feature Modules
    6. 94.6 Handling Large Dynamic Feature Modules
    7. 94.7 Summary
  95. 95. An Android Studio Dynamic Feature Tutorial
    1. 95.1 Creating the DynamicFeature Project
    2. 95.2 Adding Dynamic Feature Support to the Project
    3. 95.3 Designing the Base Activity User Interface
    4. 95.4 Adding the Dynamic Feature Module
    5. 95.5 Reviewing the Dynamic Feature Module
    6. 95.6 Adding the Dynamic Feature Activity
    7. 95.7 Implementing the launchIntent() Method
    8. 95.8 Uploading the App Bundle for Testing
    9. 95.9 Implementing the installFeature() Method
    10. 95.10 Adding the Update Listener
    11. 95.11 Handling Large Downloads
    12. 95.12 Using Deferred Installation
    13. 95.13 Removing a Dynamic Module
    14. 95.14 Summary
  96. 96. An Overview of Gradle in Android Studio
    1. 96.1 An Overview of Gradle
    2. 96.2 Gradle and Android Studio
      1. 96.2.1 Sensible Defaults
      2. 96.2.2 Dependencies
      3. 96.2.3 Build Variants
      4. 96.2.4 Manifest Entries
      5. 96.2.5 APK Signing
      6. 96.2.6 ProGuard Support
    3. 96.3 The Top-level Gradle Build File
    4. 96.4 Module Level Gradle Build Files
    5. 96.5 Configuring Signing Settings in the Build File
    6. 96.6 Running Gradle Tasks from the Command-line
    7. 96.7 Summary
  97. Index

Product information

  • Title: Android Studio 3.6 Development Essentials - Kotlin Edition
  • Author(s): Neil Smyth
  • Release date: April 2020
  • Publisher(s): Packt Publishing
  • ISBN: 9781800567665