Book Image

Android Studio 3.5 Development Essentials - Kotlin Edition

By : Neil Smyth
Book Image

Android Studio 3.5 Development Essentials - Kotlin Edition

By: Neil Smyth

Overview of this book

Popularity of Kotlin as an Android-compatible language keeps growing every day. This book will help you to build your own Android applications using Kotlin. Android Studio 3.5 Development Essentials Kotlin Edition first teaches you to install Android development and test environment on different operating systems. Next, you will create an Android app and a virtual device in Android studio, and install an Android application on emulators. You will test apps on physical android devices, then study Android Studio code editor, Android architecture, and the anatomy of an Android app. The focus then shifts to Kotlin language. You’ll get an overview of Kotlin language and practice converting code from Java to Kotlin. You’ll also explore Kotlin data types, operators, expressions, loops, functions, and the basics of OOP concept in Kotlin. This book will then cover Android Jetpack and how to create an example app project using ViewModel component, as well as advanced topics such as views and widgets 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 enough knowledge to develop powerful Android applications using Kotlin.

Related Content you might be interested in

Current Title:

Small book image
Android Studio 3.5 Development Essentials - Kotlin Edition
Neil Smyth
May, 2019 | 812 pages
Small book image
Mastering Linux Administration
Alexandru Calcatinge | Julian Balog
Mar, 2024 | 764 pages
Small book image
Linux for System Administrators
Viorel Rudareanu | Daniil Baturin
Sep, 2023 | 294 pages
Small book image
Mastering Linux Administration
Alexandru Calcatinge | Julian Balog
Jun, 2021 | 772 pages
Table of Contents (93 chapters)
Free Chapter
1
1. Introduction
1. Introduction
1.1 Downloading the Code Samples
1.2 Feedback
1.3 Errata
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 Reviewing the Layout and Resource Files
3.7 Adding Interaction
3.8 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 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. Understanding Android Application and Activity Lifecycles
18. Understanding Android Application and Activity Lifecycles
18.1 Android Applications and Resource Management
18.2 Android Process States
18.3 Inter-Process Dependencies
18.4 The Activity Lifecycle
18.5 The Activity Stack
18.6 Activity States
18.7 Configuration Changes
18.8 Handling State Change
18.9 Summary
19
19. Handling Android Activity State Changes
19. Handling Android Activity State Changes
19.1 New vs. Old Lifecycle Techniques
19.2 The Activity and Fragment Classes
19.3 Dynamic State vs. Persistent State
19.4 The Android Lifecycle Methods
19.5 Lifetimes
19.6 Foldable Devices and Multi-Resume
19.7 Disabling Configuration Change Restarts
19.8 Lifecycle Method Limitations
19.9 Summary
20
20. Android Activity State Changes by Example
20. Android Activity State Changes by Example
20.1 Creating the State Change Example Project
20.2 Designing the User Interface
20.3 Overriding the Activity Lifecycle Methods
20.4 Filtering the Logcat Panel
20.5 Running the Application
20.6 Experimenting with the Activity
20.7 Summary
21
21. Saving and Restoring the State of an Android Activity
21. Saving and Restoring the State of an Android Activity
21.1 Saving Dynamic State
21.2 Default Saving of User Interface State
21.3 The Bundle Class
21.4 Saving the State
21.5 Restoring the State
21.6 Testing the Application
21.7 Summary
22
22. Understanding Android Views, View Groups and Layouts
22. Understanding Android Views, View Groups and Layouts
22.1 Designing for Different Android Devices
22.2 Views and View Groups
22.3 Android Layout Managers
22.4 The View Hierarchy
22.5 Creating User Interfaces
22.6 Summary
23
23. A Guide to the Android Studio Layout Editor Tool
23. A Guide to the Android Studio Layout Editor Tool
23.1 Basic vs. Empty Activity Templates
23.2 The Android Studio Layout Editor
23.3 Design Mode
23.4 The Palette
23.5 Design and Layout Views
23.6 Text Mode
23.7 Setting Attributes
23.8 Converting Views
23.9 Displaying Sample Data
23.10 Creating a Custom Device Definition
23.11 Changing the Current Device
23.12 Summary
24
24. A Guide to the Android ConstraintLayout
24. A Guide to the Android ConstraintLayout
24.1 How ConstraintLayout Works
24.2 Baseline Alignment
24.3 Working with Guidelines
24.4 Configuring Widget Dimensions
24.5 Working with Barriers
24.6 Ratios
24.7 ConstraintLayout Advantages
24.8 ConstraintLayout Availability
24.9 Summary
25
25. A Guide to using ConstraintLayout in Android Studio
25. A Guide to using ConstraintLayout in Android Studio
25.1 Design and Layout Views
25.2 Autoconnect Mode
25.3 Inference Mode
25.4 Manipulating Constraints Manually
25.5 Adding Constraints in the Inspector
25.6 Viewing Constraints in the Attributes Window
25.7 Deleting Constraints
25.8 Adjusting Constraint Bias
25.9 Understanding ConstraintLayout Margins
25.10 The Importance of Opposing Constraints and Bias
25.11 Configuring Widget Dimensions
25.12 Adding Guidelines
25.13 Adding Barriers
25.14 Widget Group Alignment and Distribution
25.15 Converting other Layouts to ConstraintLayout
25.16 Summary
26
26. Working with ConstraintLayout Chains and Ratios in Android Studio
26. Working with ConstraintLayout Chains and Ratios in Android Studio
26.1 Creating a Chain
26.2 Changing the Chain Style
26.3 Spread Inside Chain Style
26.4 Packed Chain Style
26.5 Packed Chain Style with Bias
26.6 Weighted Chain
26.7 Working with Ratios
26.8 Summary
27
27. An Android Studio Layout Editor ConstraintLayout Tutorial
27. An Android Studio Layout Editor ConstraintLayout Tutorial
27.1 An Android Studio Layout Editor Tool Example
27.2 Creating a New Activity
27.3 Preparing the Layout Editor Environment
27.4 Adding the Widgets to the User Interface
27.5 Adding the Constraints
27.6 Testing the Layout
27.7 Using the Layout Inspector
27.8 Summary
28
28. Manual XML Layout Design in Android Studio
28. Manual XML Layout Design in Android Studio
28.1 Manually Creating an XML Layout
28.2 Manual XML vs. Visual Layout Design
28.3 Summary
29
29. Managing Constraints using Constraint Sets
29. Managing Constraints using Constraint Sets
29.1 Kotlin Code vs. XML Layout Files
29.2 Creating Views
29.3 View Attributes
29.4 Constraint Sets
29.5 Summary
30
30. An Android ConstraintSet Tutorial
30. An Android ConstraintSet Tutorial
30.1 Creating the Example Project in Android Studio
30.2 Adding Views to an Activity
30.3 Setting View Attributes
30.4 Creating View IDs
30.5 Configuring the Constraint Set
30.6 Adding the EditText View
30.7 Converting Density Independent Pixels (dp) to Pixels (px)
30.8 Summary
31
31. A Guide to using Apply Changes in Android Studio
31. A Guide to using Apply Changes in Android Studio
31.1 Introducing Apply Changes
31.2 Understanding Apply Changes Options
31.3 Using Apply Changes
31.4 Configuring Apply Changes Fallback Settings
31.5 An Apply Changes Tutorial
31.6 Using Apply Code Changes
31.7 Using Apply Changes and Restart Activity
31.8 Using Run App
31.9 Summary
32
32. An Overview and Example of Android Event Handling
32. An Overview and Example of Android Event Handling
32.1 Understanding Android Events
32.2 Using the android:onClick Resource
32.3 Event Listeners and Callback Methods
32.4 An Event Handling Example
32.5 Designing the User Interface
32.6 The Event Listener and Callback Method
32.7 Consuming Events
32.8 Summary
33
33. Android Touch and Multi-touch Event Handling
33. Android Touch and Multi-touch Event Handling
33.1 Intercepting Touch Events
33.2 The MotionEvent Object
33.3 Understanding Touch Actions
33.4 Handling Multiple Touches
33.5 An Example Multi-Touch Application
33.6 Designing the Activity User Interface
33.7 Implementing the Touch Event Listener
33.8 Running the Example Application
33.9 Summary
34
34. Detecting Common Gestures using the Android Gesture Detector Class
34. Detecting Common Gestures using the Android Gesture Detector Class
34.1 Implementing Common Gesture Detection
34.2 Creating an Example Gesture Detection Project
34.3 Implementing the Listener Class
34.4 Creating the GestureDetectorCompat Instance
34.5 Implementing the onTouchEvent() Method
34.6 Testing the Application
34.7 Summary
35
35. Implementing Custom Gesture and Pinch Recognition on Android
35. Implementing Custom Gesture and Pinch Recognition on Android
35.1 The Android Gesture Builder Application
35.2 The GestureOverlayView Class
35.3 Detecting Gestures
35.4 Identifying Specific Gestures
35.5 Installing and Running the Gesture Builder Application
35.6 Creating a Gestures File
35.7 Creating the Example Project
35.8 Extracting the Gestures File from the SD Card
35.9 Adding the Gestures File to the Project
35.10 Designing the User Interface
35.11 Loading the Gestures File
35.12 Registering the Event Listener
35.13 Implementing the onGesturePerformed Method
35.14 Testing the Application
35.15 Configuring the GestureOverlayView
35.16 Intercepting Gestures
35.17 Detecting Pinch Gestures
35.18 A Pinch Gesture Example Project
35.19 Summary
36
36. An Introduction to Android Fragments
36. An Introduction to Android Fragments
36.1 What is a Fragment?
36.2 Creating a Fragment
36.3 Adding a Fragment to an Activity using the Layout XML File
36.4 Adding and Managing Fragments in Code
36.5 Handling Fragment Events
36.6 Implementing Fragment Communication
36.7 Summary
37
37. Using Fragments in Android Studio - An Example
37. Using Fragments in Android Studio - An Example
37.1 About the Example Fragment Application
37.2 Creating the Example Project
37.3 Creating the First Fragment Layout
37.4 Creating the First Fragment Class
37.5 Creating the Second Fragment Layout
37.6 Adding the Fragments to the Activity
37.7 Making the Toolbar Fragment Talk to the Activity
37.8 Making the Activity Talk to the Text Fragment
37.9 Testing the Application
37.10 Summary
38
38. Modern Android App Architecture with Jetpack
38. Modern Android App Architecture with Jetpack
38.1 What is Android Jetpack?
38.2 The “Old” Architecture
38.3 Modern Android Architecture
38.4 The ViewModel Component
38.5 The LiveData Component
38.6 LiveData and Data Binding
38.7 Android Lifecycles
38.8 Repository Modules
38.9 Summary
39
39. An Android Jetpack ViewModel Tutorial
39. An Android Jetpack ViewModel Tutorial
39.1 About the Project
39.2 Creating the ViewModel Example Project
39.3 Reviewing the Project
39.4 Designing the Fragment Layout
39.5 Implementing the View Model
39.6 Associating the Fragment with the View Model
39.7 Modifying the Fragment
39.8 Accessing the ViewModel Data
39.9 Testing the Project
39.10 Summary
40
40. An Android Jetpack LiveData Tutorial
40. An Android Jetpack LiveData Tutorial
40.1 LiveData - A Recap
40.2 Adding LiveData to the ViewModel
40.3 Implementing the Observer
40.4 Summary
41
41. An Overview of Android Jetpack Data Binding
41. An Overview of Android Jetpack Data Binding
41.1 An Overview of Data Binding
41.2 The Key Components of Data Binding
41.3 Summary
42
42. An Android Jetpack Data Binding Tutorial
42. An Android Jetpack Data Binding Tutorial
42.1 Removing the Redundant Code
42.2 Enabling Data Binding
42.3 Adding the Layout Element
42.4 Adding the Data Element to Layout File
42.5 Working with the Binding Class
42.6 Assigning the ViewModel Instance to the Data Binding Variable
42.7 Adding Binding Expressions
42.8 Adding the Conversion Method
42.9 Adding a Listener Binding
42.10 Testing the App
42.11 Summary
43
43. Working with Android Lifecycle-Aware Components
43. Working with Android Lifecycle-Aware Components
43.1 Lifecycle Awareness
43.2 Lifecycle Owners
43.3 Lifecycle Observers
43.4 Lifecycle States and Events
43.5 Summary
44
44. An Android Jetpack Lifecycle Awareness Tutorial
44. An Android Jetpack Lifecycle Awareness Tutorial
44.1 Creating the Example Lifecycle Project
44.2 Creating a Lifecycle Observer
44.3 Adding the Observer
44.4 Testing the Observer
44.5 Creating a Lifecycle Owner
44.6 Testing the Custom Lifecycle Owner
44.7 Summary
45
45. An Overview of the Navigation Architecture Component
45. An Overview of the Navigation Architecture Component
45.1 Understanding Navigation
45.2 Declaring a Navigation Host
45.3 The Navigation Graph
45.4 Accessing the Navigation Controller
45.5 Triggering a Navigation Action
45.6 Passing Arguments
45.7 Summary
46
46. An Android Jetpack Navigation Component Tutorial
46. An Android Jetpack Navigation Component Tutorial
46.1 Creating the NavigationDemo Project
46.2 Adding Navigation to the Build Configuration
46.3 Creating the Navigation Graph Resource File
46.4 Declaring a Navigation Host
46.5 Adding Navigation Destinations
46.6 Designing the Destination Fragment Layouts
46.7 Adding an Action to the Navigation Graph
46.8 Implement the OnFragmentInteractionListener
46.9 Triggering the Action
46.10 Passing Data Using Safeargs
46.11 Summary
47
47. Creating and Managing Overflow Menus on Android
47. Creating and Managing Overflow Menus on Android
47.1 The Overflow Menu
47.2 Creating an Overflow Menu
47.3 Displaying an Overflow Menu
47.4 Responding to Menu Item Selections
47.5 Creating Checkable Item Groups
47.6 Menus and the Android Studio Menu Editor
47.7 Creating the Example Project
47.8 Designing the Menu
47.9 Modifying the onOptionsItemSelected() Method
47.10 Testing the Application
47.11 Summary
48
48. Animating User Interfaces with the Android Transitions Framework
48. Animating User Interfaces with the Android Transitions Framework
48.1 Introducing Android Transitions and Scenes
48.2 Using Interpolators with Transitions
48.3 Working with Scene Transitions
48.4 Custom Transitions and TransitionSets in Code
48.5 Custom Transitions and TransitionSets in XML
48.6 Working with Interpolators
48.7 Creating a Custom Interpolator
48.8 Using the beginDelayedTransition Method
48.9 Summary
49
49. An Android Transition Tutorial using beginDelayedTransition
49. An Android Transition Tutorial using beginDelayedTransition
49.1 Creating the Android Studio TransitionDemo Project
49.2 Preparing the Project Files
49.3 Implementing beginDelayedTransition Animation
49.4 Customizing the Transition
49.5 Summary
50
50. Implementing Android Scene Transitions – A Tutorial
50. Implementing Android Scene Transitions – A Tutorial
50.1 An Overview of the Scene Transition Project
50.2 Creating the Android Studio SceneTransitions Project
50.3 Identifying and Preparing the Root Container
50.4 Designing the First Scene
50.5 Designing the Second Scene
50.6 Entering the First Scene
50.7 Loading Scene 2
50.8 Implementing the Transitions
50.9 Adding the Transition File
50.10 Loading and Using the Transition Set
50.11 Configuring Additional Transitions
50.12 Summary
51
51. Working with the Floating Action Button and Snackbar
51. Working with the Floating Action Button and Snackbar
51.1 The Material Design
51.2 The Design Library
51.3 The Floating Action Button (FAB)
51.4 The Snackbar
51.5 Creating the Example Project
51.6 Reviewing the Project
51.7 Changing the Floating Action Button
51.8 Adding the ListView to the Content Layout
51.9 Adding Items to the ListView
51.10 Adding an Action to the Snackbar
51.11 Summary
52
52. Creating a Tabbed Interface using the TabLayout Component
52. Creating a Tabbed Interface using the TabLayout Component
52.1 An Introduction to the ViewPager
52.2 An Overview of the TabLayout Component
52.3 Creating the TabLayoutDemo Project
52.4 Creating the First Fragment
52.5 Duplicating the Fragments
52.6 Adding the TabLayout and ViewPager
52.7 Creating the Pager Adapter
52.8 Performing the Initialization Tasks
52.9 Testing the Application
52.10 Customizing the TabLayout
52.11 Displaying Icon Tab Items
52.12 Summary
53
53. Working with the RecyclerView and CardView Widgets
53. Working with the RecyclerView and CardView Widgets
53.1 An Overview of the RecyclerView
53.2 An Overview of the CardView
53.3 Summary
54
54. An Android RecyclerView and CardView Tutorial
54. An Android RecyclerView and CardView Tutorial
54.1 Creating the CardDemo Project
54.2 Removing the Floating Action Button
54.3 Designing the CardView Layout
54.4 Adding the RecyclerView
54.5 Creating the RecyclerView Adapter
54.6 Adding the Image Files
54.7 Initializing the RecyclerView Component
54.8 Testing the Application
54.9 Responding to Card Selections
54.10 Summary
55
55. A Layout Editor Sample Data Tutorial
55. A Layout Editor Sample Data Tutorial
55.1 Adding Sample Data to a Project
55.2 Using Custom Sample Data
55.3 Summary
56
56. Working with the AppBar and Collapsing Toolbar Layouts
56. Working with the AppBar and Collapsing Toolbar Layouts
56.1 The Anatomy of an AppBar
56.2 The Example Project
56.3 Coordinating the RecyclerView and Toolbar
56.4 Introducing the Collapsing Toolbar Layout
56.5 Changing the Title and Scrim Color
56.6 Summary
57
57. An Android Studio Master/Detail Flow Tutorial
57. An Android Studio Master/Detail Flow Tutorial
57.1 The Master/Detail Flow
57.2 Creating a Master/Detail Flow Activity
57.3 The Anatomy of the Master/Detail Flow Template
57.4 Modifying the Master/Detail Flow Template
57.5 Changing the Content Model
57.6 Changing the Detail Pane
57.7 Modifying the WebsiteDetailFragment Class
57.8 Modifying the WebsiteListActivity Class
57.9 Adding Manifest Permissions
57.10 Running the Application
57.11 Summary
58
58. An Overview of Android Intents
58. An Overview of Android Intents
58.1 An Overview of Intents
58.2 Explicit Intents
58.3 Returning Data from an Activity
58.4 Implicit Intents
58.5 Using Intent Filters
58.6 Checking Intent Availability
58.7 Summary
59
59. Android Explicit Intents – A Worked Example
59. Android Explicit Intents – A Worked Example
59.1 Creating the Explicit Intent Example Application
59.2 Designing the User Interface Layout for MainActivity
59.3 Creating the Second Activity Class
59.4 Designing the User Interface Layout for ActivityB
59.5 Reviewing the Application Manifest File
59.6 Creating the Intent
59.7 Extracting Intent Data
59.8 Launching ActivityB as a Sub-Activity
59.9 Returning Data from a Sub-Activity
59.10 Testing the Application
59.11 Summary
60
60. Android Implicit Intents – A Worked Example
60. Android Implicit Intents – A Worked Example
60.1 Creating the Android Studio Implicit Intent Example Project
60.2 Designing the User Interface
60.3 Creating the Implicit Intent
60.4 Adding a Second Matching Activity
60.5 Adding the Web View to the UI
60.6 Obtaining the Intent URL
60.7 Modifying the MyWebView Project Manifest File
60.8 Installing the MyWebView Package on a Device
60.9 Testing the Application
60.10 Summary
61
61. Android Broadcast Intents and Broadcast Receivers
61. Android Broadcast Intents and Broadcast Receivers
61.1 An Overview of Broadcast Intents
61.2 An Overview of Broadcast Receivers
61.3 Obtaining Results from a Broadcast
61.4 Sticky Broadcast Intents
61.5 The Broadcast Intent Example
61.6 Creating the Example Application
61.7 Creating and Sending the Broadcast Intent
61.8 Creating the Broadcast Receiver
61.9 Registering the Broadcast Receiver
61.10 Testing the Broadcast Example
61.11 Listening for System Broadcasts
61.12 Summary
62
62. A Basic Overview of Threads and AsyncTasks
62. A Basic Overview of Threads and AsyncTasks
62.1 An Overview of Threads
62.2 The Application Main Thread
62.3 Thread Handlers
62.4 A Basic AsyncTask Example
62.5 Subclassing AsyncTask
62.6 Testing the App
62.7 Canceling a Task
62.8 Summary
63
63. An Overview of Android Started and Bound Services
63. An Overview of Android Started and Bound Services
63.1 Started Services
63.2 Intent Service
63.3 Bound Service
63.4 The Anatomy of a Service
63.5 Controlling Destroyed Service Restart Options
63.6 Declaring a Service in the Manifest File
63.7 Starting a Service Running on System Startup
63.8 Summary
64
64. Implementing an Android Started Service – A Worked Example
64. Implementing an Android Started Service – A Worked Example
64.1 Creating the Example Project
64.2 Creating the Service Class
64.3 Adding the Service to the Manifest File
64.4 Starting the Service
64.5 Testing the IntentService Example
64.6 Using the Service Class
64.7 Creating the New Service
64.8 Modifying the User Interface
64.9 Running the Application
64.10 Creating an AsyncTask for Service Tasks
64.11 Summary
65
65. Android Local Bound Services – A Worked Example
65. Android Local Bound Services – A Worked Example
65.1 Understanding Bound Services
65.2 Bound Service Interaction Options
65.3 An Android Studio Local Bound Service Example
65.4 Adding a Bound Service to the Project
65.5 Implementing the Binder
65.6 Binding the Client to the Service
65.7 Completing the Example
65.8 Testing the Application
65.9 Summary
66
66. Android Remote Bound Services – A Worked Example
66. Android Remote Bound Services – A Worked Example
66.1 Client to Remote Service Communication
66.2 Creating the Example Application
66.3 Designing the User Interface
66.4 Implementing the Remote Bound Service
66.5 Configuring a Remote Service in the Manifest File
66.6 Launching and Binding to the Remote Service
66.7 Sending a Message to the Remote Service
66.8 Summary
67
67. An Android Notifications Tutorial
67. An Android Notifications Tutorial
67.1 An Overview of Notifications
67.2 Creating the NotifyDemo Project
67.3 Designing the User Interface
67.4 Creating the Second Activity
67.5 Creating a Notification Channel
67.6 Creating and Issuing a Basic Notification
67.7 Launching an Activity from a Notification
67.8 Adding Actions to a Notification
67.9 Bundled Notifications
67.10 Summary
68
68. An Android Direct Reply Notification Tutorial
68. An Android Direct Reply Notification Tutorial
68.1 Creating the DirectReply Project
68.2 Designing the User Interface
68.3 Creating the Notification Channel
68.4 Building the RemoteInput Object
68.5 Creating the PendingIntent
68.6 Creating the Reply Action
68.7 Receiving Direct Reply Input
68.8 Updating the Notification
68.9 Summary
69
69. Foldable Devices and Multi-Window Support
69. Foldable Devices and Multi-Window Support
69.1 Foldables and Multi-Window Support
69.2 Using a Foldable Emulator
69.3 Entering Multi-Window Mode
69.4 Enabling and using Freeform Support
69.5 Checking for Freeform Support
69.6 Enabling Multi-Window Support in an App
69.7 Specifying Multi-Window Attributes
69.8 Detecting Multi-Window Mode in an Activity
69.9 Receiving Multi-Window Notifications
69.10 Launching an Activity in Multi-Window Mode
69.11 Configuring Freeform Activity Size and Position
69.12 Summary
70
70. An Overview of Android SQLite Databases
70. An Overview of Android SQLite Databases
70.1 Understanding Database Tables
70.2 Introducing Database Schema
70.3 Columns and Data Types
70.4 Database Rows
70.5 Introducing Primary Keys
70.6 What is SQLite?
70.7 Structured Query Language (SQL)
70.8 Trying SQLite on an Android Virtual Device (AVD)
70.9 The Android Room Persistence Library
70.10 Summary
71
71. The Android Room Persistence Library
71. The Android Room Persistence Library
71.1 Revisiting Modern App Architecture
71.2 Key Elements of Room Database Persistence
71.3 Understanding Entities
71.4 Data Access Objects
71.5 The Room Database
71.6 The Repository
71.7 In-Memory Databases
71.8 Summary
72
72. An Android TableLayout and TableRow Tutorial
72. An Android TableLayout and TableRow Tutorial
72.1 The TableLayout and TableRow Layout Views
72.2 Creating the Room Database Project
72.3 Converting to a LinearLayout
72.4 Adding the TableLayout to the User Interface
72.5 Configuring the TableRows
72.6 Adding the Button Bar to the Layout
72.7 Adding the RecyclerView
72.8 Adjusting the Layout Margins
72.9 Summary
73
73. An Android Room Database and Repository Tutorial
73. An Android Room Database and Repository Tutorial
73.1 About the RoomDemo Project
73.2 Modifying the Build Configuration
73.3 Building the Entity
73.4 Creating the Data Access Object
73.5 Adding the Room Database
73.6 Adding the Repository
73.7 Modifying the ViewModel
73.8 Creating the Product Item Layout
73.9 Adding the RecyclerView Adapter
73.10 Preparing the Main Fragment
73.11 Adding the Button Listeners
73.12 Adding LiveData Observers
73.13 Initializing the RecyclerView
73.14 Testing the RoomDemo App
73.15 Summary
74
74. Accessing Cloud Storage using the Android Storage Access Framework
74. Accessing Cloud Storage using the Android Storage Access Framework
74.1 The Storage Access Framework
74.2 Working with the Storage Access Framework
74.3 Filtering Picker File Listings
74.4 Handling Intent Results
74.5 Reading the Content of a File
74.6 Writing Content to a File
74.7 Deleting a File
74.8 Gaining Persistent Access to a File
74.9 Summary
75
75. An Android Storage Access Framework Example
75. An Android Storage Access Framework Example
75.1 About the Storage Access Framework Example
75.2 Creating the Storage Access Framework Example
75.3 Designing the User Interface
75.4 Declaring Request Codes
75.5 Creating a New Storage File
75.6 The onActivityResult() Method
75.7 Saving to a Storage File
75.8 Opening and Reading a Storage File
75.9 Testing the Storage Access Application
75.10 Summary
76
76. Implementing Video Playback on Android using the VideoView and MediaController Classes
76. Implementing Video Playback on Android using the VideoView and MediaController Classes
76.1 Introducing the Android VideoView Class
76.2 Introducing the Android MediaController Class
76.3 Creating the Video Playback Example
76.4 Designing the VideoPlayer Layout
76.5 Configuring the VideoView
76.6 Adding Internet Permission
76.7 Adding the MediaController to the Video View
76.8 Setting up the onPreparedListener
76.9 Summary
77
77. Android Picture-in-Picture Mode
77. Android Picture-in-Picture Mode
77.1 Picture-in-Picture Features
77.2 Enabling Picture-in-Picture Mode
77.3 Configuring Picture-in-Picture Parameters
77.4 Entering Picture-in-Picture Mode
77.5 Detecting Picture-in-Picture Mode Changes
77.6 Adding Picture-in-Picture Actions
77.7 Summary
78
78. An Android Picture-in-Picture Tutorial
78. An Android Picture-in-Picture Tutorial
78.1 Adding Picture-in-Picture Support to the Manifest
78.2 Adding a Picture-in-Picture Button
78.3 Entering Picture-in-Picture Mode
78.4 Detecting Picture-in-Picture Mode Changes
78.5 Adding a Broadcast Receiver
78.6 Adding the PiP Action
78.7 Testing the Picture-in-Picture Action
78.8 Summary
79
79. Making Runtime Permission Requests in Android
79. Making Runtime Permission Requests in Android
79.1 Understanding Normal and Dangerous Permissions
79.2 Creating the Permissions Example Project
79.3 Checking for a Permission
79.4 Requesting Permission at Runtime
79.5 Providing a Rationale for the Permission Request
79.6 Testing the Permissions App
79.7 Summary
80
80. Android Audio Recording and Playback using MediaPlayer and MediaRecorder
80. Android Audio Recording and Playback using MediaPlayer and MediaRecorder
80.1 Playing Audio
80.2 Recording Audio and Video using the MediaRecorder Class
80.3 About the Example Project
80.4 Creating the AudioApp Project
80.5 Designing the User Interface
80.6 Checking for Microphone Availability
80.7 Performing the Activity Initialization
80.8 Implementing the recordAudio() Method
80.9 Implementing the stopAudio() Method
80.10 Implementing the playAudio() method
80.11 Configuring and Requesting Permissions
80.12 Testing the Application
80.13 Summary
81
81. Working with the Google Maps Android API in Android Studio
81. Working with the Google Maps Android API in Android Studio
81.1 The Elements of the Google Maps Android API
81.2 Creating the Google Maps Project
81.3 Obtaining Your Developer Signature
81.4 Adding the Apache HTTP Legacy Library Requirement
81.5 Testing the Application
81.6 Understanding Geocoding and Reverse Geocoding
81.7 Adding a Map to an Application
81.8 Requesting Current Location Permission
81.9 Displaying the User’s Current Location
81.10 Changing the Map Type
81.11 Displaying Map Controls to the User
81.12 Handling Map Gesture Interaction
81.13 Creating Map Markers
81.14 Controlling the Map Camera
81.15 Summary
82
82. Printing with the Android Printing Framework
82. Printing with the Android Printing Framework
82.1 The Android Printing Architecture
82.2 The Print Service Plugins
82.3 Google Cloud Print
82.4 Printing to Google Drive
82.5 Save as PDF
82.6 Printing from Android Devices
82.7 Options for Building Print Support into Android Apps
82.8 Summary
83
83. An Android HTML and Web Content Printing Example
83. An Android HTML and Web Content Printing Example
83.1 Creating the HTML Printing Example Application
83.2 Printing Dynamic HTML Content
83.3 Creating the Web Page Printing Example
83.4 Removing the Floating Action Button
83.5 Designing the User Interface Layout
83.6 Loading the Web Page into the WebView
83.7 Adding the Print Menu Option
83.8 Summary
84
84. A Guide to Android Custom Document Printing
84. A Guide to Android Custom Document Printing
84.1 An Overview of Android Custom Document Printing
84.2 Preparing the Custom Document Printing Project
84.3 Creating the Custom Print Adapter
84.4 Implementing the onLayout() Callback Method
84.5 Implementing the onWrite() Callback Method
84.6 Checking a Page is in Range
84.7 Drawing the Content on the Page Canvas
84.8 Starting the Print Job
84.9 Testing the Application
84.10 Summary
85
85. An Introduction to Android App Links
85. An Introduction to Android App Links
85.1 An Overview of Android App Links
85.2 App Link Intent Filters
85.3 Handling App Link Intents
85.4 Associating the App with a Website
85.5 Summary
86
86. An Android Studio App Links Tutorial
86. An Android Studio App Links Tutorial
86.1 About the Example App
86.2 The Database Schema
86.3 Loading and Running the Project
86.4 Adding the URL Mapping
86.5 Adding the Intent Filter
86.6 Adding Intent Handling Code
86.7 Testing the App Link
86.8 Associating an App Link with a Web Site
86.9 Summary
87
87. A Guide to the Android Studio Profiler
87. A Guide to the Android Studio Profiler
87.1 Accessing the Android Profiler
87.2 Enabling Advanced Profiling
87.3 The Android Profiler Tool Window
87.4 The Sessions Panel
87.5 The CPU Profiler
87.6 Memory Profiler
87.7 Network Profiler
87.8 Energy Profiler
87.9 Summary
88
88. An Android Biometric Authentication Tutorial
88. An Android Biometric Authentication Tutorial
88.1 An Overview of Biometric Authentication
88.2 Creating the Biometric Authentication Project
88.3 Configuring Device Fingerprint Authentication
88.4 Adding the Biometric Permission to the Manifest File
88.5 Designing the User Interface
88.6 Adding a Toast Convenience Method
88.7 Checking the Security Settings
88.8 Configuring the Authentication Callbacks
88.9 Adding the CancellationSignal
88.10 Starting the Biometric Prompt
88.11 Testing the Project
88.12 Summary
89
89. Creating, Testing and Uploading an Android App Bundle
89. Creating, Testing and Uploading an Android App Bundle
89.1 The Release Preparation Process
89.2 Android App Bundles
89.3 Register for a Google Play Developer Console Account
89.4 Configuring the App in the Console
89.5 Enabling Google Play App Signing
89.6 Creating a Keystore File
89.7 Creating the Android App Bundle
89.8 Generating Test APK Files
89.9 Uploading the App Bundle to the Google Play Developer Console
89.10 Exploring the App Bundle
89.11 Managing Testers
89.12 Uploading New App Bundle Revisions
89.13 Analyzing the App Bundle File
89.14 Enabling Google Play Signing for an Existing App
89.15 Summary
90
90. An Overview of Android Dynamic Feature Modules
90. An Overview of Android Dynamic Feature Modules
90.1 An Overview of Dynamic Feature Modules
90.2 Dynamic Feature Module Architecture
90.3 Creating a Dynamic Feature Module
90.4 Converting an Existing Module for Dynamic Delivery
90.5 Working with Dynamic Feature Modules
90.6 Handling Large Dynamic Feature Modules
90.7 Summary
91
91. An Android Studio Dynamic Feature Tutorial
91. An Android Studio Dynamic Feature Tutorial
91.1 Creating the DynamicFeature Project
91.2 Adding Dynamic Feature Support to the Project
91.3 Designing the Base Activity User Interface
91.4 Adding the Dynamic Feature Module
91.5 Reviewing the Dynamic Feature Module
91.6 Adding the Dynamic Feature Activity
91.7 Implementing the launchIntent() Method
91.8 Uploading the App Bundle for Testing
91.9 Implementing the installFeature() Method
91.10 Adding the Update Listener
91.11 Handling Large Downloads
91.12 Using Deferred Installation
91.13 Removing a Dynamic Module
91.14 Summary
92
92. An Overview of Gradle in Android Studio
92. An Overview of Gradle in Android Studio
92.1 An Overview of Gradle
92.2 Gradle and Android Studio
92.3 The Top-level Gradle Build File
92.4 Module Level Gradle Build Files
92.5 Configuring Signing Settings in the Build File
92.6 Running Gradle Tasks from the Command-line
92.7 Summary
93
Index
Index

58. An Overview of Android Intents

By this stage of the book, it should be clear that Android applications are comprised, among other things, of one or more activities. An area that has yet to be covered in extensive detail, however, is the mechanism by which one activity can trigger the launch of another activity. As outlined briefly in the chapter entitled “The Anatomy of an Android Application”, this is achieved primarily by using Intents.

Prior to working through some Android Studio based example implementations of intents in the following chapters, the goal of this chapter is to provide an overview of intents in the form of explicit intents and implicit intents together with an introduction to intent filters.

Previous Section
End of Section 1
Next Section