Android Studio Jellyfish Essentials - Java Edition

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

Developing Android Apps Using Android Studio 2023.3.1 and Java

Smyth(Author)

Payload Media, Inc. (Publisher)

1st Edition

Published on 6. May 2024

718 pages

E-Book

ePUB with Adobe-DRM

System requirements

978-1-951442-86-6 (ISBN)

€38.99incl. 7% vat

System requirements

for ePUB with Adobe-DRM

E-Book Single Licence

Available for download

Description

Alles über E-Books | Antworten auf Fragen rund um E-Books, Kopierschutz und Dateiformate finden Sie in unserem Info- & Hilfebereich.

Alles über E-Books, Kopierschutz & Dateiformate finden Sie in unserem Info- & Hilfebereich.

This book, fully updated for Android Studio Jellyfish (2023.3.1) and the new UI, teaches you how to develop Android-based applications using the Java programming language.

This book begins with the basics and outlines how to set up an Android development and testing environment, followed by an overview of areas such as tool windows, the code editor, and the Layout Editor tool. An introduction to the architecture of Android is followed by an in-depth look at the design of Android applications and user interfaces using the Android Studio environment.

Chapters also cover the Android Architecture Components, including view models, lifecycle management, Room database access, content providers, the Database Inspector, app navigation, live data, and data binding.

More advanced topics such as intents are also covered, as are touch screen handling, gesture recognition, and the recording and playback of audio. This book edition also covers printing, transitions, and foldable device support.

The concepts of material design are also covered in detail, including the use of floating action buttons, Snackbars, tabbed interfaces, card views, navigation drawers, and collapsing toolbars.

Other key features of Android Studio and Android are also covered in detail, including the Layout Editor, the ConstraintLayout and ConstraintSet classes, MotionLayout Editor, view binding, constraint chains, barriers, and direct reply notifications.

Chapters also cover advanced features of Android Studio, such as App Links, Gradle build configuration, in-app billing, and submitting apps to the Google Play Developer Console.

Assuming you already have some Java programming experience, are ready to download Android Studio and the Android SDK, have access to a Windows, Mac, or Linux system, and have ideas for some apps to develop, you are ready to get started.

More details

Other editions

Content

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 Overview of Android View Binding
11.1 Find View by Id
11.2 View Binding
11.3 Converting the AndroidSample project
11.4 Enabling View Binding
11.5 Using View Binding
11.6 Choosing an Option
11.7 View Binding in the Book Examples
11.8 Migrating a Project to View Binding
11.9 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 Views 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 Night Mode
17.7 Code Mode
17.8 Split Mode
17.9 Setting Attributes
17.10 Transforms
17.11 Tools Visibility Toggles
17.12 Converting Views
17.13 Displaying Sample Data
17.14 Creating a Custom Device Definition
17.15 Changing the Current Device
17.16 Layout Validation
17.17 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 Configuring Widget Dimensions
18.4 Guideline Helper
18.5 Group Helper
18.6 Barrier Helper
18.7 Flow Helper
18.8 Ratios
18.9 ConstraintLayout Advantages
18.10 ConstraintLayout Availability
18.11 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 Design Time Tools Positioning
19.13 Adding Guidelines
19.14 Adding Barriers
19.15 Adding a Group
19.16 Working with the Flow Helper
19.17 Widget Group Alignment and Distribution
19.18 Converting other Layouts to ConstraintLayout
19.19 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 Preparing the Layout Editor Environment
21.3 Adding the Widgets to the User Interface
21.4 Adding the Constraints
21.5 Testing the Layout
21.6 Using the Layout Inspector
21.7 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. A Guide to Gradle Version Catalogs
26.1 Library and Plugin Dependencies
26.2 Project Gradle Build File
26.3 Module Gradle Build Files
26.4 Version Catalog File
26.5 Adding Dependencies
26.6 Library Updates
26.7 Summary
27. An Overview and Example of Android Event Handling
27.1 Understanding Android Events
27.2 Using the android:onClick Resource
27.3 Event Listeners and Callback Methods
27.4 An Event Handling Example
27.5 Designing the User Interface
27.6 The Event Listener and Callback Method
27.7 Consuming Events
27.8 Summary
28. Android Touch and Multi-touch Event Handling
28.1 Intercepting Touch Events
28.2 The MotionEvent Object
28.3 Understanding Touch Actions
28.4 Handling Multiple Touches
28.5 An Example Multi-Touch Application
28.6 Designing the Activity User Interface
28.7 Implementing the Touch Event Listener
28.8 Running the Example Application
28.9 Summary
29. Detecting Common Gestures Using the Android Gesture Detector Class
29.1 Implementing Common Gesture Detection
29.2 Creating an Example Gesture Detection Project
29.3 Implementing the Listener Class
29.4 Creating the GestureDetectorCompat Instance
29.5 Implementing the onTouchEvent() Method
29.6 Testing the Application
29.7 Summary
30. Implementing Custom Gesture and Pinch Recognition on Android
30.1 The Android Gesture Builder Application
30.2 The GestureOverlayView Class
30.3 Detecting Gestures
30.4 Identifying Specific Gestures
30.5 Installing and Running the Gesture Builder Application
30.6 Creating a Gestures File
30.7 Creating the Example Project
30.8 Extracting the Gestures File from the SD Card
30.9 Adding the Gestures File to the Project
30.10 Designing the User Interface
30.11 Loading the Gestures File
30.12 Registering the Event Listener
30.13 Implementing the onGesturePerformed Method
30.14 Testing the Application
30.15 Configuring the GestureOverlayView
30.16 Intercepting Gestures
30.17 Detecting Pinch Gestures
30.18 A Pinch Gesture Example Project
30.19 Summary
31. An Introduction to Android Fragments
31.1 What is a Fragment?
31.2 Creating a Fragment
31.3 Adding a Fragment to an Activity using the Layout XML File
31.4 Adding and Managing Fragments in Code
31.5 Handling Fragment Events
31.6 Implementing Fragment Communication
31.7 Summary
32. Using Fragments in Android Studio - An Example
32.1 About the Example Fragment Application
32.2 Creating the Example Project
32.3 Creating the First Fragment Layout
32.4 Migrating a Fragment to View Binding
32.5 Adding the Second Fragment
32.6 Adding the Fragments to the Activity
32.7 Making the Toolbar Fragment Talk to the Activity
32.8 Making the Activity Talk to the Text Fragment
32.9 Testing the Application
32.10 Summary
33. Modern Android App Architecture with Jetpack
33.1 What is Android Jetpack?
33.2 The "Old" Architecture
33.3 Modern Android Architecture
33.4 The ViewModel Component
33.5 The LiveData Component
33.6 ViewModel Saved State
33.7 LiveData and Data Binding
33.8 Android Lifecycles
33.9 Repository Modules
33.10 Summary
34. An Android ViewModel Tutorial
34.1 About the Project
34.2 Creating the ViewModel Example Project
34.3 Removing Unwanted Project Elements
34.4 Designing the Fragment Layout
34.5 Implementing the View Model
34.6 Associating the Fragment with the View Model
34.7 Modifying the Fragment
34.8 Accessing the ViewModel Data
34.9 Testing the Project
34.10 Summary
35. An Android Jetpack LiveData Tutorial
35.1 LiveData - A Recap
35.2 Adding LiveData to the ViewModel
35.3 Implementing the Observer
35.4 Summary
36. An Overview of Android Jetpack Data Binding
36.1 An Overview of Data Binding
36.2 The Key Components of Data Binding
36.2.1 The Project Build Configuration
36.2.2 The Data Binding Layout File
36.2.3 The Layout File Data Element
36.2.4 The Binding Classes
36.2.5 Data Binding Variable Configuration
36.2.6 Binding Expressions (One-Way)
36.2.7 Binding Expressions (Two-Way)
36.2.8 Event and Listener Bindings
36.3 Summary
37. An Android Jetpack Data Binding Tutorial
37.1 Removing the Redundant Code
37.2 Enabling Data Binding
37.3 Adding the Layout Element
37.4 Adding the Data Element to Layout File
37.5 Working with the Binding Class
37.6 Assigning the ViewModel Instance to the Data Binding Variable
37.7 Adding Binding Expressions
37.8 Adding the Conversion Method
37.9 Adding a Listener Binding
37.10 Testing the App
37.11 Summary
38. An Android ViewModel Saved State Tutorial
38.1 Understanding ViewModel State Saving
38.2 Implementing ViewModel State Saving
38.3 Saving and Restoring State
38.4 Adding Saved State Support to the ViewModelDemo Project
38.5 Summary
39. Working with Android Lifecycle-Aware Components
39.1 Lifecycle Awareness
39.2 Lifecycle Owners
39.3 Lifecycle Observers
39.4 Lifecycle States and Events
39.5 Summary
40. An Android Jetpack Lifecycle Awareness Tutorial
40.1 Creating the Example Lifecycle Project
40.2 Creating a Lifecycle Observer
40.3 Adding the Observer
40.4 Testing the Observer
40.5 Creating a Lifecycle Owner
40.6 Testing the Custom Lifecycle Owner
40.7 Summary
41. An Overview of the Navigation Architecture Component
41.1 Understanding Navigation
41.2 Declaring a Navigation Host
41.3 The Navigation Graph
41.4 Accessing the Navigation Controller
41.5 Triggering a Navigation Action
41.6 Passing Arguments
41.7 Summary
42. An Android Jetpack Navigation Component Tutorial
42.1 Creating the NavigationDemo Project
42.2 Adding Navigation to the Build Configuration
42.3 Creating the Navigation Graph Resource File
42.4 Declaring a Navigation Host
42.5 Adding Navigation Destinations
42.6 Designing the Destination Fragment Layouts
42.7 Adding an Action to the Navigation Graph
42.8 Implement the OnFragmentInteractionListener
42.9 Adding View Binding Support to the Destination Fragments
42.10 Triggering the Action
42.11 Passing Data Using Safeargs
42.12 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 an Action to the Snackbar
46.10 Summary
47. Creating a Tabbed Interface using the TabLayout Component
47.1 An Introduction to the ViewPager2
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 ViewPager2
47.7 Performing the Initialization Tasks
47.8 Testing the Application
47.9 Customizing the TabLayout
47.10 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 Views Activity Project
49.3 Designing the CardView Layout
49.4 Adding the RecyclerView
49.5 Adding the Image Files
49.6 Creating the RecyclerView Adapter
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 Primary/Detail Flow Tutorial
52.1 The Primary/Detail Flow
52.2 Creating a Primary/Detail Flow Activity
52.3 Adding the Primary/Detail Flow Activity
52.4 Modifying the Primary/Detail Flow Template
52.5 Changing the Content Model
52.6 Changing the Detail Pane
52.7 Modifying the ItemDetailFragment Class
52.8 Modifying the ItemListFragment Class
52.9 Adding Manifest Permissions
52.10 Running the Application
52.11 Summary
53. An Overview of Android Services
53.1 Intent Service
53.2 Bound Service
53.3 The Anatomy of a Service
53.4 Controlling Destroyed Service Restart Options
53.5 Declaring a Service in the Manifest File
53.6 Starting a Service Running on System Startup
53.7 Summary
54. An Overview of Android Intents
54.1 An Overview of Intents
54.2 Explicit Intents
54.3 Returning Data from an Activity
54.4 Implicit Intents
54.5 Using Intent Filters
54.6 Automatic Link Verification
54.7 Manually Enabling Links
54.8 Checking Intent Availability
54.9 Summary
55. Android Explicit Intents - A Worked Example
55.1 Creating the Explicit Intent Example Application
55.2 Designing the User Interface Layout for MainActivity
55.3 Creating the Second Activity Class
55.4 Designing the User Interface Layout for SecondActivity
55.5 Reviewing the Application Manifest File
55.6 Creating the Intent
55.7 Extracting Intent Data
55.8 Launching SecondActivity as a Sub-Activity
55.9 Returning Data from a Sub-Activity
55.10 Testing the Application
55.11 Summary
56. Android Implicit Intents - A Worked Example
56.1 Creating the Android Studio Implicit Intent Example Project
56.2 Designing the User Interface
56.3 Creating the Implicit Intent
56.4 Adding a Second Matching Activity
56.5 Adding the Web View to the UI
56.6 Obtaining the Intent URL
56.7 Modifying the MyWebView Project Manifest File
56.8 Installing the MyWebView Package on a Device
56.9 Testing the Application
56.10 Manually Enabling the Link
56.11 Automatic Link Verification
56.12 Summary
57. Android Broadcast Intents and Broadcast Receivers
57.1 An Overview of Broadcast Intents
57.2 An Overview of Broadcast Receivers
57.3 Obtaining Results from a Broadcast
57.4 Sticky Broadcast Intents
57.5 The Broadcast Intent Example
57.6 Creating the Example Application
57.7 Creating and Sending the Broadcast Intent
57.8 Creating the Broadcast Receiver
57.9 Registering the Broadcast Receiver
57.10 Testing the Broadcast Example
57.11 Listening for System Broadcasts
57.12 Summary
58. Android Local Bound Services - A Worked Example
58.1 Understanding Bound Services
58.2 Bound Service Interaction Options
58.3 A Local Bound Service Example
58.4 Adding a Bound Service to the Project
58.5 Implementing the Binder
58.6 Binding the Client to the Service
58.7 Completing the Example
58.8 Testing the Application
58.9 Summary
59. Android Remote Bound Services - A Worked Example
59.1 Client to Remote Service Communication
59.2 Creating the Example Application
59.3 Designing the User Interface
59.4 Implementing the Remote Bound Service
59.5 Configuring a Remote Service in the Manifest File
59.6 Launching and Binding to the Remote Service
59.7 Sending a Message to the Remote Service
59.8 Summary
60. An Overview of Java Threads, Handlers and Executors
60.1 The Application Main Thread
60.2 Thread Handlers
60.3 A Threading Example
60.4 Building the App
60.5 Creating a New Thread
60.6 Implementing a Thread Handler
60.7 Passing a Message to the Handler
60.8 Java Executor Concurrency
60.9 Working with Runnable Tasks
60.10 Shutting down an Executor Service
60.11 Working with Callable Tasks and Futures
60.12 Handling a Future Result
60.13 Scheduling Tasks
60.14 Summary
61. Making Runtime Permission Requests in Android
61.1 Understanding Normal and Dangerous Permissions
61.2 Creating the Permissions Example Project
61.3 Checking for a Permission
61.4 Requesting Permission at Runtime
61.5 Providing a Rationale for the Permission Request
61.6 Testing the Permissions App
61.7 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 Requesting Notification Permission
62.7 Creating and Issuing a Notification
62.8 Launching an Activity from a Notification
62.9 Adding Actions to a Notification
62.10 Bundled Notifications
62.11 Summary
63. An Android Direct Reply Notification Tutorial
63.1 Creating the DirectReply Project
63.2 Designing the User Interface
63.3 Requesting Notification Permission
63.4 Creating the Notification Channel
63.5 Building the RemoteInput Object
63.6 Creating the PendingIntent
63.7 Creating the Reply Action
63.8 Receiving Direct Reply Input
63.9 Updating the Notification
63.10 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 Android SQLite Classes
65.9.1 Cursor
65.9.2 SQLiteDatabase
65.9.3 SQLiteOpenHelper
65.9.4 ContentValues
65.10 The Android Room Persistence Library
65.11 Summary
66. An Android SQLite Database Tutorial
66.1 About the Database Example
66.2 Creating the SQLDemo Project
66.3 Designing the User interface
66.4 Creating the Data Model
66.5 Implementing the Data Handler
66.6 The Add Handler Method
66.7 The Query Handler Method
66.8 The Delete Handler Method
66.9 Implementing the Activity Event Methods
66.10 Testing the Application
66.11 Summary
67. Understanding Android Content Providers
67.1 What is a Content Provider?
67.2 The Content Provider
67.2.1 onCreate()
67.2.2 query()
67.2.3 insert()
67.2.4 update()
67.2.5 delete()
67.2.6 getType()
67.3 The Content URI
67.4 The Content Resolver
67.5 The &provider& Manifest Element
67.6 Summary
68. An Android Content Provider Tutorial
68.1 Copying the SQLDemo Project
68.2 Adding the Content Provider Package
68.3 Creating the Content Provider Class
68.4 Constructing the Authority and Content URI
68.5 Implementing URI Matching in the Content Provider
68.6 Implementing the Content Provider onCreate() Method
68.7 Implementing the Content Provider insert() Method
68.8 Implementing the Content Provider query() Method
68.9 Implementing the Content Provider update() Method
68.10 Implementing the Content Provider delete() Method
68.11 Declaring the Content Provider in the Manifest File
68.12 Modifying the Database Handler
68.13 Summary
69. An Android Content Provider Client Tutorial
69.1 Creating the SQLDemoClient Project
69.2 Designing the User interface
69.3 Accessing the Content Provider
69.4 Adding the Query Permission
69.5 Testing the Project
69.6 Summary
70. The Android Room Persistence Library
70.1 Revisiting Modern App Architecture
70.2 Key Elements of Room Database Persistence
70.2.1 Repository
70.2.2 Room Database
70.2.3 Data Access Object (DAO)
70.2.4 Entities
70.2.5 SQLite Database
70.3 Understanding Entities
70.4 Data Access Objects
70.5 The Room Database
70.6 The Repository
70.7 In-Memory Databases
70.8 Database Inspector
70.9 Summary
71. An Android TableLayout and TableRow Tutorial
71.1 The TableLayout and TableRow Layout Views
71.2 Creating the Room Database Project
71.3 Converting to a LinearLayout
71.4 Adding the TableLayout to the User Interface
71.5 Configuring the TableRows
71.6 Adding the Button Bar to the Layout
71.7 Adding the RecyclerView
71.8 Adjusting the Layout Margins
71.9 Summary
72. An Android Room Database and Repository Tutorial
72.1 About the RoomDemo Project
72.2 Modifying the Build Configuration
72.3 Building the Entity
72.4 Creating the Data Access Object
72.5 Adding the Room Database
72.6 Adding the Repository
72.7 Adding the ViewModel
72.8 Creating the Product Item Layout
72.9 Adding the RecyclerView Adapter
72.10 Preparing the Main Activity
72.11 Adding the Button Listeners
72.12 Adding LiveData Observers
72.13 Initializing the RecyclerView
72.14 Testing the RoomDemo App
72.15 Using the Database Inspector
72.16 Summary
73. Accessing Cloud Storage using the Android Storage Access Framework
73.1 The Storage Access Framework
73.2 Working with the Storage Access Framework
73.3 Filtering Picker File Listings
73.4 Handling Intent Results
73.5 Reading the Content of a File
73.6 Writing Content to a File
73.7 Deleting a File
73.8 Gaining Persistent Access to a File
73.9 Summary
74. An Android Storage Access Framework Example
74.1 About the Storage Access Framework Example
74.2 Creating the Storage Access Framework Example
74.3 Designing the User Interface
74.4 Adding the Activity Launchers
74.5 Creating a New Storage File
74.6 Saving to a Storage File
74.7 Opening and Reading a Storage File
74.8 Testing the Storage Access Application
74.9 Summary
75. Video Playback on Android using the VideoView and MediaController Classes
75.1 Introducing the Android VideoView Class
75.2 Introducing the Android MediaController Class
75.3 Creating the Video Playback Example
75.4 Designing the VideoPlayer Layout
75.5 Downloading the Video File
75.6 Configuring the VideoView
75.7 Adding the MediaController to the Video View
75.8 Setting up the onPreparedListener
75.9 Summary
76. Android Picture-in-Picture Mode
76.1 Picture-in-Picture Features
76.2 Enabling Picture-in-Picture Mode
76.3 Configuring Picture-in-Picture Parameters
76.4 Entering Picture-in-Picture Mode
76.5 Detecting Picture-in-Picture Mode Changes
76.6 Adding Picture-in-Picture Actions
76.7 Summary
77. An Android Picture-in-Picture Tutorial
77.1 Adding Picture-in-Picture Support to the Manifest
77.2 Adding a Picture-in-Picture Button
77.3 Entering Picture-in-Picture Mode
77.4 Detecting Picture-in-Picture Mode Changes
77.5 Adding a Broadcast Receiver
77.6 Adding the PiP Action
77.7 Testing the Picture-in-Picture Action
77.8 Summary
78. Android Audio Recording and Playback using MediaPlayer and MediaRecorder
78.1 Playing Audio
78.2 Recording Audio and Video using the MediaRecorder Class
78.3 About the Example Project
78.4 Creating the AudioApp Project
78.5 Designing the User Interface
78.6 Checking for Microphone Availability
78.7 Initializing the Activity
78.8 Implementing the recordAudio() Method
78.9 Implementing the stopAudio() Method
78.10 Implementing the playAudio() method
78.11 Configuring and Requesting Permissions
78.12 Testing the Application
78.13 Summary
79. Working with the Google Maps Android API in Android Studio
79.1 The Elements of the Google Maps Android API
79.2 Creating the Google Maps Project
79.3 Creating a Google Cloud Billing Account
79.4 Creating a New Google Cloud Project
79.5 Enabling the Google Maps SDK
79.6 Generating a Google Maps API Key
79.7 Adding the API Key to the Android Studio Project
79.8 Testing the Application
79.9 Understanding Geocoding and Reverse Geocoding
79.10 Adding a Map to an Application
79.11 Requesting Current Location Permission
79.12 Displaying the User's Current Location
79.13 Changing the Map Type
79.14 Displaying Map Controls to the User
79.15 Handling Map Gesture Interaction
79.15.1 Map Zooming Gestures
79.15.2 Map Scrolling/Panning Gestures
79.15.3 Map Tilt Gestures
79.15.4 Map Rotation Gestures
79.16 Creating Map Markers
79.17 Controlling the Map Camera
79.18 Summary
80. Printing with the Android Printing Framework
80.1 The Android Printing Architecture
80.2 The Print Service Plugins
80.3 Google Cloud Print
80.4 Printing to Google Drive
80.5 Save as PDF
80.6 Printing from Android Devices
80.7 Options for Building Print Support into Android Apps
80.7.1 Image Printing
80.7.2 Creating and Printing HTML Content
80.7.3 Printing a Web Page
80.7.4 Printing a Custom Document
80.8 Summary
81. An Android HTML and Web Content Printing Example
81.1 Creating the HTML Printing Example Application
81.2 Printing Dynamic HTML Content
81.3 Creating the Web Page Printing Example
81.4 Removing the Floating Action Button
81.5 Removing Navigation Features
81.6 Designing the User Interface Layout
81.7 Accessing the WebView from the Main Activity
81.8 Loading the Web Page into the WebView
81.9 Adding the Print Menu Option
81.10 Summary
82. A Guide to Android Custom Document Printing
82.1 An Overview of Android Custom Document Printing
82.1.1 Custom Print Adapters
82.2 Preparing the Custom Document Printing Project
82.3 Designing the UI
82.4 Creating the Custom Print Adapter
82.5 Implementing the onLayout() Callback Method
82.6 Implementing the onWrite() Callback Method
82.7 Checking a Page is in Range
82.8 Drawing the Content on the Page Canvas
82.9 Starting the Print Job
82.10 Testing the Application
82.11 Summary
83. An Introduction to Android App Links
83.1 An Overview of Android App Links
83.2 App Link Intent Filters
83.3 Handling App Link Intents
83.4 Associating the App with a Website
83.5 Summary
84. An Android Studio App Links Tutorial
84.1 About the Example App
84.2 The Database Schema
84.3 Loading and Running the Project
84.4 Adding the URL Mapping
84.5 Adding the Intent Filter
84.6 Adding Intent Handling Code
84.7 Testing the App
84.8 Creating the Digital Asset Links File
84.9 Testing the App Link
84.10 Summary
85. An Android Biometric Authentication Tutorial
85.1 An Overview of Biometric Authentication
85.2 Creating the Biometric Authentication Project
85.3 Configuring Device Fingerprint Authentication
85.4 Adding the Biometric Permission to the Manifest File
85.5 Designing the User Interface
85.6 Adding a Toast Convenience Method
85.7 Checking the Security Settings
85.8 Configuring the Authentication Callbacks
85.9 Adding the CancellationSignal
85.10 Starting the Biometric Prompt
85.11 Testing the Project
85.12 Summary
86. Creating, Testing, and Uploading an Android App Bundle
86.1 The Release Preparation Process
86.2 Android App Bundles
86.3 Register for a Google Play Developer Console Account
86.4 Configuring the App in the Console
86.5 Enabling Google Play App Signing
86.6 Creating a Keystore File
86.7 Creating the Android App Bundle
86.8 Generating Test APK Files
86.9 Uploading the App Bundle to the Google Play Developer Console
86.10 Exploring the App Bundle
86.11 Managing Testers
86.12 Rolling the App Out for Testing
86.13 Uploading New App Bundle Revisions
86.14 Analyzing the App Bundle File
86.15 Summary
87. An Overview of Android In-App Billing
87.1 Preparing a Project for In-App Purchasing
87.2 Creating In-App Products and Subscriptions
87.3 Billing Client Initialization
87.4 Connecting to the Google Play Billing Library
87.5 Querying Available Products
87.6 Starting the Purchase Process
87.7 Completing the Purchase
87.8 Querying Previous Purchases
87.9 Summary
88. An Android In-App Purchasing Tutorial
88.1 About the In-App Purchasing Example Project
88.2 Creating the InAppPurchase Project
88.3 Adding Libraries to the Project
88.4 Designing the User Interface
88.5 Adding the App to the Google Play Store
88.6 Creating an In-App Product
88.7 Enabling License Testers
88.8 Initializing the Billing Client
88.9 Querying the Product
88.10 Launching the Purchase Flow
88.11 Handling Purchase Updates
88.12 Consuming the Product
88.13 Restoring a Previous Purchase
88.14 Testing the App
88.15 Troubleshooting
88.16 Summary
89. Creating and Managing Overflow Menus on Android
89.1 The Overflow Menu
89.2 Creating an Overflow Menu
89.3 Displaying an Overflow Menu
89.4 Responding to Menu Item Selections
89.5 Creating Checkable Item Groups
89.6 Menus and the Android Studio Menu Editor
89.7 Creating the Example Project
89.8 Designing the Menu
89.9 Modifying the onOptionsItemSelected() Method
89.10 Testing the Application
89.11 Summary
90. Working with Material Design 3 Theming
90.1 Material Design 2 vs. Material Design 3
90.2 Understanding Material Design Theming
90.3 Material Design 3 Theming
90.4 Building a Custom Theme
90.5 Summary
91. A Material Design 3 Theming and Dynamic Color Tutorial
91.1 Creating the ThemeDemo Project
91.2 Designing the User Interface
91.3 Building a New Theme
91.4 Adding the Theme to the Project
91.5 Enabling Dynamic Color Support
91.6 Previewing Dynamic Colors
91.7 Summary
92. An Overview of Gradle in Android Studio
92.1 An Overview of Gradle
92.2 Gradle and Android Studio
92.2.1 Sensible Defaults
92.2.2 Dependencies
92.2.3 Build Variants
92.2.4 Manifest Entries
92.2.5 APK Signing
92.2.6 ProGuard Support
92.3 The Property and Settings Gradle Build File
92.4 The Top-level Gradle Build File
92.5 Module Level Gradle Build Files
92.6 Configuring Signing Settings in the Build File
92.7 Running Gradle Tasks from the Command Line
92.8 Summary
Index

System requirements

Save as PDF Copy link into clipboard

Schweitzer Fachinformationen

Android Studio Jellyfish Essentials - Java Edition

Description

More details

Other editions

Additional editions

Content

System requirements