Book Image

Android Studio 4.0 Development Essentials - Kotlin Edition

By : Neil Smyth
Book Image

Android Studio 4.0 Development Essentials - Kotlin Edition

By: Neil Smyth

Overview of this book

Kotlin as an Android-compatible programming language is becoming increasingly popular. Fully updated for Android Studio 4.0, this book will teach you the skills necessary to develop Android-based applications using Kotlin. Starting with the basics, this book outlines the steps necessary to set up Android development and testing environments, and goes on to introduce you to programming in Kotlin. You’ll practice Java to Kotlin code conversion and explore data types, operators, expressions, loops, functions, as well as the basics of OOP in Kotlin. You’ll then learn about Android architecture components and advanced topics, such as intents, touchscreen handling, gesture recognition, multi-window support integration, and biometric authentication. As you make progress, you’ll explore Android Studio 4.0’s key features, including layout editor, direct reply notifications, and dynamic delivery. You’ll also delve into Android Jetpack and create a sample app project using ViewModel, the Android Jetpack component. Finally, you will upload your app to Google Play Console and model the build process using Gradle. By the end of this Android book, you’ll be fully prepared to develop applications using Android Studio 4.0 and Kotlin.

Related Content you might be interested in

Current Title:

Small book image
Android Studio 4.0 Development Essentials - Kotlin Edition
Neil Smyth
Oct, 2020 | 817 pages
Small book image
SwiftUI Essentials – iOS 14 Edition
Neil Smyth
May, 2021 | 494 pages
Small book image
How to Build Android Apps with Kotlin
Alex Forrester | Alexandru Dumbravan | Eran Boudjnah | Jomar Tigcal
May, 2023 | 704 pages
Small book image
Mastering Android Development with Kotlin
Miloš Vasić
Nov, 2017 | 378 pages
Table of Contents (97 chapters)
1
1. Introduction
1. Introduction
1.1 Downloading the Code Samples
1.2 Feedback
1.3 Errata
Free Chapter
2
2. Setting up an Android Studio Development Environment
2. Setting up an Android Studio Development Environment
2.1 System Requirements
2.2 Downloading the Android Studio Package
2.3 Installing Android Studio
2.4 The Android Studio Setup Wizard
2.5 Installing Additional Android SDK Packages
2.6 Making the Android SDK Tools Command-line Accessible
2.7 Android Studio Memory Management
2.8 Updating Android Studio and the SDK
2.9 Summary
3
3. Creating an Example Android App in Android Studio
3. Creating an Example Android App in Android Studio
3.1 About the Project
3.2 Creating a New Android Project
3.3 Creating an Activity
3.4 Defining the Project and SDK Settings
3.5 Modifying the Example Application
3.6 Modifying the User Interface
3.7 Reviewing the Layout and Resource Files
3.8 Adding Interaction
3.9 Summary
4
4. Creating an Android Virtual Device (AVD) in Android Studio
4. Creating an Android Virtual Device (AVD) in Android Studio
4.1 About Android Virtual Devices
4.2 Creating a New AVD
4.3 Starting the Emulator
4.4 Running the Application in the AVD
4.5 Stopping a Running Application
4.6 Supporting Dark Theme
4.7 AVD Command-line Creation
4.8 Android Virtual Device Configuration Files
4.9 Moving and Renaming an Android Virtual Device
4.10 Summary
5
5. Using and Configuring the Android Studio AVD Emulator
5. Using and Configuring the Android Studio AVD Emulator
5.1 The Emulator Environment
5.2 The Emulator Toolbar Options
5.3 Working in Zoom Mode
5.4 Resizing the Emulator Window
5.5 Extended Control Options
5.6 Working with Snapshots
5.7 Configuring Fingerprint Emulation
5.8 Summary
6
6. A Tour of the Android Studio User Interface
6. A Tour of the Android Studio User Interface
6.1 The Welcome Screen
6.2 The Main Window
6.3 The Tool Windows
6.4 Android Studio Keyboard Shortcuts
6.5 Switcher and Recent Files Navigation
6.6 Changing the Android Studio Theme
6.7 Summary
7
7. Testing Android Studio Apps on a Physical Android Device
7. Testing Android Studio Apps on a Physical Android Device
7.1 An Overview of the Android Debug Bridge (ADB)
7.2 Enabling ADB on Android based Devices
7.3 Testing the adb Connection
7.4 Summary
8
8. The Basics of the Android Studio Code Editor
8. The Basics of the Android Studio Code Editor
8.1 The Android Studio Editor
8.2 Splitting the Editor Window
8.3 Code Completion
8.4 Statement Completion
8.5 Parameter Information
8.6 Parameter Name Hints
8.7 Code Generation
8.8 Code Folding
8.9 Quick Documentation Lookup
8.10 Code Reformatting
8.11 Finding Sample Code
8.12 Live Templates
8.13 Summary
9
9. An Overview of the Android Architecture
9. An Overview of the Android Architecture
9.1 The Android Software Stack
9.2 The Linux Kernel
9.3 Android Runtime – ART
9.4 Android Libraries
9.5 Application Framework
9.6 Applications
9.7 Summary
10
10. The Anatomy of an Android Application
10. The Anatomy of an Android Application
10.1 Android Activities
10.2 Android Fragments
10.3 Android Intents
10.4 Broadcast Intents
10.5 Broadcast Receivers
10.6 Android Services
10.7 Content Providers
10.8 The Application Manifest
10.9 Application Resources
10.10 Application Context
10.11 Summary
11
11. An Introduction to Kotlin
11. An Introduction to Kotlin
11.1 What is Kotlin?
11.2 Kotlin and Java
11.3 Converting from Java to Kotlin
11.4 Kotlin and Android Studio
11.5 Experimenting with Kotlin
11.6 Semi-colons in Kotlin
11.7 Summary
12
12. Kotlin Data Types,Variables and Nullability
12. Kotlin Data Types,Variables and Nullability
12.1 Kotlin Data Types
12.2 Mutable Variables
12.3 Immutable Variables
12.4 Declaring Mutable and Immutable Variables
12.5 Data Types are Objects
12.6 Type Annotations and Type Inference
12.7 Nullable Type
12.8 The Safe Call Operator
12.9 Not-Null Assertion
12.10 Nullable Types and the let Function
12.11 Late Initialization (lateinit)
12.12 The Elvis Operator
12.13 Type Casting and Type Checking
12.14 Summary
13
13. Kotlin Operators and Expressions
13. Kotlin Operators and Expressions
13.1 Expression Syntax in Kotlin
13.2 The Basic Assignment Operator
13.3 Kotlin Arithmetic Operators
13.4 Augmented Assignment Operators
13.5 Increment and Decrement Operators
13.6 Equality Operators
13.7 Boolean Logical Operators
13.8 Range Operator
13.9 Bitwise Operators
13.10 Summary
14
14. Kotlin Flow Control
14. Kotlin Flow Control
14.1 Looping Flow Control
14.2 Conditional Flow Control
14.3 Summary
15
15. An Overview of Kotlin Functions and Lambdas
15. An Overview of Kotlin Functions and Lambdas
15.1 What is a Function?
15.2 How to Declare a Kotlin Function
15.3 Calling a Kotlin Function
15.4 Single Expression Functions
15.5 Local Functions
15.6 Handling Return Values
15.7 Declaring Default Function Parameters
15.8 Variable Number of Function Parameters
15.9 Lambda Expressions
15.10 Higher-order Functions
15.11 Summary
16
16. The Basics of Object Oriented Programming in Kotlin
16. The Basics of Object Oriented Programming in Kotlin
16.1 What is an Object?
16.2 What is a Class?
16.3 Declaring a Kotlin Class
16.4 Adding Properties to a Class
16.5 Defining Methods
16.6 Declaring and Initializing a Class Instance
16.7 Primary and Secondary Constructors
16.8 Initializer Blocks
16.9 Calling Methods and Accessing Properties
16.10 Custom Accessors
16.11 Nested and Inner Classes
16.12 Companion Objects
16.13 Summary
17
17. An Introduction to Kotlin Inheritance and Subclassing
17. An Introduction to Kotlin Inheritance and Subclassing
17.1 Inheritance, Classes and Subclasses
17.2 Subclassing Syntax
17.3 A Kotlin Inheritance Example
17.4 Extending the Functionality of a Subclass
17.5 Overriding Inherited Methods
17.6 Adding a Custom Secondary Constructor
17.7 Using the SavingsAccount Class
17.8 Summary
18
18. An Overview of Android View Binding
18. An Overview of Android View Binding
18.1 Find View by ID and Synthetic Properties
18.2 View Bindings
18.3 Converting the AndroidSample Project
18.4 Enabling View Binding
18.5 Using View Bindings
18.6 Choosing an Option
18.7 Summary
19
19. Understanding Android Application and Activity Lifecycles
19. Understanding Android Application and Activity Lifecycles
19.1 Android Applications and Resource Management
19.2 Android Process States
19.3 Inter-Process Dependencies
19.4 The Activity Lifecycle
19.5 The Activity Stack
19.6 Activity States
19.7 Configuration Changes
19.8 Handling State Change
19.9 Summary
20
20. Handling Android Activity State Changes
20. Handling Android Activity State Changes
20.1 New vs. Old Lifecycle Techniques
20.2 The Activity and Fragment Classes
20.3 Dynamic State vs. Persistent State
20.4 The Android Lifecycle Methods
20.5 Lifetimes
20.6 Foldable Devices and Multi-Resume
20.7 Disabling Configuration Change Restarts
20.8 Lifecycle Method Limitations
20.9 Summary
21
21. Android Activity State Changes by Example
21. Android Activity State Changes by Example
21.1 Creating the State Change Example Project
21.2 Designing the User Interface
21.3 Overriding the Activity Lifecycle Methods
21.4 Filtering the Logcat Panel
21.5 Running the Application
21.6 Experimenting with the Activity
21.7 Summary
22
22. Saving and Restoring the State of an Android Activity
22. Saving and Restoring the State of an Android Activity
22.1 Saving Dynamic State
22.2 Default Saving of User Interface State
22.3 The Bundle Class
22.4 Saving the State
22.5 Restoring the State
22.6 Testing the Application
22.7 Summary
23
23. Understanding Android Views, View Groups and Layouts
23. Understanding Android Views, View Groups and Layouts
23.1 Designing for Different Android Devices
23.2 Views and View Groups
23.3 Android Layout Managers
23.4 The View Hierarchy
23.5 Creating User Interfaces
23.6 Summary
24
24. A Guide to the Android Studio Layout Editor Tool
24. A Guide to the Android Studio Layout Editor Tool
24.1 Basic vs. Empty Activity Templates
24.2 The Android Studio Layout Editor
24.3 Design Mode
24.4 The Palette
24.5 Design Mode and Layout Views
24.6 Code Mode
24.7 Split Mode
24.8 Setting Attributes
24.9 Converting Views
24.10 Displaying Sample Data
24.11 Creating a Custom Device Definition
24.12 Changing the Current Device
24.13 Layout Validation (Multi Preview)
24.14 Summary
25
25. A Guide to the Android ConstraintLayout
25. A Guide to the Android ConstraintLayout
25.1 How ConstraintLayout Works
25.2 Baseline Alignment
25.3 Working with Guidelines
25.4 Configuring Widget Dimensions
25.5 Working with Barriers
25.6 Ratios
25.7 ConstraintLayout Advantages
25.8 ConstraintLayout Availability
25.9 Summary
26
26. A Guide to using ConstraintLayout in Android Studio
26. A Guide to using ConstraintLayout in Android Studio
26.1 Design and Layout Views
26.2 Autoconnect Mode
26.3 Inference Mode
26.4 Manipulating Constraints Manually
26.5 Adding Constraints in the Inspector
26.6 Viewing Constraints in the Attributes Window
26.7 Deleting Constraints
26.8 Adjusting Constraint Bias
26.9 Understanding ConstraintLayout Margins
26.10 The Importance of Opposing Constraints and Bias
26.11 Configuring Widget Dimensions
26.12 Adding Guidelines
26.13 Adding Barriers
26.14 Widget Group Alignment and Distribution
26.15 Converting other Layouts to ConstraintLayout
26.16 Summary
27
27. Working with ConstraintLayout Chains and Ratios in Android Studio
27. Working with ConstraintLayout Chains and Ratios in Android Studio
27.1 Creating a Chain
27.2 Changing the Chain Style
27.3 Spread Inside Chain Style
27.4 Packed Chain Style
27.5 Packed Chain Style with Bias
27.6 Weighted Chain
27.7 Working with Ratios
27.8 Summary
28
28. An Android Studio Layout Editor ConstraintLayout Tutorial
28. An Android Studio Layout Editor ConstraintLayout Tutorial
28.1 An Android Studio Layout Editor Tool Example
28.2 Creating a New Activity
28.3 Preparing the Layout Editor Environment
28.4 Adding the Widgets to the User Interface
28.5 Adding the Constraints
28.6 Testing the Layout
28.7 Using the Layout Inspector
28.8 Summary
29
29. Manual XML Layout Design in Android Studio
29. Manual XML Layout Design in Android Studio
29.1 Manually Creating an XML Layout
29.2 Manual XML vs. Visual Layout Design
29.3 Summary
30
30. Managing Constraints using Constraint Sets
30. Managing Constraints using Constraint Sets
30.1 Kotlin Code vs. XML Layout Files
30.2 Creating Views
30.3 View Attributes
30.4 Constraint Sets
30.5 Summary
31
31. An Android ConstraintSet Tutorial
31. An Android ConstraintSet Tutorial
31.1 Creating the Example Project in Android Studio
31.2 Adding Views to an Activity
31.3 Setting View Attributes
31.4 Creating View IDs
31.5 Configuring the Constraint Set
31.6 Adding the EditText View
31.7 Converting Density Independent Pixels (dp) to Pixels (px)
31.8 Summary
32
32. A Guide to using Apply Changes in Android Studio
32. A Guide to using Apply Changes in Android Studio
32.1 Introducing Apply Changes
32.2 Understanding Apply Changes Options
32.3 Using Apply Changes
32.4 Configuring Apply Changes Fallback Settings
32.5 An Apply Changes Tutorial
32.6 Using Apply Code Changes
32.7 Using Apply Changes and Restart Activity
32.8 Using Run App
32.9 Summary
33
33. An Overview and Example of Android Event Handling
33. An Overview and Example of Android Event Handling
33.1 Understanding Android Events
33.2 Using the android:onClick Resource
33.3 Event Listeners and Callback Methods
33.4 An Event Handling Example
33.5 Designing the User Interface
33.6 The Event Listener and Callback Method
33.7 Consuming Events
33.8 Summary
34
34. Android Touch and Multi-touch Event Handling
34. Android Touch and Multi-touch Event Handling
34.1 Intercepting Touch Events
34.2 The MotionEvent Object
34.3 Understanding Touch Actions
34.4 Handling Multiple Touches
34.5 An Example Multi-Touch Application
34.6 Designing the Activity User Interface
34.7 Implementing the Touch Event Listener
34.8 Running the Example Application
34.9 Summary
35
35. Detecting Common Gestures using the Android Gesture Detector Class
35. Detecting Common Gestures using the Android Gesture Detector Class
35.1 Implementing Common Gesture Detection
35.2 Creating an Example Gesture Detection Project
35.3 Implementing the Listener Class
35.4 Creating the GestureDetectorCompat Instance
35.5 Implementing the onTouchEvent() Method
35.6 Testing the Application
35.7 Summary
36
36. Implementing Custom Gesture and Pinch Recognition on Android
36. Implementing Custom Gesture and Pinch Recognition on Android
36.1 The Android Gesture Builder Application
36.2 The GestureOverlayView Class
36.3 Detecting Gestures
36.4 Identifying Specific Gestures
36.5 Installing and Running the Gesture Builder Application
36.6 Creating a Gestures File
36.7 Creating the Example Project
36.8 Extracting the Gestures File from the SD Card
36.9 Adding the Gestures File to the Project
36.10 Designing the User Interface
36.11 Loading the Gestures File
36.12 Registering the Event Listener
36.13 Implementing the onGesturePerformed Method
36.14 Testing the Application
36.15 Configuring the GestureOverlayView
36.16 Intercepting Gestures
36.17 Detecting Pinch Gestures
36.18 A Pinch Gesture Example Project
36.19 Summary
37
37. An Introduction to Android Fragments
37. An Introduction to Android Fragments
37.1 What is a Fragment?
37.2 Creating a Fragment
37.3 Adding a Fragment to an Activity using the Layout XML File
37.4 Adding and Managing Fragments in Code
37.5 Handling Fragment Events
37.6 Implementing Fragment Communication
37.7 Summary
38
38. Using Fragments in Android Studio - An Example
38. Using Fragments in Android Studio - An Example
38.1 About the Example Fragment Application
38.2 Creating the Example Project
38.3 Creating the First Fragment Layout
38.4 Adding the Second Fragment
38.5 Adding the Fragments to the Activity
38.6 Making the Toolbar Fragment Talk to the Activity
38.7 Making the Activity Talk to the Text Fragment
38.8 Testing the Application
38.9 Summary
39
39. Modern Android App Architecture with Jetpack
39. Modern Android App Architecture with Jetpack
39.1 What is Android Jetpack?
39.2 The “Old” Architecture
39.3 Modern Android Architecture
39.4 The ViewModel Component
39.5 The LiveData Component
39.6 ViewModel Saved State
39.7 LiveData and Data Binding
39.8 Android Lifecycles
39.9 Repository Modules
39.10 Summary
40
40. An Android Jetpack ViewModel Tutorial
40. An Android Jetpack ViewModel Tutorial
40.1 About the Project
40.2 Creating the ViewModel Example Project
40.3 Reviewing the Project
40.4 Designing the Fragment Layout
40.5 Implementing the View Model
40.6 Associating the Fragment with the View Model
40.7 Modifying the Fragment
40.8 Accessing the ViewModel Data
40.9 Testing the Project
40.10 Summary
41
41. An Android Jetpack LiveData Tutorial
41. An Android Jetpack LiveData Tutorial
41.1 LiveData - A Recap
41.2 Adding LiveData to the ViewModel
41.3 Implementing the Observer
41.4 Summary
42
42. An Overview of Android Jetpack Data Binding
42. An Overview of Android Jetpack Data Binding
42.1 An Overview of Data Binding
42.2 The Key Components of Data Binding
42.3 Summary
43
43. An Android Jetpack Data Binding Tutorial
43. An Android Jetpack Data Binding Tutorial
43.1 Removing the Redundant Code
43.2 Enabling Data Binding
43.3 Adding the Layout Element
43.4 Adding the Data Element to Layout File
43.5 Working with the Binding Class
43.6 Assigning the ViewModel Instance to the Data Binding Variable
43.7 Adding Binding Expressions
43.8 Adding the Conversion Method
43.9 Adding a Listener Binding
43.10 Testing the App
43.11 Summary
44
44. An Android ViewModel Saved State Tutorial
44. An Android ViewModel Saved State Tutorial
44.1 Understanding ViewModel State Saving
44.2 Implementing ViewModel State Saving
44.3 Saving and Restoring State
44.4 Adding Saved State Support to the ViewModelDemo Project
44.5 Summary
45
45. Working with Android Lifecycle-Aware Components
45. Working with Android Lifecycle-Aware Components
45.1 Lifecycle Awareness
45.2 Lifecycle Owners
45.3 Lifecycle Observers
45.4 Lifecycle States and Events
45.5 Summary
46
46. An Android Jetpack Lifecycle Awareness Tutorial
46. An Android Jetpack Lifecycle Awareness Tutorial
46.1 Creating the Example Lifecycle Project
46.2 Creating a Lifecycle Observer
46.3 Adding the Observer
46.4 Testing the Observer
46.5 Creating a Lifecycle Owner
46.6 Testing the Custom Lifecycle Owner
46.7 Summary
47
47. An Overview of the Navigation Architecture Component
47. An Overview of the Navigation Architecture Component
47.1 Understanding Navigation
47.2 Declaring a Navigation Host
47.3 The Navigation Graph
47.4 Accessing the Navigation Controller
47.5 Triggering a Navigation Action
47.6 Passing Arguments
47.7 Summary
48
48. An Android Jetpack Navigation Component Tutorial
48. An Android Jetpack Navigation Component Tutorial
48.1 Creating the NavigationDemo Project
48.2 Adding Navigation to the Build Configuration
48.3 Creating the Navigation Graph Resource File
48.4 Declaring a Navigation Host
48.5 Adding Navigation Destinations
48.6 Designing the Destination Fragment Layouts
48.7 Adding an Action to the Navigation Graph
48.8 Implement the OnFragmentInteractionListener
48.9 Triggering the Action
48.10 Passing Data Using Safeargs
48.11 Summary
49
49. Creating and Managing Overflow Menus on Android
49. Creating and Managing Overflow Menus on Android
49.1 The Overflow Menu
49.2 Creating an Overflow Menu
49.3 Displaying an Overflow Menu
49.4 Responding to Menu Item Selections
49.5 Creating Checkable Item Groups
49.6 Menus and the Android Studio Menu Editor
49.7 Creating the Example Project
49.8 Designing the Menu
49.9 Modifying the onOptionsItemSelected() Method
49.10 Testing the Application
49.11 Summary
50
50. An Introduction to MotionLayout
50. An Introduction to MotionLayout
50.1 An Overview of MotionLayout
50.2 MotionLayout
50.3 MotionScene
50.4 Configuring ConstraintSets
50.5 Custom Attributes
50.6 Triggering an Animation
50.7 Arc Motion
50.8 Keyframes
50.9 Time Linearity
50.10 KeyTrigger
50.11 Cycle and Time Cycle Keyframes
50.12 Starting an Animation from Code
50.13 Summary
51
51. An Android MotionLayout Editor Tutorial
51. An Android MotionLayout Editor Tutorial
51.1 Creating the MotionLayoutDemo Project
51.2 ConstraintLayout to MotionLayout Conversion
51.3 Configuring Start and End Constraints
51.4 Previewing the MotionLayout Animation
51.5 Adding an OnClick Gesture
51.6 Adding an Attribute Keyframe to the Transition
51.7 Adding a CustomAttribute to a Transition
51.8 Adding Position Keyframes
51.9 Summary
52
52. A MotionLayout KeyCycle Tutorial
52. A MotionLayout KeyCycle Tutorial
52.1 An Overview of Cycle Keyframes
52.2 Using the Cycle Editor
52.3 Creating the KeyCycleDemo Project
52.4 Configuring the Start and End Constraints
52.5 Creating the Cycles
52.6 Previewing the Animation
52.7 Adding the KeyFrameSet to the MotionScene
52.8 Summary
53
53. Working with the Floating Action Button and Snackbar
53. Working with the Floating Action Button and Snackbar
53.1 The Material Design
53.2 The Design Library
53.3 The Floating Action Button (FAB)
53.4 The Snackbar
53.5 Creating the Example Project
53.6 Reviewing the Project
53.7 Removing Navigation Features
53.8 Changing the Floating Action Button
53.9 Adding the ListView to the Content Layout
53.10 Adding Items to the ListView
53.11 Adding an Action to the Snackbar
53.12 Summary
54
54. Creating a Tabbed Interface using the TabLayout Component
54. Creating a Tabbed Interface using the TabLayout Component
54.1 An Introduction to the ViewPager
54.2 An Overview of the TabLayout Component
54.3 Creating the TabLayoutDemo Project
54.4 Creating the First Fragment
54.5 Duplicating the Fragments
54.6 Adding the TabLayout and ViewPager
54.7 Creating the Pager Adapter
54.8 Performing the Initialization Tasks
54.9 Testing the Application
54.10 Customizing the TabLayout
54.11 Displaying Icon Tab Items
54.12 Summary
55
55. Working with the RecyclerView and CardView Widgets
55. Working with the RecyclerView and CardView Widgets
55.1 An Overview of the RecyclerView
55.2 An Overview of the CardView
55.3 Summary
56
56. An Android RecyclerView and CardView Tutorial
56. An Android RecyclerView and CardView Tutorial
56.1 Creating the CardDemo Project
56.2 Modifying the Basic Activity Project
56.3 Designing the CardView Layout
56.4 Adding the RecyclerView
56.5 Creating the RecyclerView Adapter
56.6 Adding the Image Files
56.7 Initializing the RecyclerView Component
56.8 Testing the Application
56.9 Responding to Card Selections
56.10 Summary
57
57. A Layout Editor Sample Data Tutorial
57. A Layout Editor Sample Data Tutorial
57.1 Adding Sample Data to a Project
57.2 Using Custom Sample Data
57.3 Summary
58
58. Working with the AppBar and Collapsing Toolbar Layouts
58. Working with the AppBar and Collapsing Toolbar Layouts
58.1 The Anatomy of an AppBar
58.2 The Example Project
58.3 Coordinating the RecyclerView and Toolbar
58.4 Introducing the Collapsing Toolbar Layout
58.5 Changing the Title and Scrim Color
58.6 Summary
59
59. An Android Studio Master/Detail Flow Tutorial
59. An Android Studio Master/Detail Flow Tutorial
59.1 The Master/Detail Flow
59.2 Creating a Master/Detail Flow Activity
59.3 The Anatomy of the Master/Detail Flow Template
59.4 Modifying the Master/Detail Flow Template
59.5 Changing the Content Model
59.6 Changing the Detail Pane
59.7 Modifying the WebsiteDetailFragment Class
59.8 Modifying the WebsiteListActivity Class
59.9 Adding Manifest Permissions
59.10 Running the Application
59.11 Summary
60
60. An Overview of Android Intents
60. An Overview of Android Intents
60.1 An Overview of Intents
60.2 Explicit Intents
60.3 Returning Data from an Activity
60.4 Implicit Intents
60.5 Using Intent Filters
60.6 Checking Intent Availability
60.7 Summary
61
61. Android Explicit Intents – A Worked Example
61. Android Explicit Intents – A Worked Example
61.1 Creating the Explicit Intent Example Application
61.2 Designing the User Interface Layout for MainActivity
61.3 Creating the Second Activity Class
61.4 Designing the User Interface Layout for ActivityB
61.5 Reviewing the Application Manifest File
61.6 Creating the Intent
61.7 Extracting Intent Data
61.8 Launching ActivityB as a Sub-Activity
61.9 Returning Data from a Sub-Activity
61.10 Testing the Application
61.11 Summary
62
62. Android Implicit Intents – A Worked Example
62. Android Implicit Intents – A Worked Example
62.1 Creating the Android Studio Implicit Intent Example Project
62.2 Designing the User Interface
62.3 Creating the Implicit Intent
62.4 Adding a Second Matching Activity
62.5 Adding the Web View to the UI
62.6 Obtaining the Intent URL
62.7 Modifying the MyWebView Project Manifest File
62.8 Installing the MyWebView Package on a Device
62.9 Testing the Application
62.10 Summary
63
63. Android Broadcast Intents and Broadcast Receivers
63. Android Broadcast Intents and Broadcast Receivers
63.1 An Overview of Broadcast Intents
63.2 An Overview of Broadcast Receivers
63.3 Obtaining Results from a Broadcast
63.4 Sticky Broadcast Intents
63.5 The Broadcast Intent Example
63.6 Creating the Example Application
63.7 Creating and Sending the Broadcast Intent
63.8 Creating the Broadcast Receiver
63.9 Registering the Broadcast Receiver
63.10 Testing the Broadcast Example
63.11 Listening for System Broadcasts
63.12 Summary
64
64. A Basic Overview of Threads and AsyncTasks
64. A Basic Overview of Threads and AsyncTasks
64.1 An Overview of Threads
64.2 The Application Main Thread
64.3 Thread Handlers
64.4 A Basic AsyncTask Example
64.5 Subclassing AsyncTask
64.6 Testing the App
64.7 Canceling a Task
64.8 Summary
65
65. An Introduction to Kotlin Coroutines
65. An Introduction to Kotlin Coroutines
65.1 What are Coroutines?
65.2 Threads vs Coroutines
65.3 Coroutine Scope
65.4 Suspend Functions
65.5 Coroutine Dispatchers
65.6 Coroutine Builders
65.7 Jobs
65.8 Coroutines – Suspending and Resuming
65.9 Returning Results from a Coroutine
65.10 Using withContext
65.11 Coroutine Channel Communication
65.12 Summary
66
66. An Android Kotlin Coroutines Tutorial
66. An Android Kotlin Coroutines Tutorial
66.1 Creating the Coroutine Example Application
66.2 Adding Coroutine Support to the Project
66.3 Designing the User Interface
66.4 Implementing the SeekBar
66.5 Adding the Suspend Function
66.6 Implementing the launchCoroutines Method
66.7 Testing the App
66.8 Summary
67
67. An Overview of Android Started and Bound Services
67. An Overview of Android Started and Bound Services
67.1 Started Services
67.2 Intent Service
67.3 Bound Service
67.4 The Anatomy of a Service
67.5 Controlling Destroyed Service Restart Options
67.6 Declaring a Service in the Manifest File
67.7 Starting a Service Running on System Startup
67.8 Summary
68
68. Implementing an Android Started Service – A Worked Example
68. Implementing an Android Started Service – A Worked Example
68.1 Creating the Example Project
68.2 Creating the Service Class
68.3 Adding the Service to the Manifest File
68.4 Starting the Service
68.5 Testing the IntentService Example
68.6 Using the Service Class
68.7 Creating the New Service
68.8 Modifying the User Interface
68.9 Running the Application
68.10 Using a Coroutine for the Service Task
68.11 Summary
69
69. Android Local Bound Services – A Worked Example
69. Android Local Bound Services – A Worked Example
69.1 Understanding Bound Services
69.2 Bound Service Interaction Options
69.3 An Android Studio Local Bound Service Example
69.4 Adding a Bound Service to the Project
69.5 Implementing the Binder
69.6 Binding the Client to the Service
69.7 Completing the Example
69.8 Testing the Application
69.9 Summary
70
70. Android Remote Bound Services – A Worked Example
70. Android Remote Bound Services – A Worked Example
70.1 Client to Remote Service Communication
70.2 Creating the Example Application
70.3 Designing the User Interface
70.4 Implementing the Remote Bound Service
70.5 Configuring a Remote Service in the Manifest File
70.6 Launching and Binding to the Remote Service
70.7 Sending a Message to the Remote Service
70.8 Summary
71
71. An Android Notifications Tutorial
71. An Android Notifications Tutorial
71.1 An Overview of Notifications
71.2 Creating the NotifyDemo Project
71.3 Designing the User Interface
71.4 Creating the Second Activity
71.5 Creating a Notification Channel
71.6 Creating and Issuing a Basic Notification
71.7 Launching an Activity from a Notification
71.8 Adding Actions to a Notification
71.9 Bundled Notifications
71.10 Summary
72
72. An Android Direct Reply Notification Tutorial
72. An Android Direct Reply Notification Tutorial
72.1 Creating the DirectReply Project
72.2 Designing the User Interface
72.3 Creating the Notification Channel
72.4 Building the RemoteInput Object
72.5 Creating the PendingIntent
72.6 Creating the Reply Action
72.7 Receiving Direct Reply Input
72.8 Updating the Notification
72.9 Summary
73
73. Foldable Devices and Multi-Window Support
73. Foldable Devices and Multi-Window Support
73.1 Foldables and Multi-Window Support
73.2 Using a Foldable Emulator
73.3 Entering Multi-Window Mode
73.4 Enabling and using Freeform Support
73.5 Checking for Freeform Support
73.6 Enabling Multi-Window Support in an App
73.7 Specifying Multi-Window Attributes
73.8 Detecting Multi-Window Mode in an Activity
73.9 Receiving Multi-Window Notifications
73.10 Launching an Activity in Multi-Window Mode
73.11 Configuring Freeform Activity Size and Position
73.12 Summary
74
74. An Overview of Android SQLite Databases
74. An Overview of Android SQLite Databases
74.1 Understanding Database Tables
74.2 Introducing Database Schema
74.3 Columns and Data Types
74.4 Database Rows
74.5 Introducing Primary Keys
74.6 What is SQLite?
74.7 Structured Query Language (SQL)
74.8 Trying SQLite on an Android Virtual Device (AVD)
74.9 The Android Room Persistence Library
74.10 Summary
75
75. The Android Room Persistence Library
75. The Android Room Persistence Library
75.1 Revisiting Modern App Architecture
75.2 Key Elements of Room Database Persistence
75.3 Understanding Entities
75.4 Data Access Objects
75.5 The Room Database
75.6 The Repository
75.7 In-Memory Databases
75.8 Summary
76
76. An Android TableLayout and TableRow Tutorial
76. An Android TableLayout and TableRow Tutorial
76.1 The TableLayout and TableRow Layout Views
76.2 Creating the Room Database Project
76.3 Converting to a LinearLayout
76.4 Adding the TableLayout to the User Interface
76.5 Configuring the TableRows
76.6 Adding the Button Bar to the Layout
76.7 Adding the RecyclerView
76.8 Adjusting the Layout Margins
76.9 Summary
77
77. An Android Room Database and Repository Tutorial
77. An Android Room Database and Repository Tutorial
77.1 About the RoomDemo Project
77.2 Modifying the Build Configuration
77.3 Building the Entity
77.4 Creating the Data Access Object
77.5 Adding the Room Database
77.6 Adding the Repository
77.7 Modifying the ViewModel
77.8 Creating the Product Item Layout
77.9 Adding the RecyclerView Adapter
77.10 Preparing the Main Fragment
77.11 Adding the Button Listeners
77.12 Adding LiveData Observers
77.13 Initializing the RecyclerView
77.14 Testing the RoomDemo App
77.15 Summary
78
78. Accessing Cloud Storage using the Android Storage Access Framework
78. Accessing Cloud Storage using the Android Storage Access Framework
78.1 The Storage Access Framework
78.2 Working with the Storage Access Framework
78.3 Filtering Picker File Listings
78.4 Handling Intent Results
78.5 Reading the Content of a File
78.6 Writing Content to a File
78.7 Deleting a File
78.8 Gaining Persistent Access to a File
78.9 Summary
79
79. An Android Storage Access Framework Example
79. An Android Storage Access Framework Example
79.1 About the Storage Access Framework Example
79.2 Creating the Storage Access Framework Example
79.3 Designing the User Interface
79.4 Declaring Request Codes
79.5 Creating a New Storage File
79.6 The onActivityResult() Method
79.7 Saving to a Storage File
79.8 Opening and Reading a Storage File
79.9 Testing the Storage Access Application
79.10 Summary
80
80. Video Playback on Android using the VideoView and MediaController Classes
80. Video Playback on Android using the VideoView and MediaController Classes
80.1 Introducing the Android VideoView Class
80.2 Introducing the Android MediaController Class
80.3 Creating the Video Playback Example
80.4 Designing the VideoPlayer Layout
80.5 Downloading the Video File
80.6 Configuring the VideoView
80.7 Adding the MediaController to the Video View
80.8 Setting up the onPreparedListener
80.9 Summary
81
81. Android Picture-in-Picture Mode
81. Android Picture-in-Picture Mode
81.1 Picture-in-Picture Features
81.2 Enabling Picture-in-Picture Mode
81.3 Configuring Picture-in-Picture Parameters
81.4 Entering Picture-in-Picture Mode
81.5 Detecting Picture-in-Picture Mode Changes
81.6 Adding Picture-in-Picture Actions
81.7 Summary
82
82. An Android Picture-in-Picture Tutorial
82. An Android Picture-in-Picture Tutorial
82.1 Adding Picture-in-Picture Support to the Manifest
82.2 Adding a Picture-in-Picture Button
82.3 Entering Picture-in-Picture Mode
82.4 Detecting Picture-in-Picture Mode Changes
82.5 Adding a Broadcast Receiver
82.6 Adding the PiP Action
82.7 Testing the Picture-in-Picture Action
82.8 Summary
83
83. Making Runtime Permission Requests in Android
83. Making Runtime Permission Requests in Android
83.1 Understanding Normal and Dangerous Permissions
83.2 Creating the Permissions Example Project
83.3 Checking for a Permission
83.4 Requesting Permission at Runtime
83.5 Providing a Rationale for the Permission Request
83.6 Testing the Permissions App
83.7 Summary
84
84. Android Audio Recording and Playback using MediaPlayer and MediaRecorder
84. Android Audio Recording and Playback using MediaPlayer and MediaRecorder
84.1 Playing Audio
84.2 Recording Audio and Video using the MediaRecorder Class
84.3 About the Example Project
84.4 Creating the AudioApp Project
84.5 Designing the User Interface
84.6 Checking for Microphone Availability
84.7 Performing the Activity Initialization
84.8 Implementing the recordAudio() Method
84.9 Implementing the stopAudio() Method
84.10 Implementing the playAudio() method
84.11 Configuring and Requesting Permissions
84.12 Testing the Application
84.13 Summary
85
85. Working with the Google Maps Android API in Android Studio
85. Working with the Google Maps Android API in Android Studio
85.1 The Elements of the Google Maps Android API
85.2 Creating the Google Maps Project
85.3 Obtaining Your Developer Signature
85.4 Adding the Apache HTTP Legacy Library Requirement
85.5 Testing the Application
85.6 Understanding Geocoding and Reverse Geocoding
85.7 Adding a Map to an Application
85.8 Requesting Current Location Permission
85.9 Displaying the User’s Current Location
85.10 Changing the Map Type
85.11 Displaying Map Controls to the User
85.12 Handling Map Gesture Interaction
85.13 Creating Map Markers
85.14 Controlling the Map Camera
85.15 Summary
86
86. Printing with the Android Printing Framework
86. Printing with the Android Printing Framework
86.1 The Android Printing Architecture
86.2 The Print Service Plugins
86.3 Google Cloud Print
86.4 Printing to Google Drive
86.5 Save as PDF
86.6 Printing from Android Devices
86.7 Options for Building Print Support into Android Apps
86.8 Summary
87
87. An Android HTML and Web Content Printing Example
87. An Android HTML and Web Content Printing Example
87.1 Creating the HTML Printing Example Application
87.2 Printing Dynamic HTML Content
87.3 Creating the Web Page Printing Example
87.4 Removing the Floating Action Button
87.5 Removing Navigation Features
87.6 Designing the User Interface Layout
87.7 Loading the Web Page into the WebView
87.8 Adding the Print Menu Option
87.9 Summary
88
88. A Guide to Android Custom Document Printing
88. A Guide to Android Custom Document Printing
88.1 An Overview of Android Custom Document Printing
88.2 Preparing the Custom Document Printing Project
88.3 Creating the Custom Print Adapter
88.4 Implementing the onLayout() Callback Method
88.5 Implementing the onWrite() Callback Method
88.6 Checking a Page is in Range
88.7 Drawing the Content on the Page Canvas
88.8 Starting the Print Job
88.9 Testing the Application
88.10 Summary
89
89. An Introduction to Android App Links
89. An Introduction to Android App Links
89.1 An Overview of Android App Links
89.2 App Link Intent Filters
89.3 Handling App Link Intents
89.4 Associating the App with a Website
89.5 Summary
90
90. An Android Studio App Links Tutorial
90. An Android Studio App Links Tutorial
90.1 About the Example App
90.2 The Database Schema
90.3 Loading and Running the Project
90.4 Adding the URL Mapping
90.5 Adding the Intent Filter
90.6 Adding Intent Handling Code
90.7 Testing the App Link
90.8 Associating an App Link with a Web Site
90.9 Summary
91
91. A Guide to the Android Studio Profiler
91. A Guide to the Android Studio Profiler
91.1 Accessing the Android Profiler
91.2 Enabling Advanced Profiling
91.3 The Android Profiler Tool Window
91.4 The Sessions Panel
91.5 The CPU Profiler
91.6 Memory Profiler
91.7 Network Profiler
91.8 Energy Profiler
91.9 Summary
92
92. An Android Biometric Authentication Tutorial
92. An Android Biometric Authentication Tutorial
92.1 An Overview of Biometric Authentication
92.2 Creating the Biometric Authentication Project
92.3 Configuring Device Fingerprint Authentication
92.4 Adding the Biometric Permission to the Manifest File
92.5 Designing the User Interface
92.6 Adding a Toast Convenience Method
92.7 Checking the Security Settings
92.8 Configuring the Authentication Callbacks
92.9 Adding the CancellationSignal
92.10 Starting the Biometric Prompt
92.11 Testing the Project
92.12 Summary
93
93. Creating, Testing and Uploading an Android App Bundle
93. Creating, Testing and Uploading an Android App Bundle
93.1 The Release Preparation Process
93.2 Android App Bundles
93.3 Register for a Google Play Developer Console Account
93.4 Configuring the App in the Console
93.5 Enabling Google Play App Signing
93.6 Creating a Keystore File
93.7 Creating the Android App Bundle
93.8 Generating Test APK Files
93.9 Uploading the App Bundle to the Google Play Developer Console
93.10 Exploring the App Bundle
93.11 Managing Testers
93.12 Uploading New App Bundle Revisions
93.13 Analyzing the App Bundle File
93.14 Enabling Google Play Signing for an Existing App
93.15 Summary
94
94. An Overview of Android Dynamic Feature Modules
94. An Overview of Android Dynamic Feature Modules
94.1 An Overview of Dynamic Feature Modules
94.2 Dynamic Feature Module Architecture
94.3 Creating a Dynamic Feature Module
94.4 Converting an Existing Module for Dynamic Delivery
94.5 Working with Dynamic Feature Modules
94.6 Handling Large Dynamic Feature Modules
94.7 Summary
95
95. An Android Studio Dynamic Feature Tutorial
95. An Android Studio Dynamic Feature Tutorial
95.1 Creating the DynamicFeature Project
95.2 Adding Dynamic Feature Support to the Project
95.3 Designing the Base Activity User Interface
95.4 Adding the Dynamic Feature Module
95.5 Reviewing the Dynamic Feature Module
95.6 Adding the Dynamic Feature Activity
95.7 Implementing the launchIntent() Method
95.8 Uploading the App Bundle for Testing
95.9 Implementing the installFeature() Method
95.10 Adding the Update Listener
95.11 Handling Large Downloads
95.12 Using Deferred Installation
95.13 Removing a Dynamic Module
95.14 Summary
96
96. An Overview of Gradle in Android Studio
96. An Overview of Gradle in Android Studio
96.1 An Overview of Gradle
96.2 Gradle and Android Studio
96.3 The Top-level Gradle Build File
96.4 Module Level Gradle Build Files
96.5 Configuring Signing Settings in the Build File
96.6 Running Gradle Tasks from the Command-line
96.7 Summary
97
Index
Index

82.4 Detecting Picture-in-Picture Mode Changes

As discussed in the previous chapter, PiP mode changes are detected by overriding the onPictureInPictureModeChanged() method within the affected activity. In this case, the method needs to be written such that it can detect whether the activity is entering or exiting PiP mode and to take appropriate action to re-activate the PiP button and the playback controls. Remaining within the MainActivity.kt file, add this method now:

override fun onPictureInPictureModeChanged(

       isInPictureInPictureMode: Boolean, newConfig: Configuration?) {

    super.onPictureInPictureModeChanged(isInPictureInPictureMode, newConfig)

    if (isInPictureInPictureMode) {

 

    } else {

        pipButton.visibility = View.VISIBLE

        videoView1.setMediaController...

Previous Section
End of Section 5
Next Section