book

Android Studio Arctic Fox Essentials - Kotlin Edition

Name: Android Studio Arctic Fox Essentials - Kotlin Edition
Author: Neil Smyth
ISBN: 9781803247458

by Neil Smyth

October 2021

Intermediate to advanced

790 pages

23h 3m

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 8.12.6.2 Windows 102.6.3 Linux2.6.4 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 Battery5.5.5 Camera5.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 Control flow
14.1 Looping Control flow14.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 Control flow14.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 Binding 18.3 Converting the AndroidSample project18.4 Enabling View Binding18.5 Using View Binding18.6 Choosing an Option18.7 View Binding in the Book Examples18.8 Migrating a Project to View Binding18.9 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 Night Mode24.7 Code Mode24.8 Split Mode24.9 Setting Attributes24.10 Transforms24.11 Tools Visibility Toggles24.12 Converting Views24.13 Displaying Sample Data24.14 Creating a Custom Device Definition24.15 Changing the Current Device24.16 Layout Validation (Multi Preview)24.17 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 Migrating a Fragment to View Binding38.5 Adding the Second Fragment38.6 Adding the Fragments to the Activity38.7 Making the Toolbar Fragment Talk to the Activity38.8 Making the Activity Talk to the Text Fragment38.9 Testing the Application38.10 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 Adding View Binding Support to the Destination Fragments48.10 Triggering the Action48.11 Passing Data Using Safeargs48.12 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 Code49.13 Summary
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 an Action to the Snackbar52.10 Summary
53. Creating a Tabbed Interface using the TabLayout Component
53.1 An Introduction to the ViewPager253.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 ViewPager253.7 Creating the Pager Adapter53.8 Performing the Initialization Tasks53.9 Testing the Application53.10 Customizing the TabLayout53.11 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 Primary/Detail Flow Tutorial
58.1 The Primary/Detail Flow58.2 Creating a Primary/Detail Flow Activity58.3 Modifying the Primary/Detail Flow Template58.4 Changing the Content Model58.5 Changing the Detail Pane58.6 Modifying the WebsiteDetailFragment Class58.7 Modifying the WebsiteListFragment Class58.8 Adding Manifest Permissions58.9 Running the Application58.10 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 SecondActivity60.5 Reviewing the Application Manifest File60.6 Creating the Intent60.7 Extracting Intent Data60.8 Launching SecondActivity 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. An Introduction to Kotlin Coroutines
63.1 What are Coroutines?63.2 Threads vs Coroutines63.3 Coroutine Scope63.4 Suspend Functions63.5 Coroutine Dispatchers63.6 Coroutine Builders63.7 Jobs63.8 Coroutines – Suspending and Resuming63.9 Returning Results from a Coroutine63.10 Using withContext63.11 Coroutine Channel Communication63.12 Summary
64. An Android Kotlin Coroutines Tutorial
64.1 Creating the Coroutine Example Application64.2 Adding Coroutine Support to the Project64.3 Designing the User Interface64.4 Implementing the SeekBar64.5 Adding the Suspend Function64.6 Implementing the launchCoroutines Method64.7 Testing the App64.8 Summary
65. An Overview of Android Services
65.1 Started Services65.2 Intent Service65.3 Bound Service65.4 The Anatomy of a Service65.5 Controlling Destroyed Service Restart Options65.6 Declaring a Service in the Manifest File65.7 Starting a Service Running on System Startup65.8 Summary
66. Implementing an Android Started Service – A Worked Example
66.1 Creating the Example Project66.2 Designing the User Interface66.3 Creating the Service Class66.4 Adding the Service to the Manifest File66.5 Starting the Service66.6 Testing the IntentService Example66.7 Using the Service Class66.8 Creating the New Service66.9 Launching the Service66.10 Running the Application66.11 Using a Coroutine for the Service Task66.12 Summary
67. Android Local Bound Services – A Worked Example
67.1 Understanding Bound Services67.2 Bound Service Interaction Options67.3 A Local Bound Service Example67.4 Adding a Bound Service to the Project67.5 Implementing the Binder67.6 Binding the Client to the Service67.7 Completing the Example67.8 Testing the Application67.9 Summary
68. Android Remote Bound Services – A Worked Example
68.1 Client to Remote Service Communication68.2 Creating the Example Application68.3 Designing the User Interface68.4 Implementing the Remote Bound Service68.5 Configuring a Remote Service in the Manifest File68.6 Launching and Binding to the Remote Service68.7 Sending a Message to the Remote Service68.8 Summary
69. An Android Notifications Tutorial
69.1 An Overview of Notifications69.2 Creating the NotifyDemo Project69.3 Designing the User Interface69.4 Creating the Second Activity69.5 Creating a Notification Channel69.6 Creating and Issuing a Notification69.7 Launching an Activity from a Notification69.8 Adding Actions to a Notification69.9 Bundled Notifications69.10 Summary
70. An Android Direct Reply Notification Tutorial
70.1 Creating the DirectReply Project70.2 Designing the User Interface70.3 Creating the Notification Channel70.4 Building the RemoteInput Object70.5 Creating the PendingIntent70.6 Creating the Reply Action70.7 Receiving Direct Reply Input70.8 Updating the Notification70.9 Summary
71. Foldable Devices and Multi-Window Support
71.1 Foldables and Multi-Window Support71.2 Using a Foldable Emulator71.3 Entering Multi-Window Mode71.4 Enabling and using Freeform Support71.5 Checking for Freeform Support71.6 Enabling Multi-Window Support in an App71.7 Specifying Multi-Window Attributes71.8 Detecting Multi-Window Mode in an Activity71.9 Receiving Multi-Window Notifications71.10 Launching an Activity in Multi-Window Mode71.11 Configuring Freeform Activity Size and Position71.12 Summary
72. An Overview of Android SQLite Databases
72.1 Understanding Database Tables72.2 Introducing Database Schema 72.3 Columns and Data Types 72.4 Database Rows 72.5 Introducing Primary Keys 72.6 What is SQLite?72.7 Structured Query Language (SQL)72.8 Trying SQLite on an Android Virtual Device (AVD)72.9 The Android Room Persistence Library72.10 Summary
73. The Android Room Persistence Library
73.1 Revisiting Modern App Architecture73.2 Key Elements of Room Database Persistence73.2.1 Repository73.2.2 Room Database73.2.3 Data Access Object (DAO)73.2.4 Entities73.2.5 SQLite Database73.3 Understanding Entities73.4 Data Access Objects73.5 The Room Database73.6 The Repository73.7 In-Memory Databases73.8 Database Inspector73.9 Summary
74. An Android TableLayout and TableRow Tutorial
74.1 The TableLayout and TableRow Layout Views74.2 Creating the Room Database Project74.3 Converting to a LinearLayout74.4 Adding the TableLayout to the User Interface74.5 Configuring the TableRows74.6 Adding the Button Bar to the Layout74.7 Adding the RecyclerView74.8 Adjusting the Layout Margins74.9 Summary
75. An Android Room Database and Repository Tutorial
75.1 About the RoomDemo Project75.2 Modifying the Build Configuration75.3 Building the Entity75.4 Creating the Data Access Object75.5 Adding the Room Database75.6 Adding the Repository75.7 Modifying the ViewModel75.8 Creating the Product Item Layout75.9 Adding the RecyclerView Adapter75.10 Preparing the Main Fragment75.11 Adding the Button Listeners75.12 Adding LiveData Observers75.13 Initializing the RecyclerView75.14 Testing the RoomDemo App75.15 Using the Database Inspector75.16 Summary
76. Accessing Cloud Storage using the Android Storage Access Framework
76.1 The Storage Access Framework76.2 Working with the Storage Access Framework76.3 Filtering Picker File Listings76.4 Handling Intent Results76.5 Reading the Content of a File76.6 Writing Content to a File76.7 Deleting a File76.8 Gaining Persistent Access to a File76.9 Summary
77. An Android Storage Access Framework Example
77.1 About the Storage Access Framework Example77.2 Creating the Storage Access Framework Example77.3 Designing the User Interface77.4 Adding the Activity Launchers77.5 Creating a New Storage File77.6 Saving to a Storage File77.7 Opening and Reading a Storage File77.8 Testing the Storage Access Application77.9 Summary
78. Video Playback on Android using the VideoView and MediaController Classes
78.1 Introducing the Android VideoView Class78.2 Introducing the Android MediaController Class78.3 Creating the Video Playback Example78.4 Designing the VideoPlayer Layout78.5 Downloading the Video File78.6 Configuring the VideoView78.7 Adding the MediaController to the Video View78.8 Setting up the onPreparedListener78.9 Summary
79. Android Picture-in-Picture Mode
79.1 Picture-in-Picture Features79.2 Enabling Picture-in-Picture Mode79.3 Configuring Picture-in-Picture Parameters79.4 Entering Picture-in-Picture Mode79.5 Detecting Picture-in-Picture Mode Changes79.6 Adding Picture-in-Picture Actions79.7 Summary
80. An Android Picture-in-Picture Tutorial
80.1 Adding Picture-in-Picture Support to the Manifest80.2 Adding a Picture-in-Picture Button80.3 Entering Picture-in-Picture Mode80.4 Detecting Picture-in-Picture Mode Changes80.5 Adding a Broadcast Receiver80.6 Adding the PiP Action80.7 Testing the Picture-in-Picture Action80.8 Summary
81. Making Runtime Permission Requests in Android
81.1 Understanding Normal and Dangerous Permissions81.2 Creating the Permissions Example Project81.3 Checking for a Permission81.4 Requesting Permission at Runtime81.5 Providing a Rationale for the Permission Request81.6 Testing the Permissions App81.7 Summary
82. Android Audio Recording and Playback using MediaPlayer and MediaRecorder
82.1 Playing Audio82.2 Recording Audio and Video using the MediaRecorder Class82.3 About the Example Project82.4 Creating the AudioApp Project82.5 Designing the User Interface82.6 Checking for Microphone Availability82.7 Initializing the Activity82.8 Implementing the recordAudio() Method82.9 Implementing the stopAudio() Method82.10 Implementing the playAudio() method82.11 Configuring and Requesting Permissions82.12 Testing the Application82.13 Summary
83. Printing with the Android Printing Framework
83.1 The Android Printing Architecture83.2 The Print Service Plugins83.3 Google Cloud Print83.4 Printing to Google Drive83.5 Save as PDF83.6 Printing from Android Devices83.7 Options for Building Print Support into Android Apps83.7.1 Image Printing83.7.2 Creating and Printing HTML Content83.7.3 Printing a Web Page83.7.4 Printing a Custom Document83.8 Summary
84. An Android HTML and Web Content Printing Example
84.1 Creating the HTML Printing Example Application84.2 Printing Dynamic HTML Content84.3 Creating the Web Page Printing Example84.4 Removing the Floating Action Button84.5 Removing Navigation Features84.6 Designing the User Interface Layout84.7 Accessing the WebView from the Main Activity84.8 Loading the Web Page into the WebView84.9 Adding the Print Menu Option84.10 Summary
85. A Guide to Android Custom Document Printing
85.1 An Overview of Android Custom Document Printing85.1.1 Custom Print Adapters85.2 Preparing the Custom Document Printing Project85.3 Creating the Custom Print Adapter85.4 Implementing the onLayout() Callback Method85.5 Implementing the onWrite() Callback Method85.6 Checking a Page is in Range85.7 Drawing the Content on the Page Canvas85.8 Starting the Print Job85.9 Testing the Application85.10 Summary
86. An Introduction to Android App Links
86.1 An Overview of Android App Links86.2 App Link Intent Filters86.3 Handling App Link Intents86.4 Associating the App with a Website86.5 Summary
87. An Android Studio App Links Tutorial
87.1 About the Example App87.2 The Database Schema87.3 Loading and Running the Project87.4 Adding the URL Mapping87.5 Adding the Intent Filter87.6 Adding Intent Handling Code87.7 Testing the App Link87.8 Associating an App Link with a Web Site87.9 Summary
88. An Android Biometric Authentication Tutorial
88.1 An Overview of Biometric Authentication88.2 Creating the Biometric Authentication Project88.3 Configuring Device Fingerprint Authentication88.4 Adding the Biometric Permission to the Manifest File88.5 Designing the User Interface88.6 Adding a Toast Convenience Method88.7 Checking the Security Settings88.8 Configuring the Authentication Callbacks88.9 Adding the CancellationSignal88.10 Starting the Biometric Prompt88.11 Testing the Project88.12 Summary
89. Creating, Testing and Uploading an Android App Bundle
89.1 The Release Preparation Process89.2 Android App Bundles89.3 Register for a Google Play Developer Console Account89.4 Configuring the App in the Console89.5 Enabling Google Play App Signing89.6 Creating a Keystore File89.7 Creating the Android App Bundle89.8 Generating Test APK Files89.9 Uploading the App Bundle to the Google Play Developer Console89.10 Exploring the App Bundle89.11 Managing Testers89.12 Rolling the App Out for Testing89.13 Uploading New App Bundle Revisions89.14 Analyzing the App Bundle File89.15 Summary
90. An Overview of Android Dynamic Feature Modules
90.1 An Overview of Dynamic Feature Modules90.2 Dynamic Feature Module Architecture90.3 Creating a Dynamic Feature Module90.4 Converting an Existing Module for Dynamic Delivery90.5 Working with Dynamic Feature Modules90.6 Handling Large Dynamic Feature Modules90.7 Summary
91. An Android Studio Dynamic Feature Tutorial
91.1 Creating the DynamicFeature Project91.2 Adding Dynamic Feature Support to the Project91.3 Designing the Base Activity User Interface91.4 Adding the Dynamic Feature Module91.5 Reviewing the Dynamic Feature Module91.6 Adding the Dynamic Feature Activity91.7 Implementing the launchIntent() Method91.8 Uploading the App Bundle for Testing91.9 Implementing the installFeature() Method91.10 Adding the Update Listener91.11 Using Deferred Installation91.12 Removing a Dynamic Module91.13 Summary
92. An Overview of Gradle in Android Studio
92.1 An Overview of Gradle92.2 Gradle and Android Studio92.2.1 Sensible Defaults92.2.2 Dependencies92.2.3 Build Variants92.2.4 Manifest Entries92.2.5 APK Signing92.2.6 ProGuard Support92.3 The Top-level Gradle Build File92.4 Module Level Gradle Build Files92.5 Configuring Signing Settings in the Build File92.6 Running Gradle Tasks from the Command-line92.7 Summary
Index

Content preview from Android Studio Arctic Fox Essentials - Kotlin Edition

19. Understanding Android Application and Activity Lifecycles

In earlier chapters we have learned that Android applications run within processes and that they are comprised of multiple components in the form of activities, services and broadcast receivers. The goal of this chapter is to expand on this knowledge by looking at the lifecycle of applications and activities within the Android runtime system.

Regardless of the fanfare about how much memory and computing power resides in the mobile devices of today compared to the desktop systems of yesterday, it is important to keep in mind that these devices are still considered to be “resource constrained” by the standards of modern desktop and laptop based systems, particularly in terms of memory. ...

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

Publisher Resources

ISBN: 9781803247458

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Android Studio Arctic Fox 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.