- 1. Introduction
- 2. Setting up an Android Studio Development Environment
- 2.1 System Requirements
- 2.2 Downloading the Android Studio Package
- 2.3 Installing Android Studio
- 2.4 The Android Studio Setup Wizard
- 2.5 Installing Additional Android SDK Packages
- 2.6 Making the Android SDK Tools Command-line Accessible
- 2.7 Android Studio Memory Management
- 2.8 Updating Android Studio and the SDK
- 2.9 Summary
- 3. Creating an Example Android App in Android Studio
- 4. Creating an Android Virtual Device (AVD) in Android Studio
- 4.1 About Android Virtual Devices
- 4.2 Creating a New AVD
- 4.3 Starting the Emulator
- 4.4 Running the Application in the AVD
- 4.5 Stopping a Running Application
- 4.6 Supporting Dark Theme
- 4.7 AVD Command-line Creation
- 4.8 Android Virtual Device Configuration Files
- 4.9 Moving and Renaming an Android Virtual Device
- 4.10 Summary
- 5. Using and Configuring the Android Studio AVD Emulator
- 6. A Tour of the Android Studio User Interface
- 7. Testing Android Studio Apps on a Physical Android Device
- 8. The Basics of the Android Studio Code Editor
- 9. An Overview of the Android Architecture
- 10. The Anatomy of an Android Application
- 11. An Overview of Android View Binding
- 12. Understanding Android Application and Activity Lifecycles
- 13. Handling Android Activity State Changes
- 14. Android Activity State Changes by Example
- 15. Saving and Restoring the State of an Android Activity
- 16. Understanding Android Views, View Groups and Layouts
- 17. A Guide to the Android Studio Layout Editor Tool
- 17.1 Basic vs. Empty Activity Templates
- 17.2 The Android Studio Layout Editor
- 17.3 Design Mode
- 17.4 The Palette
- 17.5 Design Mode and Layout Views
- 17.6 Code Mode
- 17.7 Split Mode
- 17.8 Setting Attributes
- 17.9 Converting Views
- 17.10 Displaying Sample Data
- 17.11 Creating a Custom Device Definition
- 17.12 Changing the Current Device
- 17.13 Multi Preview
- 17.14 Summary
- 18. A Guide to the Android ConstraintLayout
- 19. A Guide to using ConstraintLayout in Android Studio
- 19.1 Design and Layout Views
- 19.2 Autoconnect Mode
- 19.3 Inference Mode
- 19.4 Manipulating Constraints Manually
- 19.5 Adding Constraints in the Inspector
- 19.6 Viewing Constraints in the Attributes Window
- 19.7 Deleting Constraints
- 19.8 Adjusting Constraint Bias
- 19.9 Understanding ConstraintLayout Margins
- 19.10 The Importance of Opposing Constraints and Bias
- 19.11 Configuring Widget Dimensions
- 19.12 Adding Guidelines
- 19.13 Adding Barriers
- 19.14 Widget Group Alignment and Distribution
- 19.15 Converting other Layouts to ConstraintLayout
- 19.16 Summary
- 20. Working with ConstraintLayout Chains and Ratios in Android Studio
- 21. An Android Studio Layout Editor ConstraintLayout Tutorial
- 22. Manual XML Layout Design in Android Studio
- 23. Managing Constraints using Constraint Sets
- 23.1 Java Code vs. XML Layout Files
- 23.2 Creating Views
- 23.3 View Attributes
- 23.4 Constraint Sets
- 23.4.1 Establishing Connections
- 23.4.2 Applying Constraints to a Layout
- 23.4.3 Parent Constraint Connections
- 23.4.4 Sizing Constraints
- 23.4.5 Constraint Bias
- 23.4.6 Alignment Constraints
- 23.4.7 Copying and Applying Constraint Sets
- 23.4.8 ConstraintLayout Chains
- 23.4.9 Guidelines
- 23.4.10 Removing Constraints
- 23.4.11 Scaling
- 23.4.12 Rotation
- 23.5 Summary
- 24. An Android ConstraintSet Tutorial
- 25. A Guide to using Apply Changes in Android Studio
- 26. An Overview and Example of Android Event Handling
- 27. Android Touch and Multi-touch Event Handling
- 28. Detecting Common Gestures using the Android Gesture Detector Class
- 29. Implementing Custom Gesture and Pinch Recognition on Android
- 29.1 The Android Gesture Builder Application
- 29.2 The GestureOverlayView Class
- 29.3 Detecting Gestures
- 29.4 Identifying Specific Gestures
- 29.5 Installing and Running the Gesture Builder Application
- 29.6 Creating a Gestures File
- 29.7 Creating the Example Project
- 29.8 Extracting the Gestures File from the SD Card
- 29.9 Adding the Gestures File to the Project
- 29.10 Designing the User Interface
- 29.11 Loading the Gestures File
- 29.12 Registering the Event Listener
- 29.13 Implementing the onGesturePerformed Method
- 29.14 Testing the Application
- 29.15 Configuring the GestureOverlayView
- 29.16 Intercepting Gestures
- 29.17 Detecting Pinch Gestures
- 29.18 A Pinch Gesture Example Project
- 29.19 Summary
- 30. An Introduction to Android Fragments
- 31. Using Fragments in Android Studio - An Example
- 31.1 About the Example Fragment Application
- 31.2 Creating the Example Project
- 31.3 Creating the First Fragment Layout
- 31.4 Creating the First Fragment Class
- 31.5 Creating the Second Fragment Layout
- 31.6 Adding the Fragments to the Activity
- 31.7 Making the Toolbar Fragment Talk to the Activity
- 31.8 Making the Activity Talk to the Text Fragment
- 31.9 Testing the Application
- 31.10 Summary
- 32. Modern Android App Architecture with Jetpack
- 33. An Android Jetpack ViewModel Tutorial
- 33.1 About the Project
- 33.2 Creating the ViewModel Example Project
- 33.3 Reviewing the Project
- 33.4 Designing the Fragment Layout
- 33.5 Implementing the View Model
- 33.6 Associating the Fragment with the View Model
- 33.7 Modifying the Fragment
- 33.8 Accessing the ViewModel Data
- 33.9 Testing the Project
- 33.10 Summary
- 34. An Android Jetpack LiveData Tutorial
- 35. An Overview of Android Jetpack Data Binding
- 36. An Android Jetpack Data Binding Tutorial
- 36.1 Removing the Redundant Code
- 36.2 Enabling Data Binding
- 36.3 Adding the Layout Element
- 36.4 Adding the Data Element to Layout File
- 36.5 Working with the Binding Class
- 36.6 Assigning the ViewModel Instance to the Data Binding Variable
- 36.7 Adding Binding Expressions
- 36.8 Adding the Conversion Method
- 36.9 Adding a Listener Binding
- 36.10 Testing the App
- 36.11 Summary
- 37. An Android ViewModel Saved State Tutorial
- 38. Working with Android Lifecycle-Aware Components
- 39. An Android Jetpack Lifecycle Awareness Tutorial
- 40. An Overview of the Navigation Architecture Component
- 41. An Android Jetpack Navigation Component Tutorial
- 41.1 Creating the NavigationDemo Project
- 41.2 Adding Navigation to the Build Configuration
- 41.3 Creating the Navigation Graph Resource File
- 41.4 Declaring a Navigation Host
- 41.5 Adding Navigation Destinations
- 41.6 Designing the Destination Fragment Layouts
- 41.7 Adding an Action to the Navigation Graph
- 41.8 Implement the OnFragmentInteractionListener
- 41.9 Triggering the Action
- 41.10 Passing Data Using Safeargs
- 41.11 Summary
- 42. Creating and Managing Overflow Menus on Android
- 42.1 The Overflow Menu
- 42.2 Creating an Overflow Menu
- 42.3 Displaying an Overflow Menu
- 42.4 Responding to Menu Item Selections
- 42.5 Creating Checkable Item Groups
- 42.6 Menus and the Android Studio Menu Editor
- 42.7 Creating the Example Project
- 42.8 Designing the Menu
- 42.9 Modifying the onOptionsItemSelected() Method
- 42.10 Testing the Application
- 42.11 Summary
- 43. Animating User Interfaces with the Android Transitions Framework
- 43.1 Introducing Android Transitions and Scenes
- 43.2 Using Interpolators with Transitions
- 43.3 Working with Scene Transitions
- 43.4 Custom Transitions and TransitionSets in Code
- 43.5 Custom Transitions and TransitionSets in XML
- 43.6 Working with Interpolators
- 43.7 Creating a Custom Interpolator
- 43.8 Using the beginDelayedTransition Method
- 43.9 Summary
- 44. An Android Transition Tutorial using beginDelayedTransition
- 45. Implementing Android Scene Transitions – A Tutorial
- 45.1 An Overview of the Scene Transition Project
- 45.2 Creating the Android Studio SceneTransitions Project
- 45.3 Identifying and Preparing the Root Container
- 45.4 Designing the First Scene
- 45.5 Designing the Second Scene
- 45.6 Entering the First Scene
- 45.7 Loading Scene 2
- 45.8 Implementing the Transitions
- 45.9 Adding the Transition File
- 45.10 Loading and Using the Transition Set
- 45.11 Configuring Additional Transitions
- 45.12 Summary
- 46. Working with the Floating Action Button and Snackbar
- 46.1 The Material Design
- 46.2 The Design Library
- 46.3 The Floating Action Button (FAB)
- 46.4 The Snackbar
- 46.5 Creating the Example Project
- 46.6 Reviewing the Project
- 46.7 Removing Navigation Features
- 46.8 Changing the Floating Action Button
- 46.9 Adding the ListView to the Content Layout
- 46.10 Adding Items to the ListView
- 46.11 Adding an Action to the Snackbar
- 46.12 Summary
- 47. Creating a Tabbed Interface using the TabLayout Component
- 47.1 An Introduction to the ViewPager
- 47.2 An Overview of the TabLayout Component
- 47.3 Creating the TabLayoutDemo Project
- 47.4 Creating the First Fragment
- 47.5 Duplicating the Fragments
- 47.6 Adding the TabLayout and ViewPager
- 47.7 Creating the Pager Adapter
- 47.8 Performing the Initialization Tasks
- 47.9 Testing the Application
- 47.10 Customizing the TabLayout
- 47.11 Displaying Icon Tab Items
- 47.12 Summary
- 48. Working with the RecyclerView and CardView Widgets
- 49. An Android RecyclerView and CardView Tutorial
- 49.1 Creating the CardDemo Project
- 49.2 Modifying the Basic Activity Project
- 49.3 Designing the CardView Layout
- 49.4 Adding the RecyclerView
- 49.5 Creating the RecyclerView Adapter
- 49.6 Adding the Image Files
- 49.7 Initializing the RecyclerView Component
- 49.8 Testing the Application
- 49.9 Responding to Card Selections
- 49.10 Summary
- 50. A Layout Editor Sample Data Tutorial
- 51. Working with the AppBar and Collapsing Toolbar Layouts
- 52. An Android Studio Master/Detail Flow Tutorial
- 52.1 The Master/Detail Flow
- 52.2 Creating a Master/Detail Flow Activity
- 52.3 The Anatomy of the Master/Detail Flow Template
- 52.4 Modifying the Master/Detail Flow Template
- 52.5 Changing the Content Model
- 52.6 Changing the Detail Pane
- 52.7 Modifying the WebsiteDetailFragment Class
- 52.8 Modifying the WebsiteListActivity Class
- 52.9 Adding Manifest Permissions
- 52.10 Running the Application
- 52.11 Summary
- 53. An Overview of Android Intents
- 54. Android Explicit Intents – A Worked Example
- 54.1 Creating the Explicit Intent Example Application
- 54.2 Designing the User Interface Layout for MainActivity
- 54.3 Creating the Second Activity Class
- 54.4 Designing the User Interface Layout for ActivityB
- 54.5 Reviewing the Application Manifest File
- 54.6 Creating the Intent
- 54.7 Extracting Intent Data
- 54.8 Launching ActivityB as a Sub-Activity
- 54.9 Returning Data from a Sub-Activity
- 54.10 Testing the Application
- 54.11 Summary
- 55. Android Implicit Intents – A Worked Example
- 55.1 Creating the Android Studio Implicit Intent Example Project
- 55.2 Designing the User Interface
- 55.3 Creating the Implicit Intent
- 55.4 Adding a Second Matching Activity
- 55.5 Adding the Web View to the UI
- 55.6 Obtaining the Intent URL
- 55.7 Modifying the MyWebView Project Manifest File
- 55.8 Installing the MyWebView Package on a Device
- 55.9 Testing the Application
- 55.10 Summary
- 56. Android Broadcast Intents and Broadcast Receivers
- 56.1 An Overview of Broadcast Intents
- 56.2 An Overview of Broadcast Receivers
- 56.3 Obtaining Results from a Broadcast
- 56.4 Sticky Broadcast Intents
- 56.5 The Broadcast Intent Example
- 56.6 Creating the Example Application
- 56.7 Creating and Sending the Broadcast Intent
- 56.8 Creating the Broadcast Receiver
- 56.9 Registering the Broadcast Receiver
- 56.10 Testing the Broadcast Example
- 56.11 Listening for System Broadcasts
- 56.12 Summary
- 57. A Basic Overview of Threads and AsyncTasks
- 58. An Overview of Android Started and Bound Services
- 59. Implementing an Android Started Service – A Worked Example
- 59.1 Creating the Example Project
- 59.2 Creating the Service Class
- 59.3 Adding the Service to the Manifest File
- 59.4 Starting the Service
- 59.5 Testing the IntentService Example
- 59.6 Using the Service Class
- 59.7 Creating the New Service
- 59.8 Modifying the User Interface
- 59.9 Running the Application
- 59.10 Creating an AsyncTask for Service Tasks
- 59.11 Summary
- 60. Android Local Bound Services – A Worked Example
- 60.1 Understanding Bound Services
- 60.2 Bound Service Interaction Options
- 60.3 An Android Studio Local Bound Service Example
- 60.4 Adding a Bound Service to the Project
- 60.5 Implementing the Binder
- 60.6 Binding the Client to the Service
- 60.7 Completing the Example
- 60.8 Testing the Application
- 60.9 Summary
- 61. Android Remote Bound Services – A Worked Example
- 61.1 Client to Remote Service Communication
- 61.2 Creating the Example Application
- 61.3 Designing the User Interface
- 61.4 Implementing the Remote Bound Service
- 61.5 Configuring a Remote Service in the Manifest File
- 61.6 Launching and Binding to the Remote Service
- 61.7 Sending a Message to the Remote Service
- 61.8 Summary
- 62. An Android Notifications Tutorial
- 62.1 An Overview of Notifications
- 62.2 Creating the NotifyDemo Project
- 62.3 Designing the User Interface
- 62.4 Creating the Second Activity
- 62.5 Creating a Notification Channel
- 62.6 Creating and Issuing a Basic Notification
- 62.7 Launching an Activity from a Notification
- 62.8 Adding Actions to a Notification
- 62.9 Bundled Notifications
- 62.10 Summary
- 63. An Android Direct Reply Notification Tutorial
- 64. Foldable Devices and Multi-Window Support
- 64.1 Foldables and Multi-Window Support
- 64.2 Using a Foldable Emulator
- 64.3 Entering Multi-Window Mode
- 64.4 Enabling and using Freeform Support
- 64.5 Checking for Freeform Support
- 64.6 Enabling Multi-Window Support in an App
- 64.7 Specifying Multi-Window Attributes
- 64.8 Detecting Multi-Window Mode in an Activity
- 64.9 Receiving Multi-Window Notifications
- 64.10 Launching an Activity in Multi-Window Mode
- 64.11 Configuring Freeform Activity Size and Position
- 64.12 Summary
- 65. An Overview of Android SQLite Databases
- 65.1 Understanding Database Tables
- 65.2 Introducing Database Schema
- 65.3 Columns and Data Types
- 65.4 Database Rows
- 65.5 Introducing Primary Keys
- 65.6 What is SQLite?
- 65.7 Structured Query Language (SQL)
- 65.8 Trying SQLite on an Android Virtual Device (AVD)
- 65.9 The Android Room Persistence Library
- 65.10 Summary
- 66. The Android Room Persistence Library
- 67. An Android TableLayout and TableRow Tutorial
- 67.1 The TableLayout and TableRow Layout Views
- 67.2 Creating the Room Database Project
- 67.3 Converting to a LinearLayout
- 67.4 Adding the TableLayout to the User Interface
- 67.5 Configuring the TableRows
- 67.6 Adding the Button Bar to the Layout
- 67.7 Adding the RecyclerView
- 67.8 Adjusting the Layout Margins
- 67.9 Summary
- 68. An Android Room Database and Repository Tutorial
- 68.1 About the RoomDemo Project
- 68.2 Modifying the Build Configuration
- 68.3 Building the Entity
- 68.4 Creating the Data Access Object
- 68.5 Adding the Room Database
- 68.6 Adding the Repository
- 68.7 Modifying the ViewModel
- 68.8 Creating the Product Item Layout
- 68.9 Adding the RecyclerView Adapter
- 68.10 Preparing the Main Fragment
- 68.11 Adding the Button Listeners
- 68.12 Adding LiveData Observers
- 68.13 Initializing the RecyclerView
- 68.14 Testing the RoomDemo App
- 68.15 Summary
- 69. Accessing Cloud Storage using the Android Storage Access Framework
- 70. An Android Storage Access Framework Example
- 70.1 About the Storage Access Framework Example
- 70.2 Creating the Storage Access Framework Example
- 70.3 Designing the User Interface
- 70.4 Declaring Request Codes
- 70.5 Creating a New Storage File
- 70.6 The onActivityResult() Method
- 70.7 Saving to a Storage File
- 70.8 Opening and Reading a Storage File
- 70.9 Testing the Storage Access Application
- 70.10 Summary
- 71. Implementing Video Playback on Android using the VideoView and MediaController Classes
- 71.1 Introducing the Android VideoView Class
- 71.2 Introducing the Android MediaController Class
- 71.3 Creating the Video Playback Example
- 71.4 Designing the VideoPlayer Layout
- 71.5 Downloading the Video File
- 71.6 Configuring the VideoView
- 71.7 Adding the MediaController to the Video View
- 71.8 Setting up the onPreparedListener
- 71.9 Summary
- 72. Android Picture-in-Picture Mode
- 73. An Android Picture-in-Picture Tutorial
- 74. Making Runtime Permission Requests in Android
- 75. Android Audio Recording and Playback using MediaPlayer and MediaRecorder
- 75.1 Playing Audio
- 75.2 Recording Audio and Video using the MediaRecorder Class
- 75.3 About the Example Project
- 75.4 Creating the AudioApp Project
- 75.5 Designing the User Interface
- 75.6 Checking for Microphone Availability
- 75.7 Performing the Activity Initialization
- 75.8 Implementing the recordAudio() Method
- 75.9 Implementing the stopAudio() Method
- 75.10 Implementing the playAudio() method
- 75.11 Configuring and Requesting Permissions
- 75.12 Testing the Application
- 75.13 Summary
- 76. Working with the Google Maps Android API in Android Studio
- 76.1 The Elements of the Google Maps Android API
- 76.2 Creating the Google Maps Project
- 76.3 Obtaining Your Developer Signature
- 76.4 Adding the Apache HTTP Legacy Library Requirement
- 76.5 Testing the Application
- 76.6 Understanding Geocoding and Reverse Geocoding
- 76.7 Adding a Map to an Application
- 76.8 Requesting Current Location Permission
- 76.9 Displaying the User’s Current Location
- 76.10 Changing the Map Type
- 76.11 Displaying Map Controls to the User
- 76.12 Handling Map Gesture Interaction
- 76.13 Creating Map Markers
- 76.14 Controlling the Map Camera
- 76.15 Summary
- 77. Printing with the Android Printing Framework
- 78. An Android HTML and Web Content Printing Example
- 78.1 Creating the HTML Printing Example Application
- 78.2 Printing Dynamic HTML Content
- 78.3 Creating the Web Page Printing Example
- 78.4 Removing the Floating Action Button
- 78.5 Removing Navigation Features
- 78.6 Designing the User Interface Layout
- 78.7 Loading the Web Page into the WebView
- 78.8 Adding the Print Menu Option
- 78.9 Summary
- 79. A Guide to Android Custom Document Printing
- 79.1 An Overview of Android Custom Document Printing
- 79.2 Preparing the Custom Document Printing Project
- 79.3 Creating the Custom Print Adapter
- 79.4 Implementing the onLayout() Callback Method
- 79.5 Implementing the onWrite() Callback Method
- 79.6 Checking a Page is in Range
- 79.7 Drawing the Content on the Page Canvas
- 79.8 Starting the Print Job
- 79.9 Testing the Application
- 79.10 Summary
- 80. An Introduction to Android App Links
- 81. An Android Studio App Links Tutorial
- 82. A Guide to the Android Studio Profiler
- 83. An Android Biometric Authentication Tutorial
- 83.1 An Overview of Biometric Authentication
- 83.2 Creating the Biometric Authentication Project
- 83.3 Configuring Device Fingerprint Authentication
- 83.4 Adding the Biometric Permission to the Manifest File
- 83.5 Designing the User Interface
- 83.6 Adding a Toast Convenience Method
- 83.7 Checking the Security Settings
- 83.8 Configuring the Authentication Callbacks
- 83.9 Adding the CancellationSignal
- 83.10 Starting the Biometric Prompt
- 83.11 Testing the Project
- 83.12 Summary
- 84. Creating, Testing and Uploading an Android App Bundle
- 84.1 The Release Preparation Process
- 84.2 Android App Bundles
- 84.3 Register for a Google Play Developer Console Account
- 84.4 Configuring the App in the Console
- 84.5 Enabling Google Play App Signing
- 84.6 Creating a Keystore File
- 84.7 Creating the Android App Bundle
- 84.8 Generating Test APK Files
- 84.9 Uploading the App Bundle to the Google Play Developer Console
- 84.10 Exploring the App Bundle
- 84.11 Managing Testers
- 84.12 Uploading New App Bundle Revisions
- 84.13 Analyzing the App Bundle File
- 84.14 Enabling Google Play Signing for an Existing App
- 84.15 Summary
- 85. An Overview of Android Dynamic Feature Modules
- 86. An Android Studio Dynamic Feature Tutorial
- 86.1 Creating the DynamicFeature Project
- 86.2 Adding Dynamic Feature Support to the Project
- 86.3 Designing the Base Activity User Interface
- 86.4 Adding the Dynamic Feature Module
- 86.5 Reviewing the Dynamic Feature Module
- 86.6 Adding the Dynamic Feature Activity
- 86.7 Implementing the launchIntent() Method
- 86.8 Uploading the App Bundle for Testing
- 86.9 Implementing the installFeature() Method
- 86.10 Adding the Update Listener
- 86.11 Handling Large Downloads
- 86.12 Using Deferred Installation
- 86.13 Removing a Dynamic Module
- 86.14 Summary
- 87. An Overview of Gradle in Android Studio
- Index
Android Studio 3.6
Development Essentials
Java Edition
Android Studio 3.6 Development Essentials – Java Edition
ISBN-13: 978-1-951442-14-9
© 2020 Neil Smyth / Payload Media, Inc. All Rights Reserved.
This book is provided for personal use only. Unauthorized use, reproduction and/or distribution strictly prohibited. All rights reserved.
The content of this book is provided for informational purposes only. Neither the publisher nor the author offers any warranties or representation, express or implied, with regard to the accuracy of information contained in this book, nor do they accept any liability for any loss or damage arising from any errors or omissions.
This book contains trademarked terms that are used solely for editorial purposes and to the benefit of the respective trademark owner. The terms used within this book are not intended as infringement of any trademarks.
Rev: 1.0
-
No Comment
..................Content has been hidden....................
You can't read the all page of ebook, please click here login for view all page.