book

Android Studio 4.2 Development Essentials - Java Edition

Name: Android Studio 4.2 Development Essentials - Java Edition
Author: Neil Smyth
ISBN: 9781803238814

by Neil Smyth

August 2021

Intermediate to advanced

782 pages

22h 37m

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 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 Overview of Android View Binding
11.1 Find View by Id11.2 View Binding 11.3 Converting the AndroidSample project11.4 Enabling View Binding11.5 Using View Binding11.6 Choosing an Option11.7 View Binding in the Book Examples11.8 Migrating a Project to View Binding11.9 Summary
12. Understanding Android Application and Activity Lifecycles
12.1 Android Applications and Resource Management12.2 Android Process States12.2.1 Foreground Process12.2.2 Visible Process12.2.3 Service Process12.2.4 Background Process12.2.5 Empty Process12.3 Inter-Process Dependencies 12.4 The Activity Lifecycle12.5 The Activity Stack12.6 Activity States12.7 Configuration Changes12.8 Handling State Change12.9 Summary
13. Handling Android Activity State Changes
13.1 New vs. Old Lifecycle Techniques13.2 The Activity and Fragment Classes13.3 Dynamic State vs. Persistent State13.4 The Android Lifecycle Methods13.5 Lifetimes13.6 Foldable Devices and Multi-Resume13.7 Disabling Configuration Change Restarts13.8 Lifecycle Method Limitations13.9 Summary
14. Android Activity State Changes by Example
14.1 Creating the State Change Example Project14.2 Designing the User Interface14.3 Overriding the Activity Lifecycle Methods14.4 Filtering the Logcat Panel14.5 Running the Application14.6 Experimenting with the Activity14.7 Summary
15. Saving and Restoring the State of an Android Activity
15.1 Saving Dynamic State15.2 Default Saving of User Interface State15.3 The Bundle Class15.4 Saving the State15.5 Restoring the State15.6 Testing the Application15.7 Summary
16. Understanding Android Views, View Groups and Layouts
16.1 Designing for Different Android Devices16.2 Views and View Groups16.3 Android Layout Managers16.4 The View Hierarchy16.5 Creating User Interfaces16.6 Summary
17. A Guide to the Android Studio Layout Editor Tool
17.1 Basic vs. Empty Activity Templates17.2 The Android Studio Layout Editor17.3 Design Mode17.4 The Palette17.5 Design Mode and Layout Views17.6 Night Mode17.7 Code Mode17.8 Split Mode17.9 Setting Attributes17.10 Transforms17.11 Tools Visibility Toggles17.12 Converting Views17.13 Displaying Sample Data17.14 Creating a Custom Device Definition17.15 Changing the Current Device17.16 Layout Validation (Multi Preview)17.17 Summary
18. A Guide to the Android ConstraintLayout
18.1 How ConstraintLayout Works18.1.1 Constraints18.1.2 Margins18.1.3 Opposing Constraints18.1.4 Constraint Bias18.1.5 Chains18.1.6 Chain Styles18.2 Baseline Alignment18.3 Configuring Widget Dimensions18.4 Guideline Helper18.5 Group Helper18.6 Barrier Helper18.7 Flow Helper18.8 Ratios18.9 ConstraintLayout Advantages18.10 ConstraintLayout Availability18.11 Summary
19. A Guide to Using ConstraintLayout in Android Studio
19.1 Design and Layout Views19.2 Autoconnect Mode19.3 Inference Mode19.4 Manipulating Constraints Manually19.5 Adding Constraints in the Inspector19.6 Viewing Constraints in the Attributes Window19.7 Deleting Constraints19.8 Adjusting Constraint Bias19.9 Understanding ConstraintLayout Margins19.10 The Importance of Opposing Constraints and Bias19.11 Configuring Widget Dimensions19.12 Design Time Tools Positioning19.13 Adding Guidelines19.14 Adding Barriers19.15 Adding a Group19.16 Working with the Flow Helper19.17 Widget Group Alignment and Distribution19.18 Converting other Layouts to ConstraintLayout19.19 Summary
20. Working with ConstraintLayout Chains and Ratios in Android Studio
20.1 Creating a Chain20.2 Changing the Chain Style20.3 Spread Inside Chain Style20.4 Packed Chain Style20.5 Packed Chain Style with Bias20.6 Weighted Chain20.7 Working with Ratios20.8 Summary
21. An Android Studio Layout Editor ConstraintLayout Tutorial
21.1 An Android Studio Layout Editor Tool Example21.2 Creating a New Activity21.3 Preparing the Layout Editor Environment21.4 Adding the Widgets to the User Interface21.5 Adding the Constraints21.6 Testing the Layout21.7 Using the Layout Inspector21.8 Summary
22. Manual XML Layout Design in Android Studio
22.1 Manually Creating an XML Layout22.2 Manual XML vs. Visual Layout Design22.3 Summary
23. Managing Constraints using Constraint Sets
23.1 Java Code vs. XML Layout Files23.2 Creating Views23.3 View Attributes23.4 Constraint Sets23.4.1 Establishing Connections23.4.2 Applying Constraints to a Layout23.4.3 Parent Constraint Connections23.4.4 Sizing Constraints23.4.5 Constraint Bias23.4.6 Alignment Constraints23.4.7 Copying and Applying Constraint Sets23.4.8 ConstraintLayout Chains23.4.9 Guidelines23.4.10 Removing Constraints23.4.11 Scaling23.4.12 Rotation23.5 Summary
24. An Android ConstraintSet Tutorial
24.1 Creating the Example Project in Android Studio24.2 Adding Views to an Activity24.3 Setting View Attributes24.4 Creating View IDs24.5 Configuring the Constraint Set24.6 Adding the EditText View24.7 Converting Density Independent Pixels (dp) to Pixels (px)24.8 Summary
25. A Guide to using Apply Changes in Android Studio
25.1 Introducing Apply Changes25.2 Understanding Apply Changes Options25.3 Using Apply Changes25.4 Configuring Apply Changes Fallback Settings25.5 An Apply Changes Tutorial25.6 Using Apply Code Changes25.7 Using Apply Changes and Restart Activity25.8 Using Run App25.9 Summary
26. An Overview and Example of Android Event Handling
26.1 Understanding Android Events26.2 Using the android:onClick Resource26.3 Event Listeners and Callback Methods26.4 An Event Handling Example26.5 Designing the User Interface26.6 The Event Listener and Callback Method26.7 Consuming Events26.8 Summary
27. Android Touch and Multi-touch Event Handling
27.1 Intercepting Touch Events27.2 The MotionEvent Object27.3 Understanding Touch Actions27.4 Handling Multiple Touches27.5 An Example Multi-Touch Application27.6 Designing the Activity User Interface27.7 Implementing the Touch Event Listener27.8 Running the Example Application27.9 Summary
28. Detecting Common Gestures Using the Android Gesture Detector Class
28.1 Implementing Common Gesture Detection28.2 Creating an Example Gesture Detection Project28.3 Implementing the Listener Class28.4 Creating the GestureDetectorCompat Instance28.5 Implementing the onTouchEvent() Method28.6 Testing the Application28.7 Summary
29. Implementing Custom Gesture and Pinch Recognition on Android
29.1 The Android Gesture Builder Application29.2 The GestureOverlayView Class29.3 Detecting Gestures29.4 Identifying Specific Gestures29.5 Installing and Running the Gesture Builder Application29.6 Creating a Gestures File29.7 Creating the Example Project29.8 Extracting the Gestures File from the SD Card29.9 Adding the Gestures File to the Project29.10 Designing the User Interface29.11 Loading the Gestures File29.12 Registering the Event Listener29.13 Implementing the onGesturePerformed Method29.14 Testing the Application29.15 Configuring the GestureOverlayView29.16 Intercepting Gestures29.17 Detecting Pinch Gestures29.18 A Pinch Gesture Example Project29.19 Summary
30. An Introduction to Android Fragments
30.1 What is a Fragment?30.2 Creating a Fragment30.3 Adding a Fragment to an Activity using the Layout XML File30.4 Adding and Managing Fragments in Code30.5 Handling Fragment Events30.6 Implementing Fragment Communication30.7 Summary
31. Using Fragments in Android Studio - An Example
31.1 About the Example Fragment Application31.2 Creating the Example Project31.3 Creating the First Fragment Layout31.4 Migrating a Fragment to View Binding31.5 Adding the Second Fragment31.6 Adding the Fragments to the Activity31.7 Making the Toolbar Fragment Talk to the Activity31.8 Making the Activity Talk to the Text Fragment31.9 Testing the Application31.10 Summary
32. Modern Android App Architecture with Jetpack
32.1 What is Android Jetpack?32.2 The “Old” Architecture32.3 Modern Android Architecture32.4 The ViewModel Component32.5 The LiveData Component32.6 ViewModel Saved State32.7 LiveData and Data Binding32.8 Android Lifecycles32.9 Repository Modules32.10 Summary
33. An Android Jetpack ViewModel Tutorial
33.1 About the Project33.2 Creating the ViewModel Example Project33.3 Reviewing the Project33.3.1 The Main Activity33.3.2 The Content Fragment33.3.3 The ViewModel33.4 Designing the Fragment Layout33.5 Implementing the View Model33.6 Associating the Fragment with the View Model33.7 Modifying the Fragment33.8 Accessing the ViewModel Data33.9 Testing the Project33.10 Summary
34. An Android Jetpack LiveData Tutorial
34.1 LiveData - A Recap34.2 Adding LiveData to the ViewModel34.3 Implementing the Observer34.4 Summary
35. An Overview of Android Jetpack Data Binding
35.1 An Overview of Data Binding35.2 The Key Components of Data Binding35.2.1 The Project Build Configuration35.2.2 The Data Binding Layout File35.2.3 The Layout File Data Element35.2.4 The Binding Classes35.2.5 Data Binding Variable Configuration35.2.6 Binding Expressions (One-Way)35.2.7 Binding Expressions (Two-Way)35.2.8 Event and Listener Bindings35.3 Summary
36. An Android Jetpack Data Binding Tutorial
36.1 Removing the Redundant Code36.2 Enabling Data Binding36.3 Adding the Layout Element36.4 Adding the Data Element to Layout File36.5 Working with the Binding Class36.6 Assigning the ViewModel Instance to the Data Binding Variable36.7 Adding Binding Expressions36.8 Adding the Conversion Method36.9 Adding a Listener Binding36.10 Testing the App36.11 Summary
37. An Android ViewModel Saved State Tutorial
37.1 Understanding ViewModel State Saving37.2 Implementing ViewModel State Saving37.3 Saving and Restoring State37.4 Adding Saved State Support to the ViewModelDemo Project37.5 Summary
38. Working with Android Lifecycle-Aware Components
38.1 Lifecycle Awareness38.2 Lifecycle Owners38.3 Lifecycle Observers38.4 Lifecycle States and Events38.5 Summary
39. An Android Jetpack Lifecycle Awareness Tutorial
39.1 Creating the Example Lifecycle Project39.2 Creating a Lifecycle Observer39.3 Adding the Observer39.4 Testing the Observer39.5 Creating a Lifecycle Owner39.6 Testing the Custom Lifecycle Owner39.7 Summary
40. An Overview of the Navigation Architecture Component
40.1 Understanding Navigation40.2 Declaring a Navigation Host40.3 The Navigation Graph40.4 Accessing the Navigation Controller40.5 Triggering a Navigation Action40.6 Passing Arguments40.7 Summary
41. An Android Jetpack Navigation Component Tutorial
41.1 Creating the NavigationDemo Project41.2 Adding Navigation to the Build Configuration41.3 Creating the Navigation Graph Resource File41.4 Declaring a Navigation Host41.5 Adding Navigation Destinations41.6 Designing the Destination Fragment Layouts41.7 Adding an Action to the Navigation Graph41.8 Implement the OnFragmentInteractionListener41.9 Adding View Binding Support to the Destination Fragments41.10 Triggering the Action41.11 Passing Data Using Safeargs41.12 Summary
42. An Introduction to MotionLayout
42.1 An Overview of MotionLayout42.2 MotionLayout42.3 MotionScene42.4 Configuring ConstraintSets42.5 Custom Attributes42.6 Triggering an Animation42.7 Arc Motion42.8 Keyframes42.8.1 Attribute Keyframes42.8.2 Position Keyframes42.9 Time Linearity42.10 KeyTrigger42.11 Cycle and Time Cycle Keyframes42.12 Starting an Animation from Code
43. An Android MotionLayout Editor Tutorial
43.1 Creating the MotionLayoutDemo Project43.2 ConstraintLayout to MotionLayout Conversion43.3 Configuring Start and End Constraints43.4 Previewing the MotionLayout Animation43.5 Adding an OnClick Gesture43.6 Adding an Attribute Keyframe to the Transition43.7 Adding a CustomAttribute to a Transition43.8 Adding Position Keyframes43.9 Summary
44. A MotionLayout KeyCycle Tutorial
44.1 An Overview of Cycle Keyframes44.2 Using the Cycle Editor44.3 Creating the KeyCycleDemo Project44.4 Configuring the Start and End Constraints44.5 Creating the Cycles44.6 Previewing the Animation44.7 Adding the KeyFrameSet to the MotionScene44.8 Summary
45. Working with the Floating Action Button and Snackbar
45.1 The Material Design45.2 The Design Library45.3 The Floating Action Button (FAB) 45.4 The Snackbar45.5 Creating the Example Project45.6 Reviewing the Project45.7 Removing Navigation Features45.8 Changing the Floating Action Button45.9 Adding an Action to the Snackbar45.10 Summary
46. Creating a Tabbed Interface using the TabLayout Component
46.1 An Introduction to the ViewPager2 Class46.2 An Overview of the TabLayout Component46.3 Creating the TabLayoutDemo Project46.4 Creating the First Fragment46.5 Duplicating the Fragments46.6 Adding the TabLayout and ViewPager246.7 Creating the Fragment State Adapter46.8 Performing the Initialization Tasks46.9 Testing the Application46.10 Customizing the TabLayout46.11 Summary
47. Working with the RecyclerView and CardView Widgets
47.1 An Overview of the RecyclerView47.2 An Overview of the CardView47.3 Summary
48. An Android RecyclerView and CardView Tutorial
48.1 Creating the CardDemo Project48.2 Modifying the Basic Activity Project48.3 Designing the CardView Layout48.4 Adding the RecyclerView48.5 Adding the Image Files48.6 Creating the RecyclerView Adapter48.7 Initializing the RecyclerView Component48.8 Testing the Application48.9 Responding to Card Selections48.10 Summary
49. A Layout Editor Sample Data Tutorial
49.1 Adding Sample Data to a Project49.2 Using Custom Sample Data49.3 Summary
50. Working with the AppBar and Collapsing Toolbar Layouts
50.1 The Anatomy of an AppBar50.2 The Example Project50.3 Coordinating the RecyclerView and Toolbar50.4 Introducing the Collapsing Toolbar Layout50.5 Changing the Title and Scrim Color50.6 Summary
51. An Android Studio Primary/Detail Flow Tutorial
51.1 The Primary/Detail Flow51.2 Creating a Primary/Detail Flow Activity51.3 Modifying the Primary/Detail Flow Template51.4 Changing the Content Model51.5 Changing the Detail Pane51.6 Modifying the WebsiteDetailFragment Class51.7 Modifying the WebsiteListFragment Class51.8 Adding Manifest Permissions51.9 Running the Application51.10 Summary
52. An Overview of Android Intents
52.1 An Overview of Intents52.2 Explicit Intents52.3 Returning Data from an Activity52.4 Implicit Intents52.5 Using Intent Filters52.6 Checking Intent Availability52.7 Summary
53. Android Explicit Intents – A Worked Example
53.1 Creating the Explicit Intent Example Application53.2 Designing the User Interface Layout for MainActivity53.3 Creating the Second Activity Class53.4 Designing the User Interface Layout for SecondActivity53.5 Reviewing the Application Manifest File53.6 Creating the Intent53.7 Extracting Intent Data53.8 Launching SecondActivity as a Sub-Activity53.9 Returning Data from a Sub-Activity53.10 Testing the Application53.11 Summary
54. Android Implicit Intents – A Worked Example
54.1 Creating the Android Studio Implicit Intent Example Project54.2 Designing the User Interface54.3 Creating the Implicit Intent54.4 Adding a Second Matching Activity54.5 Adding the Web View to the UI54.6 Obtaining the Intent URL54.7 Modifying the MyWebView Project Manifest File54.8 Installing the MyWebView Package on a Device54.9 Testing the Application54.10 Summary
55. Android Broadcast Intents and Broadcast Receivers
55.1 An Overview of Broadcast Intents55.2 An Overview of Broadcast Receivers55.3 Obtaining Results from a Broadcast55.4 Sticky Broadcast Intents55.5 The Broadcast Intent Example55.6 Creating the Example Application55.7 Creating and Sending the Broadcast Intent55.8 Creating the Broadcast Receiver55.9 Registering the Broadcast Receiver55.10 Testing the Broadcast Example55.11 Listening for System Broadcasts55.12 Summary
56. A Basic Overview of Java Threads, Handlers and Executors
56.1 An Overview of Threads56.2 The Application Main Thread56.3 Thread Handlers56.4 A Threading Example56.5 Building the App56.6 Creating a New Thread56.7 Implementing a Thread Handler56.8 Passing a Message to the Handler56.9 Java Executor Concurrency56.10 Working with Runnable Tasks56.11 Shutting down an Executor Service56.12 Working with Callable Tasks and Futures56.13 Handling a Future Result56.14 Scheduling Tasks56.15 Summary
57. An Overview of Android Services
57.1 Started Services57.2 Intent Service57.3 Bound Service57.4 The Anatomy of a Service57.5 Controlling Destroyed Service Restart Options57.6 Declaring a Service in the Manifest File57.7 Starting a Service Running on System Startup57.8 Summary
58. Implementing an Android Started Service – A Worked Example
58.1 Creating the Example Project58.2 Designing the User Interface58.3 Creating the Service Class58.4 Adding the Service to the Manifest File58.5 Starting the Service58.6 Testing the IntentService Example58.7 Using the Service Class58.8 Creating the New Service58.9 Launching the Service58.10 Running the Application58.11 Adding Threading to the Service58.12 Summary
59. Android Local Bound Services – A Worked Example
59.1 Understanding Bound Services59.2 Bound Service Interaction Options59.3 A Local Bound Service Example59.4 Adding a Bound Service to the Project59.5 Implementing the Binder59.6 Binding the Client to the Service59.7 Completing the Example59.8 Testing the Application59.9 Summary
60. Android Remote Bound Services – A Worked Example
60.1 Client to Remote Service Communication60.2 Creating the Example Application60.3 Designing the User Interface60.4 Implementing the Remote Bound Service60.5 Configuring a Remote Service in the Manifest File60.6 Launching and Binding to the Remote Service60.7 Sending a Message to the Remote Service60.8 Summary
61. An Android Notifications Tutorial
61.1 An Overview of Notifications61.2 Creating the NotifyDemo Project61.3 Designing the User Interface61.4 Creating the Second Activity61.5 Creating a Notification Channel61.6 Creating and Issuing a Notification61.7 Launching an Activity from a Notification61.8 Adding Actions to a Notification61.9 Bundled Notifications61.10 Summary
62. An Android Direct Reply Notification Tutorial
62.1 Creating the DirectReply Project62.2 Designing the User Interface62.3 Creating the Notification Channel62.4 Building the RemoteInput Object62.5 Creating the PendingIntent62.6 Creating the Reply Action62.7 Receiving Direct Reply Input62.8 Updating the Notification62.9 Summary
63. Foldable Devices and Multi-Window Support
63.1 Foldables and Multi-Window Support63.2 Using a Foldable Emulator63.3 Entering Multi-Window Mode63.4 Enabling and using Freeform Support63.5 Checking for Freeform Support63.6 Enabling Multi-Window Support in an App63.7 Specifying Multi-Window Attributes63.8 Detecting Multi-Window Mode in an Activity63.9 Receiving Multi-Window Notifications63.10 Launching an Activity in Multi-Window Mode63.11 Configuring Freeform Activity Size and Position63.12 Summary
64. An Overview of Android SQLite Databases
64.1 Understanding Database Tables64.2 Introducing Database Schema 64.3 Columns and Data Types 64.4 Database Rows 64.5 Introducing Primary Keys 64.6 What is SQLite?64.7 Structured Query Language (SQL)64.8 Trying SQLite on an Android Virtual Device (AVD)64.9 The Android Room Persistence Library64.10 Summary
65. The Android Room Persistence Library
65.1 Revisiting Modern App Architecture65.2 Key Elements of Room Database Persistence65.2.1 Repository65.2.2 Room Database65.2.3 Data Access Object (DAO)65.2.4 Entities65.2.5 SQLite Database65.3 Understanding Entities65.4 Data Access Objects65.5 The Room Database65.6 The Repository65.7 In-Memory Databases65.8 Database Inspector65.9 Summary
66. An Android TableLayout and TableRow Tutorial
66.1 The TableLayout and TableRow Layout Views66.2 Creating the Room Database Project66.3 Converting to a LinearLayout66.4 Adding the TableLayout to the User Interface66.5 Configuring the TableRows66.6 Adding the Button Bar to the Layout66.7 Adding the RecyclerView66.8 Adjusting the Layout Margins66.9 Summary
67. An Android Room Database and Repository Tutorial
67.1 About the RoomDemo Project67.2 Modifying the Build Configuration67.3 Building the Entity67.4 Creating the Data Access Object67.5 Adding the Room Database67.6 Adding the Repository67.7 Modifying the ViewModel67.8 Creating the Product Item Layout67.9 Adding the RecyclerView Adapter67.10 Preparing the Main Fragment67.11 Adding the Button Listeners67.12 Adding LiveData Observers67.13 Initializing the RecyclerView67.14 Testing the RoomDemo App67.15 Using the Database Inspector67.16 Summary
68. Accessing Cloud Storage using the Android Storage Access Framework
68.1 The Storage Access Framework68.2 Working with the Storage Access Framework68.3 Filtering Picker File Listings68.4 Handling Intent Results68.5 Reading the Content of a File68.6 Writing Content to a File68.7 Deleting a File68.8 Gaining Persistent Access to a File68.9 Summary
69. An Android Storage Access Framework Example
69.1 About the Storage Access Framework Example69.2 Creating the Storage Access Framework Example69.3 Designing the User Interface69.4 Declaring Request Codes69.5 Creating a New Storage File69.6 The onActivityResult() Method69.7 Saving to a Storage File69.8 Opening and Reading a Storage File69.9 Testing the Storage Access Application69.10 Summary
70. Video Playback on Android using the VideoView and MediaController Classes
70.1 Introducing the Android VideoView Class70.2 Introducing the Android MediaController Class70.3 Creating the Video Playback Example70.4 Designing the VideoPlayer Layout70.5 Downloading the Video File70.6 Configuring the VideoView70.7 Adding the MediaController to the Video View70.8 Setting up the onPreparedListener70.9 Summary
71. Android Picture-in-Picture Mode
71.1 Picture-in-Picture Features71.2 Enabling Picture-in-Picture Mode71.3 Configuring Picture-in-Picture Parameters71.4 Entering Picture-in-Picture Mode71.5 Detecting Picture-in-Picture Mode Changes71.6 Adding Picture-in-Picture Actions71.7 Summary
72. An Android Picture-in-Picture Tutorial
72.1 Adding Picture-in-Picture Support to the Manifest72.2 Adding a Picture-in-Picture Button72.3 Entering Picture-in-Picture Mode72.4 Detecting Picture-in-Picture Mode Changes72.5 Adding a Broadcast Receiver72.6 Adding the PiP Action72.7 Testing the Picture-in-Picture Action72.8 Summary
73. Making Runtime Permission Requests in Android
73.1 Understanding Normal and Dangerous Permissions73.2 Creating the Permissions Example Project73.3 Checking for a Permission73.4 Requesting Permission at Runtime73.5 Providing a Rationale for the Permission Request73.6 Testing the Permissions App73.7 Summary
74. Android Audio Recording and Playback using MediaPlayer and MediaRecorder
74.1 Playing Audio74.2 Recording Audio and Video using the MediaRecorder Class74.3 About the Example Project74.4 Creating the AudioApp Project74.5 Designing the User Interface74.6 Checking for Microphone Availability74.7 Initializing the Activity74.8 Implementing the recordAudio() Method74.9 Implementing the stopAudio() Method74.10 Implementing the playAudio() method74.11 Configuring and Requesting Permissions74.12 Testing the Application74.13 Summary
75. Working with the Google Maps Android API in Android Studio
75.1 The Elements of the Google Maps Android API75.2 Creating the Google Maps Project75.3 Obtaining Your Developer Signature75.4 Adding the Apache HTTP Legacy Library Requirement75.5 Testing the Application75.6 Understanding Geocoding and Reverse Geocoding75.7 Adding a Map to an Application75.8 Requesting Current Location Permission75.9 Displaying the User’s Current Location75.10 Changing the Map Type75.11 Displaying Map Controls to the User75.12 Handling Map Gesture Interaction75.12.1 Map Zooming Gestures75.12.2 Map Scrolling/Panning Gestures75.12.3 Map Tilt Gestures75.12.4 Map Rotation Gestures75.13 Creating Map Markers75.14 Controlling the Map Camera75.15 Summary
76. Printing with the Android Printing Framework
76.1 The Android Printing Architecture76.2 The Print Service Plugins76.3 Google Cloud Print76.4 Printing to Google Drive76.5 Save as PDF76.6 Printing from Android Devices76.7 Options for Building Print Support into Android Apps76.7.1 Image Printing76.7.2 Creating and Printing HTML Content76.7.3 Printing a Web Page76.7.4 Printing a Custom Document76.8 Summary
77. An Android HTML and Web Content Printing Example
77.1 Creating the HTML Printing Example Application77.2 Printing Dynamic HTML Content77.3 Creating the Web Page Printing Example77.4 Removing the Floating Action Button77.5 Removing Navigation Features77.6 Designing the User Interface Layout77.7 Accessing the WebView from the Main Activity77.8 Loading the Web Page into the WebView77.9 Adding the Print Menu Option77.10 Summary
78. A Guide to Android Custom Document Printing
78.1 An Overview of Android Custom Document Printing78.1.1 Custom Print Adapters78.2 Preparing the Custom Document Printing Project78.3 Creating the Custom Print Adapter78.4 Implementing the onLayout() Callback Method78.5 Implementing the onWrite() Callback Method78.6 Checking a Page is in Range78.7 Drawing the Content on the Page Canvas78.8 Starting the Print Job78.9 Testing the Application78.10 Summary
79. An Introduction to Android App Links
79.1 An Overview of Android App Links79.2 App Link Intent Filters79.3 Handling App Link Intents79.4 Associating the App with a Website79.5 Summary
80. An Android Studio App Links Tutorial
80.1 About the Example App80.2 The Database Schema80.3 Loading and Running the Project80.4 Adding the URL Mapping80.5 Adding the Intent Filter80.6 Adding Intent Handling Code80.7 Testing the App Link80.8 Associating an App Link with a Web Site80.9 Summary
81. A Guide to the Android Studio Profiler
81.1 Accessing the Android Profiler81.2 Enabling Advanced Profiling81.3 The Android Profiler Tool Window81.4 The Sessions Panel81.5 The CPU Profiler81.6 Memory Profiler81.7 Network Profiler81.8 Energy Profiler81.9 Summary
82. An Android Biometric Authentication Tutorial
82.1 An Overview of Biometric Authentication82.2 Creating the Biometric Authentication Project82.3 Configuring Device Fingerprint Authentication82.4 Adding the Biometric Permission to the Manifest File82.5 Designing the User Interface82.6 Adding a Toast Convenience Method82.7 Checking the Security Settings82.8 Configuring the Authentication Callbacks82.9 Adding the CancellationSignal82.10 Starting the Biometric Prompt82.11 Testing the Project82.12 Summary
83. Creating, Testing and Uploading an Android App Bundle
83.1 The Release Preparation Process83.2 Android App Bundles83.3 Register for a Google Play Developer Console Account83.4 Configuring the App in the Console83.5 Enabling Google Play App Signing83.6 Creating a Keystore File83.7 Creating the Android App Bundle83.8 Generating Test APK Files83.9 Uploading the App Bundle to the Google Play Developer Console83.10 Exploring the App Bundle83.11 Managing Testers83.12 Rolling the App Out for Testing83.13 Uploading New App Bundle Revisions83.14 Analyzing the App Bundle File83.15 Summary
84. An Overview of Android Dynamic Feature Modules
84.1 An Overview of Dynamic Feature Modules84.2 Dynamic Feature Module Architecture84.3 Creating a Dynamic Feature Module84.4 Converting an Existing Module for Dynamic Delivery84.5 Working with Dynamic Feature Modules84.6 Handling Large Dynamic Feature Modules84.7 Summary
85. An Android Studio Dynamic Feature Tutorial
85.1 Creating the DynamicFeature Project85.2 Adding Dynamic Feature Support to the Project85.3 Designing the Base Activity User Interface85.4 Adding the Dynamic Feature Module85.5 Reviewing the Dynamic Feature Module85.6 Adding the Dynamic Feature Activity85.7 Implementing the launchIntent() Method85.8 Uploading the App Bundle for Testing85.9 Implementing the installFeature() Method85.10 Adding the Update Listener85.11 Handling Large Downloads85.12 Using Deferred Installation85.13 Removing a Dynamic Module85.14 Summary
86. An Overview of Gradle in Android Studio
86.1 An Overview of Gradle86.2 Gradle and Android Studio86.2.1 Sensible Defaults86.2.2 Dependencies86.2.3 Build Variants86.2.4 Manifest Entries86.2.5 APK Signing86.2.6 ProGuard Support86.3 The Top-level Gradle Build File86.4 Module Level Gradle Build Files86.5 Configuring Signing Settings in the Build File86.6 Running Gradle Tasks from the Command-line86.7 Summary
Index

Content preview from Android Studio 4.2 Development Essentials - Java Edition

23. Managing Constraints using Constraint Sets

Up until this point in the book, all user interface design tasks have been performed using the Android Studio Layout Editor tool, either in text or design mode. An alternative to writing XML resource files or using the Android Studio Layout Editor is to write Java code to directly create, configure and manipulate the view objects that comprise the user interface of an Android activity. Within the context of this chapter, we will explore some of the advantages and disadvantages of writing Java code to create a user interface before describing some of the key concepts such as view properties and the creation and management of layout constraints.

In the next chapter, an example project will be created ...

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: 9781803238814

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Android Studio 4.2 Development Essentials - Java 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.