book

Android Studio 4.0 Development Essentials - Kotlin Edition

Name: Android Studio 4.0 Development Essentials - Kotlin Edition
Author: Neil Smyth
ISBN: 9781800560437

by Neil Smyth

October 2020

Intermediate to advanced

817 pages

23h 57m

English

Packt Publishing

Read now

Unlock full access

1. Introduction
1.1 Downloading the Code Samples1.2 Feedback1.3 Errata
2. Setting up an Android Studio Development Environment
2.1 System Requirements2.2 Downloading the Android Studio Package2.3 Installing Android Studio2.3.1 Installation on Windows2.3.2 Installation on macOS2.3.3 Installation on Linux2.4 The Android Studio Setup Wizard2.5 Installing Additional Android SDK Packages2.6 Making the Android SDK Tools Command-line Accessible2.6.1 Windows 72.6.2 Windows 8.12.6.3 Windows 102.6.4 Linux2.6.5 macOS2.7 Android Studio Memory Management2.8 Updating Android Studio and the SDK2.9 Summary
3. Creating an Example Android App in Android Studio
3.1 About the Project3.2 Creating a New Android Project3.3 Creating an Activity3.4 Defining the Project and SDK Settings3.5 Modifying the Example Application3.6 Modifying the User Interface 3.7 Reviewing the Layout and Resource Files3.8 Adding Interaction3.9 Summary
4. Creating an Android Virtual Device (AVD) in Android Studio
4.1 About Android Virtual Devices4.2 Creating a New AVD4.3 Starting the Emulator4.4 Running the Application in the AVD4.5 Stopping a Running Application4.6 Supporting Dark Theme4.7 AVD Command-line Creation4.8 Android Virtual Device Configuration Files4.9 Moving and Renaming an Android Virtual Device4.10 Summary
5. Using and Configuring the Android Studio AVD Emulator
5.1 The Emulator Environment5.2 The Emulator Toolbar Options5.3 Working in Zoom Mode5.4 Resizing the Emulator Window5.5 Extended Control Options5.5.1 Location5.5.2 Displays5.5.3 Cellular5.5.4 Camera5.5.5 Battery5.5.6 Phone5.5.7 Directional Pad5.5.8 Microphone5.5.9 Fingerprint5.5.10 Virtual Sensors5.5.11 Snapshots5.5.12 Record and Playback5.5.13 Google Play5.5.14 Settings5.5.15 Help5.6 Working with Snapshots5.7 Configuring Fingerprint Emulation5.8 Summary
6. A Tour of the Android Studio User Interface
6.1 The Welcome Screen6.2 The Main Window6.3 The Tool Windows6.4 Android Studio Keyboard Shortcuts6.5 Switcher and Recent Files Navigation6.6 Changing the Android Studio Theme6.7 Summary
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 Devices7.2.1 macOS ADB Configuration7.2.2 Windows ADB Configuration7.2.3 Linux adb Configuration7.3 Testing the adb Connection7.4 Summary
8. The Basics of the Android Studio Code Editor
8.1 The Android Studio Editor8.2 Splitting the Editor Window8.3 Code Completion8.4 Statement Completion8.5 Parameter Information8.6 Parameter Name Hints8.7 Code Generation8.8 Code Folding8.9 Quick Documentation Lookup8.10 Code Reformatting8.11 Finding Sample Code8.12 Live Templates8.13 Summary
9. An Overview of the Android Architecture
9.1 The Android Software Stack9.2 The Linux Kernel9.3 Android Runtime – ART9.4 Android Libraries9.4.1 C/C++ Libraries9.5 Application Framework9.6 Applications9.7 Summary
10. The Anatomy of an Android Application
10.1 Android Activities10.2 Android Fragments10.3 Android Intents10.4 Broadcast Intents10.5 Broadcast Receivers10.6 Android Services10.7 Content Providers10.8 The Application Manifest10.9 Application Resources10.10 Application Context10.11 Summary

11. An Introduction to Kotlin
11.1 What is Kotlin?11.2 Kotlin and Java11.3 Converting from Java to Kotlin11.4 Kotlin and Android Studio11.5 Experimenting with Kotlin11.6 Semi-colons in Kotlin11.7 Summary
12. Kotlin Data Types,Variables and Nullability
12.1 Kotlin Data Types12.1.1 Integer Data Types12.1.2 Floating Point Data Types12.1.3 Boolean Data Type12.1.4 Character Data Type12.1.5 String Data Type12.1.6 Escape Sequences12.2 Mutable Variables12.3 Immutable Variables12.4 Declaring Mutable and Immutable Variables12.5 Data Types are Objects12.6 Type Annotations and Type Inference12.7 Nullable Type12.8 The Safe Call Operator12.9 Not-Null Assertion12.10 Nullable Types and the let Function12.11 Late Initialization (lateinit)12.12 The Elvis Operator12.13 Type Casting and Type Checking12.14 Summary
13. Kotlin Operators and Expressions
13.1 Expression Syntax in Kotlin13.2 The Basic Assignment Operator13.3 Kotlin Arithmetic Operators13.4 Augmented Assignment Operators13.5 Increment and Decrement Operators13.6 Equality Operators13.7 Boolean Logical Operators13.8 Range Operator13.9 Bitwise Operators13.9.1 Bitwise Inversion13.9.2 Bitwise AND13.9.3 Bitwise OR13.9.4 Bitwise XOR13.9.5 Bitwise Left Shift13.9.6 Bitwise Right Shift13.10 Summary
14. Kotlin Flow Control
14.1 Looping Flow Control14.1.1 The Kotlin for-in Statement14.1.2 The while Loop 14.1.3 The do ... while loop 14.1.4 Breaking from Loops14.1.5 The continue Statement 14.1.6 Break and Continue Labels14.2 Conditional Flow Control14.2.1 Using the if Expressions 14.2.2 Using if ... else … Expressions 14.2.3 Using if ... else if ... Expressions 14.2.4 Using the when Statement14.3 Summary
15. An Overview of Kotlin Functions and Lambdas
15.1 What is a Function?15.2 How to Declare a Kotlin Function15.3 Calling a Kotlin Function15.4 Single Expression Functions15.5 Local Functions15.6 Handling Return Values15.7 Declaring Default Function Parameters15.8 Variable Number of Function Parameters 15.9 Lambda Expressions15.10 Higher-order Functions15.11 Summary
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 Class16.4 Adding Properties to a Class16.5 Defining Methods16.6 Declaring and Initializing a Class Instance16.7 Primary and Secondary Constructors16.8 Initializer Blocks16.9 Calling Methods and Accessing Properties16.10 Custom Accessors16.11 Nested and Inner Classes16.12 Companion Objects16.13 Summary
17. An Introduction to Kotlin Inheritance and Subclassing
17.1 Inheritance, Classes and Subclasses17.2 Subclassing Syntax17.3 A Kotlin Inheritance Example17.4 Extending the Functionality of a Subclass17.5 Overriding Inherited Methods17.6 Adding a Custom Secondary Constructor17.7 Using the SavingsAccount Class17.8 Summary
18. An Overview of Android View Binding
18.1 Find View by ID and Synthetic Properties18.2 View Bindings 18.3 Converting the AndroidSample Project18.4 Enabling View Binding18.5 Using View Bindings18.6 Choosing an Option18.7 Summary
19. Understanding Android Application and Activity Lifecycles
19.1 Android Applications and Resource Management19.2 Android Process States19.2.1 Foreground Process19.2.2 Visible Process19.2.3 Service Process19.2.4 Background Process19.2.5 Empty Process19.3 Inter-Process Dependencies 19.4 The Activity Lifecycle19.5 The Activity Stack19.6 Activity States19.7 Configuration Changes19.8 Handling State Change19.9 Summary
20. Handling Android Activity State Changes
20.1 New vs. Old Lifecycle Techniques20.2 The Activity and Fragment Classes20.3 Dynamic State vs. Persistent State20.4 The Android Lifecycle Methods20.5 Lifetimes20.6 Foldable Devices and Multi-Resume20.7 Disabling Configuration Change Restarts20.8 Lifecycle Method Limitations20.9 Summary
21. Android Activity State Changes by Example
21.1 Creating the State Change Example Project21.2 Designing the User Interface21.3 Overriding the Activity Lifecycle Methods21.4 Filtering the Logcat Panel21.5 Running the Application21.6 Experimenting with the Activity21.7 Summary
22. Saving and Restoring the State of an Android Activity
22.1 Saving Dynamic State22.2 Default Saving of User Interface State22.3 The Bundle Class22.4 Saving the State22.5 Restoring the State22.6 Testing the Application22.7 Summary
23. Understanding Android Views, View Groups and Layouts
23.1 Designing for Different Android Devices23.2 Views and View Groups23.3 Android Layout Managers23.4 The View Hierarchy23.5 Creating User Interfaces23.6 Summary
24. A Guide to the Android Studio Layout Editor Tool
24.1 Basic vs. Empty Activity Templates24.2 The Android Studio Layout Editor24.3 Design Mode24.4 The Palette24.5 Design Mode and Layout Views24.6 Code Mode24.7 Split Mode24.8 Setting Attributes24.9 Converting Views24.10 Displaying Sample Data24.11 Creating a Custom Device Definition24.12 Changing the Current Device24.13 Layout Validation (Multi Preview)24.14 Summary
25. A Guide to the Android ConstraintLayout
25.1 How ConstraintLayout Works25.1.1 Constraints25.1.2 Margins25.1.3 Opposing Constraints25.1.4 Constraint Bias25.1.5 Chains25.1.6 Chain Styles25.2 Baseline Alignment25.3 Working with Guidelines25.4 Configuring Widget Dimensions25.5 Working with Barriers25.6 Ratios25.7 ConstraintLayout Advantages25.8 ConstraintLayout Availability25.9 Summary
26. A Guide to using ConstraintLayout in Android Studio
26.1 Design and Layout Views26.2 Autoconnect Mode26.3 Inference Mode26.4 Manipulating Constraints Manually26.5 Adding Constraints in the Inspector26.6 Viewing Constraints in the Attributes Window26.7 Deleting Constraints26.8 Adjusting Constraint Bias26.9 Understanding ConstraintLayout Margins26.10 The Importance of Opposing Constraints and Bias26.11 Configuring Widget Dimensions26.12 Adding Guidelines26.13 Adding Barriers26.14 Widget Group Alignment and Distribution26.15 Converting other Layouts to ConstraintLayout26.16 Summary
27. Working with ConstraintLayout Chains and Ratios in Android Studio
27.1 Creating a Chain27.2 Changing the Chain Style27.3 Spread Inside Chain Style27.4 Packed Chain Style27.5 Packed Chain Style with Bias27.6 Weighted Chain27.7 Working with Ratios27.8 Summary
28. An Android Studio Layout Editor ConstraintLayout Tutorial
28.1 An Android Studio Layout Editor Tool Example28.2 Creating a New Activity28.3 Preparing the Layout Editor Environment28.4 Adding the Widgets to the User Interface28.5 Adding the Constraints28.6 Testing the Layout28.7 Using the Layout Inspector28.8 Summary
29. Manual XML Layout Design in Android Studio
29.1 Manually Creating an XML Layout29.2 Manual XML vs. Visual Layout Design29.3 Summary
30. Managing Constraints using Constraint Sets
30.1 Kotlin Code vs. XML Layout Files30.2 Creating Views30.3 View Attributes30.4 Constraint Sets30.4.1 Establishing Connections30.4.2 Applying Constraints to a Layout30.4.3 Parent Constraint Connections30.4.4 Sizing Constraints30.4.5 Constraint Bias30.4.6 Alignment Constraints30.4.7 Copying and Applying Constraint Sets30.4.8 ConstraintLayout Chains30.4.9 Guidelines30.4.10 Removing Constraints30.4.11 Scaling30.4.12 Rotation30.5 Summary
31. An Android ConstraintSet Tutorial
31.1 Creating the Example Project in Android Studio31.2 Adding Views to an Activity31.3 Setting View Attributes31.4 Creating View IDs31.5 Configuring the Constraint Set31.6 Adding the EditText View31.7 Converting Density Independent Pixels (dp) to Pixels (px)31.8 Summary
32. A Guide to using Apply Changes in Android Studio
32.1 Introducing Apply Changes32.2 Understanding Apply Changes Options32.3 Using Apply Changes32.4 Configuring Apply Changes Fallback Settings32.5 An Apply Changes Tutorial32.6 Using Apply Code Changes32.7 Using Apply Changes and Restart Activity32.8 Using Run App32.9 Summary
33. An Overview and Example of Android Event Handling
33.1 Understanding Android Events33.2 Using the android:onClick Resource33.3 Event Listeners and Callback Methods33.4 An Event Handling Example33.5 Designing the User Interface33.6 The Event Listener and Callback Method33.7 Consuming Events33.8 Summary
34. Android Touch and Multi-touch Event Handling
34.1 Intercepting Touch Events34.2 The MotionEvent Object34.3 Understanding Touch Actions34.4 Handling Multiple Touches34.5 An Example Multi-Touch Application34.6 Designing the Activity User Interface34.7 Implementing the Touch Event Listener34.8 Running the Example Application34.9 Summary
35. Detecting Common Gestures using the Android Gesture Detector Class
35.1 Implementing Common Gesture Detection35.2 Creating an Example Gesture Detection Project35.3 Implementing the Listener Class35.4 Creating the GestureDetectorCompat Instance35.5 Implementing the onTouchEvent() Method35.6 Testing the Application35.7 Summary
36. Implementing Custom Gesture and Pinch Recognition on Android
36.1 The Android Gesture Builder Application36.2 The GestureOverlayView Class36.3 Detecting Gestures36.4 Identifying Specific Gestures36.5 Installing and Running the Gesture Builder Application36.6 Creating a Gestures File36.7 Creating the Example Project36.8 Extracting the Gestures File from the SD Card36.9 Adding the Gestures File to the Project36.10 Designing the User Interface36.11 Loading the Gestures File36.12 Registering the Event Listener36.13 Implementing the onGesturePerformed Method36.14 Testing the Application36.15 Configuring the GestureOverlayView36.16 Intercepting Gestures36.17 Detecting Pinch Gestures36.18 A Pinch Gesture Example Project36.19 Summary
37. An Introduction to Android Fragments
37.1 What is a Fragment?37.2 Creating a Fragment37.3 Adding a Fragment to an Activity using the Layout XML File37.4 Adding and Managing Fragments in Code37.5 Handling Fragment Events37.6 Implementing Fragment Communication37.7 Summary
38. Using Fragments in Android Studio - An Example
38.1 About the Example Fragment Application38.2 Creating the Example Project38.3 Creating the First Fragment Layout38.4 Adding the Second Fragment38.5 Adding the Fragments to the Activity38.6 Making the Toolbar Fragment Talk to the Activity38.7 Making the Activity Talk to the Text Fragment38.8 Testing the Application38.9 Summary
39. Modern Android App Architecture with Jetpack
39.1 What is Android Jetpack?39.2 The “Old” Architecture39.3 Modern Android Architecture39.4 The ViewModel Component39.5 The LiveData Component39.6 ViewModel Saved State39.7 LiveData and Data Binding39.8 Android Lifecycles39.9 Repository Modules39.10 Summary
40. An Android Jetpack ViewModel Tutorial
40.1 About the Project40.2 Creating the ViewModel Example Project40.3 Reviewing the Project40.3.1 The Main Activity40.3.2 The Content Fragment40.3.3 The ViewModel40.4 Designing the Fragment Layout40.5 Implementing the View Model40.6 Associating the Fragment with the View Model40.7 Modifying the Fragment40.8 Accessing the ViewModel Data40.9 Testing the Project40.10 Summary
41. An Android Jetpack LiveData Tutorial
41.1 LiveData - A Recap41.2 Adding LiveData to the ViewModel41.3 Implementing the Observer41.4 Summary
42. An Overview of Android Jetpack Data Binding
42.1 An Overview of Data Binding42.2 The Key Components of Data Binding42.2.1 The Project Build Configuration42.2.2 The Data Binding Layout File42.2.3 The Layout File Data Element42.2.4 The Binding Classes42.2.5 Data Binding Variable Configuration42.2.6 Binding Expressions (One-Way)42.2.7 Binding Expressions (Two-Way)42.2.8 Event and Listener Bindings42.3 Summary
43. An Android Jetpack Data Binding Tutorial
43.1 Removing the Redundant Code43.2 Enabling Data Binding43.3 Adding the Layout Element43.4 Adding the Data Element to Layout File43.5 Working with the Binding Class43.6 Assigning the ViewModel Instance to the Data Binding Variable43.7 Adding Binding Expressions43.8 Adding the Conversion Method43.9 Adding a Listener Binding43.10 Testing the App43.11 Summary
44. An Android ViewModel Saved State Tutorial
44.1 Understanding ViewModel State Saving44.2 Implementing ViewModel State Saving44.3 Saving and Restoring State44.4 Adding Saved State Support to the ViewModelDemo Project44.5 Summary
45. Working with Android Lifecycle-Aware Components
45.1 Lifecycle Awareness45.2 Lifecycle Owners45.3 Lifecycle Observers45.4 Lifecycle States and Events45.5 Summary
46. An Android Jetpack Lifecycle Awareness Tutorial
46.1 Creating the Example Lifecycle Project46.2 Creating a Lifecycle Observer46.3 Adding the Observer46.4 Testing the Observer46.5 Creating a Lifecycle Owner46.6 Testing the Custom Lifecycle Owner46.7 Summary
47. An Overview of the Navigation Architecture Component
47.1 Understanding Navigation47.2 Declaring a Navigation Host47.3 The Navigation Graph47.4 Accessing the Navigation Controller47.5 Triggering a Navigation Action47.6 Passing Arguments47.7 Summary
48. An Android Jetpack Navigation Component Tutorial
48.1 Creating the NavigationDemo Project48.2 Adding Navigation to the Build Configuration48.3 Creating the Navigation Graph Resource File48.4 Declaring a Navigation Host48.5 Adding Navigation Destinations48.6 Designing the Destination Fragment Layouts48.7 Adding an Action to the Navigation Graph48.8 Implement the OnFragmentInteractionListener48.9 Triggering the Action48.10 Passing Data Using Safeargs48.11 Summary
49. Creating and Managing Overflow Menus on Android
49.1 The Overflow Menu49.2 Creating an Overflow Menu49.3 Displaying an Overflow Menu49.4 Responding to Menu Item Selections49.5 Creating Checkable Item Groups49.6 Menus and the Android Studio Menu Editor49.7 Creating the Example Project49.8 Designing the Menu49.9 Modifying the onOptionsItemSelected() Method49.10 Testing the Application49.11 Summary
50. An Introduction to MotionLayout
50.1 An Overview of MotionLayout50.2 MotionLayout50.3 MotionScene50.4 Configuring ConstraintSets50.5 Custom Attributes50.6 Triggering an Animation50.7 Arc Motion50.8 Keyframes50.8.1 Attribute Keyframes50.8.2 Position Keyframes50.9 Time Linearity50.10 KeyTrigger50.11 Cycle and Time Cycle Keyframes50.12 Starting an Animation from Code50.13 Summary
51. An Android MotionLayout Editor Tutorial
51.1 Creating the MotionLayoutDemo Project51.2 ConstraintLayout to MotionLayout Conversion51.3 Configuring Start and End Constraints51.4 Previewing the MotionLayout Animation51.5 Adding an OnClick Gesture51.6 Adding an Attribute Keyframe to the Transition51.7 Adding a CustomAttribute to a Transition51.8 Adding Position Keyframes51.9 Summary
52. A MotionLayout KeyCycle Tutorial
52.1 An Overview of Cycle Keyframes52.2 Using the Cycle Editor52.3 Creating the KeyCycleDemo Project52.4 Configuring the Start and End Constraints52.5 Creating the Cycles52.6 Previewing the Animation52.7 Adding the KeyFrameSet to the MotionScene52.8 Summary
53. Working with the Floating Action Button and Snackbar
53.1 The Material Design53.2 The Design Library53.3 The Floating Action Button (FAB) 53.4 The Snackbar53.5 Creating the Example Project53.6 Reviewing the Project53.7 Removing Navigation Features53.8 Changing the Floating Action Button53.9 Adding the ListView to the Content Layout53.10 Adding Items to the ListView53.11 Adding an Action to the Snackbar53.12 Summary
54. Creating a Tabbed Interface using the TabLayout Component
54.1 An Introduction to the ViewPager54.2 An Overview of the TabLayout Component54.3 Creating the TabLayoutDemo Project54.4 Creating the First Fragment54.5 Duplicating the Fragments54.6 Adding the TabLayout and ViewPager54.7 Creating the Pager Adapter54.8 Performing the Initialization Tasks54.9 Testing the Application54.10 Customizing the TabLayout54.11 Displaying Icon Tab Items54.12 Summary
55. Working with the RecyclerView and CardView Widgets
55.1 An Overview of the RecyclerView55.2 An Overview of the CardView55.3 Summary
56. An Android RecyclerView and CardView Tutorial
56.1 Creating the CardDemo Project56.2 Modifying the Basic Activity Project56.3 Designing the CardView Layout56.4 Adding the RecyclerView56.5 Creating the RecyclerView Adapter56.6 Adding the Image Files56.7 Initializing the RecyclerView Component56.8 Testing the Application56.9 Responding to Card Selections56.10 Summary
57. A Layout Editor Sample Data Tutorial
57.1 Adding Sample Data to a Project57.2 Using Custom Sample Data57.3 Summary
58. Working with the AppBar and Collapsing Toolbar Layouts
58.1 The Anatomy of an AppBar58.2 The Example Project58.3 Coordinating the RecyclerView and Toolbar58.4 Introducing the Collapsing Toolbar Layout58.5 Changing the Title and Scrim Color58.6 Summary
59. An Android Studio Master/Detail Flow Tutorial
59.1 The Master/Detail Flow59.2 Creating a Master/Detail Flow Activity59.3 The Anatomy of the Master/Detail Flow Template59.4 Modifying the Master/Detail Flow Template59.5 Changing the Content Model59.6 Changing the Detail Pane59.7 Modifying the WebsiteDetailFragment Class59.8 Modifying the WebsiteListActivity Class59.9 Adding Manifest Permissions59.10 Running the Application59.11 Summary
60. An Overview of Android Intents
60.1 An Overview of Intents60.2 Explicit Intents60.3 Returning Data from an Activity60.4 Implicit Intents60.5 Using Intent Filters60.6 Checking Intent Availability60.7 Summary
61. Android Explicit Intents – A Worked Example
61.1 Creating the Explicit Intent Example Application61.2 Designing the User Interface Layout for MainActivity61.3 Creating the Second Activity Class61.4 Designing the User Interface Layout for ActivityB61.5 Reviewing the Application Manifest File61.6 Creating the Intent61.7 Extracting Intent Data61.8 Launching ActivityB as a Sub-Activity61.9 Returning Data from a Sub-Activity61.10 Testing the Application61.11 Summary
62. Android Implicit Intents – A Worked Example
62.1 Creating the Android Studio Implicit Intent Example Project62.2 Designing the User Interface62.3 Creating the Implicit Intent62.4 Adding a Second Matching Activity62.5 Adding the Web View to the UI62.6 Obtaining the Intent URL62.7 Modifying the MyWebView Project Manifest File62.8 Installing the MyWebView Package on a Device62.9 Testing the Application62.10 Summary
63. Android Broadcast Intents and Broadcast Receivers
63.1 An Overview of Broadcast Intents63.2 An Overview of Broadcast Receivers63.3 Obtaining Results from a Broadcast63.4 Sticky Broadcast Intents63.5 The Broadcast Intent Example63.6 Creating the Example Application63.7 Creating and Sending the Broadcast Intent63.8 Creating the Broadcast Receiver63.9 Registering the Broadcast Receiver63.10 Testing the Broadcast Example63.11 Listening for System Broadcasts63.12 Summary
64. A Basic Overview of Threads and AsyncTasks
64.1 An Overview of Threads64.2 The Application Main Thread64.3 Thread Handlers64.4 A Basic AsyncTask Example64.5 Subclassing AsyncTask64.6 Testing the App64.7 Canceling a Task64.8 Summary
65. An Introduction to Kotlin Coroutines
65.1 What are Coroutines?65.2 Threads vs Coroutines65.3 Coroutine Scope65.4 Suspend Functions65.5 Coroutine Dispatchers65.6 Coroutine Builders65.7 Jobs65.8 Coroutines – Suspending and Resuming65.9 Returning Results from a Coroutine65.10 Using withContext65.11 Coroutine Channel Communication65.12 Summary
66. An Android Kotlin Coroutines Tutorial
66.1 Creating the Coroutine Example Application66.2 Adding Coroutine Support to the Project66.3 Designing the User Interface66.4 Implementing the SeekBar66.5 Adding the Suspend Function66.6 Implementing the launchCoroutines Method66.7 Testing the App66.8 Summary
67. An Overview of Android Started and Bound Services
67.1 Started Services67.2 Intent Service67.3 Bound Service67.4 The Anatomy of a Service67.5 Controlling Destroyed Service Restart Options67.6 Declaring a Service in the Manifest File67.7 Starting a Service Running on System Startup67.8 Summary
68. Implementing an Android Started Service – A Worked Example
68.1 Creating the Example Project68.2 Creating the Service Class68.3 Adding the Service to the Manifest File68.4 Starting the Service68.5 Testing the IntentService Example68.6 Using the Service Class68.7 Creating the New Service68.8 Modifying the User Interface68.9 Running the Application68.10 Using a Coroutine for the Service Task68.11 Summary
69. Android Local Bound Services – A Worked Example
69.1 Understanding Bound Services69.2 Bound Service Interaction Options69.3 An Android Studio Local Bound Service Example69.4 Adding a Bound Service to the Project69.5 Implementing the Binder69.6 Binding the Client to the Service69.7 Completing the Example69.8 Testing the Application69.9 Summary
70. Android Remote Bound Services – A Worked Example
70.1 Client to Remote Service Communication70.2 Creating the Example Application70.3 Designing the User Interface70.4 Implementing the Remote Bound Service70.5 Configuring a Remote Service in the Manifest File70.6 Launching and Binding to the Remote Service70.7 Sending a Message to the Remote Service70.8 Summary
71. An Android Notifications Tutorial
71.1 An Overview of Notifications71.2 Creating the NotifyDemo Project71.3 Designing the User Interface71.4 Creating the Second Activity71.5 Creating a Notification Channel71.6 Creating and Issuing a Basic Notification71.7 Launching an Activity from a Notification71.8 Adding Actions to a Notification71.9 Bundled Notifications71.10 Summary
72. An Android Direct Reply Notification Tutorial
72.1 Creating the DirectReply Project72.2 Designing the User Interface72.3 Creating the Notification Channel72.4 Building the RemoteInput Object72.5 Creating the PendingIntent72.6 Creating the Reply Action72.7 Receiving Direct Reply Input72.8 Updating the Notification72.9 Summary
73. Foldable Devices and Multi-Window Support
73.1 Foldables and Multi-Window Support73.2 Using a Foldable Emulator73.3 Entering Multi-Window Mode73.4 Enabling and using Freeform Support73.5 Checking for Freeform Support73.6 Enabling Multi-Window Support in an App73.7 Specifying Multi-Window Attributes73.8 Detecting Multi-Window Mode in an Activity73.9 Receiving Multi-Window Notifications73.10 Launching an Activity in Multi-Window Mode73.11 Configuring Freeform Activity Size and Position73.12 Summary
74. An Overview of Android SQLite Databases
74.1 Understanding Database Tables74.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 Library74.10 Summary
75. The Android Room Persistence Library
75.1 Revisiting Modern App Architecture75.2 Key Elements of Room Database Persistence75.2.1 Repository75.2.2 Room Database75.2.3 Data Access Object (DAO)75.2.4 Entities75.2.5 SQLite Database75.3 Understanding Entities75.4 Data Access Objects75.5 The Room Database75.6 The Repository75.7 In-Memory Databases75.8 Summary
76. An Android TableLayout and TableRow Tutorial
76.1 The TableLayout and TableRow Layout Views76.2 Creating the Room Database Project76.3 Converting to a LinearLayout76.4 Adding the TableLayout to the User Interface76.5 Configuring the TableRows76.6 Adding the Button Bar to the Layout76.7 Adding the RecyclerView76.8 Adjusting the Layout Margins76.9 Summary
77. An Android Room Database and Repository Tutorial
77.1 About the RoomDemo Project77.2 Modifying the Build Configuration77.3 Building the Entity77.4 Creating the Data Access Object77.5 Adding the Room Database77.6 Adding the Repository77.7 Modifying the ViewModel77.8 Creating the Product Item Layout77.9 Adding the RecyclerView Adapter77.10 Preparing the Main Fragment77.11 Adding the Button Listeners77.12 Adding LiveData Observers77.13 Initializing the RecyclerView77.14 Testing the RoomDemo App77.15 Summary
78. Accessing Cloud Storage using the Android Storage Access Framework
78.1 The Storage Access Framework78.2 Working with the Storage Access Framework78.3 Filtering Picker File Listings78.4 Handling Intent Results78.5 Reading the Content of a File78.6 Writing Content to a File78.7 Deleting a File78.8 Gaining Persistent Access to a File78.9 Summary
79. An Android Storage Access Framework Example
79.1 About the Storage Access Framework Example79.2 Creating the Storage Access Framework Example79.3 Designing the User Interface79.4 Declaring Request Codes79.5 Creating a New Storage File79.6 The onActivityResult() Method79.7 Saving to a Storage File79.8 Opening and Reading a Storage File79.9 Testing the Storage Access Application79.10 Summary
80. Video Playback on Android using the VideoView and MediaController Classes
80.1 Introducing the Android VideoView Class80.2 Introducing the Android MediaController Class80.3 Creating the Video Playback Example80.4 Designing the VideoPlayer Layout80.5 Downloading the Video File80.6 Configuring the VideoView80.7 Adding the MediaController to the Video View80.8 Setting up the onPreparedListener80.9 Summary
81. Android Picture-in-Picture Mode
81.1 Picture-in-Picture Features81.2 Enabling Picture-in-Picture Mode81.3 Configuring Picture-in-Picture Parameters81.4 Entering Picture-in-Picture Mode81.5 Detecting Picture-in-Picture Mode Changes81.6 Adding Picture-in-Picture Actions81.7 Summary
82. An Android Picture-in-Picture Tutorial
82.1 Adding Picture-in-Picture Support to the Manifest82.2 Adding a Picture-in-Picture Button82.3 Entering Picture-in-Picture Mode82.4 Detecting Picture-in-Picture Mode Changes82.5 Adding a Broadcast Receiver82.6 Adding the PiP Action82.7 Testing the Picture-in-Picture Action82.8 Summary
83. Making Runtime Permission Requests in Android
83.1 Understanding Normal and Dangerous Permissions83.2 Creating the Permissions Example Project83.3 Checking for a Permission83.4 Requesting Permission at Runtime83.5 Providing a Rationale for the Permission Request83.6 Testing the Permissions App83.7 Summary
84. Android Audio Recording and Playback using MediaPlayer and MediaRecorder
84.1 Playing Audio84.2 Recording Audio and Video using the MediaRecorder Class84.3 About the Example Project84.4 Creating the AudioApp Project84.5 Designing the User Interface84.6 Checking for Microphone Availability84.7 Performing the Activity Initialization84.8 Implementing the recordAudio() Method84.9 Implementing the stopAudio() Method84.10 Implementing the playAudio() method84.11 Configuring and Requesting Permissions84.12 Testing the Application84.13 Summary
85. Working with the Google Maps Android API in Android Studio
85.1 The Elements of the Google Maps Android API85.2 Creating the Google Maps Project85.3 Obtaining Your Developer Signature85.4 Adding the Apache HTTP Legacy Library Requirement85.5 Testing the Application85.6 Understanding Geocoding and Reverse Geocoding85.7 Adding a Map to an Application85.8 Requesting Current Location Permission85.9 Displaying the User’s Current Location85.10 Changing the Map Type85.11 Displaying Map Controls to the User85.12 Handling Map Gesture Interaction85.12.1 Map Zooming Gestures85.12.2 Map Scrolling/Panning Gestures85.12.3 Map Tilt Gestures85.12.4 Map Rotation Gestures85.13 Creating Map Markers85.14 Controlling the Map Camera85.15 Summary
86. Printing with the Android Printing Framework
86.1 The Android Printing Architecture86.2 The Print Service Plugins86.3 Google Cloud Print86.4 Printing to Google Drive86.5 Save as PDF86.6 Printing from Android Devices86.7 Options for Building Print Support into Android Apps86.7.1 Image Printing86.7.2 Creating and Printing HTML Content86.7.3 Printing a Web Page86.7.4 Printing a Custom Document86.8 Summary
87. An Android HTML and Web Content Printing Example
87.1 Creating the HTML Printing Example Application87.2 Printing Dynamic HTML Content87.3 Creating the Web Page Printing Example87.4 Removing the Floating Action Button87.5 Removing Navigation Features87.6 Designing the User Interface Layout87.7 Loading the Web Page into the WebView87.8 Adding the Print Menu Option87.9 Summary
88. A Guide to Android Custom Document Printing
88.1 An Overview of Android Custom Document Printing88.1.1 Custom Print Adapters88.2 Preparing the Custom Document Printing Project88.3 Creating the Custom Print Adapter88.4 Implementing the onLayout() Callback Method88.5 Implementing the onWrite() Callback Method88.6 Checking a Page is in Range88.7 Drawing the Content on the Page Canvas88.8 Starting the Print Job88.9 Testing the Application88.10 Summary
89. An Introduction to Android App Links
89.1 An Overview of Android App Links89.2 App Link Intent Filters89.3 Handling App Link Intents89.4 Associating the App with a Website89.5 Summary
90. An Android Studio App Links Tutorial
90.1 About the Example App90.2 The Database Schema90.3 Loading and Running the Project90.4 Adding the URL Mapping90.5 Adding the Intent Filter90.6 Adding Intent Handling Code90.7 Testing the App Link90.8 Associating an App Link with a Web Site90.9 Summary
91. A Guide to the Android Studio Profiler
91.1 Accessing the Android Profiler91.2 Enabling Advanced Profiling91.3 The Android Profiler Tool Window91.4 The Sessions Panel91.5 The CPU Profiler91.6 Memory Profiler91.7 Network Profiler91.8 Energy Profiler91.9 Summary
92. An Android Biometric Authentication Tutorial
92.1 An Overview of Biometric Authentication92.2 Creating the Biometric Authentication Project92.3 Configuring Device Fingerprint Authentication92.4 Adding the Biometric Permission to the Manifest File92.5 Designing the User Interface92.6 Adding a Toast Convenience Method92.7 Checking the Security Settings92.8 Configuring the Authentication Callbacks92.9 Adding the CancellationSignal92.10 Starting the Biometric Prompt92.11 Testing the Project92.12 Summary
93. Creating, Testing and Uploading an Android App Bundle
93.1 The Release Preparation Process93.2 Android App Bundles93.3 Register for a Google Play Developer Console Account93.4 Configuring the App in the Console93.5 Enabling Google Play App Signing93.6 Creating a Keystore File93.7 Creating the Android App Bundle93.8 Generating Test APK Files93.9 Uploading the App Bundle to the Google Play Developer Console93.10 Exploring the App Bundle93.11 Managing Testers93.12 Uploading New App Bundle Revisions93.13 Analyzing the App Bundle File93.14 Enabling Google Play Signing for an Existing App93.15 Summary
94. An Overview of Android Dynamic Feature Modules
94.1 An Overview of Dynamic Feature Modules94.2 Dynamic Feature Module Architecture94.3 Creating a Dynamic Feature Module94.4 Converting an Existing Module for Dynamic Delivery94.5 Working with Dynamic Feature Modules94.6 Handling Large Dynamic Feature Modules94.7 Summary
95. An Android Studio Dynamic Feature Tutorial
95.1 Creating the DynamicFeature Project95.2 Adding Dynamic Feature Support to the Project95.3 Designing the Base Activity User Interface95.4 Adding the Dynamic Feature Module95.5 Reviewing the Dynamic Feature Module95.6 Adding the Dynamic Feature Activity95.7 Implementing the launchIntent() Method95.8 Uploading the App Bundle for Testing95.9 Implementing the installFeature() Method95.10 Adding the Update Listener95.11 Handling Large Downloads95.12 Using Deferred Installation95.13 Removing a Dynamic Module95.14 Summary
96. An Overview of Gradle in Android Studio
96.1 An Overview of Gradle96.2 Gradle and Android Studio96.2.1 Sensible Defaults96.2.2 Dependencies96.2.3 Build Variants96.2.4 Manifest Entries96.2.5 APK Signing96.2.6 ProGuard Support96.3 The Top-level Gradle Build File96.4 Module Level Gradle Build Files96.5 Configuring Signing Settings in the Build File96.6 Running Gradle Tasks from the Command-line96.7 Summary
Index

Content preview from Android Studio 4.0 Development Essentials - Kotlin Edition

57. A Layout Editor Sample Data Tutorial

The CardDemo project created in the previous chapter has provided a good example of how it can be difficult to assess from within the layout editor exactly how a user interface is going to appear until the completed app is tested. This is a problem that frequently occurs when the content to be displayed in a user interface is only generated or acquired once the user has the app installed and running.

For some time now, the Android Studio layout editor has provided the ability to specify simple attributes that are active only when the layout is being designed. A design-time only string resource could, for example, be assigned to a TextView within the layout editor that would not appear when the app runs. ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Android Studio 3.6 Development Essentials - Kotlin Edition

Publisher Resources

ISBN: 9781800560437

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Android Studio 4.0 Development Essentials - Kotlin Edition

by Neil Smyth

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.