Android Studio Jellyfish Essentials - Kotlin Edition

Name: Android Studio Jellyfish Essentials - Kotlin Edition | Developing Android Apps Using Android Studio 2023.3.1 and Kotlin
Brand: Payload Media, Inc.
Price: 37.99 EUR
Availability: OnlineOnly

Developing Android Apps Using Android Studio 2023.3.1 and Kotlin

Neil Smyth(Autor*in)

Payload Media, Inc. (Verlag)

1. Auflage

Erschienen am 14. Mai 2024

866 Seiten

E-Book

ePUB mit Adobe-DRM

Systemvoraussetzungen

978-1-951442-92-7 (ISBN)

37,99 €inkl. 7% MwSt.

Systemvoraussetzungen

für ePUB mit Adobe-DRM

E-Book Einzellizenz

Als Download verfügbar

Beschreibung

Weitere Details

Weitere Ausgaben

Inhalt

Intro
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 Installing additional Android SDK packages
2.5 Installing the Android SDK Command-line Tools
2.5.1 Windows 8.1
2.5.2 Windows 10
2.5.3 Windows 11
2.5.4 Linux
2.5.5 macOS
2.6 Android Studio memory management
2.7 Updating Android Studio and the SDK
2.8 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 Starting the Emulator
4.3 Running the Application in the AVD
4.4 Running on Multiple Devices
4.5 Stopping a Running Application
4.6 Supporting Dark Theme
4.7 Running the Emulator in a Separate Window
4.8 Removing the Device Frame
4.9 Summary
5. Using and Configuring the Android Studio AVD Emulator
5.1 The Emulator Environment
5.2 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 Battery
5.5.5 Camera
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 The Emulator in Tool Window Mode
5.9 Creating a Resizable Emulator
5.10 Summary
6. A Tour of the Android Studio User Interface
6.1 The Welcome Screen
6.2 The Menu Bar
6.3 The Main Window
6.4 The Tool Windows
6.5 The Tool Window Menus
6.6 Android Studio Keyboard Shortcuts
6.7 Switcher and Recent Files Navigation
6.8 Changing the Android Studio Theme
6.9 Summary
7. Testing Android Studio Apps on a Physical Android Device
7.1 An Overview of the Android Debug Bridge (ADB)
7.2 Enabling USB Debugging ADB on Android Devices
7.2.1 macOS ADB Configuration
7.2.2 Windows ADB Configuration
7.2.3 Linux adb Configuration
7.3 Resolving USB Connection Issues
7.4 Enabling Wireless Debugging on Android Devices
7.5 Testing the adb Connection
7.6 Device Mirroring
7.7 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 Hardware Abstraction Layer
9.4 Android Runtime - ART
9.5 Android Libraries
9.5.1 C/C++ Libraries
9.6 Application Framework
9.7 Applications
9.8 Summary
10. The Anatomy of an Android App
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 Introduction to Kotlin
11.1 What is Kotlin?
11.2 Kotlin and Java
11.3 Converting from Java to Kotlin
11.4 Kotlin and Android Studio
11.5 Experimenting with Kotlin
11.6 Semi-colons in Kotlin
11.7 Summary
12. Kotlin Data Types, Variables, and Nullability
12.1 Kotlin Data Types
12.1.1 Integer Data Types
12.1.2 Floating-Point Data Types
12.1.3 Boolean Data Type
12.1.4 Character Data Type
12.1.5 String Data Type
12.1.6 Escape Sequences
12.2 Mutable Variables
12.3 Immutable Variables
12.4 Declaring Mutable and Immutable Variables
12.5 Data Types are Objects
12.6 Type Annotations and Type Inference
12.7 Nullable Type
12.8 The Safe Call Operator
12.9 Not-Null Assertion
12.10 Nullable Types and the let Function
12.11 Late Initialization (lateinit)
12.12 The Elvis Operator
12.13 Type Casting and Type Checking
12.14 Summary
13. Kotlin Operators and Expressions
13.1 Expression Syntax in Kotlin
13.2 The Basic Assignment Operator
13.3 Kotlin Arithmetic Operators
13.4 Augmented Assignment Operators
13.5 Increment and Decrement Operators
13.6 Equality Operators
13.7 Boolean Logical Operators
13.8 Range Operator
13.9 Bitwise Operators
13.9.1 Bitwise Inversion
13.9.2 Bitwise AND
13.9.3 Bitwise OR
13.9.4 Bitwise XOR
13.9.5 Bitwise Left Shift
13.9.6 Bitwise Right Shift
13.10 Summary
14. Kotlin Control Flow
14.1 Looping Control flow
14.1.1 The Kotlin for-in Statement
14.1.2 The while Loop
14.1.3 The do ... while loop
14.1.4 Breaking from Loops
14.1.5 The continue Statement
14.1.6 Break and Continue Labels
14.2 Conditional Control Flow
14.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 Statement
14.3 Summary
15. An Overview of Kotlin Functions and Lambdas
15.1 What is a Function?
15.2 How to Declare a Kotlin Function
15.3 Calling a Kotlin Function
15.4 Single Expression Functions
15.5 Local Functions
15.6 Handling Return Values
15.7 Declaring Default Function Parameters
15.8 Variable Number of Function Parameters
15.9 Lambda Expressions
15.10 Higher-order Functions
15.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 Class
16.4 Adding Properties to a Class
16.5 Defining Methods
16.6 Declaring and Initializing a Class Instance
16.7 Primary and Secondary Constructors
16.8 Initializer Blocks
16.9 Calling Methods and Accessing Properties
16.10 Custom Accessors
16.11 Nested and Inner Classes
16.12 Companion Objects
16.13 Summary
17. An Introduction to Kotlin Inheritance and Subclassing
17.1 Inheritance, Classes and Subclasses
17.2 Subclassing Syntax
17.3 A Kotlin Inheritance Example
17.4 Extending the Functionality of a Subclass
17.5 Overriding Inherited Methods
17.6 Adding a Custom Secondary Constructor
17.7 Using the SavingsAccount Class
17.8 Summary
18. An Overview of Android View Binding
18.1 Find View by Id
18.2 View Binding
18.3 Converting the AndroidSample project
18.4 Enabling View Binding
18.5 Using View Binding
18.6 Choosing an Option
18.7 View Binding in the Book Examples
18.8 Migrating a Project to View Binding
18.9 Summary
19. Understanding Android Application and Activity Lifecycles
19.1 Android Applications and Resource Management
19.2 Android Process States
19.2.1 Foreground Process
19.2.2 Visible Process
19.2.3 Service Process
19.2.4 Background Process
19.2.5 Empty Process
19.3 Inter-Process Dependencies
19.4 The Activity Lifecycle
19.5 The Activity Stack
19.6 Activity States
19.7 Configuration Changes
19.8 Handling State Change
19.9 Summary
20. Handling Android Activity State Changes
20.1 New vs. Old Lifecycle Techniques
20.2 The Activity and Fragment Classes
20.3 Dynamic State vs. Persistent State
20.4 The Android Lifecycle Methods
20.5 Lifetimes
20.6 Foldable Devices and Multi-Resume
20.7 Disabling Configuration Change Restarts
20.8 Lifecycle Method Limitations
20.9 Summary
21. Android Activity State Changes by Example
21.1 Creating the State Change Example Project
21.2 Designing the User Interface
21.3 Overriding the Activity Lifecycle Methods
21.4 Filtering the Logcat Panel
21.5 Running the Application
21.6 Experimenting with the Activity
21.7 Summary
22. Saving and Restoring the State of an Android Activity
22.1 Saving Dynamic State
22.2 Default Saving of User Interface State
22.3 The Bundle Class
22.4 Saving the State
22.5 Restoring the State
22.6 Testing the Application
22.7 Summary
23. Understanding Android Views, View Groups and Layouts
23.1 Designing for Different Android Devices
23.2 Views and View Groups
23.3 Android Layout Managers
23.4 The View Hierarchy
23.5 Creating User Interfaces
23.6 Summary
24. A Guide to the Android Studio Layout Editor Tool
24.1 Basic vs. Empty Views Activity Templates
24.2 The Android Studio Layout Editor
24.3 Design Mode
24.4 The Palette
24.5 Design Mode and Layout Views
24.6 Night Mode
24.7 Code Mode
24.8 Split Mode
24.9 Setting Attributes
24.10 Transforms
24.11 Tools Visibility Toggles
24.12 Converting Views
24.13 Displaying Sample Data
24.14 Creating a Custom Device Definition
24.15 Changing the Current Device
24.16 Layout Validation
24.17 Summary
25. A Guide to the Android ConstraintLayout
25.1 How ConstraintLayout Works
25.1.1 Constraints
25.1.2 Margins
25.1.3 Opposing Constraints
25.1.4 Constraint Bias
25.1.5 Chains
25.1.6 Chain Styles
25.2 Baseline Alignment
25.3 Configuring Widget Dimensions
25.4 Guideline Helper
25.5 Group Helper
25.6 Barrier Helper
25.7 Flow Helper
25.8 Ratios
25.9 ConstraintLayout Advantages
25.10 ConstraintLayout Availability
25.11 Summary
26. A Guide to Using ConstraintLayout in Android Studio
26.1 Design and Layout Views
26.2 Autoconnect Mode
26.3 Inference Mode
26.4 Manipulating Constraints Manually
26.5 Adding Constraints in the Inspector
26.6 Viewing Constraints in the Attributes Window
26.7 Deleting Constraints
26.8 Adjusting Constraint Bias
26.9 Understanding ConstraintLayout Margins
26.10 The Importance of Opposing Constraints and Bias
26.11 Configuring Widget Dimensions
26.12 Design Time Tools Positioning
26.13 Adding Guidelines
26.14 Adding Barriers
26.15 Adding a Group
26.16 Working with the Flow Helper
26.17 Widget Group Alignment and Distribution
26.18 Converting other Layouts to ConstraintLayout
26.19 Summary
27. Working with ConstraintLayout Chains and Ratios in Android Studio
27.1 Creating a Chain
27.2 Changing the Chain Style
27.3 Spread Inside Chain Style
27.4 Packed Chain Style
27.5 Packed Chain Style with Bias
27.6 Weighted Chain
27.7 Working with Ratios
27.8 Summary
28. An Android Studio Layout Editor ConstraintLayout Tutorial
28.1 An Android Studio Layout Editor Tool Example
28.2 Preparing the Layout Editor Environment
28.3 Adding the Widgets to the User Interface
28.4 Adding the Constraints
28.5 Testing the Layout
28.6 Using the Layout Inspector
28.7 Summary
29. Manual XML Layout Design in Android Studio
29.1 Manually Creating an XML Layout
29.2 Manual XML vs. Visual Layout Design
29.3 Summary
30. Managing Constraints using Constraint Sets
30.1 Kotlin Code vs. XML Layout Files
30.2 Creating Views
30.3 View Attributes
30.4 Constraint Sets
30.4.1 Establishing Connections
30.4.2 Applying Constraints to a Layout
30.4.3 Parent Constraint Connections
30.4.4 Sizing Constraints
30.4.5 Constraint Bias
30.4.6 Alignment Constraints
30.4.7 Copying and Applying Constraint Sets
30.4.8 ConstraintLayout Chains
30.4.9 Guidelines
30.4.10 Removing Constraints
30.4.11 Scaling
30.4.12 Rotation
30.5 Summary
31. An Android ConstraintSet Tutorial
31.1 Creating the Example Project in Android Studio
31.2 Adding Views to an Activity
31.3 Setting View Attributes
31.4 Creating View IDs
31.5 Configuring the Constraint Set
31.6 Adding the EditText View
31.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 Changes
32.2 Understanding Apply Changes Options
32.3 Using Apply Changes
32.4 Configuring Apply Changes Fallback Settings
32.5 An Apply Changes Tutorial
32.6 Using Apply Code Changes
32.7 Using Apply Changes and Restart Activity
32.8 Using Run App
32.9 Summary
33. A Guide to Gradle Version Catalogs
33.1 Library and Plugin Dependencies
33.2 Project Gradle Build File
33.3 Module Gradle Build Files
33.4 Version Catalog File
33.5 Adding Dependencies
33.6 Library Updates
33.7 Summary
34. An Overview and Example of Android Event Handling
34.1 Understanding Android Events
34.2 Using the android:onClick Resource
34.3 Event Listeners and Callback Methods
34.4 An Event Handling Example
34.5 Designing the User Interface
34.6 The Event Listener and Callback Method
34.7 Consuming Events
34.8 Summary
35. Android Touch and Multi-touch Event Handling
35.1 Intercepting Touch Events
35.2 The MotionEvent Object
35.3 Understanding Touch Actions
35.4 Handling Multiple Touches
35.5 An Example Multi-Touch Application
35.6 Designing the Activity User Interface
35.7 Implementing the Touch Event Listener
35.8 Running the Example Application
35.9 Summary
36. Detecting Common Gestures Using the Android Gesture Detector Class
36.1 Implementing Common Gesture Detection
36.2 Creating an Example Gesture Detection Project
36.3 Implementing the Listener Class
36.4 Creating the GestureDetector Instance
36.5 Implementing the onTouchEvent() Method
36.6 Testing the Application
36.7 Summary
37. Implementing Custom Gesture and Pinch Recognition on Android
37.1 The Android Gesture Builder Application
37.2 The GestureOverlayView Class
37.3 Detecting Gestures
37.4 Identifying Specific Gestures
37.5 Installing and Running the Gesture Builder Application
37.6 Creating a Gestures File
37.7 Creating the Example Project
37.8 Extracting the Gestures File from the SD Card
37.9 Adding the Gestures File to the Project
37.10 Designing the User Interface
37.11 Loading the Gestures File
37.12 Registering the Event Listener
37.13 Implementing the onGesturePerformed Method
37.14 Testing the Application
37.15 Configuring the GestureOverlayView
37.16 Intercepting Gestures
37.17 Detecting Pinch Gestures
37.18 A Pinch Gesture Example Project
37.19 Summary
38. An Introduction to Android Fragments
38.1 What is a Fragment?
38.2 Creating a Fragment
38.3 Adding a Fragment to an Activity using the Layout XML File
38.4 Adding and Managing Fragments in Code
38.5 Handling Fragment Events
38.6 Implementing Fragment Communication
38.7 Summary
39. Using Fragments in Android Studio - An Example
39.1 About the Example Fragment Application
39.2 Creating the Example Project
39.3 Creating the First Fragment Layout
39.4 Migrating a Fragment to View Binding
39.5 Adding the Second Fragment
39.6 Adding the Fragments to the Activity
39.7 Making the Toolbar Fragment Talk to the Activity
39.8 Making the Activity Talk to the Text Fragment
39.9 Testing the Application
39.10 Summary
40. Modern Android App Architecture with Jetpack
40.1 What is Android Jetpack?
40.2 The "Old" Architecture
40.3 Modern Android Architecture
40.4 The ViewModel Component
40.5 The LiveData Component
40.6 ViewModel Saved State
40.7 LiveData and Data Binding
40.8 Android Lifecycles
40.9 Repository Modules
40.10 Summary
41. An Android ViewModel Tutorial
41.1 About the Project
41.2 Creating the ViewModel Example Project
41.3 Removing Unwanted Project Elements
41.4 Designing the Fragment Layout
41.5 Implementing the View Model
41.6 Associating the Fragment with the View Model
41.7 Modifying the Fragment
41.8 Accessing the ViewModel Data
41.9 Testing the Project
41.10 Summary
42. An Android Jetpack LiveData Tutorial
42.1 LiveData - A Recap
42.2 Adding LiveData to the ViewModel
42.3 Implementing the Observer
42.4 Summary
43. An Overview of Android Jetpack Data Binding
43.1 An Overview of Data Binding
43.2 The Key Components of Data Binding
43.2.1 The Project Build Configuration
43.2.2 The Data Binding Layout File
43.2.3 The Layout File Data Element
43.2.4 The Binding Classes
43.2.5 Data Binding Variable Configuration
43.2.6 Binding Expressions (One-Way)
43.2.7 Binding Expressions (Two-Way)
43.2.8 Event and Listener Bindings
43.3 Summary
44. An Android Jetpack Data Binding Tutorial
44.1 Removing the Redundant Code
44.2 Enabling Data Binding
44.3 Adding the Layout Element
44.4 Adding the Data Element to Layout File
44.5 Working with the Binding Class
44.6 Assigning the ViewModel Instance to the Data Binding Variable
44.7 Adding Binding Expressions
44.8 Adding the Conversion Method
44.9 Adding a Listener Binding
44.10 Testing the App
44.11 Summary
45. An Android ViewModel Saved State Tutorial
45.1 Understanding ViewModel State Saving
45.2 Implementing ViewModel State Saving
45.3 Saving and Restoring State
45.4 Adding Saved State Support to the ViewModelDemo Project
45.5 Summary
46. Working with Android Lifecycle-Aware Components
46.1 Lifecycle Awareness
46.2 Lifecycle Owners
46.3 Lifecycle Observers
46.4 Lifecycle States and Events
46.5 Summary
47. An Android Jetpack Lifecycle Awareness Tutorial
47.1 Creating the Example Lifecycle Project
47.2 Creating a Lifecycle Observer
47.3 Adding the Observer
47.4 Testing the Observer
47.5 Creating a Lifecycle Owner
47.6 Testing the Custom Lifecycle Owner
47.7 Summary
48. An Overview of the Navigation Architecture Component
48.1 Understanding Navigation
48.2 Declaring a Navigation Host
48.3 The Navigation Graph
48.4 Accessing the Navigation Controller
48.5 Triggering a Navigation Action
48.6 Passing Arguments
48.7 Summary
49. An Android Jetpack Navigation Component Tutorial
49.1 Creating the NavigationDemo Project
49.2 Adding Navigation to the Build Configuration
49.3 Creating the Navigation Graph Resource File
49.4 Declaring a Navigation Host
49.5 Adding Navigation Destinations
49.6 Designing the Destination Fragment Layouts
49.7 Adding an Action to the Navigation Graph
49.8 Implement the OnFragmentInteractionListener
49.9 Adding View Binding Support to the Destination Fragments
49.10 Triggering the Action
49.11 Passing Data Using Safeargs
49.12 Summary
50. An Introduction to MotionLayout
50.1 An Overview of MotionLayout
50.2 MotionLayout
50.3 MotionScene
50.4 Configuring ConstraintSets
50.5 Custom Attributes
50.6 Triggering an Animation
50.7 Arc Motion
50.8 Keyframes
50.8.1 Attribute Keyframes
50.8.2 Position Keyframes
50.9 Time Linearity
50.10 KeyTrigger
50.11 Cycle and Time Cycle Keyframes
50.12 Starting an Animation from Code
50.13 Summary
51. An Android MotionLayout Editor Tutorial
51.1 Creating the MotionLayoutDemo Project
51.2 ConstraintLayout to MotionLayout Conversion
51.3 Configuring Start and End Constraints
51.4 Previewing the MotionLayout Animation
51.5 Adding an OnClick Gesture
51.6 Adding an Attribute Keyframe to the Transition
51.7 Adding a CustomAttribute to a Transition
51.8 Adding Position Keyframes
51.9 Summary
52. A MotionLayout KeyCycle Tutorial
52.1 An Overview of Cycle Keyframes
52.2 Using the Cycle Editor
52.3 Creating the KeyCycleDemo Project
52.4 Configuring the Start and End Constraints
52.5 Creating the Cycles
52.6 Previewing the Animation
52.7 Adding the KeyFrameSet to the MotionScene
52.8 Summary
53. Working with the Floating Action Button and Snackbar
53.1 The Material Design
53.2 The Design Library
53.3 The Floating Action Button (FAB)
53.4 The Snackbar
53.5 Creating the Example Project
53.6 Reviewing the Project
53.7 Removing Navigation Features
53.8 Changing the Floating Action Button
53.9 Adding an Action to the Snackbar
53.10 Summary
54. Creating a Tabbed Interface using the TabLayout Component
54.1 An Introduction to the ViewPager2
54.2 An Overview of the TabLayout Component
54.3 Creating the TabLayoutDemo Project
54.4 Creating the First Fragment
54.5 Duplicating the Fragments
54.6 Adding the TabLayout and ViewPager2
54.7 Performing the Initialization Tasks
54.8 Testing the Application
54.9 Customizing the TabLayout
54.10 Summary
55. Working with the RecyclerView and CardView Widgets
55.1 An Overview of the RecyclerView
55.2 An Overview of the CardView
55.3 Summary
56. An Android RecyclerView and CardView Tutorial
56.1 Creating the CardDemo Project
56.2 Modifying the Basic Views Activity Project
56.3 Designing the CardView Layout
56.4 Adding the RecyclerView
56.5 Adding the Image Files
56.6 Creating the RecyclerView Adapter
56.7 Initializing the RecyclerView Component
56.8 Testing the Application
56.9 Responding to Card Selections
56.10 Summary
57. Working with the AppBar and Collapsing Toolbar Layouts
57.1 The Anatomy of an AppBar
57.2 The Example Project
57.3 Coordinating the RecyclerView and Toolbar
57.4 Introducing the Collapsing Toolbar Layout
57.5 Changing the Title and Scrim Color
57.6 Summary
58. An Overview of Android Intents
58.1 An Overview of Intents
58.2 Explicit Intents
58.3 Returning Data from an Activity
58.4 Implicit Intents
58.5 Using Intent Filters
58.6 Automatic Link Verification
58.7 Manually Enabling Links
58.8 Checking Intent Availability
58.9 Summary
59. Android Explicit Intents - A Worked Example
59.1 Creating the Explicit Intent Example Application
59.2 Designing the User Interface Layout for MainActivity
59.3 Creating the Second Activity Class
59.4 Designing the User Interface Layout for SecondActivity
59.5 Reviewing the Application Manifest File
59.6 Creating the Intent
59.7 Extracting Intent Data
59.8 Launching SecondActivity as a Sub-Activity
59.9 Returning Data from a Sub-Activity
59.10 Testing the Application
59.11 Summary
60. Android Implicit Intents - A Worked Example
60.1 Creating the Android Studio Implicit Intent Example Project
60.2 Designing the User Interface
60.3 Creating the Implicit Intent
60.4 Adding a Second Matching Activity
60.5 Adding the Web View to the UI
60.6 Obtaining the Intent URL
60.7 Modifying the MyWebView Project Manifest File
60.8 Installing the MyWebView Package on a Device
60.9 Testing the Application
60.10 Manually Enabling the Link
60.11 Automatic Link Verification
60.12 Summary
61. Android Broadcast Intents and Broadcast Receivers
61.1 An Overview of Broadcast Intents
61.2 An Overview of Broadcast Receivers
61.3 Obtaining Results from a Broadcast
61.4 Sticky Broadcast Intents
61.5 The Broadcast Intent Example
61.6 Creating the Example Application
61.7 Creating and Sending the Broadcast Intent
61.8 Creating the Broadcast Receiver
61.9 Registering the Broadcast Receiver
61.10 Testing the Broadcast Example
61.11 Listening for System Broadcasts
61.12 Summary
62. An Introduction to Kotlin Coroutines
62.1 What are Coroutines?
62.2 Threads vs. Coroutines
62.3 Coroutine Scope
62.4 Suspend Functions
62.5 Coroutine Dispatchers
62.6 Coroutine Builders
62.7 Jobs
62.8 Coroutines - Suspending and Resuming
62.9 Returning Results from a Coroutine
62.10 Using withContext
62.11 Coroutine Channel Communication
62.12 Summary
63. An Android Kotlin Coroutines Tutorial
63.1 Creating the Coroutine Example Application
63.2 Designing the User Interface
63.3 Implementing the SeekBar
63.4 Adding the Suspend Function
63.5 Implementing the launchCoroutines Method
63.6 Testing the App
63.7 Summary
64. An Overview of Android Services
64.1 Intent Service
64.2 Bound Service
64.3 The Anatomy of a Service
64.4 Controlling Destroyed Service Restart Options
64.5 Declaring a Service in the Manifest File
64.6 Starting a Service Running on System Startup
64.7 Summary
65. Android Local Bound Services - A Worked Example
65.1 Understanding Bound Services
65.2 Bound Service Interaction Options
65.3 A Local Bound Service Example
65.4 Adding a Bound Service to the Project
65.5 Implementing the Binder
65.6 Binding the Client to the Service
65.7 Completing the Example
65.8 Testing the Application
65.9 Summary
66. Android Remote Bound Services - A Worked Example
66.1 Client to Remote Service Communication
66.2 Creating the Example Application
66.3 Designing the User Interface
66.4 Implementing the Remote Bound Service
66.5 Configuring a Remote Service in the Manifest File
66.6 Launching and Binding to the Remote Service
66.7 Sending a Message to the Remote Service
66.8 Summary
67. An Introduction to Kotlin Flow
67.1 Understanding Flows
67.2 Creating the Sample Project
67.3 Adding the Kotlin Lifecycle Library
67.4 Declaring a Flow
67.5 Emitting Flow Data
67.6 Collecting Flow Data
67.7 Adding a Flow Buffer
67.8 Transforming Data with Intermediaries
67.9 Terminal Flow Operators
67.10 Flow Flattening
67.11 Combining Multiple Flows
67.12 Hot and Cold Flows
67.13 StateFlow
67.14 SharedFlow
67.15 Summary
68. An Android SharedFlow Tutorial
68.1 About the Project
68.2 Creating the SharedFlowDemo Project
68.3 Adding the Lifecycle Libraries
68.4 Designing the User Interface Layout
68.5 Adding the List Row Layout
68.6 Adding the RecyclerView Adapter
68.7 Adding the ViewModel
68.8 Configuring the ViewModelProvider
68.9 Collecting the Flow Values
68.10 Testing the SharedFlowDemo App
68.11 Handling Flows in the Background
68.12 Summary
69. An Overview of Android SQLite Databases
69.1 Understanding Database Tables
69.2 Introducing Database Schema
69.3 Columns and Data Types
69.4 Database Rows
69.5 Introducing Primary Keys
69.6 What is SQLite?
69.7 Structured Query Language (SQL)
69.8 Trying SQLite on an Android Virtual Device (AVD)
69.9 Android SQLite Classes
69.9.1 Cursor
69.9.2 SQLiteDatabase
69.9.3 SQLiteOpenHelper
69.9.4 ContentValues
69.10 The Android Room Persistence Library
69.11 Summary
70. An Android SQLite Database Tutorial
70.1 About the Database Example
70.2 Creating the SQLDemo Project
70.3 Designing the User interface
70.4 Creating the Data Model
70.5 Implementing the Data Handler
70.6 The Add Handler Method
70.7 The Query Handler Method
70.8 The Delete Handler Method
70.9 Implementing the Activity Event Methods
70.10 Testing the Application
70.11 Summary
71. Understanding Android Content Providers
71.1 What is a Content Provider?
71.2 The Content Provider
71.2.1 onCreate()
71.2.2 query()
71.2.3 insert()
71.2.4 update()
71.2.5 delete()
71.2.6 getType()
71.3 The Content URI
71.4 The Content Resolver
71.5 The &provider& Manifest Element
71.6 Summary
72. An Android Content Provider Tutorial
72.1 Copying the SQLDemo Project
72.2 Adding the Content Provider Package
72.3 Creating the Content Provider Class
72.4 Constructing the Authority and Content URI
72.5 Implementing URI Matching in the Content Provider
72.6 Implementing the Content Provider onCreate() Method
72.7 Implementing the Content Provider insert() Method
72.8 Implementing the Content Provider query() Method
72.9 Implementing the Content Provider update() Method
72.10 Implementing the Content Provider delete() Method
72.11 Declaring the Content Provider in the Manifest File
72.12 Modifying the Database Handler
72.13 Summary
73. An Android Content Provider Client Tutorial
73.1 Creating the SQLDemoClient Project
73.2 Designing the User interface
73.3 Accessing the Content Provider
73.4 Adding the Query Permission
73.5 Testing the Project
73.6 Summary
74. The Android Room Persistence Library
74.1 Revisiting Modern App Architecture
74.2 Key Elements of Room Database Persistence
74.2.1 Repository
74.2.2 Room Database
74.2.3 Data Access Object (DAO)
74.2.4 Entities
74.2.5 SQLite Database
74.3 Understanding Entities
74.4 Data Access Objects
74.5 The Room Database
74.6 The Repository
74.7 In-Memory Databases
74.8 Database Inspector
74.9 Summary
75. An Android TableLayout and TableRow Tutorial
75.1 The TableLayout and TableRow Layout Views
75.2 Creating the Room Database Project
75.3 Converting to a LinearLayout
75.4 Adding the TableLayout to the User Interface
75.5 Configuring the TableRows
75.6 Adding the Button Bar to the Layout
75.7 Adding the RecyclerView
75.8 Adjusting the Layout Margins
75.9 Summary
76. An Android Room Database and Repository Tutorial
76.1 About the RoomDemo Project
76.2 Modifying the Build Configuration
76.3 Building the Entity
76.4 Creating the Data Access Object
76.5 Adding the Room Database
76.6 Adding the Repository
76.7 Adding the ViewModel
76.8 Creating the Product Item Layout
76.9 Adding the RecyclerView Adapter
76.10 Preparing the Main Activity
76.11 Adding the Button Listeners
76.12 Adding LiveData Observers
76.13 Initializing the RecyclerView
76.14 Testing the RoomDemo App
76.15 Using the Database Inspector
76.16 Summary
77. Video Playback on Android using the VideoView and MediaController Classes
77.1 Introducing the Android VideoView Class
77.2 Introducing the Android MediaController Class
77.3 Creating the Video Playback Example
77.4 Designing the VideoPlayer Layout
77.5 Downloading the Video File
77.6 Configuring the VideoView
77.7 Adding the MediaController to the Video View
77.8 Setting up the onPreparedListener
77.9 Summary
78. Android Picture-in-Picture Mode
78.1 Picture-in-Picture Features
78.2 Enabling Picture-in-Picture Mode
78.3 Configuring Picture-in-Picture Parameters
78.4 Entering Picture-in-Picture Mode
78.5 Detecting Picture-in-Picture Mode Changes
78.6 Adding Picture-in-Picture Actions
78.7 Summary
79. An Android Picture-in-Picture Tutorial
79.1 Adding Picture-in-Picture Support to the Manifest
79.2 Adding a Picture-in-Picture Button
79.3 Entering Picture-in-Picture Mode
79.4 Detecting Picture-in-Picture Mode Changes
79.5 Adding a Broadcast Receiver
79.6 Adding the PiP Action
79.7 Testing the Picture-in-Picture Action
79.8 Summary
80. Making Runtime Permission Requests in Android
80.1 Understanding Normal and Dangerous Permissions
80.2 Creating the Permissions Example Project
80.3 Checking for a Permission
80.4 Requesting Permission at Runtime
80.5 Providing a Rationale for the Permission Request
80.6 Testing the Permissions App
80.7 Summary
81. Android Audio Recording and Playback using MediaPlayer and MediaRecorder
81.1 Playing Audio
81.2 Recording Audio and Video using the MediaRecorder Class
81.3 About the Example Project
81.4 Creating the AudioApp Project
81.5 Designing the User Interface
81.6 Checking for Microphone Availability
81.7 Initializing the Activity
81.8 Implementing the recordAudio() Method
81.9 Implementing the stopAudio() Method
81.10 Implementing the playAudio() method
81.11 Configuring and Requesting Permissions
81.12 Testing the Application
81.13 Summary
82. An Android Notifications Tutorial
82.1 An Overview of Notifications
82.2 Creating the NotifyDemo Project
82.3 Designing the User Interface
82.4 Creating the Second Activity
82.5 Creating a Notification Channel
82.6 Requesting Notification Permission
82.7 Creating and Issuing a Notification
82.8 Launching an Activity from a Notification
82.9 Adding Actions to a Notification
82.10 Bundled Notifications
82.11 Summary
83. An Android Direct Reply Notification Tutorial
83.1 Creating the DirectReply Project
83.2 Designing the User Interface
83.3 Requesting Notification Permission
83.4 Creating the Notification Channel
83.5 Building the RemoteInput Object
83.6 Creating the PendingIntent
83.7 Creating the Reply Action
83.8 Receiving Direct Reply Input
83.9 Updating the Notification
83.10 Summary
84. Working with the Google Maps Android API in Android Studio
84.1 The Elements of the Google Maps Android API
84.2 Creating the Google Maps Project
84.3 Creating a Google Cloud Billing Account
84.4 Creating a New Google Cloud Project
84.5 Enabling the Google Maps SDK
84.6 Generating a Google Maps API Key
84.7 Adding the API Key to the Android Studio Project
84.8 Testing the Application
84.9 Understanding Geocoding and Reverse Geocoding
84.10 Adding a Map to an Application
84.11 Requesting Current Location Permission
84.12 Displaying the User's Current Location
84.13 Changing the Map Type
84.14 Displaying Map Controls to the User
84.15 Handling Map Gesture Interaction
84.15.1 Map Zooming Gestures
84.15.2 Map Scrolling/Panning Gestures
84.15.3 Map Tilt Gestures
84.15.4 Map Rotation Gestures
84.16 Creating Map Markers
84.17 Controlling the Map Camera
84.18 Summary
85. Printing with the Android Printing Framework
85.1 The Android Printing Architecture
85.2 The Print Service Plugins
85.3 Google Cloud Print
85.4 Printing to Google Drive
85.5 Save as PDF
85.6 Printing from Android Devices
85.7 Options for Building Print Support into Android Apps
85.7.1 Image Printing
85.7.2 Creating and Printing HTML Content
85.7.3 Printing a Web Page
85.7.4 Printing a Custom Document
85.8 Summary
86. An Android HTML and Web Content Printing Example
86.1 Creating the HTML Printing Example Application
86.2 Printing Dynamic HTML Content
86.3 Creating the Web Page Printing Example
86.4 Removing the Floating Action Button
86.5 Removing Navigation Features
86.6 Designing the User Interface Layout
86.7 Accessing the WebView from the Main Activity
86.8 Loading the Web Page into the WebView
86.9 Adding the Print Menu Option
86.10 Summary
87. A Guide to Android Custom Document Printing
87.1 An Overview of Android Custom Document Printing
87.1.1 Custom Print Adapters
87.2 Preparing the Custom Document Printing Project
87.3 Designing the UI
87.4 Creating the Custom Print Adapter
87.5 Implementing the onLayout() Callback Method
87.6 Implementing the onWrite() Callback Method
87.7 Checking a Page is in Range
87.8 Drawing the Content on the Page Canvas
87.9 Starting the Print Job
87.10 Testing the Application
87.11 Summary
88. An Introduction to Android App Links
88.1 An Overview of Android App Links
88.2 App Link Intent Filters
88.3 Handling App Link Intents
88.4 Associating the App with a Website
88.5 Summary
89. An Android Studio App Links Tutorial
89.1 About the Example App
89.2 The Database Schema
89.3 Loading and Running the Project
89.4 Adding the URL Mapping
89.5 Adding the Intent Filter
89.6 Adding Intent Handling Code
89.7 Testing the App
89.8 Creating the Digital Asset Links File
89.9 Testing the App Link
89.10 Summary
90. An Android Biometric Authentication Tutorial
90.1 An Overview of Biometric Authentication
90.2 Creating the Biometric Authentication Project
90.3 Configuring Device Fingerprint Authentication
90.4 Adding the Biometric Permission to the Manifest File
90.5 Designing the User Interface
90.6 Adding a Toast Convenience Method
90.7 Checking the Security Settings
90.8 Configuring the Authentication Callbacks
90.9 Adding the CancellationSignal
90.10 Starting the Biometric Prompt
90.11 Testing the Project
90.12 Summary
91. Creating, Testing, and Uploading an Android App Bundle
91.1 The Release Preparation Process
91.2 Android App Bundles
91.3 Register for a Google Play Developer Console Account
91.4 Configuring the App in the Console
91.5 Enabling Google Play App Signing
91.6 Creating a Keystore File
91.7 Creating the Android App Bundle
91.8 Generating Test APK Files
91.9 Uploading the App Bundle to the Google Play Developer Console
91.10 Exploring the App Bundle
91.11 Managing Testers
91.12 Rolling the App Out for Testing
91.13 Uploading New App Bundle Revisions
91.14 Analyzing the App Bundle File
91.15 Summary
92. An Overview of Android In-App Billing
92.1 Preparing a Project for In-App Purchasing
92.2 Creating In-App Products and Subscriptions
92.3 Billing Client Initialization
92.4 Connecting to the Google Play Billing Library
92.5 Querying Available Products
92.6 Starting the Purchase Process
92.7 Completing the Purchase
92.8 Querying Previous Purchases
92.9 Summary
93. An Android In-App Purchasing Tutorial
93.1 About the In-App Purchasing Example Project
93.2 Creating the InAppPurchase Project
93.3 Adding Libraries to the Project
93.4 Designing the User Interface
93.5 Adding the App to the Google Play Store
93.6 Creating an In-App Product
93.7 Enabling License Testers
93.8 Initializing the Billing Client
93.9 Querying the Product
93.10 Launching the Purchase Flow
93.11 Handling Purchase Updates
93.12 Consuming the Product
93.13 Restoring a Previous Purchase
93.14 Testing the App
93.15 Troubleshooting
93.16 Summary
94. Accessing Cloud Storage using the Android Storage Access Framework
94.1 The Storage Access Framework
94.2 Working with the Storage Access Framework
94.3 Filtering Picker File Listings
94.4 Handling Intent Results
94.5 Reading the Content of a File
94.6 Writing Content to a File
94.7 Deleting a File
94.8 Gaining Persistent Access to a File
94.9 Summary
95. An Android Storage Access Framework Example
95.1 About the Storage Access Framework Example
95.2 Creating the Storage Access Framework Example
95.3 Designing the User Interface
95.4 Adding the Activity Launchers
95.5 Creating a New Storage File
95.6 Saving to a Storage File
95.7 Opening and Reading a Storage File
95.8 Testing the Storage Access Application
95.9 Summary
96. An Android Studio Primary/Detail Flow Tutorial
96.1 The Primary/Detail Flow
96.2 Creating a Primary/Detail Flow Activity
96.3 Adding the Primary/Detail Flow Activity
96.4 Modifying the Primary/Detail Flow Template
96.5 Changing the Content Model
96.6 Changing the Detail Pane
96.7 Modifying the ItemDetailFragment Class
96.8 Modifying the ItemListFragment Class
96.9 Adding Manifest Permissions
96.10 Running the Application
96.11 Summary
97. Working with Material Design 3 Theming
97.1 Material Design 2 vs. Material Design 3
97.2 Understanding Material Design Theming
97.3 Material Design 3 Theming
97.4 Building a Custom Theme
97.5 Summary
98. A Material Design 3 Theming and Dynamic Color Tutorial
98.1 Creating the ThemeDemo Project
98.2 Designing the User Interface
98.3 Building a New Theme
98.4 Adding the Theme to the Project
98.5 Enabling Dynamic Color Support
98.6 Previewing Dynamic Colors
98.7 Summary
99. An Overview of Gradle in Android Studio
99.1 An Overview of Gradle
99.2 Gradle and Android Studio
99.2.1 Sensible Defaults
99.2.2 Dependencies
99.2.3 Build Variants
99.2.4 Manifest Entries
99.2.5 APK Signing
99.2.6 ProGuard Support
99.3 The Property and Settings Gradle Build File
99.4 The Top-level Gradle Build File
99.5 Module Level Gradle Build Files
99.6 Configuring Signing Settings in the Build File
99.7 Running Gradle Tasks from the Command Line
99.8 Summary
Index

Systemvoraussetzungen

Als PDF speichern Als Link merken