Book Image

Android Studio 3.5 Development Essentials - Java Edition

By : Neil Smyth
Book Image

Android Studio 3.5 Development Essentials - Java Edition

By: Neil Smyth

Overview of this book

Android applications have become an important part of our daily lives and lots of effort goes into developing an Android application. This book will help you to build you own Android applications using Java. Android Studio 3.5 Development Essentials – Java 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 emulator. You will test apps on physical Android devices, then study Android Studio code editor and constraint layout, Android architecture, the anatomy of an Android app, and Android activity state changes. The book then covers advanced topics such as views and widgets implementation, multi-window support integration, and biometric authentication, and finally, you will learn to upload your app to 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 Java.

Related Content you might be interested in

Current Title:

Small book image
Android Studio 3.5 Development Essentials - Java Edition
Neil Smyth
May, 2019 | 778 pages
No titles found
Table of Contents (86 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. Understanding Android Application and Activity Lifecycles
11. Understanding Android Application and Activity Lifecycles
11.1 Android Applications and Resource Management
11.2 Android Process States
11.3 Inter-Process Dependencies
11.4 The Activity Lifecycle
11.5 The Activity Stack
11.6 Activity States
11.7 Configuration Changes
11.8 Handling State Change
11.9 Summary
12
12. Handling Android Activity State Changes
12. Handling Android Activity State Changes
12.1 New vs. Old Lifecycle Techniques
12.2 The Activity and Fragment Classes
12.3 Dynamic State vs. Persistent State
12.4 The Android Lifecycle Methods
12.5 Lifetimes
12.6 Foldable Devices and Multi-Resume
12.7 Disabling Configuration Change Restarts
12.8 Lifecycle Method Limitations
12.9 Summary
13
13. Android Activity State Changes by Example
13. Android Activity State Changes by Example
13.1 Creating the State Change Example Project
13.2 Designing the User Interface
13.3 Overriding the Activity Lifecycle Methods
13.4 Filtering the Logcat Panel
13.5 Running the Application
13.6 Experimenting with the Activity
13.7 Summary
14
14. Saving and Restoring the State of an Android Activity
14. Saving and Restoring the State of an Android Activity
14.1 Saving Dynamic State
14.2 Default Saving of User Interface State
14.3 The Bundle Class
14.4 Saving the State
14.5 Restoring the State
14.6 Testing the Application
14.7 Summary
15
15. Understanding Android Views, View Groups and Layouts
15. Understanding Android Views, View Groups and Layouts
15.1 Designing for Different Android Devices
15.2 Views and View Groups
15.3 Android Layout Managers
15.4 The View Hierarchy
15.5 Creating User Interfaces
15.6 Summary
16
16. A Guide to the Android Studio Layout Editor Tool
16. A Guide to the Android Studio Layout Editor Tool
16.1 Basic vs. Empty Activity Templates
16.2 The Android Studio Layout Editor
16.3 Design Mode
16.4 The Palette
16.5 Design and Layout Views
16.6 Text Mode
16.7 Setting Attributes
16.8 Converting Views
16.9 Displaying Sample Data
16.10 Creating a Custom Device Definition
16.11 Changing the Current Device
16.12 Summary
17
17. A Guide to the Android ConstraintLayout
17. A Guide to the Android ConstraintLayout
17.1 How ConstraintLayout Works
17.2 Baseline Alignment
17.3 Working with Guidelines
17.4 Configuring Widget Dimensions
17.5 Working with Barriers
17.6 Ratios
17.7 ConstraintLayout Advantages
17.8 ConstraintLayout Availability
17.9 Summary
18
18. A Guide to using ConstraintLayout in Android Studio
18. A Guide to using ConstraintLayout in Android Studio
18.1 Design and Layout Views
18.2 Autoconnect Mode
18.3 Inference Mode
18.4 Manipulating Constraints Manually
18.5 Adding Constraints in the Inspector
18.6 Viewing Constraints in the Attributes Window
18.7 Deleting Constraints
18.8 Adjusting Constraint Bias
18.9 Understanding ConstraintLayout Margins
18.10 The Importance of Opposing Constraints and Bias
18.11 Configuring Widget Dimensions
18.12 Adding Guidelines
18.13 Adding Barriers
18.14 Widget Group Alignment and Distribution
18.15 Converting other Layouts to ConstraintLayout
18.16 Summary
19
19. Working with ConstraintLayout Chains and Ratios in Android Studio
19. Working with ConstraintLayout Chains and Ratios in Android Studio
19.1 Creating a Chain
19.2 Changing the Chain Style
19.3 Spread Inside Chain Style
19.4 Packed Chain Style
19.5 Packed Chain Style with Bias
19.6 Weighted Chain
19.7 Working with Ratios
19.8 Summary
20
20. An Android Studio Layout Editor ConstraintLayout Tutorial
20. An Android Studio Layout Editor ConstraintLayout Tutorial
20.1 An Android Studio Layout Editor Tool Example
20.2 Creating a New Activity
20.3 Preparing the Layout Editor Environment
20.4 Adding the Widgets to the User Interface
20.5 Adding the Constraints
20.6 Testing the Layout
20.7 Using the Layout Inspector
20.8 Summary
21
21. Manual XML Layout Design in Android Studio
21. Manual XML Layout Design in Android Studio
21.1 Manually Creating an XML Layout
21.2 Manual XML vs. Visual Layout Design
21.3 Summary
22
22. Managing Constraints using Constraint Sets
22. Managing Constraints using Constraint Sets
22.1 Java Code vs. XML Layout Files
22.2 Creating Views
22.3 View Attributes
22.4 Constraint Sets
22.5 Summary
23
23. An Android ConstraintSet Tutorial
23. An Android ConstraintSet Tutorial
23.1 Creating the Example Project in Android Studio
23.2 Adding Views to an Activity
23.3 Setting View Attributes
23.4 Creating View IDs
23.5 Configuring the Constraint Set
23.6 Adding the EditText View
23.7 Converting Density Independent Pixels (dp) to Pixels (px)
23.8 Summary
24
24. A Guide to using Apply Changes in Android Studio
24. A Guide to using Apply Changes in Android Studio
24.1 Introducing Apply Changes
24.2 Understanding Apply Changes Options
24.3 Using Apply Changes
24.4 Configuring Apply Changes Fallback Settings
24.5 An Apply Changes Tutorial
24.6 Using Apply Code Changes
24.7 Using Apply Changes and Restart Activity
24.8 Using Run App
24.9 Summary
25
25. An Overview and Example of Android Event Handling
25. An Overview and Example of Android Event Handling
25.1 Understanding Android Events
25.2 Using the android:onClick Resource
25.3 Event Listeners and Callback Methods
25.4 An Event Handling Example
25.5 Designing the User Interface
25.6 The Event Listener and Callback Method
25.7 Consuming Events
25.8 Summary
26
26. Android Touch and Multi-touch Event Handling
26. Android Touch and Multi-touch Event Handling
26.1 Intercepting Touch Events
26.2 The MotionEvent Object
26.3 Understanding Touch Actions
26.4 Handling Multiple Touches
26.5 An Example Multi-Touch Application
26.6 Designing the Activity User Interface
26.7 Implementing the Touch Event Listener
26.8 Running the Example Application
26.9 Summary
27
27. Detecting Common Gestures using the Android Gesture Detector Class
27. Detecting Common Gestures using the Android Gesture Detector Class
27.1 Implementing Common Gesture Detection
27.2 Creating an Example Gesture Detection Project
27.3 Implementing the Listener Class
27.4 Creating the GestureDetectorCompat Instance
27.5 Implementing the onTouchEvent() Method
27.6 Testing the Application
27.7 Summary
28
28. Implementing Custom Gesture and Pinch Recognition on Android
28. Implementing Custom Gesture and Pinch Recognition on Android
28.1 The Android Gesture Builder Application
28.2 The GestureOverlayView Class
28.3 Detecting Gestures
28.4 Identifying Specific Gestures
28.5 Installing and Running the Gesture Builder Application
28.6 Creating a Gestures File
28.7 Creating the Example Project
28.8 Extracting the Gestures File from the SD Card
28.9 Adding the Gestures File to the Project
28.10 Designing the User Interface
28.11 Loading the Gestures File
28.12 Registering the Event Listener
28.13 Implementing the onGesturePerformed Method
28.14 Testing the Application
28.15 Configuring the GestureOverlayView
28.16 Intercepting Gestures
28.17 Detecting Pinch Gestures
28.18 A Pinch Gesture Example Project
28.19 Summary
29
29. An Introduction to Android Fragments
29. An Introduction to Android Fragments
29.1 What is a Fragment?
29.2 Creating a Fragment
29.3 Adding a Fragment to an Activity using the Layout XML File
29.4 Adding and Managing Fragments in Code
29.5 Handling Fragment Events
29.6 Implementing Fragment Communication
29.7 Summary
30
30. Using Fragments in Android Studio - An Example
30. Using Fragments in Android Studio - An Example
30.1 About the Example Fragment Application
30.2 Creating the Example Project
30.3 Creating the First Fragment Layout
30.4 Creating the First Fragment Class
30.5 Creating the Second Fragment Layout
30.6 Adding the Fragments to the Activity
30.7 Making the Toolbar Fragment Talk to the Activity
30.8 Making the Activity Talk to the Text Fragment
30.9 Testing the Application
30.10 Summary
31
31. Modern Android App Architecture with Jetpack
31. Modern Android App Architecture with Jetpack
31.1 What is Android Jetpack?
31.2 The “Old” Architecture
31.3 Modern Android Architecture
31.4 The ViewModel Component
31.5 The LiveData Component
31.6 LiveData and Data Binding
31.7 Android Lifecycles
31.8 Repository Modules
31.9 Summary
32
32. An Android Jetpack ViewModel Tutorial
32. An Android Jetpack ViewModel Tutorial
32.1 About the Project
32.2 Creating the ViewModel Example Project
32.3 Reviewing the Project
32.4 Designing the Fragment Layout
32.5 Implementing the View Model
32.6 Associating the Fragment with the View Model
32.7 Modifying the Fragment
32.8 Accessing the ViewModel Data
32.9 Testing the Project
32.10 Summary
33
33. An Android Jetpack LiveData Tutorial
33. An Android Jetpack LiveData Tutorial
33.1 LiveData - A Recap
33.2 Adding LiveData to the ViewModel
33.3 Implementing the Observer
33.4 Summary
34
34. An Overview of Android Jetpack Data Binding
34. An Overview of Android Jetpack Data Binding
34.1 An Overview of Data Binding
34.2 The Key Components of Data Binding
34.3 Summary
35
35. An Android Jetpack Data Binding Tutorial
35. An Android Jetpack Data Binding Tutorial
35.1 Removing the Redundant Code
35.2 Enabling Data Binding
35.3 Adding the Layout Element
35.4 Adding the Data Element to Layout File
35.5 Working with the Binding Class
35.6 Assigning the ViewModel Instance to the Data Binding Variable
35.7 Adding Binding Expressions
35.8 Adding the Conversion Method
35.9 Adding a Listener Binding
35.10 Testing the App
35.11 Summary
36
36. Working with Android Lifecycle-Aware Components
36. Working with Android Lifecycle-Aware Components
36.1 Lifecycle Awareness
36.2 Lifecycle Owners
36.3 Lifecycle Observers
36.4 Lifecycle States and Events
36.5 Summary
37
37. An Android Jetpack Lifecycle Awareness Tutorial
37. An Android Jetpack Lifecycle Awareness Tutorial
37.1 Creating the Example Lifecycle Project
37.2 Creating a Lifecycle Observer
37.3 Adding the Observer
37.4 Testing the Observer
37.5 Creating a Lifecycle Owner
37.6 Testing the Custom Lifecycle Owner
37.7 Summary
38
38. An Overview of the Navigation Architecture Component
38. An Overview of the Navigation Architecture Component
38.1 Understanding Navigation
38.2 Declaring a Navigation Host
38.3 The Navigation Graph
38.4 Accessing the Navigation Controller
38.5 Triggering a Navigation Action
38.6 Passing Arguments
38.7 Summary
39
39. An Android Jetpack Navigation Component Tutorial
39. An Android Jetpack Navigation Component Tutorial
39.1 Creating the NavigationDemo Project
39.2 Adding Navigation to the Build Configuration
39.3 Creating the Navigation Graph Resource File
39.4 Declaring a Navigation Host
39.5 Adding Navigation Destinations
39.6 Designing the Destination Fragment Layouts
39.7 Adding an Action to the Navigation Graph
39.8 Implement the OnFragmentInteractionListener
39.9 Triggering the Action
39.10 Passing Data Using Safeargs
39.11 Summary
40
40. Creating and Managing Overflow Menus on Android
40. Creating and Managing Overflow Menus on Android
40.1 The Overflow Menu
40.2 Creating an Overflow Menu
40.3 Displaying an Overflow Menu
40.4 Responding to Menu Item Selections
40.5 Creating Checkable Item Groups
40.6 Menus and the Android Studio Menu Editor
40.7 Creating the Example Project
40.8 Designing the Menu
40.9 Modifying the onOptionsItemSelected() Method
40.10 Testing the Application
40.11 Summary
41
41. Animating User Interfaces with the Android Transitions Framework
41. Animating User Interfaces with the Android Transitions Framework
41.1 Introducing Android Transitions and Scenes
41.2 Using Interpolators with Transitions
41.3 Working with Scene Transitions
41.4 Custom Transitions and TransitionSets in Code
41.5 Custom Transitions and TransitionSets in XML
41.6 Working with Interpolators
41.7 Creating a Custom Interpolator
41.8 Using the beginDelayedTransition Method
41.9 Summary
42
42. An Android Transition Tutorial using beginDelayedTransition
42. An Android Transition Tutorial using beginDelayedTransition
42.1 Creating the Android Studio TransitionDemo Project
42.2 Preparing the Project Files
42.3 Implementing beginDelayedTransition Animation
42.4 Customizing the Transition
42.5 Summary
43
43. Implementing Android Scene Transitions – A Tutorial
43. Implementing Android Scene Transitions – A Tutorial
43.1 An Overview of the Scene Transition Project
43.2 Creating the Android Studio SceneTransitions Project
43.3 Identifying and Preparing the Root Container
43.4 Designing the First Scene
43.5 Designing the Second Scene
43.6 Entering the First Scene
43.7 Loading Scene 2
43.8 Implementing the Transitions
43.9 Adding the Transition File
43.10 Loading and Using the Transition Set
43.11 Configuring Additional Transitions
43.12 Summary
44
44. Working with the Floating Action Button and Snackbar
44. Working with the Floating Action Button and Snackbar
44.1 The Material Design
44.2 The Design Library
44.3 The Floating Action Button (FAB)
44.4 The Snackbar
44.5 Creating the Example Project
44.6 Reviewing the Project
44.7 Changing the Floating Action Button
44.8 Adding the ListView to the Content Layout
44.9 Adding Items to the ListView
44.10 Adding an Action to the Snackbar
44.11 Summary
45
45. Creating a Tabbed Interface using the TabLayout Component
45. Creating a Tabbed Interface using the TabLayout Component
45.1 An Introduction to the ViewPager
45.2 An Overview of the TabLayout Component
45.3 Creating the TabLayoutDemo Project
45.4 Creating the First Fragment
45.5 Duplicating the Fragments
45.6 Adding the TabLayout and ViewPager
45.7 Creating the Pager Adapter
45.8 Performing the Initialization Tasks
45.9 Testing the Application
45.10 Customizing the TabLayout
45.11 Displaying Icon Tab Items
45.12 Summary
46
46. Working with the RecyclerView and CardView Widgets
46. Working with the RecyclerView and CardView Widgets
46.1 An Overview of the RecyclerView
46.2 An Overview of the CardView
46.3 Summary
47
47. An Android RecyclerView and CardView Tutorial
47. An Android RecyclerView and CardView Tutorial
47.1 Creating the CardDemo Project
47.2 Removing the Floating Action Button
47.3 Designing the CardView Layout
47.4 Adding the RecyclerView
47.5 Creating the RecyclerView Adapter
47.6 Adding the Image Files
47.7 Initializing the RecyclerView Component
47.8 Testing the Application
47.9 Responding to Card Selections
47.10 Summary
48
48. A Layout Editor Sample Data Tutorial
48. A Layout Editor Sample Data Tutorial
48.1 Adding Sample Data to a Project
48.2 Using Custom Sample Data
48.3 Summary
49
49. Working with the AppBar and Collapsing Toolbar Layouts
49. Working with the AppBar and Collapsing Toolbar Layouts
49.1 The Anatomy of an AppBar
49.2 The Example Project
49.3 Coordinating the RecyclerView and Toolbar
49.4 Introducing the Collapsing Toolbar Layout
49.5 Changing the Title and Scrim Color
49.6 Summary
50
50. An Android Studio Master/Detail Flow Tutorial
50. An Android Studio Master/Detail Flow Tutorial
50.1 The Master/Detail Flow
50.2 Creating a Master/Detail Flow Activity
50.3 The Anatomy of the Master/Detail Flow Template
50.4 Modifying the Master/Detail Flow Template
50.5 Changing the Content Model
50.6 Changing the Detail Pane
50.7 Modifying the WebsiteDetailFragment Class
50.8 Modifying the WebsiteListActivity Class
50.9 Adding Manifest Permissions
50.10 Running the Application
50.11 Summary
51
51. An Overview of Android Intents
51. An Overview of Android Intents
51.1 An Overview of Intents
51.2 Explicit Intents
51.3 Returning Data from an Activity
51.4 Implicit Intents
51.5 Using Intent Filters
51.6 Checking Intent Availability
51.7 Summary
52
52. Android Explicit Intents – A Worked Example
52. Android Explicit Intents – A Worked Example
52.1 Creating the Explicit Intent Example Application
52.2 Designing the User Interface Layout for MainActivity
52.3 Creating the Second Activity Class
52.4 Designing the User Interface Layout for ActivityB
52.5 Reviewing the Application Manifest File
52.6 Creating the Intent
52.7 Extracting Intent Data
52.8 Launching ActivityB as a Sub-Activity
52.9 Returning Data from a Sub-Activity
52.10 Testing the Application
52.11 Summary
53
53. Android Implicit Intents – A Worked Example
53. Android Implicit Intents – A Worked Example
53.1 Creating the Android Studio Implicit Intent Example Project
53.2 Designing the User Interface
53.3 Creating the Implicit Intent
53.4 Adding a Second Matching Activity
53.5 Adding the Web View to the UI
53.6 Obtaining the Intent URL
53.7 Modifying the MyWebView Project Manifest File
53.8 Installing the MyWebView Package on a Device
53.9 Testing the Application
53.10 Summary
54
54. Android Broadcast Intents and Broadcast Receivers
54. Android Broadcast Intents and Broadcast Receivers
54.1 An Overview of Broadcast Intents
54.2 An Overview of Broadcast Receivers
54.3 Obtaining Results from a Broadcast
54.4 Sticky Broadcast Intents
54.5 The Broadcast Intent Example
54.6 Creating the Example Application
54.7 Creating and Sending the Broadcast Intent
54.8 Creating the Broadcast Receiver
54.9 Registering the Broadcast Receiver
54.10 Testing the Broadcast Example
54.11 Listening for System Broadcasts
54.12 Summary
55
55. A Basic Overview of Threads and AsyncTasks
55. A Basic Overview of Threads and AsyncTasks
55.1 An Overview of Threads
55.2 The Application Main Thread
55.3 Thread Handlers
55.4 A Basic AsyncTask Example
55.5 Subclassing AsyncTask
55.6 Testing the App
55.7 Canceling a Task
55.8 Summary
56
56. An Overview of Android Started and Bound Services
56. An Overview of Android Started and Bound Services
56.1 Started Services
56.2 Intent Service
56.3 Bound Service
56.4 The Anatomy of a Service
56.5 Controlling Destroyed Service Restart Options
56.6 Declaring a Service in the Manifest File
56.7 Starting a Service Running on System Startup
56.8 Summary
57
57. Implementing an Android Started Service – A Worked Example
57. Implementing an Android Started Service – A Worked Example
57.1 Creating the Example Project
57.2 Creating the Service Class
57.3 Adding the Service to the Manifest File
57.4 Starting the Service
57.5 Testing the IntentService Example
57.6 Using the Service Class
57.7 Creating the New Service
57.8 Modifying the User Interface
57.9 Running the Application
57.10 Creating an AsyncTask for Service Tasks
57.11 Summary
58
58. Android Local Bound Services – A Worked Example
58. Android Local Bound Services – A Worked Example
58.1 Understanding Bound Services
58.2 Bound Service Interaction Options
58.3 An Android Studio Local Bound Service Example
58.4 Adding a Bound Service to the Project
58.5 Implementing the Binder
58.6 Binding the Client to the Service
58.7 Completing the Example
58.8 Testing the Application
58.9 Summary
59
59. Android Remote Bound Services – A Worked Example
59. Android Remote Bound Services – A Worked Example
59.1 Client to Remote Service Communication
59.2 Creating the Example Application
59.3 Designing the User Interface
59.4 Implementing the Remote Bound Service
59.5 Configuring a Remote Service in the Manifest File
59.6 Launching and Binding to the Remote Service
59.7 Sending a Message to the Remote Service
59.8 Summary
60
60. An Android Notifications Tutorial
60. An Android Notifications Tutorial
60.1 An Overview of Notifications
60.2 Creating the NotifyDemo Project
60.3 Designing the User Interface
60.4 Creating the Second Activity
60.5 Creating a Notification Channel
60.6 Creating and Issuing a Basic Notification
60.7 Launching an Activity from a Notification
60.8 Adding Actions to a Notification
60.9 Bundled Notifications
60.10 Summary
61
61. An Android Direct Reply Notification Tutorial
61. An Android Direct Reply Notification Tutorial
61.1 Creating the DirectReply Project
61.2 Designing the User Interface
61.3 Creating the Notification Channel
61.4 Building the RemoteInput Object
61.5 Creating the PendingIntent
61.6 Creating the Reply Action
61.7 Receiving Direct Reply Input
61.8 Updating the Notification
61.9 Summary
62
62. Foldable Devices and Multi-Window Support
62. Foldable Devices and Multi-Window Support
62.1 Foldables and Multi-Window Support
62.2 Using a Foldable Emulator
62.3 Entering Multi-Window Mode
62.4 Enabling and using Freeform Support
62.5 Checking for Freeform Support
62.6 Enabling Multi-Window Support in an App
62.7 Specifying Multi-Window Attributes
62.8 Detecting Multi-Window Mode in an Activity
62.9 Receiving Multi-Window Notifications
62.10 Launching an Activity in Multi-Window Mode
62.11 Configuring Freeform Activity Size and Position
62.12 Summary
63
63. An Overview of Android SQLite Databases
63. An Overview of Android SQLite Databases
63.1 Understanding Database Tables
63.2 Introducing Database Schema
63.3 Columns and Data Types
63.4 Database Rows
63.5 Introducing Primary Keys
63.6 What is SQLite?
63.7 Structured Query Language (SQL)
63.8 Trying SQLite on an Android Virtual Device (AVD)
63.9 The Android Room Persistence Library
63.10 Summary
64
64. The Android Room Persistence Library
64. The Android Room Persistence Library
64.1 Revisiting Modern App Architecture
64.2 Key Elements of Room Database Persistence
64.3 Understanding Entities
64.4 Data Access Objects
64.5 The Room Database
64.6 The Repository
64.7 In-Memory Databases
64.8 Summary
65
65. An Android TableLayout and TableRow Tutorial
65. An Android TableLayout and TableRow Tutorial
65.1 The TableLayout and TableRow Layout Views
65.2 Creating the Room Database Project
65.3 Converting to a LinearLayout
65.4 Adding the TableLayout to the User Interface
65.5 Configuring the TableRows
65.6 Adding the Button Bar to the Layout
65.7 Adding the RecyclerView
65.8 Adjusting the Layout Margins
65.9 Summary
66
66. An Android Room Database and Repository Tutorial
66. An Android Room Database and Repository Tutorial
66.1 About the RoomDemo Project
66.2 Modifying the Build Configuration
66.3 Building the Entity
66.4 Creating the Data Access Object
66.5 Adding the Room Database
66.6 Adding the Repository
66.7 Modifying the ViewModel
66.8 Creating the Product Item Layout
66.9 Adding the RecyclerView Adapter
66.10 Preparing the Main Fragment
66.11 Adding the Button Listeners
66.12 Adding LiveData Observers
66.13 Initializing the RecyclerView
66.14 Testing the RoomDemo App
66.15 Summary
67
67. Accessing Cloud Storage using the Android Storage Access Framework
67. Accessing Cloud Storage using the Android Storage Access Framework
67.1 The Storage Access Framework
67.2 Working with the Storage Access Framework
67.3 Filtering Picker File Listings
67.4 Handling Intent Results
67.5 Reading the Content of a File
67.6 Writing Content to a File
67.7 Deleting a File
67.8 Gaining Persistent Access to a File
67.9 Summary
68
68. An Android Storage Access Framework Example
68. An Android Storage Access Framework Example
68.1 About the Storage Access Framework Example
68.2 Creating the Storage Access Framework Example
68.3 Designing the User Interface
68.4 Declaring Request Codes
68.5 Creating a New Storage File
68.6 The onActivityResult() Method
68.7 Saving to a Storage File
68.8 Opening and Reading a Storage File
68.9 Testing the Storage Access Application
68.10 Summary
69
69. Implementing Video Playback on Android using the VideoView and MediaController Classes
69. Implementing Video Playback on Android using the VideoView and MediaController Classes
69.1 Introducing the Android VideoView Class
69.2 Introducing the Android MediaController Class
69.3 Creating the Video Playback Example
69.4 Designing the VideoPlayer Layout
69.5 Configuring the VideoView
69.6 Adding Internet Permission
69.7 Adding the MediaController to the Video View
69.8 Setting up the onPreparedListener
69.9 Summary
70
70. Android Picture-in-Picture Mode
70. Android Picture-in-Picture Mode
70.1 Picture-in-Picture Features
70.2 Enabling Picture-in-Picture Mode
70.3 Configuring Picture-in-Picture Parameters
70.4 Entering Picture-in-Picture Mode
70.5 Detecting Picture-in-Picture Mode Changes
70.6 Adding Picture-in-Picture Actions
70.7 Summary
71
71. An Android Picture-in-Picture Tutorial
71. An Android Picture-in-Picture Tutorial
71.1 Adding Picture-in-Picture Support to the Manifest
71.2 Adding a Picture-in-Picture Button
71.3 Entering Picture-in-Picture Mode
71.4 Detecting Picture-in-Picture Mode Changes
71.5 Adding a Broadcast Receiver
71.6 Adding the PiP Action
71.7 Testing the Picture-in-Picture Action
71.8 Summary
72
72. Making Runtime Permission Requests in Android
72. Making Runtime Permission Requests in Android
72.1 Understanding Normal and Dangerous Permissions
72.2 Creating the Permissions Example Project
72.3 Checking for a Permission
72.4 Requesting Permission at Runtime
72.5 Providing a Rationale for the Permission Request
72.6 Testing the Permissions App
72.7 Summary
73
73. Android Audio Recording and Playback using MediaPlayer and MediaRecorder
73. Android Audio Recording and Playback using MediaPlayer and MediaRecorder
73.1 Playing Audio
73.2 Recording Audio and Video using the MediaRecorder Class
73.3 About the Example Project
73.4 Creating the AudioApp Project
73.5 Designing the User Interface
73.6 Checking for Microphone Availability
73.7 Performing the Activity Initialization
73.8 Implementing the recordAudio() Method
73.9 Implementing the stopAudio() Method
73.10 Implementing the playAudio() method
73.11 Configuring and Requesting Permissions
73.12 Testing the Application
73.13 Summary
74
74. Working with the Google Maps Android API in Android Studio
74. Working with the Google Maps Android API in Android Studio
74.1 The Elements of the Google Maps Android API
74.2 Creating the Google Maps Project
74.3 Obtaining Your Developer Signature
74.4 Adding the Apache HTTP Legacy Library Requirement
74.5 Testing the Application
74.6 Understanding Geocoding and Reverse Geocoding
74.7 Adding a Map to an Application
74.8 Requesting Current Location Permission
74.9 Displaying the User’s Current Location
74.10 Changing the Map Type
74.11 Displaying Map Controls to the User
74.12 Handling Map Gesture Interaction
74.13 Creating Map Markers
74.14 Controlling the Map Camera
74.15 Summary
75
75. Printing with the Android Printing Framework
75. Printing with the Android Printing Framework
75.1 The Android Printing Architecture
75.2 The Print Service Plugins
75.3 Google Cloud Print
75.4 Printing to Google Drive
75.5 Save as PDF
75.6 Printing from Android Devices
75.7 Options for Building Print Support into Android Apps
75.8 Summary
76
76. An Android HTML and Web Content Printing Example
76. An Android HTML and Web Content Printing Example
76.1 Creating the HTML Printing Example Application
76.2 Printing Dynamic HTML Content
76.3 Creating the Web Page Printing Example
76.4 Removing the Floating Action Button
76.5 Designing the User Interface Layout
76.6 Loading the Web Page into the WebView
76.7 Adding the Print Menu Option
76.8 Summary
77
77. A Guide to Android Custom Document Printing
77. A Guide to Android Custom Document Printing
77.1 An Overview of Android Custom Document Printing
77.2 Preparing the Custom Document Printing Project
77.3 Creating the Custom Print Adapter
77.4 Implementing the onLayout() Callback Method
77.5 Implementing the onWrite() Callback Method
77.6 Checking a Page is in Range
77.7 Drawing the Content on the Page Canvas
77.8 Starting the Print Job
77.9 Testing the Application
77.10 Summary
78
78. An Introduction to Android App Links
78. An Introduction to Android App Links
78.1 An Overview of Android App Links
78.2 App Link Intent Filters
78.3 Handling App Link Intents
78.4 Associating the App with a Website
78.5 Summary
79
79. An Android Studio App Links Tutorial
79. An Android Studio App Links Tutorial
79.1 About the Example App
79.2 The Database Schema
79.3 Loading and Running the Project
79.4 Adding the URL Mapping
79.5 Adding the Intent Filter
79.6 Adding Intent Handling Code
79.7 Testing the App Link
79.8 Associating an App Link with a Web Site
79.9 Summary
80
80. A Guide to the Android Studio Profiler
80. A Guide to the Android Studio Profiler
80.1 Accessing the Android Profiler
80.2 Enabling Advanced Profiling
80.3 The Android Profiler Tool Window
80.4 The Sessions Panel
80.5 The CPU Profiler
80.6 Memory Profiler
80.7 Network Profiler
80.8 Energy Profiler
80.9 Summary
81
81. An Android Biometric Authentication Tutorial
81. An Android Biometric Authentication Tutorial
81.1 An Overview of Biometric Authentication
81.2 Creating the Biometric Authentication Project
81.3 Configuring Device Fingerprint Authentication
81.4 Adding the Biometric Permission to the Manifest File
81.5 Designing the User Interface
81.6 Adding a Toast Convenience Method
81.7 Checking the Security Settings
81.8 Configuring the Authentication Callbacks
81.9 Adding the CancellationSignal
81.10 Starting the Biometric Prompt
81.11 Testing the Project
81.12 Summary
82
82. Creating, Testing and Uploading an Android App Bundle
82. Creating, Testing and Uploading an Android App Bundle
82.1 The Release Preparation Process
82.2 Android App Bundles
82.3 Register for a Google Play Developer Console Account
82.4 Configuring the App in the Console
82.5 Enabling Google Play App Signing
82.6 Creating a Keystore File
82.7 Creating the Android App Bundle
82.8 Generating Test APK Files
82.9 Uploading the App Bundle to the Google Play Developer Console
82.10 Exploring the App Bundle
82.11 Managing Testers
82.12 Uploading New App Bundle Revisions
82.13 Analyzing the App Bundle File
82.14 Enabling Google Play Signing for an Existing App
82.15 Summary
83
83. An Overview of Android Dynamic Feature Modules
83. An Overview of Android Dynamic Feature Modules
83.1 An Overview of Dynamic Feature Modules
83.2 Dynamic Feature Module Architecture
83.3 Creating a Dynamic Feature Module
83.4 Converting an Existing Module for Dynamic Delivery
83.5 Working with Dynamic Feature Modules
83.6 Handling Large Dynamic Feature Modules
83.7 Summary
84
84. An Android Studio Dynamic Feature Tutorial
84. An Android Studio Dynamic Feature Tutorial
84.1 Creating the DynamicFeature Project
84.2 Adding Dynamic Feature Support to the Project
84.3 Designing the Base Activity User Interface
84.4 Adding the Dynamic Feature Module
84.5 Reviewing the Dynamic Feature Module
84.6 Adding the Dynamic Feature Activity
84.7 Implementing the launchIntent() Method
84.8 Uploading the App Bundle for Testing
84.9 Implementing the installFeature() Method
84.10 Adding the Update Listener
84.11 Handling Large Downloads
84.12 Using Deferred Installation
84.13 Removing a Dynamic Module
84.14 Summary
85
85. An Overview of Gradle in Android Studio
85. An Overview of Gradle in Android Studio
85.1 An Overview of Gradle
85.2 Gradle and Android Studio
85.3 The Top-level Gradle Build File
85.4 Module Level Gradle Build Files
85.5 Configuring Signing Settings in the Build File
85.6 Running Gradle Tasks from the Command-line
85.7 Summary
86
Index
Index

84.3 Designing the Base Activity User Interface

At this point, the project consists of a single activity which will serve as the entry point for the base module of the app. This base module will be responsible for requesting, installing and managing the dynamic feature module.

To demonstrate the use of dynamic features, the base activity will consist of a series of buttons which will allow the dynamic feature module to be installed, launched and removed. The user interface will also include a TextView object to display status information relating to the dynamic feature module. With these requirements in mind, load the activity_main.xml layout file into the layout editor, delete the default TextView object, and implement the design so that it resembles Figure 84-1 below.

Figure 84-1

Once the objects have been positioned, select the TextView widget and use the Attributes tool window to set the id property to status_text. Begin applying layout constraints by selecting all...

Previous Section
End of Section 4
Next Section