Android Studio 4.0 Development Essentials - Java Edition

Spis treści książki

• 1. Introduction
  • 1.1 Downloading the Code Samples
  • 1.2 Feedback
  • 1.3 Errata
• 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.3.1 Installation on Windows
    • 2.3.2 Installation on macOS
    • 2.3.3 Installation on Linux
  • 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.6.1 Windows 7
    • 2.6.2 Windows 8.1
    • 2.6.3 Windows 10
    • 2.6.4 Linux
    • 2.6.5 macOS
  • 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
  • 3.1 About the Project
  • 3.2 Creating a New Android Project
  • 3.3 Creating an Activity
  • 3.4 Defining the Project and SDK Settings
  • 3.5 Modifying the Example Application
  • 3.6 Modifying the User Interface
  • 3.7 Reviewing the Layout and Resource Files
  • 3.8 Adding Interaction
  • 3.9 Summary
• 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
  • 5.1 The Emulator Environment
  • 5.2 The Emulator Toolbar Options
  • 5.3 Working in Zoom Mode
  • 5.4 Resizing the Emulator Window
  • 5.5 Extended Control Options
    • 5.5.1 Location
    • 5.5.2 Displays
    • 5.5.3 Cellular
    • 5.5.4 Camera
    • 5.5.5 Battery
    • 5.5.6 Phone
    • 5.5.7 Directional Pad
    • 5.5.8 Microphone
    • 5.5.9 Fingerprint
    • 5.5.10 Virtual Sensors
    • 5.5.11 Snapshots
    • 5.5.12 Record and Playback
    • 5.5.13 Google Play
    • 5.5.14 Settings
    • 5.5.15 Help
  • 5.6 Working with Snapshots
  • 5.7 Configuring Fingerprint Emulation
  • 5.8 Summary
• 6. A Tour of the Android Studio User Interface
  • 6.1 The Welcome Screen
  • 6.2 The Main Window
  • 6.3 The Tool Windows
  • 6.4 Android Studio Keyboard Shortcuts
  • 6.5 Switcher and Recent Files Navigation
  • 6.6 Changing the Android Studio Theme
  • 6.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 Devices
    • 7.2.1 macOS ADB Configuration
    • 7.2.2 Windows ADB Configuration
    • 7.2.3 Linux adb Configuration
  • 7.3 Testing the adb Connection
  • 7.4 Summary
• 8. The Basics of the Android Studio Code Editor
  • 8.1 The Android Studio Editor
  • 8.2 Splitting the Editor Window
  • 8.3 Code Completion
  • 8.4 Statement Completion
  • 8.5 Parameter Information
  • 8.6 Parameter Name Hints
  • 8.7 Code Generation
  • 8.8 Code Folding
  • 8.9 Quick Documentation Lookup
  • 8.10 Code Reformatting
  • 8.11 Finding Sample Code
  • 8.12 Live Templates
  • 8.13 Summary
• 9. An Overview of the Android Architecture
  • 9.1 The Android Software Stack
  • 9.2 The Linux Kernel
  • 9.3 Android Runtime ART
  • 9.4 Android Libraries
    • 9.4.1 C/C++ Libraries
  • 9.5 Application Framework
  • 9.6 Applications
  • 9.7 Summary
• 10. The Anatomy of an Android Application
  • 10.1 Android Activities
  • 10.2 Android Fragments
  • 10.3 Android Intents
  • 10.4 Broadcast Intents
  • 10.5 Broadcast Receivers
  • 10.6 Android Services
  • 10.7 Content Providers
  • 10.8 The Application Manifest
  • 10.9 Application Resources
  • 10.10 Application Context
  • 10.11 Summary
• 11. An Overview of Android View Binding
  • 11.1 Find View by ID
  • 11.2 View Bindings
  • 11.3 Converting the AndroidSample Project
  • 11.4 Enabling View Binding
  • 11.5 Using View Bindings
  • 11.6 Choosing an Option
  • 11.7 Summary
• 12. Understanding Android Application and Activity Lifecycles
  • 12.1 Android Applications and Resource Management
  • 12.2 Android Process States
    • 12.2.1 Foreground Process
    • 12.2.2 Visible Process
    • 12.2.3 Service Process
    • 12.2.4 Background Process
    • 12.2.5 Empty Process
  • 12.3 Inter-Process Dependencies
  • 12.4 The Activity Lifecycle
  • 12.5 The Activity Stack
  • 12.6 Activity States
  • 12.7 Configuration Changes
  • 12.8 Handling State Change
  • 12.9 Summary
• 13. Handling Android Activity State Changes
  • 13.1 New vs. Old Lifecycle Techniques
  • 13.2 The Activity and Fragment Classes
  • 13.3 Dynamic State vs. Persistent State
  • 13.4 The Android Lifecycle Methods
  • 13.5 Lifetimes
  • 13.6 Foldable Devices and Multi-Resume
  • 13.7 Disabling Configuration Change Restarts
  • 13.8 Lifecycle Method Limitations
  • 13.9 Summary
• 14. Android Activity State Changes by Example
  • 14.1 Creating the State Change Example Project
  • 14.2 Designing the User Interface
  • 14.3 Overriding the Activity Lifecycle Methods
  • 14.4 Filtering the Logcat Panel
  • 14.5 Running the Application
  • 14.6 Experimenting with the Activity
  • 14.7 Summary
• 15. Saving and Restoring the State of an Android Activity
  • 15.1 Saving Dynamic State
  • 15.2 Default Saving of User Interface State
  • 15.3 The Bundle Class
  • 15.4 Saving the State
  • 15.5 Restoring the State
  • 15.6 Testing the Application
  • 15.7 Summary
• 16. Understanding Android Views, View Groups and Layouts
  • 16.1 Designing for Different Android Devices
  • 16.2 Views and View Groups
  • 16.3 Android Layout Managers
  • 16.4 The View Hierarchy
  • 16.5 Creating User Interfaces
  • 16.6 Summary
• 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 Layout Validation (Multi Preview)
  • 17.14 Summary
• 18. A Guide to the Android ConstraintLayout
  • 18.1 How ConstraintLayout Works
    • 18.1.1 Constraints
    • 18.1.2 Margins
    • 18.1.3 Opposing Constraints
    • 18.1.4 Constraint Bias
    • 18.1.5 Chains
    • 18.1.6 Chain Styles
  • 18.2 Baseline Alignment
  • 18.3 Working with Guidelines
  • 18.4 Configuring Widget Dimensions
  • 18.5 Working with Barriers
  • 18.6 Ratios
  • 18.7 ConstraintLayout Advantages
  • 18.8 ConstraintLayout Availability
  • 18.9 Summary
• 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
  • 20.1 Creating a Chain
  • 20.2 Changing the Chain Style
  • 20.3 Spread Inside Chain Style
  • 20.4 Packed Chain Style
  • 20.5 Packed Chain Style with Bias
  • 20.6 Weighted Chain
  • 20.7 Working with Ratios
  • 20.8 Summary
• 21. An Android Studio Layout Editor ConstraintLayout Tutorial
  • 21.1 An Android Studio Layout Editor Tool Example
  • 21.2 Creating a New Activity
  • 21.3 Preparing the Layout Editor Environment
  • 21.4 Adding the Widgets to the User Interface
  • 21.5 Adding the Constraints
  • 21.6 Testing the Layout
  • 21.7 Using the Layout Inspector
  • 21.8 Summary
• 22. Manual XML Layout Design in Android Studio
  • 22.1 Manually Creating an XML Layout
  • 22.2 Manual XML vs. Visual Layout Design
  • 22.3 Summary
• 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
  • 24.1 Creating the Example Project in Android Studio
  • 24.2 Adding Views to an Activity
  • 24.3 Setting View Attributes
  • 24.4 Creating View IDs
  • 24.5 Configuring the Constraint Set
  • 24.6 Adding the EditText View
  • 24.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 Changes
  • 25.2 Understanding Apply Changes Options
  • 25.3 Using Apply Changes
  • 25.4 Configuring Apply Changes Fallback Settings
  • 25.5 An Apply Changes Tutorial
  • 25.6 Using Apply Code Changes
  • 25.7 Using Apply Changes and Restart Activity
  • 25.8 Using Run App
  • 25.9 Summary
• 26. An Overview and Example of Android Event Handling
  • 26.1 Understanding Android Events
  • 26.2 Using the android:onClick Resource
  • 26.3 Event Listeners and Callback Methods
  • 26.4 An Event Handling Example
  • 26.5 Designing the User Interface
  • 26.6 The Event Listener and Callback Method
  • 26.7 Consuming Events
  • 26.8 Summary
• 27. Android Touch and Multi-touch Event Handling
  • 27.1 Intercepting Touch Events
  • 27.2 The MotionEvent Object
  • 27.3 Understanding Touch Actions
  • 27.4 Handling Multiple Touches
  • 27.5 An Example Multi-Touch Application
  • 27.6 Designing the Activity User Interface
  • 27.7 Implementing the Touch Event Listener
  • 27.8 Running the Example Application
  • 27.9 Summary
• 28. Detecting Common Gestures using the Android Gesture Detector Class
  • 28.1 Implementing Common Gesture Detection
  • 28.2 Creating an Example Gesture Detection Project
  • 28.3 Implementing the Listener Class
  • 28.4 Creating the GestureDetectorCompat Instance
  • 28.5 Implementing the onTouchEvent() Method
  • 28.6 Testing the Application
  • 28.7 Summary
• 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
  • 30.1 What is a Fragment?
  • 30.2 Creating a Fragment
  • 30.3 Adding a Fragment to an Activity using the Layout XML File
  • 30.4 Adding and Managing Fragments in Code
  • 30.5 Handling Fragment Events
  • 30.6 Implementing Fragment Communication
  • 30.7 Summary
• 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 Adding the Second Fragment
  • 31.5 Adding the Fragments to the Activity
  • 31.6 Making the Toolbar Fragment Talk to the Activity
  • 31.7 Making the Activity Talk to the Text Fragment
  • 31.8 Testing the Application
  • 31.9 Summary
• 32. Modern Android App Architecture with Jetpack
  • 32.1 What is Android Jetpack?
  • 32.2 The Old Architecture
  • 32.3 Modern Android Architecture
  • 32.4 The ViewModel Component
  • 32.5 The LiveData Component
  • 32.6 ViewModel Saved State
  • 32.7 LiveData and Data Binding
  • 32.8 Android Lifecycles
  • 32.9 Repository Modules
  • 32.10 Summary
• 33. An Android Jetpack ViewModel Tutorial
  • 33.1 About the Project
  • 33.2 Creating the ViewModel Example Project
  • 33.3 Reviewing the Project
    • 33.3.1 The Main Activity
    • 33.3.2 The Content Fragment
    • 33.3.3 The ViewModel
  • 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
  • 34.1 LiveData - A Recap
  • 34.2 Adding LiveData to the ViewModel
  • 34.3 Implementing the Observer
  • 34.4 Summary
• 35. An Overview of Android Jetpack Data Binding
  • 35.1 An Overview of Data Binding
  • 35.2 The Key Components of Data Binding
    • 35.2.1 The Project Build Configuration
    • 35.2.2 The Data Binding Layout File
    • 35.2.3 The Layout File Data Element
    • 35.2.4 The Binding Classes
    • 35.2.5 Data Binding Variable Configuration
    • 35.2.6 Binding Expressions (One-Way)
    • 35.2.7 Binding Expressions (Two-Way)
    • 35.2.8 Event and Listener Bindings
  • 35.3 Summary
• 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
  • 37.1 Understanding ViewModel State Saving
  • 37.2 Implementing ViewModel State Saving
  • 37.3 Saving and Restoring State
  • 37.4 Adding Saved State Support to the ViewModelDemo Project
  • 37.5 Summary
• 38. Working with Android Lifecycle-Aware Components
  • 38.1 Lifecycle Awareness
  • 38.2 Lifecycle Owners
  • 38.3 Lifecycle Observers
  • 38.4 Lifecycle States and Events
  • 38.5 Summary
• 39. An Android Jetpack Lifecycle Awareness Tutorial
  • 39.1 Creating the Example Lifecycle Project
  • 39.2 Creating a Lifecycle Observer
  • 39.3 Adding the Observer
  • 39.4 Testing the Observer
  • 39.5 Creating a Lifecycle Owner
  • 39.6 Testing the Custom Lifecycle Owner
  • 39.7 Summary
• 40. An Overview of the Navigation Architecture Component
  • 40.1 Understanding Navigation
  • 40.2 Declaring a Navigation Host
  • 40.3 The Navigation Graph
  • 40.4 Accessing the Navigation Controller
  • 40.5 Triggering a Navigation Action
  • 40.6 Passing Arguments
  • 40.7 Summary
• 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. An Introduction to MotionLayout
  • 43.1 An Overview of MotionLayout
  • 43.2 MotionLayout
  • 43.3 MotionScene
  • 43.4 Configuring ConstraintSets
  • 43.5 Custom Attributes
  • 43.6 Triggering an Animation
  • 43.7 Arc Motion
  • 43.8 Keyframes
    • 43.8.1 Attribute Keyframes
    • 43.8.2 Position Keyframes
  • 43.9 Time Linearity
  • 43.10 KeyTrigger
  • 43.11 Cycle and Time Cycle Keyframes
  • 43.12 Starting an Animation from Code
  • 43.13 Summary
• 44. An Android MotionLayout Editor Tutorial
  • 44.1 Creating the MotionLayoutDemo Project
  • 44.2 ConstraintLayout to MotionLayout Conversion
  • 44.3 Configuring Start and End Constraints
  • 44.4 Previewing the MotionLayout Animation
  • 44.5 Adding an OnClick Gesture
  • 44.6 Adding an Attribute Keyframe to the Transition
  • 44.7 Adding a CustomAttribute to a Transition
  • 44.8 Adding Position Keyframes
  • 44.9 Summary
• 45. A MotionLayout KeyCycle Tutorial
  • 45.1 An Overview of Cycle Keyframes
  • 45.2 Using the Cycle Editor
  • 45.3 Creating the KeyCycleDemo Project
  • 45.4 Configuring the Start and End Constraints
  • 45.5 Creating the Cycles
  • 45.6 Previewing the Animation
  • 45.7 Adding the KeyFrameSet to the MotionScene
  • 45.8 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
  • 48.1 An Overview of the RecyclerView
  • 48.2 An Overview of the CardView
  • 48.3 Summary
• 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
  • 50.1 Adding Sample Data to a Project
  • 50.2 Using Custom Sample Data
  • 50.3 Summary
• 51. Working with the AppBar and Collapsing Toolbar Layouts
  • 51.1 The Anatomy of an AppBar
  • 51.2 The Example Project
  • 51.3 Coordinating the RecyclerView and Toolbar
  • 51.4 Introducing the Collapsing Toolbar Layout
  • 51.5 Changing the Title and Scrim Color
  • 51.6 Summary
• 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
  • 53.1 An Overview of Intents
  • 53.2 Explicit Intents
  • 53.3 Returning Data from an Activity
  • 53.4 Implicit Intents
  • 53.5 Using Intent Filters
  • 53.6 Checking Intent Availability
  • 53.7 Summary
• 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
  • 57.1 An Overview of Threads
  • 57.2 The Application Main Thread
  • 57.3 Thread Handlers
  • 57.4 A Basic AsyncTask Example
  • 57.5 Subclassing AsyncTask
  • 57.6 Testing the App
  • 57.7 Canceling a Task
  • 57.8 Summary
• 58. An Overview of Android Started and Bound Services
  • 58.1 Started Services
  • 58.2 Intent Service
  • 58.3 Bound Service
  • 58.4 The Anatomy of a Service
  • 58.5 Controlling Destroyed Service Restart Options
  • 58.6 Declaring a Service in the Manifest File
  • 58.7 Starting a Service Running on System Startup
  • 58.8 Summary
• 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
  • 63.1 Creating the DirectReply Project
  • 63.2 Designing the User Interface
  • 63.3 Creating the Notification Channel
  • 63.4 Building the RemoteInput Object
  • 63.5 Creating the PendingIntent
  • 63.6 Creating the Reply Action
  • 63.7 Receiving Direct Reply Input
  • 63.8 Updating the Notification
  • 63.9 Summary
• 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
  • 66.1 Revisiting Modern App Architecture
  • 66.2 Key Elements of Room Database Persistence
    • 66.2.1 Repository
    • 66.2.2 Room Database
    • 66.2.3 Data Access Object (DAO)
    • 66.2.4 Entities
    • 66.2.5 SQLite Database
  • 66.3 Understanding Entities
  • 66.4 Data Access Objects
  • 66.5 The Room Database
  • 66.6 The Repository
  • 66.7 In-Memory Databases
  • 66.8 Summary
• 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
  • 69.1 The Storage Access Framework
  • 69.2 Working with the Storage Access Framework
  • 69.3 Filtering Picker File Listings
  • 69.4 Handling Intent Results
  • 69.5 Reading the Content of a File
  • 69.6 Writing Content to a File
  • 69.7 Deleting a File
  • 69.8 Gaining Persistent Access to a File
  • 69.9 Summary
• 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. 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
  • 72.1 Picture-in-Picture Features
  • 72.2 Enabling Picture-in-Picture Mode
  • 72.3 Configuring Picture-in-Picture Parameters
  • 72.4 Entering Picture-in-Picture Mode
  • 72.5 Detecting Picture-in-Picture Mode Changes
  • 72.6 Adding Picture-in-Picture Actions
  • 72.7 Summary
• 73. An Android Picture-in-Picture Tutorial
  • 73.1 Adding Picture-in-Picture Support to the Manifest
  • 73.2 Adding a Picture-in-Picture Button
  • 73.3 Entering Picture-in-Picture Mode
  • 73.4 Detecting Picture-in-Picture Mode Changes
  • 73.5 Adding a Broadcast Receiver
  • 73.6 Adding the PiP Action
  • 73.7 Testing the Picture-in-Picture Action
  • 73.8 Summary
• 74. Making Runtime Permission Requests in Android
  • 74.1 Understanding Normal and Dangerous Permissions
  • 74.2 Creating the Permissions Example Project
  • 74.3 Checking for a Permission
  • 74.4 Requesting Permission at Runtime
  • 74.5 Providing a Rationale for the Permission Request
  • 74.6 Testing the Permissions App
  • 74.7 Summary
• 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 Users Current Location
  • 76.10 Changing the Map Type
  • 76.11 Displaying Map Controls to the User
  • 76.12 Handling Map Gesture Interaction
    • 76.12.1 Map Zooming Gestures
    • 76.12.2 Map Scrolling/Panning Gestures
    • 76.12.3 Map Tilt Gestures
    • 76.12.4 Map Rotation Gestures
  • 76.13 Creating Map Markers
  • 76.14 Controlling the Map Camera
  • 76.15 Summary
• 77. Printing with the Android Printing Framework
  • 77.1 The Android Printing Architecture
  • 77.2 The Print Service Plugins
  • 77.3 Google Cloud Print
  • 77.4 Printing to Google Drive
  • 77.5 Save as PDF
  • 77.6 Printing from Android Devices
  • 77.7 Options for Building Print Support into Android Apps
    • 77.7.1 Image Printing
    • 77.7.2 Creating and Printing HTML Content
    • 77.7.3 Printing a Web Page
    • 77.7.4 Printing a Custom Document
  • 77.8 Summary
• 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.1.1 Custom Print Adapters
  • 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
  • 80.1 An Overview of Android App Links
  • 80.2 App Link Intent Filters
  • 80.3 Handling App Link Intents
  • 80.4 Associating the App with a Website
  • 80.5 Summary
• 81. An Android Studio App Links Tutorial
  • 81.1 About the Example App
  • 81.2 The Database Schema
  • 81.3 Loading and Running the Project
  • 81.4 Adding the URL Mapping
  • 81.5 Adding the Intent Filter
  • 81.6 Adding Intent Handling Code
  • 81.7 Testing the App Link
  • 81.8 Associating an App Link with a Web Site
  • 81.9 Summary
• 82. A Guide to the Android Studio Profiler
  • 82.1 Accessing the Android Profiler
  • 82.2 Enabling Advanced Profiling
  • 82.3 The Android Profiler Tool Window
  • 82.4 The Sessions Panel
  • 82.5 The CPU Profiler
  • 82.6 Memory Profiler
  • 82.7 Network Profiler
  • 82.8 Energy Profiler
  • 82.9 Summary
• 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
  • 85.1 An Overview of Dynamic Feature Modules
  • 85.2 Dynamic Feature Module Architecture
  • 85.3 Creating a Dynamic Feature Module
  • 85.4 Converting an Existing Module for Dynamic Delivery
  • 85.5 Working with Dynamic Feature Modules
  • 85.6 Handling Large Dynamic Feature Modules
  • 85.7 Summary
• 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
  • 87.1 An Overview of Gradle
  • 87.2 Gradle and Android Studio
    • 87.2.1 Sensible Defaults
    • 87.2.2 Dependencies
    • 87.2.3 Build Variants
    • 87.2.4 Manifest Entries
    • 87.2.5 APK Signing
    • 87.2.6 ProGuard Support
  • 87.3 The Top-level Gradle Build File
  • 87.4 Module Level Gradle Build Files
  • 87.5 Configuring Signing Settings in the Build File
  • 87.6 Running Gradle Tasks from the Command-line
  • 87.7 Summary
• Index

pokaż cały spis treści

ukryj recenzje