29,99 €
Mehr erfahren.
- Herausgeber: Packt Publishing
- Kategorie: Wissenschaft und neue Technologien
- Sprache: Englisch
Android Studio is an Integrated Development Environment that is based on the JetBrains IntelliJ IDEA. It provides developers with a unique platform to design and develop Android apps using various developer tools. The new Android Studio 4.2 has an upgraded IntelliJ platform and a variety of new features designed to improve the productivity of Android app developers. Fully updated for Android Studio 4.2, the objective of this book is to help you master the skills necessary to develop Android applications using Kotlin as the programming language.
This book begins by outlining the steps necessary to set up an Android development and testing environment and introduces programming in Kotlin, addressing data types, flow control, functions, lambdas, and object-oriented programming. It includes an overview of Android Studio, covering areas such as tool windows, the code editor, and the Layout Editor tool. An introduction to Android architecture is followed by an in-depth explanation of the design of Android applications and user interfaces using the Android Studio environment.
Early chapters detail Android Architecture components like view models, lifecycle management, Room database access, the Database Inspector, app navigation, live data, and data binding. Advanced topics such as intents are also covered, as are touch screen handling, gesture recognition, and the recording and playback of audio. You will also explore printing, transitions, cloud-based file storage, and foldable device support.
Detailed descriptions of material design concepts are provided, including the use of floating action buttons, Snackbars, tabbed interfaces, card views, navigation drawers, and collapsing toolbars. Some key features of Android Studio 4.2 and Android discussed in-depth include the Layout Editor, the ConstraintLayout and ConstraintSet classes, MotionLayout Editor, view binding, constraint chains, barriers, and direct reply notifications. Later chapters cover advanced features of Android Studio such as App links, Dynamic Delivery, the Android Studio Profiler, Gradle build configuration, and submitting apps to the Google Play Developer Console.
Das E-Book können Sie in Legimi-Apps oder einer beliebigen App lesen, die das folgende Format unterstützen:
Veröffentlichungsjahr: 2021
Ähnliche
Android Studio 4.2
Development Essentials
Kotlin Edition
Android Studio 4.2 Development Essentials – Kotlin Edition
ISBN-13: 978-1-951442-30-9
© 2021 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
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 The Android Studio Setup Wizard
2.5 Installing Additional Android SDK Packages
2.6 Making the Android SDK Tools Command-line Accessible
2.6.1 Windows 7
2.6.2 Windows 8.1
2.6.3 Windows 10
2.6.4 Linux
2.6.5 macOS
2.7 Android Studio Memory Management
2.8 Updating Android Studio and the SDK
2.9 Summary
3. Creating an Example Android App in Android Studio
3.1 About the Project
3.2 Creating a New Android Project
3.3 Creating an Activity
3.4 Defining the Project and SDK Settings
3.5 Modifying the Example Application
3.6 Modifying the User Interface
3.7 Reviewing the Layout and Resource Files
3.8 Adding the Kotlin Extensions Plugin
3.9 Adding Interaction
3.10 Summary
4. Creating an Android Virtual Device (AVD) in Android Studio
4.1 About Android Virtual Devices
4.2 Creating a New AVD
4.3 Starting the Emulator
4.4 Running the Application in the AVD
4.5 Running on Multiple Devices
4.6 Stopping a Running Application
4.7 Supporting Dark Theme
4.8 Running the Emulator in a Tool Window
4.9 AVD Command-line Creation
4.10 Android Virtual Device Configuration Files
4.11 Moving and Renaming an Android Virtual Device
4.12 Summary
5. Using and Configuring the Android Studio AVD Emulator
5.1 The Emulator Environment
5.2 The Emulator Toolbar Options
5.3 Working in Zoom Mode
5.4 Resizing the Emulator Window
5.5 Extended Control Options
5.5.1 Location
5.5.2 Displays
5.5.3 Cellular
5.5.4 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 Summary
6. A Tour of the Android Studio User Interface
6.1 The Welcome Screen
6.2 The Main Window
6.3 The Tool Windows
6.4 Android Studio Keyboard Shortcuts
6.5 Switcher and Recent Files Navigation
6.6 Changing the Android Studio Theme
6.7 Summary
7. Testing Android Studio Apps on a Physical Android Device
7.1 An Overview of the Android Debug Bridge (ADB)
7.2 Enabling ADB on Android based Devices
7.2.1 macOS ADB Configuration
7.2.2 Windows ADB Configuration
7.2.3 Linux adb Configuration
7.3 Testing the adb Connection
7.4 Summary
8. The Basics of the Android Studio Code Editor
8.1 The Android Studio Editor
8.2 Splitting the Editor Window
8.3 Code Completion
8.4 Statement Completion
8.5 Parameter Information
8.6 Parameter Name Hints
8.7 Code Generation
8.8 Code Folding
8.9 Quick Documentation Lookup
8.10 Code Reformatting
8.11 Finding Sample Code
8.12 Live Templates
8.13 Summary
9. An Overview of the Android Architecture
9.1 The Android Software Stack
9.2 The Linux Kernel
9.3 Android Runtime – ART
9.4 Android Libraries
9.4.1 C/C++ Libraries
9.5 Application Framework
9.6 Applications
9.7 Summary
10. The Anatomy of an Android Application
10.1 Android Activities
10.2 Android Fragments
10.3 Android Intents
10.4 Broadcast Intents
10.5 Broadcast Receivers
10.6 Android Services
10.7 Content Providers
10.8 The Application Manifest
10.9 Application Resources
10.10 Application Context
10.11 Summary
11. An Introduction to Kotlin
11.1 What is Kotlin?
11.2 Kotlin and Java
11.3 Converting from Java to Kotlin
11.4 Kotlin and Android Studio
11.5 Experimenting with Kotlin
11.6 Semi-colons in Kotlin
11.7 Summary
12. Kotlin Data Types,Variables and Nullability
12.1 Kotlin Data Types
12.1.1 Integer Data Types
12.1.2 Floating Point Data Types
12.1.3 Boolean Data Type
12.1.4 Character Data Type
12.1.5 String Data Type
12.1.6 Escape Sequences
12.2 Mutable Variables
12.3 Immutable Variables
12.4 Declaring Mutable and Immutable Variables
12.5 Data Types are Objects
12.6 Type Annotations and Type Inference
12.7 Nullable Type
12.8 The Safe Call Operator
12.9 Not-Null Assertion
12.10 Nullable Types and the let Function
12.11 Late Initialization (lateinit)
12.12 The Elvis Operator
12.13 Type Casting and Type Checking
12.14 Summary
13. Kotlin Operators and Expressions
13.1 Expression Syntax in Kotlin
13.2 The Basic Assignment Operator
13.3 Kotlin Arithmetic Operators
13.4 Augmented Assignment Operators
13.5 Increment and Decrement Operators
13.6 Equality Operators
13.7 Boolean Logical Operators
13.8 Range Operator
13.9 Bitwise Operators
13.9.1 Bitwise Inversion
13.9.2 Bitwise AND
13.9.3 Bitwise OR
13.9.4 Bitwise XOR
13.9.5 Bitwise Left Shift
13.9.6 Bitwise Right Shift
13.10 Summary
14. Kotlin Flow Control
14.1 Looping Flow Control
14.1.1 The Kotlin for-in Statement
14.1.2 The while Loop
14.1.3 The do ... while loop
14.1.4 Breaking from Loops
14.1.5 The continue Statement
14.1.6 Break and Continue Labels
14.2 Conditional Flow Control
14.2.1 Using the if Expressions
14.2.2 Using if ... else … Expressions
14.2.3 Using if ... else if ... Expressions
14.2.4 Using the when Statement
14.3 Summary
15. An Overview of Kotlin Functions and Lambdas
15.1 What is a Function?
15.2 How to Declare a Kotlin Function
15.3 Calling a Kotlin Function
15.4 Single Expression Functions
15.5 Local Functions
15.6 Handling Return Values
15.7 Declaring Default Function Parameters
15.8 Variable Number of Function Parameters
15.9 Lambda Expressions
15.10 Higher-order Functions
15.11 Summary
16. The Basics of Object Oriented Programming in Kotlin
16.1 What is an Object?
16.2 What is a Class?
16.3 Declaring a Kotlin Class
16.4 Adding Properties to a Class
16.5 Defining Methods
16.6 Declaring and Initializing a Class Instance
16.7 Primary and Secondary Constructors
16.8 Initializer Blocks
16.9 Calling Methods and Accessing Properties
16.10 Custom Accessors
16.11 Nested and Inner Classes
16.12 Companion Objects
16.13 Summary
17. An Introduction to Kotlin Inheritance and Subclassing
17.1 Inheritance, Classes and Subclasses
17.2 Subclassing Syntax
17.3 A Kotlin Inheritance Example
17.4 Extending the Functionality of a Subclass
17.5 Overriding Inherited Methods
17.6 Adding a Custom Secondary Constructor
17.7 Using the SavingsAccount Class
17.8 Summary
18. An Overview of Android View Binding
18.1 Find View by Id and Synthetic Properties
18.2 View Binding
18.3 Converting the AndroidSample project
18.4 Enabling View Binding
18.5 Using View Binding
18.6 Choosing an Option
18.7 View Binding in the Book Examples
18.8 Migrating a Project to View Binding
18.9 Summary
19. Understanding Android Application and Activity Lifecycles
19.1 Android Applications and Resource Management
19.2 Android Process States
19.2.1 Foreground Process
19.2.2 Visible Process
19.2.3 Service Process
19.2.4 Background Process
19.2.5 Empty Process
19.3 Inter-Process Dependencies
19.4 The Activity Lifecycle
19.5 The Activity Stack
19.6 Activity States
19.7 Configuration Changes
19.8 Handling State Change
19.9 Summary
20. Handling Android Activity State Changes
20.1 New vs. Old Lifecycle Techniques
20.2 The Activity and Fragment Classes
20.3 Dynamic State vs. Persistent State
20.4 The Android Lifecycle Methods
20.5 Lifetimes
20.6 Foldable Devices and Multi-Resume
20.7 Disabling Configuration Change Restarts
20.8 Lifecycle Method Limitations
20.9 Summary
21. Android Activity State Changes by Example
21.1 Creating the State Change Example Project
21.2 Designing the User Interface
21.3 Overriding the Activity Lifecycle Methods
21.4 Filtering the Logcat Panel
21.5 Running the Application
21.6 Experimenting with the Activity
21.7 Summary
22. Saving and Restoring the State of an Android Activity
22.1 Saving Dynamic State
22.2 Default Saving of User Interface State
22.3 The Bundle Class
22.4 Saving the State
22.5 Restoring the State
22.6 Testing the Application
22.7 Summary
23. Understanding Android Views, View Groups and Layouts
23.1 Designing for Different Android Devices
23.2 Views and View Groups
23.3 Android Layout Managers
23.4 The View Hierarchy
23.5 Creating User Interfaces
23.6 Summary
24. A Guide to the Android Studio Layout Editor Tool
24.1 Basic vs. Empty Activity Templates
24.2 The Android Studio Layout Editor
24.3 Design Mode
24.4 The Palette
24.5 Design Mode and Layout Views
24.6 Night Mode
24.7 Code Mode
24.8 Split Mode
24.9 Setting Attributes
24.10 Transforms
24.11 Tools Visibility Toggles
24.12 Converting Views
24.13 Displaying Sample Data
24.14 Creating a Custom Device Definition
24.15 Changing the Current Device
24.16 Layout Validation (Multi Preview)
24.17 Summary
25. A Guide to the Android ConstraintLayout
25.1 How ConstraintLayout Works
25.1.1 Constraints
25.1.2 Margins
25.1.3 Opposing Constraints
25.1.4 Constraint Bias
25.1.5 Chains
25.1.6 Chain Styles
25.2 Baseline Alignment
25.3 Configuring Widget Dimensions
25.4 Guideline Helper
25.5 Group Helper
25.6 Barrier Helper
25.7 Flow Helper
25.8 Ratios
25.9 ConstraintLayout Advantages
25.10 ConstraintLayout Availability
25.11 Summary
26. A Guide to Using ConstraintLayout in Android Studio
26.1 Design and Layout Views
26.2 Autoconnect Mode
26.3 Inference Mode
26.4 Manipulating Constraints Manually
26.5 Adding Constraints in the Inspector
26.6 Viewing Constraints in the Attributes Window
26.7 Deleting Constraints
26.8 Adjusting Constraint Bias
26.9 Understanding ConstraintLayout Margins
26.10 The Importance of Opposing Constraints and Bias
26.11 Configuring Widget Dimensions
26.12 Design Time Tools Positioning
26.13 Adding Guidelines
26.14 Adding Barriers
26.15 Adding a Group
26.16 Working with the Flow Helper
26.17 Widget Group Alignment and Distribution
26.18 Converting other Layouts to ConstraintLayout
26.19 Summary
27. Working with ConstraintLayout Chains and Ratios in Android Studio
27.1 Creating a Chain
27.2 Changing the Chain Style
27.3 Spread Inside Chain Style
27.4 Packed Chain Style
27.5 Packed Chain Style with Bias
27.6 Weighted Chain
27.7 Working with Ratios
27.8 Summary
28. An Android Studio Layout Editor ConstraintLayout Tutorial
28.1 An Android Studio Layout Editor Tool Example
28.2 Creating a New Activity
28.3 Preparing the Layout Editor Environment
28.4 Adding the Widgets to the User Interface
28.5 Adding the Constraints
28.6 Testing the Layout
28.7 Using the Layout Inspector
28.8 Summary
29. Manual XML Layout Design in Android Studio
29.1 Manually Creating an XML Layout
29.2 Manual XML vs. Visual Layout Design
29.3 Summary
30. Managing Constraints using Constraint Sets
30.1 Kotlin Code vs. XML Layout Files
30.2 Creating Views
30.3 View Attributes
30.4 Constraint Sets
30.4.1 Establishing Connections
30.4.2 Applying Constraints to a Layout
30.4.3 Parent Constraint Connections
30.4.4 Sizing Constraints
30.4.5 Constraint Bias
30.4.6 Alignment Constraints
30.4.7 Copying and Applying Constraint Sets
30.4.8 ConstraintLayout Chains
30.4.9 Guidelines
30.4.10 Removing Constraints
30.4.11 Scaling
30.4.12 Rotation
30.5 Summary
31. An Android ConstraintSet Tutorial
31.1 Creating the Example Project in Android Studio
31.2 Adding Views to an Activity
31.3 Setting View Attributes
31.4 Creating View IDs
31.5 Configuring the Constraint Set
31.6 Adding the EditText View
31.7 Converting Density Independent Pixels (dp) to Pixels (px)
31.8 Summary
32. A Guide to using Apply Changes in Android Studio
32.1 Introducing Apply Changes
32.2 Understanding Apply Changes Options
32.3 Using Apply Changes
32.4 Configuring Apply Changes Fallback Settings
32.5 An Apply Changes Tutorial
32.6 Using Apply Code Changes
32.7 Using Apply Changes and Restart Activity
32.8 Using Run App
32.9 Summary
33. An Overview and Example of Android Event Handling
33.1 Understanding Android Events
33.2 Using the android:onClick Resource
33.3 Event Listeners and Callback Methods
33.4 An Event Handling Example
33.5 Designing the User Interface
33.6 The Event Listener and Callback Method
33.7 Consuming Events
33.8 Summary
34. Android Touch and Multi-touch Event Handling
34.1 Intercepting Touch Events
34.2 The MotionEvent Object
34.3 Understanding Touch Actions
34.4 Handling Multiple Touches
34.5 An Example Multi-Touch Application
34.6 Designing the Activity User Interface
34.7 Implementing the Touch Event Listener
34.8 Running the Example Application
34.9 Summary
35. Detecting Common Gestures Using the Android Gesture Detector Class
35.1 Implementing Common Gesture Detection
35.2 Creating an Example Gesture Detection Project
35.3 Implementing the Listener Class
35.4 Creating the GestureDetectorCompat Instance
35.5 Implementing the onTouchEvent() Method
35.6 Testing the Application
35.7 Summary
36. Implementing Custom Gesture and Pinch Recognition on Android
36.1 The Android Gesture Builder Application
36.2 The GestureOverlayView Class
36.3 Detecting Gestures
36.4 Identifying Specific Gestures
36.5 Installing and Running the Gesture Builder Application
36.6 Creating a Gestures File
36.7 Creating the Example Project
36.8 Extracting the Gestures File from the SD Card
36.9 Adding the Gestures File to the Project
36.10 Designing the User Interface
36.11 Loading the Gestures File
36.12 Registering the Event Listener
36.13 Implementing the onGesturePerformed Method
36.14 Testing the Application
36.15 Configuring the GestureOverlayView
36.16 Intercepting Gestures
36.17 Detecting Pinch Gestures
36.18 A Pinch Gesture Example Project
36.19 Summary
37. An Introduction to Android Fragments
37.1 What is a Fragment?
37.2 Creating a Fragment
37.3 Adding a Fragment to an Activity using the Layout XML File
37.4 Adding and Managing Fragments in Code
37.5 Handling Fragment Events
37.6 Implementing Fragment Communication
37.7 Summary
38. Using Fragments in Android Studio - An Example
38.1 About the Example Fragment Application
38.2 Creating the Example Project
38.3 Creating the First Fragment Layout
38.4 Migrating a Fragment to View Binding
38.5 Adding the Second Fragment
38.6 Adding the Fragments to the Activity
38.7 Making the Toolbar Fragment Talk to the Activity
38.8 Making the Activity Talk to the Text Fragment
38.9 Testing the Application
38.10 Summary
39. Modern Android App Architecture with Jetpack
39.1 What is Android Jetpack?
39.2 The “Old” Architecture
39.3 Modern Android Architecture
39.4 The ViewModel Component
39.5 The LiveData Component
39.6 ViewModel Saved State
39.7 LiveData and Data Binding
39.8 Android Lifecycles
39.9 Repository Modules
39.10 Summary
40. An Android Jetpack ViewModel Tutorial
40.1 About the Project
40.2 Creating the ViewModel Example Project
40.3 Reviewing the Project
40.3.1 The Main Activity
40.3.2 The Content Fragment
40.3.3 The ViewModel
40.4 Designing the Fragment Layout
40.5 Implementing the View Model
40.6 Associating the Fragment with the View Model
40.7 Modifying the Fragment
40.8 Accessing the ViewModel Data
40.9 Testing the Project
40.10 Summary
41. An Android Jetpack LiveData Tutorial
41.1 LiveData - A Recap
41.2 Adding LiveData to the ViewModel
41.3 Implementing the Observer
41.4 Summary
42. An Overview of Android Jetpack Data Binding
42.1 An Overview of Data Binding
42.2 The Key Components of Data Binding
42.2.1 The Project Build Configuration
42.2.2 The Data Binding Layout File
42.2.3 The Layout File Data Element
42.2.4 The Binding Classes
42.2.5 Data Binding Variable Configuration
42.2.6 Binding Expressions (One-Way)
42.2.7 Binding Expressions (Two-Way)
42.2.8 Event and Listener Bindings
42.3 Summary
43. An Android Jetpack Data Binding Tutorial
43.1 Removing the Redundant Code
43.2 Enabling Data Binding
43.3 Adding the Layout Element
43.4 Adding the Data Element to Layout File
43.5 Working with the Binding Class
43.6 Assigning the ViewModel Instance to the Data Binding Variable
43.7 Adding Binding Expressions
43.8 Adding the Conversion Method
43.9 Adding a Listener Binding
43.10 Testing the App
43.11 Summary
44. An Android ViewModel Saved State Tutorial
44.1 Understanding ViewModel State Saving
44.2 Implementing ViewModel State Saving
44.3 Saving and Restoring State
44.4 Adding Saved State Support to the ViewModelDemo Project
44.5 Summary
45. Working with Android Lifecycle-Aware Components
45.1 Lifecycle Awareness
45.2 Lifecycle Owners
45.3 Lifecycle Observers
45.4 Lifecycle States and Events
45.5 Summary
46. An Android Jetpack Lifecycle Awareness Tutorial
46.1 Creating the Example Lifecycle Project
46.2 Creating a Lifecycle Observer
46.3 Adding the Observer
46.4 Testing the Observer
46.5 Creating a Lifecycle Owner
46.6 Testing the Custom Lifecycle Owner
46.7 Summary
47. An Overview of the Navigation Architecture Component
47.1 Understanding Navigation
47.2 Declaring a Navigation Host
47.3 The Navigation Graph
47.4 Accessing the Navigation Controller
47.5 Triggering a Navigation Action
47.6 Passing Arguments
47.7 Summary
48. An Android Jetpack Navigation Component Tutorial
48.1 Creating the NavigationDemo Project
48.2 Adding Navigation to the Build Configuration
48.3 Creating the Navigation Graph Resource File
48.4 Declaring a Navigation Host
48.5 Adding Navigation Destinations
48.6 Designing the Destination Fragment Layouts
48.7 Adding an Action to the Navigation Graph
48.8 Implement the OnFragmentInteractionListener
48.9 Adding View Binding Support to the Destination Fragments
48.10 Triggering the Action
48.11 Passing Data Using Safeargs
48.12 Summary
49. An Introduction to MotionLayout
49.1 An Overview of MotionLayout
49.2 MotionLayout
49.3 MotionScene
49.4 Configuring ConstraintSets
49.5 Custom Attributes
49.6 Triggering an Animation
49.7 Arc Motion
49.8 Keyframes
49.8.1 Attribute Keyframes
49.8.2 Position Keyframes
49.9 Time Linearity
49.10 KeyTrigger
49.11 Cycle and Time Cycle Keyframes
49.12 Starting an Animation from Code
49.13 Summary
50. An Android MotionLayout Editor Tutorial
50.1 Creating the MotionLayoutDemo Project
50.2 ConstraintLayout to MotionLayout Conversion
50.3 Configuring Start and End Constraints
50.4 Previewing the MotionLayout Animation
50.5 Adding an OnClick Gesture
50.6 Adding an Attribute Keyframe to the Transition
50.7 Adding a CustomAttribute to a Transition
50.8 Adding Position Keyframes
50.9 Summary
51. A MotionLayout KeyCycle Tutorial
51.1 An Overview of Cycle Keyframes
51.2 Using the Cycle Editor
51.3 Creating the KeyCycleDemo Project
51.4 Configuring the Start and End Constraints
51.5 Creating the Cycles
51.6 Previewing the Animation
51.7 Adding the KeyFrameSet to the MotionScene
51.8 Summary
52. Working with the Floating Action Button and Snackbar
52.1 The Material Design
52.2 The Design Library
52.3 The Floating Action Button (FAB)
52.4 The Snackbar
52.5 Creating the Example Project
52.6 Reviewing the Project
52.7 Removing Navigation Features
52.8 Changing the Floating Action Button
52.9 Adding an Action to the Snackbar
52.10 Summary
53. Creating a Tabbed Interface using the TabLayout Component
53.1 An Introduction to the ViewPager
53.2 An Overview of the TabLayout Component
53.3 Creating the TabLayoutDemo Project
53.4 Creating the First Fragment
53.5 Duplicating the Fragments
53.6 Adding the TabLayout and ViewPager
53.7 Creating the Pager Adapter
53.8 Performing the Initialization Tasks
53.9 Testing the Application
53.10 Customizing the TabLayout
53.11 Displaying Icon Tab Items
53.12 Summary
54. Working with the RecyclerView and CardView Widgets
54.1 An Overview of the RecyclerView
54.2 An Overview of the CardView
54.3 Summary
55. An Android RecyclerView and CardView Tutorial
55.1 Creating the CardDemo Project
55.2 Modifying the Basic Activity Project
55.3 Designing the CardView Layout
55.4 Adding the RecyclerView
55.5 Adding the Image Files
55.6 Creating the RecyclerView Adapter
55.7 Initializing the RecyclerView Component
55.8 Testing the Application
55.9 Responding to Card Selections
55.10 Summary
56. A Layout Editor Sample Data Tutorial
56.1 Adding Sample Data to a Project
56.2 Using Custom Sample Data
56.3 Summary
57. Working with the AppBar and Collapsing Toolbar Layouts
57.1 The Anatomy of an AppBar
57.2 The Example Project
57.3 Coordinating the RecyclerView and Toolbar
57.4 Introducing the Collapsing Toolbar Layout
57.5 Changing the Title and Scrim Color
57.6 Summary
58. An Android Studio Primary/Detail Flow Tutorial
58.1 The Primary/Detail Flow
58.2 Creating a Primary/Detail Flow Activity
58.3 Modifying the Primary/Detail Flow Template
58.4 Changing the Content Model
58.5 Changing the Detail Pane
58.6 Modifying the WebsiteDetailFragment Class
58.7 Modifying the WebsiteListFragment Class
58.8 Adding Manifest Permissions
58.9 Running the Application
58.10 Summary
59. An Overview of Android Intents
59.1 An Overview of Intents
59.2 Explicit Intents
59.3 Returning Data from an Activity
59.4 Implicit Intents
59.5 Using Intent Filters
59.6 Checking Intent Availability
59.7 Summary
60. Android Explicit Intents – A Worked Example
60.1 Creating the Explicit Intent Example Application
60.2 Designing the User Interface Layout for MainActivity
60.3 Creating the Second Activity Class
60.4 Designing the User Interface Layout for SecondActivity
60.5 Reviewing the Application Manifest File
60.6 Creating the Intent
60.7 Extracting Intent Data
60.8 Launching SecondActivity as a Sub-Activity
60.9 Returning Data from a Sub-Activity
60.10 Testing the Application
60.11 Summary
61. Android Implicit Intents – A Worked Example
61.1 Creating the Android Studio Implicit Intent Example Project
61.2 Designing the User Interface
61.3 Creating the Implicit Intent
61.4 Adding a Second Matching Activity
61.5 Adding the Web View to the UI
61.6 Obtaining the Intent URL
61.7 Modifying the MyWebView Project Manifest File
61.8 Installing the MyWebView Package on a Device
61.9 Testing the Application
61.10 Summary
62. Android Broadcast Intents and Broadcast Receivers
62.1 An Overview of Broadcast Intents
62.2 An Overview of Broadcast Receivers
62.3 Obtaining Results from a Broadcast
62.4 Sticky Broadcast Intents
62.5 The Broadcast Intent Example
62.6 Creating the Example Application
62.7 Creating and Sending the Broadcast Intent
62.8 Creating the Broadcast Receiver
62.9 Registering the Broadcast Receiver
62.10 Testing the Broadcast Example
62.11 Listening for System Broadcasts
62.12 Summary
63. An Introduction to Kotlin Coroutines
63.1 What are Coroutines?
63.2 Threads vs Coroutines
63.3 Coroutine Scope
63.4 Suspend Functions
63.5 Coroutine Dispatchers
63.6 Coroutine Builders
63.7 Jobs
63.8 Coroutines – Suspending and Resuming
63.9 Returning Results from a Coroutine
63.10 Using withContext
63.11 Coroutine Channel Communication
63.12 Summary
64. An Android Kotlin Coroutines Tutorial
64.1 Creating the Coroutine Example Application
64.2 Adding Coroutine Support to the Project
64.3 Designing the User Interface
64.4 Implementing the SeekBar
64.5 Adding the Suspend Function
64.6 Implementing the launchCoroutines Method
64.7 Testing the App
64.8 Summary
65. An Overview of Android Services
65.1 Started Services
65.2 Intent Service
65.3 Bound Service
65.4 The Anatomy of a Service
65.5 Controlling Destroyed Service Restart Options
65.6 Declaring a Service in the Manifest File
65.7 Starting a Service Running on System Startup
65.8 Summary
66. Implementing an Android Started Service – A Worked Example
66.1 Creating the Example Project
66.2 Designing the User Interface
66.3 Creating the Service Class
66.4 Adding the Service to the Manifest File
66.5 Starting the Service
66.6 Testing the IntentService Example
66.7 Using the Service Class
66.8 Creating the New Service
66.9 Launching the Service
66.10 Running the Application
66.11 Using a Coroutine for the Service Task
66.12 Summary
67. Android Local Bound Services – A Worked Example
67.1 Understanding Bound Services
67.2 Bound Service Interaction Options
67.3 A Local Bound Service Example
67.4 Adding a Bound Service to the Project
67.5 Implementing the Binder
67.6 Binding the Client to the Service
67.7 Completing the Example
67.8 Testing the Application
67.9 Summary
68. Android Remote Bound Services – A Worked Example
68.1 Client to Remote Service Communication
68.2 Creating the Example Application
68.3 Designing the User Interface
68.4 Implementing the Remote Bound Service
68.5 Configuring a Remote Service in the Manifest File
68.6 Launching and Binding to the Remote Service
68.7 Sending a Message to the Remote Service
68.8 Summary
69. An Android Notifications Tutorial
69.1 An Overview of Notifications
69.2 Creating the NotifyDemo Project
69.3 Designing the User Interface
69.4 Creating the Second Activity
69.5 Creating a Notification Channel
69.6 Creating and Issuing a Notification
69.7 Launching an Activity from a Notification
69.8 Adding Actions to a Notification
69.9 Bundled Notifications
69.10 Summary
70. An Android Direct Reply Notification Tutorial
70.1 Creating the DirectReply Project
70.2 Designing the User Interface
70.3 Creating the Notification Channel
70.4 Building the RemoteInput Object
70.5 Creating the PendingIntent
70.6 Creating the Reply Action
70.7 Receiving Direct Reply Input
70.8 Updating the Notification
70.9 Summary
71. Foldable Devices and Multi-Window Support
71.1 Foldables and Multi-Window Support
71.2 Using a Foldable Emulator
71.3 Entering Multi-Window Mode
71.4 Enabling and using Freeform Support
71.5 Checking for Freeform Support
71.6 Enabling Multi-Window Support in an App
71.7 Specifying Multi-Window Attributes
71.8 Detecting Multi-Window Mode in an Activity
71.9 Receiving Multi-Window Notifications
71.10 Launching an Activity in Multi-Window Mode
71.11 Configuring Freeform Activity Size and Position
71.12 Summary
72. An Overview of Android SQLite Databases
72.1 Understanding Database Tables
72.2 Introducing Database Schema
72.3 Columns and Data Types
72.4 Database Rows
72.5 Introducing Primary Keys
72.6 What is SQLite?
72.7 Structured Query Language (SQL)
72.8 Trying SQLite on an Android Virtual Device (AVD)
72.9 The Android Room Persistence Library
72.10 Summary
73. The Android Room Persistence Library
73.1 Revisiting Modern App Architecture
73.2 Key Elements of Room Database Persistence
73.2.1 Repository
73.2.2 Room Database
73.2.3 Data Access Object (DAO)
73.2.4 Entities
73.2.5 SQLite Database
73.3 Understanding Entities
73.4 Data Access Objects
73.5 The Room Database
73.6 The Repository
73.7 In-Memory Databases
73.8 Database Inspector
73.9 Summary
74. An Android TableLayout and TableRow Tutorial
74.1 The TableLayout and TableRow Layout Views
74.2 Creating the Room Database Project
74.3 Converting to a LinearLayout
74.4 Adding the TableLayout to the User Interface
74.5 Configuring the TableRows
74.6 Adding the Button Bar to the Layout
74.7 Adding the RecyclerView
74.8 Adjusting the Layout Margins
74.9 Summary
75. An Android Room Database and Repository Tutorial
75.1 About the RoomDemo Project
75.2 Modifying the Build Configuration
75.3 Building the Entity
75.4 Creating the Data Access Object
75.5 Adding the Room Database
75.6 Adding the Repository
75.7 Modifying the ViewModel
75.8 Creating the Product Item Layout
75.9 Adding the RecyclerView Adapter
75.10 Preparing the Main Fragment
75.11 Adding the Button Listeners
75.12 Adding LiveData Observers
75.13 Initializing the RecyclerView
75.14 Testing the RoomDemo App
75.15 Using the Database Inspector
75.16 Summary
76. Accessing Cloud Storage using the Android Storage Access Framework
76.1 The Storage Access Framework
76.2 Working with the Storage Access Framework
76.3 Filtering Picker File Listings
76.4 Handling Intent Results
76.5 Reading the Content of a File
76.6 Writing Content to a File
76.7 Deleting a File
76.8 Gaining Persistent Access to a File
76.9 Summary
77. An Android Storage Access Framework Example
77.1 About the Storage Access Framework Example
77.2 Creating the Storage Access Framework Example
77.3 Designing the User Interface
77.4 Declaring Request Codes
77.5 Creating a New Storage File
77.6 The onActivityResult() Method
77.7 Saving to a Storage File
77.8 Opening and Reading a Storage File
77.9 Testing the Storage Access Application
77.10 Summary
78. Video Playback on Android using the VideoView and MediaController Classes
78.1 Introducing the Android VideoView Class
78.2 Introducing the Android MediaController Class
78.3 Creating the Video Playback Example
78.4 Designing the VideoPlayer Layout
78.5 Downloading the Video File
78.6 Configuring the VideoView
78.7 Adding the MediaController to the Video View
78.8 Setting up the onPreparedListener
78.9 Summary
79. Android Picture-in-Picture Mode
79.1 Picture-in-Picture Features
79.2 Enabling Picture-in-Picture Mode
79.3 Configuring Picture-in-Picture Parameters
79.4 Entering Picture-in-Picture Mode
79.5 Detecting Picture-in-Picture Mode Changes
79.6 Adding Picture-in-Picture Actions
79.7 Summary
80. An Android Picture-in-Picture Tutorial
80.1 Adding Picture-in-Picture Support to the Manifest
80.2 Adding a Picture-in-Picture Button
80.3 Entering Picture-in-Picture Mode
80.4 Detecting Picture-in-Picture Mode Changes
80.5 Adding a Broadcast Receiver
80.6 Adding the PiP Action
80.7 Testing the Picture-in-Picture Action
80.8 Summary
81. Making Runtime Permission Requests in Android
81.1 Understanding Normal and Dangerous Permissions
81.2 Creating the Permissions Example Project
81.3 Checking for a Permission
81.4 Requesting Permission at Runtime
81.5 Providing a Rationale for the Permission Request
81.6 Testing the Permissions App
81.7 Summary
82. Android Audio Recording and Playback using MediaPlayer and MediaRecorder
82.1 Playing Audio
82.2 Recording Audio and Video using the MediaRecorder Class
82.3 About the Example Project
82.4 Creating the AudioApp Project
82.5 Designing the User Interface
82.6 Checking for Microphone Availability
82.7 Initializing the Activity
82.8 Implementing the recordAudio() Method
82.9 Implementing the stopAudio() Method
82.10 Implementing the playAudio() method
82.11 Configuring and Requesting Permissions
82.12 Testing the Application
82.13 Summary
83. Printing with the Android Printing Framework
83.1 The Android Printing Architecture
83.2 The Print Service Plugins
83.3 Google Cloud Print
83.4 Printing to Google Drive
83.5 Save as PDF
83.6 Printing from Android Devices
83.7 Options for Building Print Support into Android Apps
83.7.1 Image Printing
83.7.2 Creating and Printing HTML Content
83.7.3 Printing a Web Page
83.7.4 Printing a Custom Document
83.8 Summary
84. An Android HTML and Web Content Printing Example
84.1 Creating the HTML Printing Example Application
84.2 Printing Dynamic HTML Content
84.3 Creating the Web Page Printing Example
84.4 Removing the Floating Action Button
84.5 Removing Navigation Features
84.6 Designing the User Interface Layout
84.7 Accessing the WebView from the Main Activity
84.8 Loading the Web Page into the WebView
84.9 Adding the Print Menu Option
84.10 Summary
85. A Guide to Android Custom Document Printing
85.1 An Overview of Android Custom Document Printing
85.1.1 Custom Print Adapters
85.2 Preparing the Custom Document Printing Project
85.3 Creating the Custom Print Adapter
85.4 Implementing the onLayout() Callback Method
85.5 Implementing the onWrite() Callback Method
85.6 Checking a Page is in Range
85.7 Drawing the Content on the Page Canvas
85.8 Starting the Print Job
85.9 Testing the Application
85.10 Summary
86. An Introduction to Android App Links
86.1 An Overview of Android App Links
86.2 App Link Intent Filters
86.3 Handling App Link Intents
86.4 Associating the App with a Website
86.5 Summary
87. An Android Studio App Links Tutorial
87.1 About the Example App
87.2 The Database Schema
87.3 Loading and Running the Project
87.4 Adding the URL Mapping
87.5 Adding the Intent Filter
87.6 Adding Intent Handling Code
87.7 Testing the App Link
87.8 Associating an App Link with a Web Site
87.9 Summary
88. A Guide to the Android Studio Profiler
88.1 Accessing the Android Profiler
88.2 Enabling Advanced Profiling
88.3 The Android Profiler Tool Window
88.4 The Sessions Panel
88.5 The CPU Profiler
88.6 Memory Profiler
88.7 Network Profiler
88.8 Energy Profiler
88.9 Summary
89. An Android Biometric Authentication Tutorial
89.1 An Overview of Biometric Authentication
89.2 Creating the Biometric Authentication Project
89.3 Configuring Device Fingerprint Authentication
89.4 Adding the Biometric Permission to the Manifest File
89.5 Designing the User Interface
89.6 Adding a Toast Convenience Method
89.7 Checking the Security Settings
89.8 Configuring the Authentication Callbacks
89.9 Adding the CancellationSignal
89.10 Starting the Biometric Prompt
89.11 Testing the Project
89.12 Summary
90. Creating, Testing and Uploading an Android App Bundle
90.1 The Release Preparation Process
90.2 Android App Bundles
90.3 Register for a Google Play Developer Console Account
90.4 Configuring the App in the Console
90.5 Enabling Google Play App Signing
90.6 Creating a Keystore File
90.7 Creating the Android App Bundle
90.8 Generating Test APK Files
90.9 Uploading the App Bundle to the Google Play Developer Console
90.10 Exploring the App Bundle
90.11 Managing Testers
90.12 Rolling the App Out for Testing
90.13 Uploading New App Bundle Revisions
90.14 Analyzing the App Bundle File
90.15 Summary
91. An Overview of Android Dynamic Feature Modules
91.1 An Overview of Dynamic Feature Modules
91.2 Dynamic Feature Module Architecture
91.3 Creating a Dynamic Feature Module
91.4 Converting an Existing Module for Dynamic Delivery
91.5 Working with Dynamic Feature Modules
91.6 Handling Large Dynamic Feature Modules
91.7 Summary
92. An Android Studio Dynamic Feature Tutorial
92.1 Creating the DynamicFeature Project
92.2 Adding Dynamic Feature Support to the Project
92.3 Designing the Base Activity User Interface
92.4 Adding the Dynamic Feature Module
92.5 Reviewing the Dynamic Feature Module
92.6 Adding the Dynamic Feature Activity
92.7 Implementing the launchIntent() Method
92.8 Uploading the App Bundle for Testing
92.9 Implementing the installFeature() Method
92.10 Adding the Update Listener
92.11 Handling Large Downloads
92.12 Using Deferred Installation
92.13 Removing a Dynamic Module
92.14 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 Top-level Gradle Build File
93.4 Module Level Gradle Build Files
93.5 Configuring Signing Settings in the Build File
93.6 Running Gradle Tasks from the Command-line
93.7 Summary
Index
1. Introduction
Fully updated for Android Studio 4.2, the goal of this book is to teach the skills necessary to develop Android based applications using the Kotlin programming language.
Beginning with the basics, this book provides an outline of the steps necessary to set up an Android development and testing environment followed by an introduction to programming in Kotlin including data types, flow control, functions, lambdas and object-oriented programming.
An overview of Android Studio is included covering 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 are also included covering the Android Architecture Components including view models, lifecycle management, Room database access, 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 edition of the book also covers printing, transitions, cloud-based file storage 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 4.2 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, Dynamic Delivery, the Android Studio Profiler, Gradle build configuration, and submitting apps to the Google Play Developer Console.
Assuming you already have some programming experience, are ready to download Android Studio and the Android SDK, have access to a Windows, Mac or Linux system and 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.ebookfrenzy.com/retail/as42kotlin/index.php
The steps to load a project from the code samples into Android Studio are as follows:
1. From the Welcome to Android Studio dialog, select the Open an Existing Project 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.ebookfrenzy.com/errata/as42kotlin.html
In the event that 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 the development of an Android application, the first step is to configure a computer system to act as the development platform. This involves a number of steps consisting of installing the Android Studio Integrated Development Environment (IDE) which also includes the Android Software Development Kit (SDK), the Kotlin plug-in and 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 7/8/10 (32-bit or 64-bit though the Android emulator will only run on 64-bit systems)
•macOS 10.10 or later (Intel based systems only)
•ChromeOS device with Intel i5 or higher and minimum 8GB of RAM
•Linux systems with version 2.19 or later of GNU C Library (glibc)
•Minimum of 4GB of RAM (8GB is preferred)
•Approximately 4GB 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 version 4.2 using the Android 11.0 (R) API 30 SDK which, at the time of writing, are the current versions.
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 it is important to note that there may be some minor differences between this book and the software. A web search for Android Studio 4.2 should provide the option to download the older version in the event that these differences become a problem. Alternatively, visit the following web page to find Android Studio 4.2 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 being performed.
2.3.1 Installation on Windows
Locate the downloaded Android Studio installation executable file (named android-studio-ide-<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 and whether or not it should be made available to other users of the system. When prompted to select the components to install, make sure that the Android Studio and Android Virtual Device options are all 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 on the Install button to begin the installation process.
On versions of Windows with a Start menu, the newly installed Android Studio can be launched from the entry added to that menu during the installation. The executable may be pinned to the task bar for easy access by navigating to the Android Studio\bin directory, right-clicking on the executable and selecting the Pin to Taskbar menu option. Note that the executable is provided in 32-bit (studio) and 64-bit (studio64) executable versions. If you are running a 32-bit system be sure to use the studio executable.
2.3.2 Installation on macOS
Android Studio for macOS is downloaded in the form of a disk image (.dmg) file. Once the android-studio-ide-<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, simply 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 which will typically take a few minutes 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:
unzip /<path to package>/android-studio-ide-<version>-linux.zip
Note that the Android Studio bundle will be installed into a sub-directory named android-studio. Assuming, therefore, 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
When running on a 64-bit Linux system, it will be necessary to install some 32-bit support libraries before Android Studio will run. On Ubuntu these libraries can be installed using the following command:
sudo apt-get install libc6:i386 libncurses5:i386 libstdc++6:i386 lib32z1 libbz2-1.0:i386
On Red Hat and Fedora based 64-bit systems, use the following command:
sudo yum install zlib.i686 ncurses-libs.i686 bzip2-libs.i686
2.4 The Android Studio Setup Wizard
The first time that Android Studio is launched after being installed, a dialog will appear providing the option to import settings from a previous Android Studio version. If you have settings from a previous version and would like to import them into the latest installation, select the appropriate option and location. Alternatively, indicate that you do not need to import any previous settings and click on the OK button to proceed.
Next, the setup wizard may appear as shown in Figure 2-2 though this dialog does not appear on all platforms:
Figure 2-2
If the wizard appears, click on the Next button, choose the Standard installation option and click on Next once again.
Android Studio will proceed to download and configure the latest Android SDK and some additional components and packages. Once this process has completed, click on the Finish button in the Downloading Components dialog at which point the Welcome to Android Studio screen should then appear:
Figure 2-3
2.5 Installing Additional Android SDK Packages
The steps performed so far have installed Java, 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 using the Android SDK Settingsscreen, which may be launched from within the Android Studio tool by selecting the Configure -> SDK Manager option from within the Android Studio welcome dialog. Once invoked, the Android SDK screen of the default settings dialog will appear as shown in Figure 2-4:
Figure 2-4
Immediately after installing Android Studio for the first time it is likely that only the latest released version of the Android SDK has been installed. To install older versions of the Android SDK simply select the checkboxes corresponding to the versions and click on the Apply button.
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 available for update, 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-5:
Figure 2-5
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 on the Apply button.
In addition to the Android SDK packages, a number of 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-6:
Figure 2-6
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
In the event that any of the above packages are listed as Not Installed or requiring an update, simply select the checkboxes next to those packages and click on the Apply button to initiate the installation process.
Once the installation is complete, review the package list and make sure that the selected packages are now listed as Installed in the Status column. If any are listed as Not installed, make sure they are selected and click on the Apply button again.
2.6 Making the Android SDK Tools Command-line Accessible
Most of the time, the underlying tools of the Android SDK will be accessed from within the Android Studio environment. That being said, however, there will also be instances where it will be useful to be able to invoke those tools from a command prompt or terminal window. In order 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 operating system, the PATH variable needs to be configured to include the following paths (where <path_to_android_sdk_installation> represents the file system location into which the Android SDK was installed):
<path_to_android_sdk_installation>/sdk/tools
<path_to_android_sdk_installation>/sdk/tools/bin
<path_to_android_sdk_installation>/sdk/platform-tools
The location of the SDK on your system can be identified 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-7:
Figure 2-7
Once the location of the SDK has been identified, the steps to add this to the PATH variable are operating system dependent:
2.6.1 Windows 7
1. Right-click on Computer in the desktop start menu and select Properties from the resulting menu.
2. In the properties panel, select the Advanced System Settings link and, in the resulting dialog, click on the Environment Variables… button.
3. In the Environment Variables dialog, locate the Path variable in the System variables list, select it and click on the Edit… button. Using the New button in the edit dialog, add three 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\platform-tools
C:\Users\demo\AppData\Local\Android\Sdk\tools
C:\Users\demo\AppData\Local\Android\Sdk\tools\bin
4. Click on OK in each dialog box and close the system properties control panel.
Once the above steps are complete, verify that the path is correctly set by opening a Command Prompt window (Start -> All Programs -> Accessories -> Command Prompt) and at the prompt 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 launch the AVD Manager command line tool (don’t worry if the avdmanager tool reports a problem with Java - this will be addressed later):
avdmanager
In the event that 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.6.2 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. Follow the steps outlined for Windows 7 starting from step 2 through to step 4.
Open the command prompt window (move the mouse to the bottom right-hand corner of the screen, select the Search option and enter cmd into the search box). Select Command Prompt from the search results.
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
In the event that 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.6.3 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 7 starting from step 3.
2.6.4 Linux
On Linux, this configuration can typically be achieved 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/tools:/home/demo/Android/sdk/tools/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.6.5 macOS
A number of 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/tools
/Users/demo/Library/Android/sdk/tools/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.7 Android Studio Memory Management
Android Studio is a large and complex software application that consists of 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. Part of 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-8
To view and modify the current memory configuration, select the File -> Settings... (Android Studio -> Preferences... on macOS) menu option and, in the resulting dialog, select the Memory Settings option listed under System Settings in the left-hand navigation panel as illustrated in Figure 2-9 below.
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.
Figure 2-9
The IDE heap size setting adjusts the memory allocated to Android Studio and applies regardless of the currently loaded project. When a project is built and run from within Android Studio, on the other hand, a number of 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 may potentially be improved by adjusting the daemon 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.
2.8 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, click on the Configure -> Check for Updates menu option within the Android Studio welcome screen, or use the Help -> Check for Updates... (Android Studio -> Check for Updates... on macOS) menu option accessible from within the Android Studio main window.
2.9 Summary
Prior to 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). In this chapter, we have covered 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 covered the steps necessary to configure an environment suitable for the development of Android applications using the Android Studio IDE. Before moving on to slightly more advanced topics, now is a good time to validate that all of the 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 the creation of an Android application project using Android Studio. Once the project has been created, a later chapter will explore the use of 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 make use of one of the most basic of Android Studio project templates. This simplicity allows us to introduce some of the key aspects of Android app development without overwhelming the beginner by trying to introduce 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 all of the techniques and code used in this initial example project will be covered in much greater detail in later chapters.
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, simply click on the Create New Project option to display the first screen of the New Project wizard.
3.3 Creating an Activity
The first step is to define the type of initial activity that is to be created for the application. Options are available to create projects for Phone and Tablet, Wear OS, TV, Android Audio or Android Things. A range of different activity types is available when developing Android applications, many of which will be covered extensively in later chapters. For the purposes of this example, however, simply select the Phone and Tablet option from the Templates panel followed by the option to create an Empty Activity. The Empty Activity option creates a template user interface consisting of a single TextView object.
Figure 3-2
With the Empty 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 nameis used to uniquely identify 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 name of the application. 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 the purposes of 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: Android 8.0 (Oreo). This is the minimum SDK that will be used in most of the 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 also 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 Kotlin and click on Finish to initiate the project creation process.
3.5 Modifying the Example Application
At this point, Android Studio has created a minimal example application project and opened the main window.
Figure 3-4
The newly created project and references to associated files are listed in the Project tool windowlocated on the left-hand side of the main project window. The Project tool window has a number of 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 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 wide range of other device options are available for selection by clicking on this menu.
To change the orientation of the device representation between landscape and portrait simply use the drop down menu immediately to the left of the device selection menu showing the icon.
As can be seen 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. It should be noted, however, that not all user interface components are obviously 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 and a TextView child object.
Before proceeding, also 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 make sure 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 magnet icon. When disabled the magnet appears with a diagonal line through it (Figure 3-8). If necessary, re-enable Autoconnect mode by clicking on this button.
Figure 3-8
