book

Android Studio 4.1 Development Essentials – Kotlin Edition

Name: Android Studio 4.1 Development Essentials – Kotlin Edition
Author: Neil Smyth
ISBN: 9781801815987

by Neil Smyth

May 2021

Intermediate to advanced

822 pages

23h 49m

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 the Kotlin Extensions Plugin3.9 Adding Interaction3.10 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 Running on Multiple Devices4.6 Stopping a Running Application4.7 Supporting Dark Theme4.8 Running the Emulator in a Tool Window4.9 AVD Command-line Creation4.10 Android Virtual Device Configuration Files4.11 Moving and Renaming an Android Virtual Device4.12 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 The Emulator in Tool Window Mode5.9 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 Transforms24.10 Tools Visibility Toggles24.11 Converting Views24.12 Displaying Sample Data24.13 Creating a Custom Device Definition24.14 Changing the Current Device24.15 Layout Validation (Multi Preview)24.16 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 Configuring Widget Dimensions25.4 Guideline Helper25.5 Group Helper25.6 Barrier Helper25.7 Flow Helper25.8 Ratios25.9 ConstraintLayout Advantages25.10 ConstraintLayout Availability25.11 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 Design Time Tools Positioning26.13 Adding Guidelines26.14 Adding Barriers26.15 Adding a Group26.16 Working with the Flow Helper26.17 Widget Group Alignment and Distribution26.18 Converting other Layouts to ConstraintLayout26.19 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. An Introduction to MotionLayout
49.1 An Overview of MotionLayout49.2 MotionLayout49.3 MotionScene49.4 Configuring ConstraintSets49.5 Custom Attributes49.6 Triggering an Animation49.7 Arc Motion49.8 Keyframes49.8.1 Attribute Keyframes49.8.2 Position Keyframes49.9 Time Linearity49.10 KeyTrigger49.11 Cycle and Time Cycle Keyframes49.12 Starting an Animation from Code
50. An Android MotionLayout Editor Tutorial
50.1 Creating the MotionLayoutDemo Project50.2 ConstraintLayout to MotionLayout Conversion50.3 Configuring Start and End Constraints50.4 Previewing the MotionLayout Animation50.5 Adding an OnClick Gesture50.6 Adding an Attribute Keyframe to the Transition50.7 Adding a CustomAttribute to a Transition50.8 Adding Position Keyframes50.9 Summary
51. A MotionLayout KeyCycle Tutorial
51.1 An Overview of Cycle Keyframes51.2 Using the Cycle Editor51.3 Creating the KeyCycleDemo Project51.4 Configuring the Start and End Constraints51.5 Creating the Cycles51.6 Previewing the Animation51.7 Adding the KeyFrameSet to the MotionScene51.8 Summary
52. Working with the Floating Action Button and Snackbar
52.1 The Material Design52.2 The Design Library52.3 The Floating Action Button (FAB) 52.4 The Snackbar52.5 Creating the Example Project52.6 Reviewing the Project52.7 Removing Navigation Features52.8 Changing the Floating Action Button52.9 Adding the ListView to the Content Layout52.10 Adding Items to the ListView52.11 Adding an Action to the Snackbar52.12 Summary
53. Creating a Tabbed Interface using the TabLayout Component
53.1 An Introduction to the ViewPager53.2 An Overview of the TabLayout Component53.3 Creating the TabLayoutDemo Project53.4 Creating the First Fragment53.5 Duplicating the Fragments53.6 Adding the TabLayout and ViewPager53.7 Creating the Pager Adapter53.8 Performing the Initialization Tasks53.9 Testing the Application53.10 Customizing the TabLayout53.11 Displaying Icon Tab Items53.12 Summary
54. Working with the RecyclerView and CardView Widgets
54.1 An Overview of the RecyclerView54.2 An Overview of the CardView54.3 Summary
55. An Android RecyclerView and CardView Tutorial
55.1 Creating the CardDemo Project55.2 Modifying the Basic Activity Project55.3 Designing the CardView Layout55.4 Adding the RecyclerView55.5 Adding the Image Files55.6 Creating the RecyclerView Adapter55.7 Initializing the RecyclerView Component55.8 Testing the Application55.9 Responding to Card Selections55.10 Summary
56. A Layout Editor Sample Data Tutorial
56.1 Adding Sample Data to a Project56.2 Using Custom Sample Data56.3 Summary
57. Working with the AppBar and Collapsing Toolbar Layouts
57.1 The Anatomy of an AppBar57.2 The Example Project57.3 Coordinating the RecyclerView and Toolbar57.4 Introducing the Collapsing Toolbar Layout57.5 Changing the Title and Scrim Color57.6 Summary
58. An Android Studio Master/Detail Flow Tutorial
58.1 The Master/Detail Flow58.2 Creating a Master/Detail Flow Activity58.3 The Anatomy of the Master/Detail Flow Template58.4 Modifying the Master/Detail Flow Template58.5 Changing the Content Model58.6 Changing the Detail Pane58.7 Modifying the WebsiteDetailFragment Class58.8 Modifying the WebsiteListActivity Class58.9 Adding Manifest Permissions58.10 Running the Application58.11 Summary
59. An Overview of Android Intents
59.1 An Overview of Intents59.2 Explicit Intents59.3 Returning Data from an Activity59.4 Implicit Intents59.5 Using Intent Filters59.6 Checking Intent Availability59.7 Summary
60. Android Explicit Intents – A Worked Example
60.1 Creating the Explicit Intent Example Application60.2 Designing the User Interface Layout for MainActivity60.3 Creating the Second Activity Class60.4 Designing the User Interface Layout for ActivityB60.5 Reviewing the Application Manifest File60.6 Creating the Intent60.7 Extracting Intent Data60.8 Launching ActivityB as a Sub-Activity60.9 Returning Data from a Sub-Activity60.10 Testing the Application60.11 Summary
61. Android Implicit Intents – A Worked Example
61.1 Creating the Android Studio Implicit Intent Example Project61.2 Designing the User Interface61.3 Creating the Implicit Intent61.4 Adding a Second Matching Activity61.5 Adding the Web View to the UI61.6 Obtaining the Intent URL61.7 Modifying the MyWebView Project Manifest File61.8 Installing the MyWebView Package on a Device61.9 Testing the Application61.10 Summary
62. Android Broadcast Intents and Broadcast Receivers
62.1 An Overview of Broadcast Intents62.2 An Overview of Broadcast Receivers62.3 Obtaining Results from a Broadcast62.4 Sticky Broadcast Intents62.5 The Broadcast Intent Example62.6 Creating the Example Application62.7 Creating and Sending the Broadcast Intent62.8 Creating the Broadcast Receiver62.9 Registering the Broadcast Receiver62.10 Testing the Broadcast Example62.11 Listening for System Broadcasts62.12 Summary
63. A Basic Overview of Threads and AsyncTasks
63.1 An Overview of Threads63.2 The Application Main Thread63.3 Thread Handlers63.4 A Basic AsyncTask Example63.5 Subclassing AsyncTask63.6 Testing the App63.7 Canceling a Task63.8 Summary
64. An Introduction to Kotlin Coroutines
64.1 What are Coroutines?64.2 Threads vs Coroutines64.3 Coroutine Scope64.4 Suspend Functions64.5 Coroutine Dispatchers64.6 Coroutine Builders64.7 Jobs64.8 Coroutines – Suspending and Resuming64.9 Returning Results from a Coroutine64.10 Using withContext64.11 Coroutine Channel Communication64.12 Summary
65. An Android Kotlin Coroutines Tutorial
65.1 Creating the Coroutine Example Application65.2 Adding Coroutine Support to the Project65.3 Designing the User Interface65.4 Implementing the SeekBar65.5 Adding the Suspend Function65.6 Implementing the launchCoroutines Method65.7 Testing the App65.8 Summary
66. An Overview of Android Started and Bound Services
66.1 Started Services66.2 Intent Service66.3 Bound Service66.4 The Anatomy of a Service66.5 Controlling Destroyed Service Restart Options66.6 Declaring a Service in the Manifest File66.7 Starting a Service Running on System Startup66.8 Summary
67. Implementing an Android Started Service – A Worked Example
67.1 Creating the Example Project67.2 Creating the Service Class67.3 Adding the Service to the Manifest File67.4 Starting the Service67.5 Testing the IntentService Example67.6 Using the Service Class67.7 Creating the New Service67.8 Modifying the User Interface67.9 Running the Application67.10 Using a Coroutine for the Service Task67.11 Summary
68. Android Local Bound Services – A Worked Example
68.1 Understanding Bound Services68.2 Bound Service Interaction Options68.3 An Android Studio Local Bound Service Example68.4 Adding a Bound Service to the Project68.5 Implementing the Binder68.6 Binding the Client to the Service68.7 Completing the Example68.8 Testing the Application68.9 Summary
69. Android Remote Bound Services – A Worked Example
69.1 Client to Remote Service Communication69.2 Creating the Example Application69.3 Designing the User Interface69.4 Implementing the Remote Bound Service69.5 Configuring a Remote Service in the Manifest File69.6 Launching and Binding to the Remote Service69.7 Sending a Message to the Remote Service69.8 Summary
70. An Android Notifications Tutorial
70.1 An Overview of Notifications70.2 Creating the NotifyDemo Project70.3 Designing the User Interface70.4 Creating the Second Activity70.5 Creating a Notification Channel70.6 Creating and Issuing a Basic Notification70.7 Launching an Activity from a Notification70.8 Adding Actions to a Notification70.9 Bundled Notifications70.10 Summary
71. An Android Direct Reply Notification Tutorial
71.1 Creating the DirectReply Project71.2 Designing the User Interface71.3 Creating the Notification Channel71.4 Building the RemoteInput Object71.5 Creating the PendingIntent71.6 Creating the Reply Action71.7 Receiving Direct Reply Input71.8 Updating the Notification71.9 Summary
72. Foldable Devices and Multi-Window Support
72.1 Foldables and Multi-Window Support72.2 Using a Foldable Emulator72.3 Entering Multi-Window Mode72.4 Enabling and using Freeform Support72.5 Checking for Freeform Support72.6 Enabling Multi-Window Support in an App72.7 Specifying Multi-Window Attributes72.8 Detecting Multi-Window Mode in an Activity72.9 Receiving Multi-Window Notifications72.10 Launching an Activity in Multi-Window Mode72.11 Configuring Freeform Activity Size and Position72.12 Summary
73. An Overview of Android SQLite Databases
73.1 Understanding Database Tables73.2 Introducing Database Schema 73.3 Columns and Data Types 73.4 Database Rows 73.5 Introducing Primary Keys 73.6 What is SQLite?73.7 Structured Query Language (SQL)73.8 Trying SQLite on an Android Virtual Device (AVD)73.9 The Android Room Persistence Library73.10 Summary
74. The Android Room Persistence Library
74.1 Revisiting Modern App Architecture74.2 Key Elements of Room Database Persistence74.2.1 Repository74.2.2 Room Database74.2.3 Data Access Object (DAO)74.2.4 Entities74.2.5 SQLite Database74.3 Understanding Entities74.4 Data Access Objects74.5 The Room Database74.6 The Repository74.7 In-Memory Databases74.8 Database Inspector74.9 Summary
75. An Android TableLayout and TableRow Tutorial
75.1 The TableLayout and TableRow Layout Views75.2 Creating the Room Database Project75.3 Converting to a LinearLayout75.4 Adding the TableLayout to the User Interface75.5 Configuring the TableRows75.6 Adding the Button Bar to the Layout75.7 Adding the RecyclerView75.8 Adjusting the Layout Margins75.9 Summary
76. An Android Room Database and Repository Tutorial
76.1 About the RoomDemo Project76.2 Modifying the Build Configuration76.3 Building the Entity76.4 Creating the Data Access Object76.5 Adding the Room Database76.6 Adding the Repository76.7 Modifying the ViewModel76.8 Creating the Product Item Layout76.9 Adding the RecyclerView Adapter76.10 Preparing the Main Fragment76.11 Adding the Button Listeners76.12 Adding LiveData Observers76.13 Initializing the RecyclerView76.14 Testing the RoomDemo App76.15 Using the Database Inspector76.16 Summary
77. Accessing Cloud Storage using the Android Storage Access Framework
77.1 The Storage Access Framework77.2 Working with the Storage Access Framework77.3 Filtering Picker File Listings77.4 Handling Intent Results77.5 Reading the Content of a File77.6 Writing Content to a File77.7 Deleting a File77.8 Gaining Persistent Access to a File77.9 Summary
78. An Android Storage Access Framework Example
78.1 About the Storage Access Framework Example78.2 Creating the Storage Access Framework Example78.3 Designing the User Interface78.4 Declaring Request Codes78.5 Creating a New Storage File78.6 The onActivityResult() Method78.7 Saving to a Storage File78.8 Opening and Reading a Storage File78.9 Testing the Storage Access Application78.10 Summary
79. Video Playback on Android using the VideoView and MediaController Classes
79.1 Introducing the Android VideoView Class79.2 Introducing the Android MediaController Class79.3 Creating the Video Playback Example79.4 Designing the VideoPlayer Layout79.5 Downloading the Video File79.6 Configuring the VideoView79.7 Adding the MediaController to the Video View79.8 Setting up the onPreparedListener79.9 Summary
80. Android Picture-in-Picture Mode
80.1 Picture-in-Picture Features80.2 Enabling Picture-in-Picture Mode80.3 Configuring Picture-in-Picture Parameters80.4 Entering Picture-in-Picture Mode80.5 Detecting Picture-in-Picture Mode Changes80.6 Adding Picture-in-Picture Actions80.7 Summary
81. An Android Picture-in-Picture Tutorial
81.1 Adding Picture-in-Picture Support to the Manifest81.2 Adding a Picture-in-Picture Button81.3 Entering Picture-in-Picture Mode81.4 Detecting Picture-in-Picture Mode Changes81.5 Adding a Broadcast Receiver81.6 Adding the PiP Action81.7 Testing the Picture-in-Picture Action81.8 Summary
82. Making Runtime Permission Requests in Android
82.1 Understanding Normal and Dangerous Permissions82.2 Creating the Permissions Example Project82.3 Checking for a Permission82.4 Requesting Permission at Runtime82.5 Providing a Rationale for the Permission Request82.6 Testing the Permissions App82.7 Summary
83. Android Audio Recording and Playback using MediaPlayer and MediaRecorder
83.1 Playing Audio83.2 Recording Audio and Video using the MediaRecorder Class83.3 About the Example Project83.4 Creating the AudioApp Project83.5 Designing the User Interface83.6 Checking for Microphone Availability83.7 Performing the Activity Initialization83.8 Implementing the recordAudio() Method83.9 Implementing the stopAudio() Method83.10 Implementing the playAudio() method83.11 Configuring and Requesting Permissions83.12 Testing the Application83.13 Summary
84. Printing with the Android Printing Framework
84.1 The Android Printing Architecture84.2 The Print Service Plugins84.3 Google Cloud Print84.4 Printing to Google Drive84.5 Save as PDF84.6 Printing from Android Devices84.7 Options for Building Print Support into Android Apps84.7.1 Image Printing84.7.2 Creating and Printing HTML Content84.7.3 Printing a Web Page84.7.4 Printing a Custom Document84.8 Summary
85. An Android HTML and Web Content Printing Example
85.1 Creating the HTML Printing Example Application85.2 Printing Dynamic HTML Content85.3 Creating the Web Page Printing Example85.4 Removing the Floating Action Button85.5 Removing Navigation Features85.6 Designing the User Interface Layout85.7 Loading the Web Page into the WebView85.8 Adding the Print Menu Option85.9 Summary
86. A Guide to Android Custom Document Printing
86.1 An Overview of Android Custom Document Printing86.1.1 Custom Print Adapters86.2 Preparing the Custom Document Printing Project86.3 Creating the Custom Print Adapter86.4 Implementing the onLayout() Callback Method86.5 Implementing the onWrite() Callback Method86.6 Checking a Page is in Range86.7 Drawing the Content on the Page Canvas86.8 Starting the Print Job86.9 Testing the Application86.10 Summary
87. An Introduction to Android App Links
87.1 An Overview of Android App Links87.2 App Link Intent Filters87.3 Handling App Link Intents87.4 Associating the App with a Website87.5 Summary
88. An Android Studio App Links Tutorial
88.1 About the Example App88.2 The Database Schema88.3 Loading and Running the Project88.4 Adding the URL Mapping88.5 Adding the Intent Filter88.6 Adding Intent Handling Code88.7 Testing the App Link88.8 Associating an App Link with a Web Site88.9 Summary
89. A Guide to the Android Studio Profiler
89.1 Accessing the Android Profiler89.2 Enabling Advanced Profiling89.3 The Android Profiler Tool Window89.4 The Sessions Panel89.5 The CPU Profiler89.6 Memory Profiler89.7 Network Profiler89.8 Energy Profiler89.9 Summary
90. An Android Biometric Authentication Tutorial
90.1 An Overview of Biometric Authentication90.2 Creating the Biometric Authentication Project90.3 Configuring Device Fingerprint Authentication90.4 Adding the Biometric Permission to the Manifest File90.5 Designing the User Interface90.6 Adding a Toast Convenience Method90.7 Checking the Security Settings90.8 Configuring the Authentication Callbacks90.9 Adding the CancellationSignal90.10 Starting the Biometric Prompt90.11 Testing the Project90.12 Summary
91. Creating, Testing and Uploading an Android App Bundle
91.1 The Release Preparation Process91.2 Android App Bundles91.3 Register for a Google Play Developer Console Account91.4 Configuring the App in the Console91.5 Enabling Google Play App Signing91.6 Creating a Keystore File91.7 Creating the Android App Bundle91.8 Generating Test APK Files91.9 Uploading the App Bundle to the Google Play Developer Console91.10 Exploring the App Bundle91.11 Managing Testers91.12 Rolling the App Out for Testing91.13 Uploading New App Bundle Revisions91.14 Analyzing the App Bundle File91.15 Summary
92. An Overview of Android Dynamic Feature Modules
92.1 An Overview of Dynamic Feature Modules92.2 Dynamic Feature Module Architecture92.3 Creating a Dynamic Feature Module92.4 Converting an Existing Module for Dynamic Delivery92.5 Working with Dynamic Feature Modules92.6 Handling Large Dynamic Feature Modules92.7 Summary
93. An Android Studio Dynamic Feature Tutorial
93.1 Creating the DynamicFeature Project93.2 Adding Dynamic Feature Support to the Project93.3 Designing the Base Activity User Interface93.4 Adding the Dynamic Feature Module93.5 Reviewing the Dynamic Feature Module93.6 Adding the Dynamic Feature Activity93.7 Implementing the launchIntent() Method93.8 Uploading the App Bundle for Testing93.9 Implementing the installFeature() Method93.10 Adding the Update Listener93.11 Handling Large Downloads93.12 Using Deferred Installation93.13 Removing a Dynamic Module93.14 Summary
94. An Overview of Gradle in Android Studio
94.1 An Overview of Gradle94.2 Gradle and Android Studio94.2.1 Sensible Defaults94.2.2 Dependencies94.2.3 Build Variants94.2.4 Manifest Entries94.2.5 APK Signing94.2.6 ProGuard Support94.3 The Top-level Gradle Build File94.4 Module Level Gradle Build Files94.5 Configuring Signing Settings in the Build File94.6 Running Gradle Tasks from the Command-line94.7 Summary
Index

Overview

Immersing yourself in Android app development has never been simpler. In this comprehensive guide, you will learn the art of creating Android apps using Android Studio 4.1, Kotlin, and the powerful Android Jetpack framework. Designed for aspiring developers, this book takes you through all the essential components and advanced features of Android app development.

What this Book will help me do

Gain proficiency in using Android Studio 4.1 for developing Android applications.
Master the Kotlin programming language to implement efficient and modern code patterns.
Learn to design and build intuitive user interfaces following Material Design principles.
Understand the Android Jetpack architecture and lifecycle to create scalable and maintainable apps.
Integrate cloud storage solutions and advanced multimedia features into your Android applications.

Author(s)

Neil Smyth is a seasoned technical author with expertise in software development and engineering. With years of experience teaching programming, Neil makes technical topics accessible to a broad audience. His structured and hands-on approach ensures that readers not only understand concepts but can also apply them effectively. Neil's dedication to clarity and detail has made his books go-to resources for learning complex topics.

Who is it for?

This book is ideal for developers with a background in programming who want to advance their skills in Android development. If you are familiar with Kotlin and are eager to explore Android Studio and Android Jetpack, this book will serve as an essential learning tool. It's also perfect for those aiming to build versatile and professional-grade Android applications. Prepare to take an exciting step in your Android development journey with this book.

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 4.0 Development Essentials - Kotlin Edition

Publisher Resources

ISBN: 9781801815987

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills