35,99 €
Mehr erfahren.
- Herausgeber: Payload Media, Inc.
- Kategorie: Fachliteratur
- Sprache: Englisch
This book, fully updated for Android Studio Koala Feature Drop (2024.1.2), 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.
Das E-Book können Sie in Legimi-Apps oder einer beliebigen App lesen, die das folgende Format unterstützen:
Seitenzahl: 1002
Veröffentlichungsjahr: 2024
Ähnliche
Android Studio Koala
Essentials
Java Edition
Android Studio Koala Essentials – Java Edition
ISBN: 978-1-951442-96-5
© 2024 Neil Smyth / Payload Media, Inc. All Rights Reserved.
This book is provided for personal use only. Unauthorized use, reproduction and/or distribution strictly prohibited. All rights reserved.
The content of this book is provided for informational purposes only. Neither the publisher nor the author offers any warranties or representation, express or implied, with regard to the accuracy of information contained in this book, nor do they accept any liability for any loss or damage arising from any errors or omissions.
This book contains trademarked terms that are used solely for editorial purposes and to the benefit of the respective trademark owner. The terms used within this book are not intended as infringement of any trademarks.
Rev: 1.0
https://www.payloadbooks.com
Copyright
“
Table of Contents
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 Running the Emulator in a Separate Window
4.7 Removing the Device Frame
4.8 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 Common Android Settings
5.10 Creating a Resizable Emulator
5.11 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. Introducing Gemini in Android Studio
9.1 Introducing Gemini AI
9.2 Enabling Gemini in Android Studio
9.3 Gemini configuration
9.4 Asking Gemini questions
9.5 Question contexts
9.6 Inline code completion
9.7 Summary
10. An Overview of the Android Architecture
10.1 The Android Software Stack
10.2 The Linux Kernel
10.3 Hardware Abstraction Layer
10.4 Android Runtime – ART
10.5 Android Libraries
10.5.1 C/C++ Libraries
10.6 Application Framework
10.7 Applications
10.8 Summary
11. The Anatomy of an Android App
11.1 Android Activities
11.2 Android Fragments
11.3 Android Intents
11.4 Broadcast Intents
11.5 Broadcast Receivers
11.6 Android Services
11.7 Content Providers
11.8 The Application Manifest
11.9 Application Resources
11.10 Application Context
11.11 Summary
12. An Overview of Android View Binding
12.1 Find View by Id
12.2 View Binding
12.3 Converting the AndroidSample project
12.4 Enabling View Binding
12.5 Using View Binding
12.6 Choosing an Option
12.7 View Binding in the Book Examples
12.8 Migrating a Project to View Binding
12.9 Summary
13. Understanding Android Application and Activity Lifecycles
13.1 Android Applications and Resource Management
13.2 Android Process States
13.2.1 Foreground Process
13.2.2 Visible Process
13.2.3 Service Process
13.2.4 Background Process
13.2.5 Empty Process
13.3 Inter-Process Dependencies
13.4 The Activity Lifecycle
13.5 The Activity Stack
13.6 Activity States
13.7 Configuration Changes
13.8 Handling State Change
13.9 Summary
14. Handling Android Activity State Changes
14.1 New vs. Old Lifecycle Techniques
14.2 The Activity and Fragment Classes
14.3 Dynamic State vs. Persistent State
14.4 The Android Lifecycle Methods
14.5 Lifetimes
14.6 Foldable Devices and Multi-Resume
14.7 Disabling Configuration Change Restarts
14.8 Lifecycle Method Limitations
14.9 Summary
15. Android Activity State Changes by Example
15.1 Creating the State Change Example Project
15.2 Designing the User Interface
15.3 Overriding the Activity Lifecycle Methods
15.4 Filtering the Logcat Panel
15.5 Running the Application
15.6 Experimenting with the Activity
15.7 Summary
16. Saving and Restoring the State of an Android Activity
16.1 Saving Dynamic State
16.2 Default Saving of User Interface State
16.3 The Bundle Class
16.4 Saving the State
16.5 Restoring the State
16.6 Testing the Application
16.7 Summary
17. Understanding Android Views, View Groups and Layouts
17.1 Designing for Different Android Devices
17.2 Views and View Groups
17.3 Android Layout Managers
17.4 The View Hierarchy
17.5 Creating User Interfaces
17.6 Summary
18. A Guide to the Android Studio Layout Editor Tool
18.1 Basic vs. Empty Views Activity Templates
18.2 The Android Studio Layout Editor
18.3 Design Mode
18.4 The Palette
18.5 Design Mode and Layout Views
18.6 Night Mode
18.7 Code Mode
18.8 Split Mode
18.9 Setting Attributes
18.10 Transforms
18.11 Tools Visibility Toggles
18.12 Converting Views
18.13 Displaying Sample Data
18.14 Creating a Custom Device Definition
18.15 Changing the Current Device
18.16 Layout Validation
18.17 Summary
19. A Guide to the Android ConstraintLayout
19.1 How ConstraintLayout Works
19.1.1 Constraints
19.1.2 Margins
19.1.3 Opposing Constraints
19.1.4 Constraint Bias
19.1.5 Chains
19.1.6 Chain Styles
19.2 Baseline Alignment
19.3 Configuring Widget Dimensions
19.4 Guideline Helper
19.5 Group Helper
19.6 Barrier Helper
19.7 Flow Helper
19.8 Ratios
19.9 ConstraintLayout Advantages
19.10 ConstraintLayout Availability
19.11 Summary
20. A Guide to Using ConstraintLayout in Android Studio
20.1 Design and Layout Views
20.2 Autoconnect Mode
20.3 Inference Mode
20.4 Manipulating Constraints Manually
20.5 Adding Constraints in the Inspector
20.6 Viewing Constraints in the Attributes Window
20.7 Deleting Constraints
20.8 Adjusting Constraint Bias
20.9 Understanding ConstraintLayout Margins
20.10 The Importance of Opposing Constraints and Bias
20.11 Configuring Widget Dimensions
20.12 Design Time Tools Positioning
20.13 Adding Guidelines
20.14 Adding Barriers
20.15 Adding a Group
20.16 Working with the Flow Helper
20.17 Widget Group Alignment and Distribution
20.18 Converting other Layouts to ConstraintLayout
20.19 Summary
21. Working with ConstraintLayout Chains and Ratios in Android Studio
21.1 Creating a Chain
21.2 Changing the Chain Style
21.3 Spread Inside Chain Style
21.4 Packed Chain Style
21.5 Packed Chain Style with Bias
21.6 Weighted Chain
21.7 Working with Ratios
21.8 Summary
22. An Android Studio Layout Editor ConstraintLayout Tutorial
22.1 An Android Studio Layout Editor Tool Example
22.2 Preparing the Layout Editor Environment
22.3 Adding the Widgets to the User Interface
22.4 Adding the Constraints
22.5 Testing the Layout
22.6 Using the Layout Inspector
22.7 Summary
23. Manual XML Layout Design in Android Studio
23.1 Manually Creating an XML Layout
23.2 Manual XML vs. Visual Layout Design
23.3 Summary
24. Managing Constraints using Constraint Sets
24.1 Java Code vs. XML Layout Files
24.2 Creating Views
24.3 View Attributes
24.4 Constraint Sets
24.4.1 Establishing Connections
24.4.2 Applying Constraints to a Layout
24.4.3 Parent Constraint Connections
24.4.4 Sizing Constraints
24.4.5 Constraint Bias
24.4.6 Alignment Constraints
24.4.7 Copying and Applying Constraint Sets
24.4.8 ConstraintLayout Chains
24.4.9 Guidelines
24.4.10 Removing Constraints
24.4.11 Scaling
24.4.12 Rotation
24.5 Summary
25. An Android ConstraintSet Tutorial
25.1 Creating the Example Project in Android Studio
25.2 Adding Views to an Activity
25.3 Setting View Attributes
25.4 Creating View IDs
25.5 Configuring the Constraint Set
25.6 Adding the EditText View
25.7 Converting Density Independent Pixels (dp) to Pixels (px)
25.8 Summary
26. A Guide to Using Apply Changes in Android Studio
26.1 Introducing Apply Changes
26.2 Understanding Apply Changes Options
26.3 Using Apply Changes
26.4 Configuring Apply Changes Fallback Settings
26.5 An Apply Changes Tutorial
26.6 Using Apply Code Changes
26.7 Using Apply Changes and Restart Activity
26.8 Using Run App
26.9 Summary
27. A Guide to Gradle Version Catalogs
27.1 Library and Plugin Dependencies
27.2 Project Gradle Build File
27.3 Module Gradle Build Files
27.4 Version Catalog File
27.5 Adding Dependencies
27.6 Library Updates
27.7 Summary
28. An Overview and Example of Android Event Handling
28.1 Understanding Android Events
28.2 Using the android:onClick Resource
28.3 Event Listeners and Callback Methods
28.4 An Event Handling Example
28.5 Designing the User Interface
28.6 The Event Listener and Callback Method
28.7 Consuming Events
28.8 Summary
29. Android Touch and Multi-touch Event Handling
29.1 Intercepting Touch Events
29.2 The MotionEvent Object
29.3 Understanding Touch Actions
29.4 Handling Multiple Touches
29.5 An Example Multi-Touch Application
29.6 Designing the Activity User Interface
29.7 Implementing the Touch Event Listener
29.8 Running the Example Application
29.9 Summary
30. Detecting Common Gestures Using the Android Gesture Detector Class
30.1 Implementing Common Gesture Detection
30.2 Creating an Example Gesture Detection Project
30.3 Implementing the Listener Class
30.4 Creating the GestureDetector Instance
30.5 Implementing the onTouchEvent() Method
30.6 Testing the Application
30.7 Summary
31. Implementing Custom Gesture and Pinch Recognition on Android
31.1 The Android Gesture Builder Application
31.2 The GestureOverlayView Class
31.3 Detecting Gestures
31.4 Identifying Specific Gestures
31.5 Installing and Running the Gesture Builder Application
31.6 Creating a Gestures File
31.7 Creating the Example Project
31.8 Extracting the Gestures File from the SD Card
31.9 Adding the Gestures File to the Project
31.10 Designing the User Interface
31.11 Loading the Gestures File
31.12 Registering the Event Listener
31.13 Implementing the onGesturePerformed Method
31.14 Testing the Application
31.15 Configuring the GestureOverlayView
31.16 Intercepting Gestures
31.17 Detecting Pinch Gestures
31.18 A Pinch Gesture Example Project
31.19 Summary
32. An Introduction to Android Fragments
32.1 What is a Fragment?
32.2 Creating a Fragment
32.3 Adding a Fragment to an Activity using the Layout XML File
32.4 Adding and Managing Fragments in Code
32.5 Handling Fragment Events
32.6 Implementing Fragment Communication
32.7 Summary
33. Using Fragments in Android Studio - An Example
33.1 About the Example Fragment Application
33.2 Creating the Example Project
33.3 Creating the First Fragment Layout
33.4 Migrating a Fragment to View Binding
33.5 Adding the Second Fragment
33.6 Adding the Fragments to the Activity
33.7 Making the Toolbar Fragment Talk to the Activity
33.8 Making the Activity Talk to the Text Fragment
33.9 Testing the Application
33.10 Summary
34. Modern Android App Architecture with Jetpack
34.1 What is Android Jetpack?
34.2 The “Old” Architecture
34.3 Modern Android Architecture
34.4 The ViewModel Component
34.5 The LiveData Component
34.6 ViewModel Saved State
34.7 LiveData and Data Binding
34.8 Android Lifecycles
34.9 Repository Modules
34.10 Summary
35. An Android ViewModel Tutorial
35.1 About the Project
35.2 Creating the ViewModel Example Project
35.3 Removing Unwanted Project Elements
35.4 Designing the Fragment Layout
35.5 Implementing the View Model
35.6 Associating the Fragment with the View Model
35.7 Modifying the Fragment
35.8 Accessing the ViewModel Data
35.9 Testing the Project
35.10 Summary
36. An Android Jetpack LiveData Tutorial
36.1 LiveData - A Recap
36.2 Adding LiveData to the ViewModel
36.3 Implementing the Observer
36.4 Summary
37. An Overview of Android Jetpack Data Binding
37.1 An Overview of Data Binding
37.2 The Key Components of Data Binding
37.2.1 The Project Build Configuration
37.2.2 The Data Binding Layout File
37.2.3 The Layout File Data Element
37.2.4 The Binding Classes
37.2.5 Data Binding Variable Configuration
37.2.6 Binding Expressions (One-Way)
37.2.7 Binding Expressions (Two-Way)
37.2.8 Event and Listener Bindings
37.3 Summary
38. An Android Jetpack Data Binding Tutorial
38.1 Removing the Redundant Code
38.2 Enabling Data Binding
38.3 Adding the Layout Element
38.4 Adding the Data Element to Layout File
38.5 Working with the Binding Class
38.6 Assigning the ViewModel Instance to the Data Binding Variable
38.7 Adding Binding Expressions
38.8 Adding the Conversion Method
38.9 Adding a Listener Binding
38.10 Testing the App
38.11 Summary
39. An Android ViewModel Saved State Tutorial
39.1 Understanding ViewModel State Saving
39.2 Implementing ViewModel State Saving
39.3 Saving and Restoring State
39.4 Adding Saved State Support to the ViewModelDemo Project
39.5 Summary
40. Working with Android Lifecycle-Aware Components
40.1 Lifecycle Awareness
40.2 Lifecycle Owners
40.3 Lifecycle Observers
40.4 Lifecycle States and Events
40.5 Summary
41. An Android Jetpack Lifecycle Awareness Tutorial
41.1 Creating the Example Lifecycle Project
41.2 Creating a Lifecycle Observer
41.3 Adding the Observer
41.4 Testing the Observer
41.5 Creating a Lifecycle Owner
41.6 Testing the Custom Lifecycle Owner
41.7 Summary
42. An Overview of the Navigation Architecture Component
42.1 Understanding Navigation
42.2 Declaring a Navigation Host
42.3 The Navigation Graph
42.4 Accessing the Navigation Controller
42.5 Triggering a Navigation Action
42.6 Passing Arguments
42.7 Summary
43. An Android Jetpack Navigation Component Tutorial
43.1 Creating the NavigationDemo Project
43.2 Adding Navigation to the Build Configuration
43.3 Creating the Navigation Graph Resource File
43.4 Declaring a Navigation Host
43.5 Adding Navigation Destinations
43.6 Designing the Destination Fragment Layouts
43.7 Adding an Action to the Navigation Graph
43.8 Implement the OnFragmentInteractionListener
43.9 Adding View Binding Support to the Destination Fragments
43.10 Triggering the Action
43.11 Passing Data Using Safeargs
43.12 Summary
44. An Introduction to MotionLayout
44.1 An Overview of MotionLayout
44.2 MotionLayout
44.3 MotionScene
44.4 Configuring ConstraintSets
44.5 Custom Attributes
44.6 Triggering an Animation
44.7 Arc Motion
44.8 Keyframes
44.8.1 Attribute Keyframes
44.8.2 Position Keyframes
44.9 Time Linearity
44.10 KeyTrigger
44.11 Cycle and Time Cycle Keyframes
44.12 Starting an Animation from Code
44.13 Summary
45. An Android MotionLayout Editor Tutorial
45.1 Creating the MotionLayoutDemo Project
45.2 ConstraintLayout to MotionLayout Conversion
45.3 Configuring Start and End Constraints
45.4 Previewing the MotionLayout Animation
45.5 Adding an OnClick Gesture
45.6 Adding an Attribute Keyframe to the Transition
45.7 Adding a CustomAttribute to a Transition
45.8 Adding Position Keyframes
45.9 Summary
46. A MotionLayout KeyCycle Tutorial
46.1 An Overview of Cycle Keyframes
46.2 Using the Cycle Editor
46.3 Creating the KeyCycleDemo Project
46.4 Configuring the Start and End Constraints
46.5 Creating the Cycles
46.6 Previewing the Animation
46.7 Adding the KeyFrameSet to the MotionScene
46.8 Summary
47. Working with the Floating Action Button and Snackbar
47.1 The Material Design
47.2 The Design Library
47.3 The Floating Action Button (FAB)
47.4 The Snackbar
47.5 Creating the Example Project
47.6 Reviewing the Project
47.7 Removing Navigation Features
47.8 Changing the Floating Action Button
47.9 Adding an Action to the Snackbar
47.10 Summary
48. Creating a Tabbed Interface using the TabLayout Component
48.1 An Introduction to the ViewPager2
48.2 An Overview of the TabLayout Component
48.3 Creating the TabLayoutDemo Project
48.4 Creating the First Fragment
48.5 Duplicating the Fragments
48.6 Adding the TabLayout and ViewPager2
48.7 Creating the Pager Adapter
48.8 Performing the Initialization Tasks
48.9 Testing the Application
48.10 Customizing the TabLayout
48.11 Summary
49. Working with the RecyclerView and CardView Widgets
49.1 An Overview of the RecyclerView
49.2 An Overview of the CardView
49.3 Summary
50. An Android RecyclerView and CardView Tutorial
50.1 Creating the CardDemo Project
50.2 Modifying the Basic Views Activity Project
50.3 Designing the CardView Layout
50.4 Adding the RecyclerView
50.5 Adding the Image Files
50.6 Creating the RecyclerView Adapter
50.7 Initializing the RecyclerView Component
50.8 Testing the Application
50.9 Responding to Card Selections
50.10 Summary
51. A Layout Editor Sample Data Tutorial
51.1 Adding Sample Data to a Project
51.2 Using Custom Sample Data
51.3 Summary
52. Working with the AppBar and Collapsing Toolbar Layouts
52.1 The Anatomy of an AppBar
52.2 The Example Project
52.3 Coordinating the RecyclerView and Toolbar
52.4 Introducing the Collapsing Toolbar Layout
52.5 Changing the Title and Scrim Color
52.6 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. Creating, Testing, and Uploading an Android App Bundle
73.1 The Release Preparation Process
73.2 Android App Bundles
73.3 Register for a Google Play Developer Console Account
73.4 Configuring the App in the Console
73.5 Enabling Google Play App Signing
73.6 Creating a Keystore File
73.7 Creating the Android App Bundle
73.8 Generating Test APK Files
73.9 Uploading the App Bundle to the Google Play Developer Console
73.10 Exploring the App Bundle
73.11 Managing Testers
73.12 Rolling the App Out for Testing
73.13 Uploading New App Bundle Revisions
73.14 Analyzing the App Bundle File
73.15 Summary
74. An Overview of Android In-App Billing
74.1 Preparing a Project for In-App Purchasing
74.2 Creating In-App Products and Subscriptions
74.3 Billing Client Initialization
74.4 Connecting to the Google Play Billing Library
74.5 Querying Available Products
74.6 Starting the Purchase Process
74.7 Completing the Purchase
74.8 Querying Previous Purchases
74.9 Summary
75. An Android In-App Purchasing Tutorial
75.1 About the In-App Purchasing Example Project
75.2 Creating the InAppPurchase Project
75.3 Adding Libraries to the Project
75.4 Designing the User Interface
75.5 Adding the App to the Google Play Store
75.6 Creating an In-App Product
75.7 Enabling License Testers
75.8 Initializing the Billing Client
75.9 Querying the Product
75.10 Launching the Purchase Flow
75.11 Handling Purchase Updates
75.12 Consuming the Product
75.13 Restoring a Previous Purchase
75.14 Testing the App
75.15 Troubleshooting
75.16 Summary
76. Creating and Managing Overflow Menus on Android
76.1 The Overflow Menu
76.2 Creating an Overflow Menu
76.3 Displaying an Overflow Menu
76.4 Responding to Menu Item Selections
76.5 Creating Checkable Item Groups
76.6 Menus and the Android Studio Menu Editor
76.7 Creating the Example Project
76.8 Designing the Menu
76.9 Modifying the onOptionsItemSelected() Method
76.10 Testing the Application
76.11 Summary
77. An Android Studio Primary/Detail Flow Tutorial
77.1 The Primary/Detail Flow
77.2 Creating a Primary/Detail Flow Activity
77.3 Adding the Primary/Detail Flow Activity
77.4 Modifying the Primary/Detail Flow Template
77.5 Changing the Content Model
77.6 Changing the Detail Pane
77.7 Modifying the ItemDetailFragment Class
77.8 Modifying the ItemListFragment Class
77.9 Adding Manifest Permissions
77.10 Running the Application
77.11 Summary
78. An Android Biometric Authentication Tutorial
78.1 An Overview of Biometric Authentication
78.2 Creating the Biometric Authentication Project
78.3 Configuring Device Fingerprint Authentication
78.4 Adding the Biometric Permission to the Manifest File
78.5 Designing the User Interface
78.6 Adding a Toast Convenience Method
78.7 Checking the Security Settings
78.8 Configuring the Authentication Callbacks
78.9 Adding the CancellationSignal
78.10 Starting the Biometric Prompt
78.11 Testing the Project
78.12 Summary
79. Accessing Cloud Storage using the Android Storage Access Framework
79.1 The Storage Access Framework
79.2 Working with the Storage Access Framework
79.3 Filtering Picker File Listings
79.4 Handling Intent Results
79.5 Reading the Content of a File
79.6 Writing Content to a File
79.7 Deleting a File
79.8 Gaining Persistent Access to a File
79.9 Summary
80. An Android Storage Access Framework Example
80.1 About the Storage Access Framework Example
80.2 Creating the Storage Access Framework Example
80.3 Designing the User Interface
80.4 Adding the Activity Launchers
80.5 Creating a New Storage File
80.6 Saving to a Storage File
80.7 Opening and Reading a Storage File
80.8 Testing the Storage Access Application
80.9 Summary
81. Video Playback on Android using the VideoView and MediaController Classes
81.1 Introducing the Android VideoView Class
81.2 Introducing the Android MediaController Class
81.3 Creating the Video Playback Example
81.4 Designing the VideoPlayer Layout
81.5 Downloading the Video File
81.6 Configuring the VideoView
81.7 Adding the MediaController to the Video View
81.8 Setting up the onPreparedListener
81.9 Summary
82. Android Picture-in-Picture Mode
82.1 Picture-in-Picture Features
82.2 Enabling Picture-in-Picture Mode
82.3 Configuring Picture-in-Picture Parameters
82.4 Entering Picture-in-Picture Mode
82.5 Detecting Picture-in-Picture Mode Changes
82.6 Adding Picture-in-Picture Actions
82.7 Summary
83. An Android Picture-in-Picture Tutorial
83.1 Adding Picture-in-Picture Support to the Manifest
83.2 Adding a Picture-in-Picture Button
83.3 Entering Picture-in-Picture Mode
83.4 Detecting Picture-in-Picture Mode Changes
83.5 Adding a Broadcast Receiver
83.6 Adding the PiP Action
83.7 Testing the Picture-in-Picture Action
83.8 Summary
84. Android Audio Recording and Playback using MediaPlayer and MediaRecorder
84.1 Playing Audio
84.2 Recording Audio and Video using the MediaRecorder Class
84.3 About the Example Project
84.4 Creating the AudioApp Project
84.5 Designing the User Interface
84.6 Checking for Microphone Availability
84.7 Initializing the Activity
84.8 Implementing the recordAudio() Method
84.9 Implementing the stopAudio() Method
84.10 Implementing the playAudio() method
84.11 Configuring and Requesting Permissions
84.12 Testing the Application
84.13 Summary
85. Working with the Google Maps Android API in Android Studio
85.1 The Elements of the Google Maps Android API
85.2 Creating the Google Maps Project
85.3 Creating a Google Cloud Billing Account
85.4 Creating a New Google Cloud Project
85.5 Enabling the Google Maps SDK
85.6 Generating a Google Maps API Key
85.7 Adding the API Key to the Android Studio Project
85.8 Testing the Application
85.9 Understanding Geocoding and Reverse Geocoding
85.10 Adding a Map to an Application
85.11 Requesting Current Location Permission
85.12 Displaying the User’s Current Location
85.13 Changing the Map Type
85.14 Displaying Map Controls to the User
85.15 Handling Map Gesture Interaction
85.15.1 Map Zooming Gestures
85.15.2 Map Scrolling/Panning Gestures
85.15.3 Map Tilt Gestures
85.15.4 Map Rotation Gestures
85.16 Creating Map Markers
85.17 Controlling the Map Camera
85.18 Summary
86. Printing with the Android Printing Framework
86.1 The Android Printing Architecture
86.2 The Print Service Plugins
86.3 Google Cloud Print
86.4 Printing to Google Drive
86.5 Save as PDF
86.6 Printing from Android Devices
86.7 Options for Building Print Support into Android Apps
86.7.1 Image Printing
86.7.2 Creating and Printing HTML Content
86.7.3 Printing a Web Page
86.7.4 Printing a Custom Document
86.8 Summary
87. An Android HTML and Web Content Printing Example
87.1 Creating the HTML Printing Example Application
87.2 Printing Dynamic HTML Content
87.3 Creating the Web Page Printing Example
87.4 Removing the Floating Action Button
87.5 Removing Navigation Features
87.6 Designing the User Interface Layout
87.7 Accessing the WebView from the Main Activity
87.8 Loading the Web Page into the WebView
87.9 Adding the Print Menu Option
87.10 Summary
88. A Guide to Android Custom Document Printing
88.1 An Overview of Android Custom Document Printing
88.1.1 Custom Print Adapters
88.2 Preparing the Custom Document Printing Project
88.3 Designing the UI
88.4 Creating the Custom Print Adapter
88.5 Implementing the onLayout() Callback Method
88.6 Implementing the onWrite() Callback Method
88.7 Checking a Page is in Range
88.8 Drawing the Content on the Page Canvas
88.9 Starting the Print Job
88.10 Testing the Application
88.11 Summary
89. An Introduction to Android App Links
89.1 An Overview of Android App Links
89.2 App Link Intent Filters
89.3 Handling App Link Intents
89.4 Associating the App with a Website
89.5 Summary
90. An Android Studio App Links Tutorial
90.1 About the Example App
90.2 The Database Schema
90.3 Loading and Running the Project
90.4 Adding the URL Mapping
90.5 Adding the Intent Filter
90.6 Adding Intent Handling Code
90.7 Testing the App
90.8 Creating the Digital Asset Links File
90.9 Testing the App Link
90.10 Summary
91. Working with Material Design 3 Theming
91.1 Material Design 2 vs. Material Design 3
91.2 Understanding Material Design Theming
91.3 Material Design 3 Theming
91.4 Building a custom theme
91.5 Summary
92. A Material Design 3 Theming and Dynamic Color Tutorial
92.1 Creating the ThemeDemo Project
92.2 Designing the User Interface
92.3 Building a new theme
92.4 Adding the Theme to the Project
92.5 Enabling Dynamic Color Support
92.6 Summary
93. An Overview of Gradle in Android Studio
93.1 An Overview of Gradle
93.2 Gradle and Android Studio
93.2.1 Sensible Defaults
93.2.2 Dependencies
93.2.3 Build Variants
93.2.4 Manifest Entries
93.2.5 APK Signing
93.2.6 ProGuard Support
93.3 The Property and Settings Gradle Build File
93.4 The Top-level Gradle Build File
93.5 Module Level Gradle Build Files
93.6 Configuring Signing Settings in the Build File
93.7 Running Gradle Tasks from the Command Line
93.8 Summary
Index
1. Introduction
This book, fully updated for Android Studio Koala Feature Drop (2024.1.2) 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.
1.1 Downloading the Code Samples
The source code and Android Studio project files for the examples contained in this book are available for download at:
https://www.payloadbooks.com/product/koalajava
The steps to load a project from the code samples into Android Studio are as follows:
1. From the Welcome to Android Studio dialog, click on the Open button option.
2. In the project selection dialog, navigate to and select the folder containing the project to be imported and click on OK.
1.2 Feedback
We want you to be satisfied with your purchase of this book. If you find any errors in the book, or have any comments, questions or concerns please contact us at [email protected].
1.3 Errata
While we make every effort to ensure the accuracy of the content of this book, it is inevitable that a book covering a subject area of this size and complexity may include some errors and oversights. Any known issues with the book will be outlined, together with solutions, at the following URL:
https://www.payloadbooks.com/koalajava
If you find an error not listed in the errata, please let us know by emailing our technical support team at [email protected]. They are there to help you and will work to resolve any problems you may encounter.
2. Setting up an Android Studio Development Environment
Before any work can begin on developing an Android application, the first step is to configure a computer system to act as the development platform. This involves several steps consisting of installing the Android Studio Integrated Development Environment (IDE), including the Android Software Development Kit (SDK) and the OpenJDK Java development environment.
This chapter will cover the steps necessary to install the requisite components for Android application development on Windows, macOS, and Linux-based systems.
2.1 System requirements
Android application development may be performed on any of the following system types:
•Windows 8/10/11 64-bit
•macOS 10.14 or later running on Intel or Apple silicon
•Chrome OS device with Intel i5 or higher
•Linux systems with version 2.31 or later of the GNU C Library (glibc)
•Minimum of 8GB of RAM
•Approximately 8GB of available disk space
•1280 x 800 minimum screen resolution
2.2 Downloading the Android Studio package
Most of the work involved in developing applications for Android will be performed using the Android Studio environment. The content and examples in this book were created based on Android Studio Koala Feature Drop 2024.1.2 using the Android API 35 SDK (Vanilla Ice Cream), which, at the time of writing, are the latest stable releases.
Android Studio is, however, subject to frequent updates, so a newer version may have been released since this book was published.
The latest release of Android Studio may be downloaded from the primary download page, which can be found at the following URL:
https://developer.android.com/studio/index.html
If this page provides instructions for downloading a newer version of Android Studio, there may be differences between this book and the software. A web search for “Android Studio Koala Feature Drop” should provide the option to download the older version if these differences become a problem. Alternatively, visit the following web page to find Android Studio Koala Feature Drop in the archives:
https://developer.android.com/studio/archive
2.3 Installing Android Studio
Once downloaded, the exact steps to install Android Studio differ depending on the operating system on which the installation is performed.
2.3.1 Installation on Windows
Locate the downloaded Android Studio installation executable file (named android-studio-<version>-windows.exe) in a Windows Explorer window and double-click on it to start the installation process, clicking the Yes button in the User Account Control dialog if it appears.
Once the Android Studio setup wizard appears, work through the various screens to configure the installation to meet your requirements in terms of the file system location into which Android Studio should be installed. When prompted to select the components to install, ensure that the Android Studio and Android Virtual Device options are both selected.
Although there are no strict rules on where Android Studio should be installed on the system, the remainder of this book will assume that the installation was performed into C:\Program Files\Android\Android Studio and that the Android SDK packages have been installed into the user’s AppData\Local\Android\sdk sub-folder. Once the options have been configured, click the Install button to complete the installation process.
2.3.2 Installation on macOS
Android Studio for macOS is downloaded as a disk image (.dmg) file. Once the android-studio-<version>-mac.dmg file has been downloaded, locate it in a Finder window and double-click on it to open it, as shown in Figure 2-1:
Figure 2-1
To install the package, drag the Android Studio icon and drop it onto the Applications folder. The Android Studio package will then be installed into the Applications folder of the system, a process that will typically take a few seconds to complete.
To launch Android Studio, locate the executable in the Applications folder using a Finder window and double-click on it.
For future, easier access to the tool, drag the Android Studio icon from the Finder window and drop it onto the dock.
2.3.3 Installation on Linux
Having downloaded the Linux Android Studio package, open a terminal window, change directory to the location where Android Studio is to be installed, and execute the following command:
tar xvfz /<path to package>/android-studio-<version>-linux.tar.gz
Note that the Android Studio bundle will be installed into a subdirectory named android-studio. Therefore, assuming that the above command was executed in /home/demo, the software packages will be unpacked into /home/demo/android-studio.
To launch Android Studio, open a terminal window, change directory to the android-studio/bin sub-directory, and execute the following command:
./studio.sh
2.4 Installing additional Android SDK packages
When you launch Android Studio, the Welcome to Android Studio screen will appear as shown below:
Figure 2-2
The steps performed so far have installed the Android Studio IDE and the current set of default Android SDK packages. Before proceeding, it is worth taking some time to verify which packages are installed and to install any missing or updated packages.
This task can be performed by clicking on the More Actions link within the welcome dialog and selecting the SDK Manager option from the drop-down menu.Once invoked, the Android SDK screen of the Settings dialog will appear as shown in Figure 2-3:
Figure 2-3
Google pairs each release of Android Studio with a maximum supported Application Programming Interface (API) level of the Android SDK. In the case of Android Studio Koala Feature Drop, this is Android Vanilla Ice Cream (API Level 35). This information can be confirmed using the following link:
https://developer.android.com/studio/releases#api-level-support
Immediately after installing Android Studio for the first time, it is likely that only the latest supported version of the Android SDK has been installed. To install older versions of the Android SDK, select the checkboxes corresponding to the versions and click the Apply button. The rest of this book assumes that the Android Vanilla Ice Cream (API Level 35) SDK is installed.
Most of the examples in this book will support older versions of Android as far back as Android 8.0 (Oreo). This ensures that the apps run on a wide range of Android devices. Within the list of SDK versions, enable the checkbox next to Android 8.0 (Oreo) and click the Apply button. Click the OK button to install the SDK in the resulting confirmation dialog. Subsequent dialogs will seek the acceptance of licenses and terms before performing the installation. Click Finish once the installation is complete.
It is also possible that updates will be listed as being available for the latest SDK. To access detailed information about the packages that are ready to be updated, enable the Show Package Details option located in the lower right-hand corner of the screen. This will display information similar to that shown in Figure 2-4:
Figure 2-4
The above figure highlights the availability of an update. To install the updates, enable the checkbox to the left of the item name and click the Apply button.
In addition to the Android SDK packages, several tools are also installed for building Android applications. To view the currently installed packages and check for updates, remain within the SDK settings screen and select the SDK Tools tab as shown in Figure 2-5:
Figure 2-5
Within the Android SDK Tools screen, make sure that the following packages are listed as Installed in the Status column:
•Android SDK Build-tools
•Android Emulator
•Android SDK Platform-tools
•Google Play Services
•Intel x86 Emulator Accelerator (HAXM installer)*
•Google USB Driver (Windows only)
•Layout Inspector image server for API 31-35
*Note that the Intel x86 Emulator Accelerator (HAXM installer) requires an Intel processor with VT-x support enabled. It cannot be installed on Apple silicon-based Macs or AMD-based PCs.
If any of the above packages are listed as Not Installed or requiring an update, select the checkboxes next to those packages and click the Apply button to initiate the installation process. If the HAXM emulator settings dialog appears, select the recommended memory allocation:
Figure 2-6
Once the installation is complete, review the package list and ensure that the selected packages are listed as Installed in the Status column. If any are listed as Not installed, make sure they are selected and click the Apply button again.
2.5 Installing the Android SDK Command-line Tools
Android Studio includes tools that allow some tasks to be performed from your operating system command line. To install these tools on your system, open the SDK Manager, select the SDK Tools tab, and locate the Android SDK Command-line Tools (latest) package as shown in Figure 2-7:
Figure 2-7
If the command-line tools package is not already installed, enable it and click Apply, followed by OK to complete the installation. When the installation completes, click Finish and close the SDK Manager dialog.
For the operating system on which you are developing to be able to find these tools, it will be necessary to add them to the system’s PATH environment variable.
Regardless of your operating system, you will need to configure the PATH environment variable to include the following paths (where <path_to_android_sdk_installation> represents the file system location into which you installed the Android SDK):
<path_to_android_sdk_installation>/sdk/cmdline-tools/latest/bin
<path_to_android_sdk_installation>/sdk/platform-tools
You can identify the location of the SDK on your system by launching the SDK Manager and referring to the Android SDK Location: field located at the top of the settings panel, as highlighted in Figure 2-8:
Figure 2-8
Once the location of the SDK has been identified, the steps to add this to the PATH variable are operating system dependent:
2.5.1 Windows 8.1
1. On the start screen, move the mouse to the bottom right-hand corner of the screen and select Search from the resulting menu. In the search box, enter Control Panel. When the Control Panel icon appears in the results area, click on it to launch the tool on the desktop.
2. Within the Control Panel, use the Category menu to change the display to Large Icons. From the list of icons, select the one labeled System.
3. In the Environment Variables dialog, locate the Path variable in the System variables list, select it, and click the Edit… button. Using the New button in the edit dialog, add two new entries to the path. For example, assuming the Android SDK was installed into C:\Users\demo\AppData\Local\Android\Sdk, the following entries would need to be added:
C:\Users\demo\AppData\Local\Android\Sdk\cmdline-tools\latest\bin
C:\Users\demo\AppData\Local\Android\Sdk\platform-tools
4. Click OK in each dialog box and close the system properties control panel.
Open a command prompt window by pressing Windows + R on the keyboard and entering cmd into the Run dialog. Within the Command Prompt window, enter:
echo %Path%
The returned path variable value should include the paths to the Android SDK platform tools folders. Verify that the platform-tools value is correct by attempting to run the adb tool as follows:
adb
The tool should output a list of command-line options when executed.
Similarly, check the tools path setting by attempting to run the AVD Manager command-line tool (don’t worry if the avdmanager tool reports a problem with Java - this will be addressed later):
avdmanager
If a message similar to the following message appears for one or both of the commands, it is most likely that an incorrect path was appended to the Path environment variable:
'adb' is not recognized as an internal or external command,
operable program or batch file.
2.5.2 Windows 10
Right-click on the Start menu, select Settings from the resulting menu and enter “Edit the system environment variables” into the Find a setting text field. In the System Properties dialog, click the Environment Variables... button. Follow the steps outlined for Windows 8.1 starting from step 3.
2.5.3 Windows 11
Right-click on the Start icon located in the taskbar and select Settings from the resulting menu. When the Settings dialog appears, scroll down the list of categories and select the “About” option. In the About screen, select Advanced system settings from the Related links section. When the System Properties window appears, click the Environment Variables... button. Follow the steps outlined for Windows 8.1 starting from step 3.
2.5.4 Linux
This configuration can be achieved on Linux by adding a command to the .bashrc file in your home directory (specifics may differ depending on the particular Linux distribution in use). Assuming that the Android SDK bundle package was installed into /home/demo/Android/sdk, the export line in the .bashrc file would read as follows:
export PATH=/home/demo/Android/sdk/platform-tools:/home/demo/Android/sdk/cmdline-tools/latest/bin:/home/demo/android-studio/bin:$PATH
Note also that the above command adds the android-studio/bin directory to the PATH variable. This will enable the studio.sh script to be executed regardless of the current directory within a terminal window.
2.5.5 macOS
Several techniques may be employed to modify the $PATH environment variable on macOS. Arguably the cleanest method is to add a new file in the /etc/paths.d directory containing the paths to be added to $PATH. Assuming an Android SDK installation location of /Users/demo/Library/Android/sdk, the path may be configured by creating a new file named android-sdk in the /etc/paths.d directory containing the following lines:
/Users/demo/Library/Android/sdk/cmdline-tools/latest/bin
/Users/demo/Library/Android/sdk/platform-tools
Note that since this is a system directory, it will be necessary to use the sudo command when creating the file. For example:
sudo vi /etc/paths.d/android-sdk
2.6 Android Studio memory management
Android Studio is a large and complex software application with many background processes. Although Android Studio has been criticized in the past for providing less than optimal performance, Google has made significant performance improvements in recent releases and continues to do so with each new version. These improvements include allowing the user to configure the amount of memory used by both the Android Studio IDE and the background processes used to build and run apps. This allows the software to take advantage of systems with larger amounts of RAM.
If you are running Android Studio on a system with sufficient unused RAM to increase these values (this feature is only available on 64-bit systems with 5GB or more of RAM) and find that Android Studio performance appears to be degraded, it may be worth experimenting with these memory settings. Android Studio may also notify you that performance can be increased via a dialog similar to the one shown below:
Figure 2-9
To view and modify the current memory configuration, select the File -> Settings... main menu option (Android Studio -> Settings... on macOS) and, in the resulting dialog, select Appearance & Behavior followed by the Memory Settings option listed under System Settings in the left-hand navigation panel, as illustrated in Figure 2-10 below:
Figure 2-10
When changing the memory allocation, be sure not to allocate more memory than necessary or than your system can spare without slowing down other processes.
The IDE heap size setting adjusts the memory allocated to Android Studio and applies regardless of the currently loaded project. On the other hand, when a project is built and run from within Android Studio, several background processes (referred to as daemons) perform the task of compiling and running the app. When compiling and running large and complex projects, build time could be improved by adjusting thedaemon heap settings. Unlike the IDE heap settings, these daemon settings apply only to the current project and can only be accessed when a project is open in Android Studio. To display the SDK Manager from within an open project, select the Tools -> SDK Manager... menu option from the main menu.
2.7 Updating Android Studio and the SDK
From time to time, new versions of Android Studio and the Android SDK are released. New versions of the SDK are installed using the Android SDK Manager. Android Studio will typically notify you when an update is ready to be installed.
To manually check for Android Studio updates, use the Help -> Check for Updates... menu option from the Android Studio main window (Android Studio -> Check for Updates... on macOS).
2.8 Summary
Before beginning the development of Android-based applications, the first step is to set up a suitable development environment. This consists of the Android SDKs and Android Studio IDE (which also includes the OpenJDK development environment). This chapter covers the steps necessary to install these packages on Windows, macOS, and Linux.
3. Creating an Example Android App in Android Studio
The preceding chapters of this book have explained how to configure an environment suitable for developing Android applications using the Android Studio IDE. Before moving on to slightly more advanced topics, now is a good time to validate that all required development packages are installed and functioning correctly. The best way to achieve this goal is to create an Android application and compile and run it. This chapter will cover creating an Android application project using Android Studio. Once the project has been created, a later chapter will explore using the Android emulator environment to perform a test run of the application.
3.1 About the Project
The project created in this chapter takes the form of a rudimentary currency conversion calculator (so simple, in fact, that it only converts from dollars to euros and does so using an estimated conversion rate). The project will also use one of the most basic Android Studio project templates. This simplicity allows us to introduce some key aspects of Android app development without overwhelming the beginner by introducing too many concepts, such as the recommended app architecture and Android architecture components, at once. When following the tutorial in this chapter, rest assured that the techniques and code used in this initial example project will be covered in much greater detail later.
3.2 Creating a New Android Project
The first step in the application development process is to create a new project within the Android Studio environment. Begin, therefore, by launching Android Studio so that the “Welcome to Android Studio” screen appears as illustrated in Figure 3-1:
Figure 3-1
Once this window appears, Android Studio is ready for a new project to be created. To create the new project, click on the New Project option to display the first screen of the New Project wizard.
3.3 Creating an Activity
The next step is to define the type of initial activity to be created for the application. Options are available to create projects for Phone and Tablet, Wear OS, Television, or Automotive. A range of different activity types is available when developing Android applications, many of which will be covered extensively in later chapters. For this example, however, select the Phone and Tablet option from the Templates panel, followed by the option to create an Empty Views Activity. The Empty Views Activity option creates a template user interface consisting of a single TextView object.
Figure 3-2
With the Empty Views Activity option selected, click Next to continue with the project configuration.
3.4 Defining the Project and SDK Settings
In the project configuration window (Figure 3-3), set the Name field to AndroidSample. The application name is the name by which the application will be referenced and identified within Android Studio and is also the name that would be used if the completed application were to go on sale in the Google Play store.
The Package nameuniquely identifies the application within the Android application ecosystem. Although this can be set to any string that uniquely identifies your app, it is traditionally based on the reversed URL of your domain name followed by the application’s name. For example, if your domain is www.mycompany.com, and the application has been named AndroidSample, then the package name might be specified as follows:
com.mycompany.androidsample
If you do not have a domain name, you can enter any other string into the Company Domain field, or you may use example.com for testing, though this will need to be changed before an application can be published:
com.example.androidsample
The Save location setting will default to a location in the folder named AndroidStudioProjects located in your home directory and may be changed by clicking on the folder icon to the right of the text field containing the current path setting.
Set the minimum SDK setting to API 26 (Oreo; Android 8.0). This minimum SDK will be used in most projects created in this book unless a necessary feature is only available in a more recent version. The objective here is to build an app using the latest Android SDK while retaining compatibility with devices running older versions of Android (in this case, as far back as Android 8.0). The text beneath the Minimum SDK setting will outline the percentage of Android devices currently in use on which the app will run. Click on the Help me choose button (highlighted in Figure 3-3) to see a full breakdown of the various Android versions still in use:
Figure 3-3
Finally, change the Language menu to Javaand select Kotlin DSL (build.gradle.kts) as the build configuration language before clicking Finish to create the project.
3.5 Modifying the Example Application
Once the project has been created, the main window will appear containing our AndroidSample project, as illustrated in Figure 3-4 below:
Figure 3-4
The newly created project and references to associated files are listed in the Project tool windowon the left side of the main project window. The Project tool window has several modes in which information can be displayed. By default, this panel should be in Android mode. This setting is controlled by the menu at the top of the panel as highlighted in Figure 3-5. If the panel is not currently in Android mode, use the menu to switch mode:
Figure 3-5
3.6 Modifying the User Interface
The user interface design for our activity is stored in a file named activity_main.xml which, in turn, is located under app -> res -> layout in the Project tool window file hierarchy. Once located in the Project tool window, double-click on thefile to load it into the user interface Layout Editor tool, which will appear in the center panel of the Android Studio main window:
Figure 3-6
In the toolbar across the top of the Layout Editor window is a menu (currently set to Pixel in the above figure) which is reflected in the visual representation of the device within the Layout Editor panel. A range of other device options are available by clicking on this menu.
Use the System UI Mode button () to turn Night mode on and off for the device screen layout. To change the orientation of the device representation between landscape and portrait, use the drop-down menu showing the icon.
As we can see in the device screen, the content layout already includes a label that displays a “Hello World!” message. Running down the left-hand side of the panel is a palette containing different categories of user interface components that may be used to construct a user interface, such as buttons, labels, and text fields. However, it should be noted that not all user interface components are visible to the user. One such category consists of layouts. Android supports a variety of layouts that provide different levels of control over how visual user interface components are positioned and managed on the screen. Though it is difficult to tell from looking at the visual representation of the user interface, the current design has been created using a ConstraintLayout. This can be confirmed by reviewing the information in the Component Tree panel, which, by default, is located in the lower left-hand corner of the Layout Editor panel and is shown in Figure 3-7:
Figure 3-7
As we can see from the component tree hierarchy, the user interface layout consists of a ConstraintLayout parent called main and a TextView child object.
Before proceeding, check that the Layout Editor’s Autoconnect mode is enabled. This means that as components are added to the layout, the Layout Editor will automatically add constraints to ensure the components are correctly positioned for different screen sizes and device orientations (a topic that will be covered in much greater detail in future chapters). The Autoconnect button appears in the Layout Editor toolbar and is represented by a U-shaped icon. When disabled, the icon appears with a diagonal line through it (Figure 3-8). If necessary, re-enable Autoconnect mode by clicking on this button.
Figure 3-8
The next step in modifying the application is to add some additional components to the layout, the first of which will be a Button for the user to press to initiate the currency conversion.
The Palette panel consists of two columns, with the left-hand column containing a list of view component categories. The right-hand column lists the components contained within the currently selected category. In Figure 3-9, for example, the Button view is currently selected within the Buttons category:
Figure 3-9
Click and drag the Button object from the Buttons list and drop it in the horizontal center of the user interface design so that it is positioned beneath the existing TextView widget:
Figure 3-10
The next step is to change the text currently displayed by the Button component. The panel located to the right of the design area is the Attributes panel. This panel displays the attributes assigned to the currently selected component in the layout. Within this panel, locate the text property in the Common Attributes section and change the current value from “Button” to “Convert”, as shown in Figure 3-11:
Figure 3-11
The second text property with a wrench next to it allows a text property to be set, which only appears within the Layout Editor tool but is not shown at runtime. This is useful for testing how a visual component and the layout will behave with different settings without running the app repeatedly.
Just in case the Autoconnect system failed to set all of the layout connections, click on the Infer Constraints button (Figure 3-12) to add any missing constraints to the layout:
Figure 3-12
It is important to explain the warning button in the top right-hand corner of the Layout Editor tool, as indicated in Figure 3-13. This warning indicates potential problems with the layout. For details on any problems, click on the button:
Figure 3-13
When clicked, the Problems tool window (Figure 3-14) will appear, describing the nature of the problems:
Figure 3-14
