Android Studio Jellyfish Essentials - Kotlin Edition E-Book

Neil Smyth

• Herausgeber: Payload Media, Inc.
• Kategorie: Fachliteratur
• Sprache: Englisch

Seitenzahl: 1086

Veröffentlichungsjahr: 2024

Beschreibung

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

This book begins with the basics and outlines how to set up an Android development and testing environment, followed by an introduction to programming in Kotlin, including data types, control flow, functions, lambdas, and object-oriented programming. Asynchronous programming using Kotlin coroutines and flow is also covered in detail.

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 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.

Leseprobe

Android Studio Jellyfish

Essentials

Kotlin Edition

Android Studio Jellyfish Essentials – Kotlin Edition

ISBN: 978-1-951442-92-7

© 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

“

Contents

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 Supporting Dark Theme

4.7 Running the Emulator in a Separate Window

4.8 Removing the Device Frame

4.9 Summary

5. Using and Configuring the Android Studio AVD Emulator

5.1 The Emulator Environment

5.2 Emulator Toolbar Options

5.3 Working in Zoom Mode

5.4 Resizing the Emulator Window

5.5 Extended Control Options

5.5.1 Location

5.5.2 Displays

5.5.3 Cellular

5.5.4 Battery

5.5.5 Camera

5.5.6 Phone

5.5.7 Directional Pad

5.5.8 Microphone

5.5.9 Fingerprint

5.5.10 Virtual Sensors

5.5.11 Snapshots

5.5.12 Record and Playback

5.5.13 Google Play

5.5.14 Settings

5.5.15 Help

5.6 Working with Snapshots

5.7 Configuring Fingerprint Emulation

5.8 The Emulator in Tool Window Mode

5.9 Creating a Resizable Emulator

5.10 Summary

6. A Tour of the Android Studio User Interface

6.1 The Welcome Screen

6.2 The Menu Bar

6.3 The Main Window

6.4 The Tool Windows

6.5 The Tool Window Menus

6.6 Android Studio Keyboard Shortcuts

6.7 Switcher and Recent Files Navigation

6.8 Changing the Android Studio Theme

6.9 Summary

7. Testing Android Studio Apps on a Physical Android Device

7.1 An Overview of the Android Debug Bridge (ADB)

7.2 Enabling USB Debugging ADB on Android Devices

7.2.1 macOS ADB Configuration

7.2.2 Windows ADB Configuration

7.2.3 Linux adb Configuration

7.3 Resolving USB Connection Issues

7.4 Enabling Wireless Debugging on Android Devices

7.5 Testing the adb Connection

7.6 Device Mirroring

7.7 Summary

8. The Basics of the Android Studio Code Editor

8.1 The Android Studio Editor

8.2 Splitting the Editor Window

8.3 Code Completion

8.4 Statement Completion

8.5 Parameter Information

8.6 Parameter Name Hints

8.7 Code Generation

8.8 Code Folding

8.9 Quick Documentation Lookup

8.10 Code Reformatting

8.11 Finding Sample Code

8.12 Live Templates

8.13 Summary

9. An Overview of the Android Architecture

9.1 The Android Software Stack

9.2 The Linux Kernel

9.3 Hardware Abstraction Layer

9.4 Android Runtime – ART

9.5 Android Libraries

9.5.1 C/C++ Libraries

9.6 Application Framework

9.7 Applications

9.8 Summary

10. The Anatomy of an Android App

10.1 Android Activities

10.2 Android Fragments

10.3 Android Intents

10.4 Broadcast Intents

10.5 Broadcast Receivers

10.6 Android Services

10.7 Content Providers

10.8 The Application Manifest

10.9 Application Resources

10.10 Application Context

10.11 Summary

11. An Introduction to Kotlin

11.1 What is Kotlin?

11.2 Kotlin and Java

11.3 Converting from Java to Kotlin

11.4 Kotlin and Android Studio

11.5 Experimenting with Kotlin

11.6 Semi-colons in Kotlin

11.7 Summary

12. Kotlin Data Types, Variables, and Nullability

12.1 Kotlin Data Types

12.1.1 Integer Data Types

12.1.2 Floating-Point Data Types

12.1.3 Boolean Data Type

12.1.4 Character Data Type

12.1.5 String Data Type

12.1.6 Escape Sequences

12.2 Mutable Variables

12.3 Immutable Variables

12.4 Declaring Mutable and Immutable Variables

12.5 Data Types are Objects

12.6 Type Annotations and Type Inference

12.7 Nullable Type

12.8 The Safe Call Operator

12.9 Not-Null Assertion

12.10 Nullable Types and the let Function

12.11 Late Initialization (lateinit)

12.12 The Elvis Operator

12.13 Type Casting and Type Checking

12.14 Summary

13. Kotlin Operators and Expressions

13.1 Expression Syntax in Kotlin

13.2 The Basic Assignment Operator

13.3 Kotlin Arithmetic Operators

13.4 Augmented Assignment Operators

13.5 Increment and Decrement Operators

13.6 Equality Operators

13.7 Boolean Logical Operators

13.8 Range Operator

13.9 Bitwise Operators

13.9.1 Bitwise Inversion

13.9.2 Bitwise AND

13.9.3 Bitwise OR

13.9.4 Bitwise XOR

13.9.5 Bitwise Left Shift

13.9.6 Bitwise Right Shift

13.10 Summary

14. Kotlin Control Flow

14.1 Looping Control flow

14.1.1 The Kotlin for-in Statement

14.1.2 The while Loop

14.1.3 The do ... while loop

14.1.4 Breaking from Loops

14.1.5 The continue Statement

14.1.6 Break and Continue Labels

14.2 Conditional Control Flow

14.2.1 Using the if Expressions

14.2.2 Using if ... else … Expressions

14.2.3 Using if ... else if ... Expressions

14.2.4 Using the when Statement

14.3 Summary

15. An Overview of Kotlin Functions and Lambdas

15.1 What is a Function?

15.2 How to Declare a Kotlin Function

15.3 Calling a Kotlin Function

15.4 Single Expression Functions

15.5 Local Functions

15.6 Handling Return Values

15.7 Declaring Default Function Parameters

15.8 Variable Number of Function Parameters

15.9 Lambda Expressions

15.10 Higher-order Functions

15.11 Summary

16. The Basics of Object Oriented Programming in Kotlin

16.1 What is an Object?

16.2 What is a Class?

16.3 Declaring a Kotlin Class

16.4 Adding Properties to a Class

16.5 Defining Methods

16.6 Declaring and Initializing a Class Instance

16.7 Primary and Secondary Constructors

16.8 Initializer Blocks

16.9 Calling Methods and Accessing Properties

16.10 Custom Accessors

16.11 Nested and Inner Classes

16.12 Companion Objects

16.13 Summary

17. An Introduction to Kotlin Inheritance and Subclassing

17.1 Inheritance, Classes and Subclasses

17.2 Subclassing Syntax

17.3 A Kotlin Inheritance Example

17.4 Extending the Functionality of a Subclass

17.5 Overriding Inherited Methods

17.6 Adding a Custom Secondary Constructor

17.7 Using the SavingsAccount Class

17.8 Summary

18. An Overview of Android View Binding

18.1 Find View by Id

18.2 View Binding

18.3 Converting the AndroidSample project

18.4 Enabling View Binding

18.5 Using View Binding

18.6 Choosing an Option

18.7 View Binding in the Book Examples

18.8 Migrating a Project to View Binding

18.9 Summary

19. Understanding Android Application and Activity Lifecycles

19.1 Android Applications and Resource Management

19.2 Android Process States

19.2.1 Foreground Process

19.2.2 Visible Process

19.2.3 Service Process

19.2.4 Background Process

19.2.5 Empty Process

19.3 Inter-Process Dependencies

19.4 The Activity Lifecycle

19.5 The Activity Stack

19.6 Activity States

19.7 Configuration Changes

19.8 Handling State Change

19.9 Summary

20. Handling Android Activity State Changes

20.1 New vs. Old Lifecycle Techniques

20.2 The Activity and Fragment Classes

20.3 Dynamic State vs. Persistent State

20.4 The Android Lifecycle Methods

20.5 Lifetimes

20.6 Foldable Devices and Multi-Resume

20.7 Disabling Configuration Change Restarts

20.8 Lifecycle Method Limitations

20.9 Summary

21. Android Activity State Changes by Example

21.1 Creating the State Change Example Project

21.2 Designing the User Interface

21.3 Overriding the Activity Lifecycle Methods

21.4 Filtering the Logcat Panel

21.5 Running the Application

21.6 Experimenting with the Activity

21.7 Summary

22. Saving and Restoring the State of an Android Activity

22.1 Saving Dynamic State

22.2 Default Saving of User Interface State

22.3 The Bundle Class

22.4 Saving the State

22.5 Restoring the State

22.6 Testing the Application

22.7 Summary

23. Understanding Android Views, View Groups and Layouts

23.1 Designing for Different Android Devices

23.2 Views and View Groups

23.3 Android Layout Managers

23.4 The View Hierarchy

23.5 Creating User Interfaces

23.6 Summary

24. A Guide to the Android Studio Layout Editor Tool

24.1 Basic vs. Empty Views Activity Templates

24.2 The Android Studio Layout Editor

24.3 Design Mode

24.4 The Palette

24.5 Design Mode and Layout Views

24.6 Night Mode

24.7 Code Mode

24.8 Split Mode

24.9 Setting Attributes

24.10 Transforms

24.11 Tools Visibility Toggles

24.12 Converting Views

24.13 Displaying Sample Data

24.14 Creating a Custom Device Definition

24.15 Changing the Current Device

24.16 Layout Validation

24.17 Summary

25. A Guide to the Android ConstraintLayout

25.1 How ConstraintLayout Works

25.1.1 Constraints

25.1.2 Margins

25.1.3 Opposing Constraints

25.1.4 Constraint Bias

25.1.5 Chains

25.1.6 Chain Styles

25.2 Baseline Alignment

25.3 Configuring Widget Dimensions

25.4 Guideline Helper

25.5 Group Helper

25.6 Barrier Helper

25.7 Flow Helper

25.8 Ratios

25.9 ConstraintLayout Advantages

25.10 ConstraintLayout Availability

25.11 Summary

26. A Guide to Using ConstraintLayout in Android Studio

26.1 Design and Layout Views

26.2 Autoconnect Mode

26.3 Inference Mode

26.4 Manipulating Constraints Manually

26.5 Adding Constraints in the Inspector

26.6 Viewing Constraints in the Attributes Window

26.7 Deleting Constraints

26.8 Adjusting Constraint Bias

26.9 Understanding ConstraintLayout Margins

26.10 The Importance of Opposing Constraints and Bias

26.11 Configuring Widget Dimensions

26.12 Design Time Tools Positioning

26.13 Adding Guidelines

26.14 Adding Barriers

26.15 Adding a Group

26.16 Working with the Flow Helper

26.17 Widget Group Alignment and Distribution

26.18 Converting other Layouts to ConstraintLayout

26.19 Summary

27. Working with ConstraintLayout Chains and Ratios in Android Studio

27.1 Creating a Chain

27.2 Changing the Chain Style

27.3 Spread Inside Chain Style

27.4 Packed Chain Style

27.5 Packed Chain Style with Bias

27.6 Weighted Chain

27.7 Working with Ratios

27.8 Summary

28. An Android Studio Layout Editor ConstraintLayout Tutorial

28.1 An Android Studio Layout Editor Tool Example

28.2 Preparing the Layout Editor Environment

28.3 Adding the Widgets to the User Interface

28.4 Adding the Constraints

28.5 Testing the Layout

28.6 Using the Layout Inspector

28.7 Summary

29. Manual XML Layout Design in Android Studio

29.1 Manually Creating an XML Layout

29.2 Manual XML vs. Visual Layout Design

29.3 Summary

30. Managing Constraints using Constraint Sets

30.1 Kotlin Code vs. XML Layout Files

30.2 Creating Views

30.3 View Attributes

30.4 Constraint Sets

30.4.1 Establishing Connections

30.4.2 Applying Constraints to a Layout

30.4.3 Parent Constraint Connections

30.4.4 Sizing Constraints

30.4.5 Constraint Bias

30.4.6 Alignment Constraints

30.4.7 Copying and Applying Constraint Sets

30.4.8 ConstraintLayout Chains

30.4.9 Guidelines

30.4.10 Removing Constraints

30.4.11 Scaling

30.4.12 Rotation

30.5 Summary

31. An Android ConstraintSet Tutorial

31.1 Creating the Example Project in Android Studio

31.2 Adding Views to an Activity

31.3 Setting View Attributes

31.4 Creating View IDs

31.5 Configuring the Constraint Set

31.6 Adding the EditText View

31.7 Converting Density Independent Pixels (dp) to Pixels (px)

31.8 Summary

32. A Guide to Using Apply Changes in Android Studio

32.1 Introducing Apply Changes

32.2 Understanding Apply Changes Options

32.3 Using Apply Changes

32.4 Configuring Apply Changes Fallback Settings

32.5 An Apply Changes Tutorial

32.6 Using Apply Code Changes

32.7 Using Apply Changes and Restart Activity

32.8 Using Run App

32.9 Summary

33. A Guide to Gradle Version Catalogs

33.1 Library and Plugin Dependencies

33.2 Project Gradle Build File

33.3 Module Gradle Build Files

33.4 Version Catalog File

33.5 Adding Dependencies

33.6 Library Updates

33.7 Summary

34. An Overview and Example of Android Event Handling

34.1 Understanding Android Events

34.2 Using the android:onClick Resource

34.3 Event Listeners and Callback Methods

34.4 An Event Handling Example

34.5 Designing the User Interface

34.6 The Event Listener and Callback Method

34.7 Consuming Events

34.8 Summary

35. Android Touch and Multi-touch Event Handling

35.1 Intercepting Touch Events

35.2 The MotionEvent Object

35.3 Understanding Touch Actions

35.4 Handling Multiple Touches

35.5 An Example Multi-Touch Application

35.6 Designing the Activity User Interface

35.7 Implementing the Touch Event Listener

35.8 Running the Example Application

35.9 Summary

36. Detecting Common Gestures Using the Android Gesture Detector Class

36.1 Implementing Common Gesture Detection

36.2 Creating an Example Gesture Detection Project

36.3 Implementing the Listener Class

36.4 Creating the GestureDetector Instance

36.5 Implementing the onTouchEvent() Method

36.6 Testing the Application

36.7 Summary

37. Implementing Custom Gesture and Pinch Recognition on Android

37.1 The Android Gesture Builder Application

37.2 The GestureOverlayView Class

37.3 Detecting Gestures

37.4 Identifying Specific Gestures

37.5 Installing and Running the Gesture Builder Application

37.6 Creating a Gestures File

37.7 Creating the Example Project

37.8 Extracting the Gestures File from the SD Card

37.9 Adding the Gestures File to the Project

37.10 Designing the User Interface

37.11 Loading the Gestures File

37.12 Registering the Event Listener

37.13 Implementing the onGesturePerformed Method

37.14 Testing the Application

37.15 Configuring the GestureOverlayView

37.16 Intercepting Gestures

37.17 Detecting Pinch Gestures

37.18 A Pinch Gesture Example Project

37.19 Summary

38. An Introduction to Android Fragments

38.1 What is a Fragment?

38.2 Creating a Fragment

38.3 Adding a Fragment to an Activity using the Layout XML File

38.4 Adding and Managing Fragments in Code

38.5 Handling Fragment Events

38.6 Implementing Fragment Communication

38.7 Summary

39. Using Fragments in Android Studio - An Example

39.1 About the Example Fragment Application

39.2 Creating the Example Project

39.3 Creating the First Fragment Layout

39.4 Migrating a Fragment to View Binding

39.5 Adding the Second Fragment

39.6 Adding the Fragments to the Activity

39.7 Making the Toolbar Fragment Talk to the Activity

39.8 Making the Activity Talk to the Text Fragment

39.9 Testing the Application

39.10 Summary

40. Modern Android App Architecture with Jetpack

40.1 What is Android Jetpack?

40.2 The “Old” Architecture

40.3 Modern Android Architecture

40.4 The ViewModel Component

40.5 The LiveData Component

40.6 ViewModel Saved State

40.7 LiveData and Data Binding

40.8 Android Lifecycles

40.9 Repository Modules

40.10 Summary

41. An Android ViewModel Tutorial

41.1 About the Project

41.2 Creating the ViewModel Example Project

41.3 Removing Unwanted Project Elements

41.4 Designing the Fragment Layout

41.5 Implementing the View Model

41.6 Associating the Fragment with the View Model

41.7 Modifying the Fragment

41.8 Accessing the ViewModel Data

41.9 Testing the Project

41.10 Summary

42. An Android Jetpack LiveData Tutorial

42.1 LiveData - A Recap

42.2 Adding LiveData to the ViewModel

42.3 Implementing the Observer

42.4 Summary

43. An Overview of Android Jetpack Data Binding

43.1 An Overview of Data Binding

43.2 The Key Components of Data Binding

43.2.1 The Project Build Configuration

43.2.2 The Data Binding Layout File

43.2.3 The Layout File Data Element

43.2.4 The Binding Classes

43.2.5 Data Binding Variable Configuration

43.2.6 Binding Expressions (One-Way)

43.2.7 Binding Expressions (Two-Way)

43.2.8 Event and Listener Bindings

43.3 Summary

44. An Android Jetpack Data Binding Tutorial

44.1 Removing the Redundant Code

44.2 Enabling Data Binding

44.3 Adding the Layout Element

44.4 Adding the Data Element to Layout File

44.5 Working with the Binding Class

44.6 Assigning the ViewModel Instance to the Data Binding Variable

44.7 Adding Binding Expressions

44.8 Adding the Conversion Method

44.9 Adding a Listener Binding

44.10 Testing the App

44.11 Summary

45. An Android ViewModel Saved State Tutorial

45.1 Understanding ViewModel State Saving

45.2 Implementing ViewModel State Saving

45.3 Saving and Restoring State

45.4 Adding Saved State Support to the ViewModelDemo Project

45.5 Summary

46. Working with Android Lifecycle-Aware Components

46.1 Lifecycle Awareness

46.2 Lifecycle Owners

46.3 Lifecycle Observers

46.4 Lifecycle States and Events

46.5 Summary

47. An Android Jetpack Lifecycle Awareness Tutorial

47.1 Creating the Example Lifecycle Project

47.2 Creating a Lifecycle Observer

47.3 Adding the Observer

47.4 Testing the Observer

47.5 Creating a Lifecycle Owner

47.6 Testing the Custom Lifecycle Owner

47.7 Summary

48. An Overview of the Navigation Architecture Component

48.1 Understanding Navigation

48.2 Declaring a Navigation Host

48.3 The Navigation Graph

48.4 Accessing the Navigation Controller

48.5 Triggering a Navigation Action

48.6 Passing Arguments

48.7 Summary

49. An Android Jetpack Navigation Component Tutorial

49.1 Creating the NavigationDemo Project

49.2 Adding Navigation to the Build Configuration

49.3 Creating the Navigation Graph Resource File

49.4 Declaring a Navigation Host

49.5 Adding Navigation Destinations

49.6 Designing the Destination Fragment Layouts

49.7 Adding an Action to the Navigation Graph

49.8 Implement the OnFragmentInteractionListener

49.9 Adding View Binding Support to the Destination Fragments

49.10 Triggering the Action

49.11 Passing Data Using Safeargs

49.12 Summary

50. An Introduction to MotionLayout

50.1 An Overview of MotionLayout

50.2 MotionLayout

50.3 MotionScene

50.4 Configuring ConstraintSets

50.5 Custom Attributes

50.6 Triggering an Animation

50.7 Arc Motion

50.8 Keyframes

50.8.1 Attribute Keyframes

50.8.2 Position Keyframes

50.9 Time Linearity

50.10 KeyTrigger

50.11 Cycle and Time Cycle Keyframes

50.12 Starting an Animation from Code

50.13 Summary

51. An Android MotionLayout Editor Tutorial

51.1 Creating the MotionLayoutDemo Project

51.2 ConstraintLayout to MotionLayout Conversion

51.3 Configuring Start and End Constraints

51.4 Previewing the MotionLayout Animation

51.5 Adding an OnClick Gesture

51.6 Adding an Attribute Keyframe to the Transition

51.7 Adding a CustomAttribute to a Transition

51.8 Adding Position Keyframes

51.9 Summary

52. A MotionLayout KeyCycle Tutorial

52.1 An Overview of Cycle Keyframes

52.2 Using the Cycle Editor

52.3 Creating the KeyCycleDemo Project

52.4 Configuring the Start and End Constraints

52.5 Creating the Cycles

52.6 Previewing the Animation

52.7 Adding the KeyFrameSet to the MotionScene

52.8 Summary

53. Working with the Floating Action Button and Snackbar

53.1 The Material Design

53.2 The Design Library

53.3 The Floating Action Button (FAB)

53.4 The Snackbar

53.5 Creating the Example Project

53.6 Reviewing the Project

53.7 Removing Navigation Features

53.8 Changing the Floating Action Button

53.9 Adding an Action to the Snackbar

53.10 Summary

54. Creating a Tabbed Interface using the TabLayout Component

54.1 An Introduction to the ViewPager2

54.2 An Overview of the TabLayout Component

54.3 Creating the TabLayoutDemo Project

54.4 Creating the First Fragment

54.5 Duplicating the Fragments

54.6 Adding the TabLayout and ViewPager2

54.7 Performing the Initialization Tasks

54.8 Testing the Application

54.9 Customizing the TabLayout

54.10 Summary

55. Working with the RecyclerView and CardView Widgets

55.1 An Overview of the RecyclerView

55.2 An Overview of the CardView

55.3 Summary

56. An Android RecyclerView and CardView Tutorial

56.1 Creating the CardDemo Project

56.2 Modifying the Basic Views Activity Project

56.3 Designing the CardView Layout

56.4 Adding the RecyclerView

56.5 Adding the Image Files

56.6 Creating the RecyclerView Adapter

56.7 Initializing the RecyclerView Component

56.8 Testing the Application

56.9 Responding to Card Selections

56.10 Summary

57. Working with the AppBar and Collapsing Toolbar Layouts

57.1 The Anatomy of an AppBar

57.2 The Example Project

57.3 Coordinating the RecyclerView and Toolbar

57.4 Introducing the Collapsing Toolbar Layout

57.5 Changing the Title and Scrim Color

57.6 Summary

58. An Overview of Android Intents

58.1 An Overview of Intents

58.2 Explicit Intents

58.3 Returning Data from an Activity

58.4 Implicit Intents

58.5 Using Intent Filters

58.6 Automatic Link Verification

58.7 Manually Enabling Links

58.8 Checking Intent Availability

58.9 Summary

59. Android Explicit Intents – A Worked Example

59.1 Creating the Explicit Intent Example Application

59.2 Designing the User Interface Layout for MainActivity

59.3 Creating the Second Activity Class

59.4 Designing the User Interface Layout for SecondActivity

59.5 Reviewing the Application Manifest File

59.6 Creating the Intent

59.7 Extracting Intent Data

59.8 Launching SecondActivity as a Sub-Activity

59.9 Returning Data from a Sub-Activity

59.10 Testing the Application

59.11 Summary

60. Android Implicit Intents – A Worked Example

60.1 Creating the Android Studio Implicit Intent Example Project

60.2 Designing the User Interface

60.3 Creating the Implicit Intent

60.4 Adding a Second Matching Activity

60.5 Adding the Web View to the UI

60.6 Obtaining the Intent URL

60.7 Modifying the MyWebView Project Manifest File

60.8 Installing the MyWebView Package on a Device

60.9 Testing the Application

60.10 Manually Enabling the Link

60.11 Automatic Link Verification

60.12 Summary

61. Android Broadcast Intents and Broadcast Receivers

61.1 An Overview of Broadcast Intents

61.2 An Overview of Broadcast Receivers

61.3 Obtaining Results from a Broadcast

61.4 Sticky Broadcast Intents

61.5 The Broadcast Intent Example

61.6 Creating the Example Application

61.7 Creating and Sending the Broadcast Intent

61.8 Creating the Broadcast Receiver

61.9 Registering the Broadcast Receiver

61.10 Testing the Broadcast Example

61.11 Listening for System Broadcasts

61.12 Summary

62. An Introduction to Kotlin Coroutines

62.1 What are Coroutines?

62.2 Threads vs. Coroutines

62.3 Coroutine Scope

62.4 Suspend Functions

62.5 Coroutine Dispatchers

62.6 Coroutine Builders

62.7 Jobs

62.8 Coroutines – Suspending and Resuming

62.9 Returning Results from a Coroutine

62.10 Using withContext

62.11 Coroutine Channel Communication

62.12 Summary

63. An Android Kotlin Coroutines Tutorial

63.1 Creating the Coroutine Example Application

63.2 Designing the User Interface

63.3 Implementing the SeekBar

63.4 Adding the Suspend Function

63.5 Implementing the launchCoroutines Method

63.6 Testing the App

63.7 Summary

64. An Overview of Android Services

64.1 Intent Service

64.2 Bound Service

64.3 The Anatomy of a Service

64.4 Controlling Destroyed Service Restart Options

64.5 Declaring a Service in the Manifest File

64.6 Starting a Service Running on System Startup

64.7 Summary

65. Android Local Bound Services – A Worked Example

65.1 Understanding Bound Services

65.2 Bound Service Interaction Options

65.3 A Local Bound Service Example

65.4 Adding a Bound Service to the Project

65.5 Implementing the Binder

65.6 Binding the Client to the Service

65.7 Completing the Example

65.8 Testing the Application

65.9 Summary

66. Android Remote Bound Services – A Worked Example

66.1 Client to Remote Service Communication

66.2 Creating the Example Application

66.3 Designing the User Interface

66.4 Implementing the Remote Bound Service

66.5 Configuring a Remote Service in the Manifest File

66.6 Launching and Binding to the Remote Service

66.7 Sending a Message to the Remote Service

66.8 Summary

67. An Introduction to Kotlin Flow

67.1 Understanding Flows

67.2 Creating the Sample Project

67.3 Adding the Kotlin Lifecycle Library

67.4 Declaring a Flow

67.5 Emitting Flow Data

67.6 Collecting Flow Data

67.7 Adding a Flow Buffer

67.8 Transforming Data with Intermediaries

67.9 Terminal Flow Operators

67.10 Flow Flattening

67.11 Combining Multiple Flows

67.12 Hot and Cold Flows

67.13 StateFlow

67.14 SharedFlow

67.15 Summary

68. An Android SharedFlow Tutorial

68.1 About the Project

68.2 Creating the SharedFlowDemo Project

68.3 Adding the Lifecycle Libraries

68.4 Designing the User Interface Layout

68.5 Adding the List Row Layout

68.6 Adding the RecyclerView Adapter

68.7 Adding the ViewModel

68.8 Configuring the ViewModelProvider

68.9 Collecting the Flow Values

68.10 Testing the SharedFlowDemo App

68.11 Handling Flows in the Background

68.12 Summary

69. An Overview of Android SQLite Databases

69.1 Understanding Database Tables

69.2 Introducing Database Schema

69.3 Columns and Data Types

69.4 Database Rows

69.5 Introducing Primary Keys

69.6 What is SQLite?

69.7 Structured Query Language (SQL)

69.8 Trying SQLite on an Android Virtual Device (AVD)

69.9 Android SQLite Classes

69.9.1 Cursor

69.9.2 SQLiteDatabase

69.9.3 SQLiteOpenHelper

69.9.4 ContentValues

69.10 The Android Room Persistence Library

69.11 Summary

70. An Android SQLite Database Tutorial

70.1 About the Database Example

70.2 Creating the SQLDemo Project

70.3 Designing the User interface

70.4 Creating the Data Model

70.5 Implementing the Data Handler

70.6 The Add Handler Method

70.7 The Query Handler Method

70.8 The Delete Handler Method

70.9 Implementing the Activity Event Methods

70.10 Testing the Application

70.11 Summary

71. Understanding Android Content Providers

71.1 What is a Content Provider?

71.2 The Content Provider

71.2.1 onCreate()

71.2.2 query()

71.2.3 insert()

71.2.4 update()

71.2.5 delete()

71.2.6 getType()

71.3 The Content URI

71.4 The Content Resolver

71.5 The <provider> Manifest Element

71.6 Summary

72. An Android Content Provider Tutorial

72.1 Copying the SQLDemo Project

72.2 Adding the Content Provider Package

72.3 Creating the Content Provider Class

72.4 Constructing the Authority and Content URI

72.5 Implementing URI Matching in the Content Provider

72.6 Implementing the Content Provider onCreate() Method

72.7 Implementing the Content Provider insert() Method

72.8 Implementing the Content Provider query() Method

72.9 Implementing the Content Provider update() Method

72.10 Implementing the Content Provider delete() Method

72.11 Declaring the Content Provider in the Manifest File

72.12 Modifying the Database Handler

72.13 Summary

73. An Android Content Provider Client Tutorial

73.1 Creating the SQLDemoClient Project

73.2 Designing the User interface

73.3 Accessing the Content Provider

73.4 Adding the Query Permission

73.5 Testing the Project

73.6 Summary

74. The Android Room Persistence Library

74.1 Revisiting Modern App Architecture

74.2 Key Elements of Room Database Persistence

74.2.1 Repository

74.2.2 Room Database

74.2.3 Data Access Object (DAO)

74.2.4 Entities

74.2.5 SQLite Database

74.3 Understanding Entities

74.4 Data Access Objects

74.5 The Room Database

74.6 The Repository

74.7 In-Memory Databases

74.8 Database Inspector

74.9 Summary

75. An Android TableLayout and TableRow Tutorial

75.1 The TableLayout and TableRow Layout Views

75.2 Creating the Room Database Project

75.3 Converting to a LinearLayout

75.4 Adding the TableLayout to the User Interface

75.5 Configuring the TableRows

75.6 Adding the Button Bar to the Layout

75.7 Adding the RecyclerView

75.8 Adjusting the Layout Margins

75.9 Summary

76. An Android Room Database and Repository Tutorial

76.1 About the RoomDemo Project

76.2 Modifying the Build Configuration

76.3 Building the Entity

76.4 Creating the Data Access Object

76.5 Adding the Room Database

76.6 Adding the Repository

76.7 Adding the ViewModel

76.8 Creating the Product Item Layout

76.9 Adding the RecyclerView Adapter

76.10 Preparing the Main Activity

76.11 Adding the Button Listeners

76.12 Adding LiveData Observers

76.13 Initializing the RecyclerView

76.14 Testing the RoomDemo App

76.15 Using the Database Inspector

76.16 Summary

77. Video Playback on Android using the VideoView and MediaController Classes

77.1 Introducing the Android VideoView Class

77.2 Introducing the Android MediaController Class

77.3 Creating the Video Playback Example

77.4 Designing the VideoPlayer Layout

77.5 Downloading the Video File

77.6 Configuring the VideoView

77.7 Adding the MediaController to the Video View

77.8 Setting up the onPreparedListener

77.9 Summary

78. Android Picture-in-Picture Mode

78.1 Picture-in-Picture Features

78.2 Enabling Picture-in-Picture Mode

78.3 Configuring Picture-in-Picture Parameters

78.4 Entering Picture-in-Picture Mode

78.5 Detecting Picture-in-Picture Mode Changes

78.6 Adding Picture-in-Picture Actions

78.7 Summary

79. An Android Picture-in-Picture Tutorial

79.1 Adding Picture-in-Picture Support to the Manifest

79.2 Adding a Picture-in-Picture Button

79.3 Entering Picture-in-Picture Mode

79.4 Detecting Picture-in-Picture Mode Changes

79.5 Adding a Broadcast Receiver

79.6 Adding the PiP Action

79.7 Testing the Picture-in-Picture Action

79.8 Summary

80. Making Runtime Permission Requests in Android

80.1 Understanding Normal and Dangerous Permissions

80.2 Creating the Permissions Example Project

80.3 Checking for a Permission

80.4 Requesting Permission at Runtime

80.5 Providing a Rationale for the Permission Request

80.6 Testing the Permissions App

80.7 Summary

81. Android Audio Recording and Playback using MediaPlayer and MediaRecorder

81.1 Playing Audio

81.2 Recording Audio and Video using the MediaRecorder Class

81.3 About the Example Project

81.4 Creating the AudioApp Project

81.5 Designing the User Interface

81.6 Checking for Microphone Availability

81.7 Initializing the Activity

81.8 Implementing the recordAudio() Method

81.9 Implementing the stopAudio() Method

81.10 Implementing the playAudio() method

81.11 Configuring and Requesting Permissions

81.12 Testing the Application

81.13 Summary

82. An Android Notifications Tutorial

82.1 An Overview of Notifications

82.2 Creating the NotifyDemo Project

82.3 Designing the User Interface

82.4 Creating the Second Activity

82.5 Creating a Notification Channel

82.6 Requesting Notification Permission

82.7 Creating and Issuing a Notification

82.8 Launching an Activity from a Notification

82.9 Adding Actions to a Notification

82.10 Bundled Notifications

82.11 Summary

83. An Android Direct Reply Notification Tutorial

83.1 Creating the DirectReply Project

83.2 Designing the User Interface

83.3 Requesting Notification Permission

83.4 Creating the Notification Channel

83.5 Building the RemoteInput Object

83.6 Creating the PendingIntent

83.7 Creating the Reply Action

83.8 Receiving Direct Reply Input

83.9 Updating the Notification

83.10 Summary

84. Working with the Google Maps Android API in Android Studio

84.1 The Elements of the Google Maps Android API

84.2 Creating the Google Maps Project

84.3 Creating a Google Cloud Billing Account

84.4 Creating a New Google Cloud Project

84.5 Enabling the Google Maps SDK

84.6 Generating a Google Maps API Key

84.7 Adding the API Key to the Android Studio Project

84.8 Testing the Application

84.9 Understanding Geocoding and Reverse Geocoding

84.10 Adding a Map to an Application

84.11 Requesting Current Location Permission

84.12 Displaying the User’s Current Location

84.13 Changing the Map Type

84.14 Displaying Map Controls to the User

84.15 Handling Map Gesture Interaction

84.15.1 Map Zooming Gestures

84.15.2 Map Scrolling/Panning Gestures

84.15.3 Map Tilt Gestures

84.15.4 Map Rotation Gestures

84.16 Creating Map Markers

84.17 Controlling the Map Camera

84.18 Summary

85. Printing with the Android Printing Framework

85.1 The Android Printing Architecture

85.2 The Print Service Plugins

85.3 Google Cloud Print

85.4 Printing to Google Drive

85.5 Save as PDF

85.6 Printing from Android Devices

85.7 Options for Building Print Support into Android Apps

85.7.1 Image Printing

85.7.2 Creating and Printing HTML Content

85.7.3 Printing a Web Page

85.7.4 Printing a Custom Document

85.8 Summary

86. An Android HTML and Web Content Printing Example

86.1 Creating the HTML Printing Example Application

86.2 Printing Dynamic HTML Content

86.3 Creating the Web Page Printing Example

86.4 Removing the Floating Action Button

86.5 Removing Navigation Features

86.6 Designing the User Interface Layout

86.7 Accessing the WebView from the Main Activity

86.8 Loading the Web Page into the WebView

86.9 Adding the Print Menu Option

86.10 Summary

87. A Guide to Android Custom Document Printing

87.1 An Overview of Android Custom Document Printing

87.1.1 Custom Print Adapters

87.2 Preparing the Custom Document Printing Project

87.3 Designing the UI

87.4 Creating the Custom Print Adapter

87.5 Implementing the onLayout() Callback Method

87.6 Implementing the onWrite() Callback Method

87.7 Checking a Page is in Range

87.8 Drawing the Content on the Page Canvas

87.9 Starting the Print Job

87.10 Testing the Application

87.11 Summary

88. An Introduction to Android App Links

88.1 An Overview of Android App Links

88.2 App Link Intent Filters

88.3 Handling App Link Intents

88.4 Associating the App with a Website

88.5 Summary

89. An Android Studio App Links Tutorial

89.1 About the Example App

89.2 The Database Schema

89.3 Loading and Running the Project

89.4 Adding the URL Mapping

89.5 Adding the Intent Filter

89.6 Adding Intent Handling Code

89.7 Testing the App

89.8 Creating the Digital Asset Links File

89.9 Testing the App Link

89.10 Summary

90. An Android Biometric Authentication Tutorial

90.1 An Overview of Biometric Authentication

90.2 Creating the Biometric Authentication Project

90.3 Configuring Device Fingerprint Authentication

90.4 Adding the Biometric Permission to the Manifest File

90.5 Designing the User Interface

90.6 Adding a Toast Convenience Method

90.7 Checking the Security Settings

90.8 Configuring the Authentication Callbacks

90.9 Adding the CancellationSignal

90.10 Starting the Biometric Prompt

90.11 Testing the Project

90.12 Summary

91. Creating, Testing, and Uploading an Android App Bundle

91.1 The Release Preparation Process

91.2 Android App Bundles

91.3 Register for a Google Play Developer Console Account

91.4 Configuring the App in the Console

91.5 Enabling Google Play App Signing

91.6 Creating a Keystore File

91.7 Creating the Android App Bundle

91.8 Generating Test APK Files

91.9 Uploading the App Bundle to the Google Play Developer Console

91.10 Exploring the App Bundle

91.11 Managing Testers

91.12 Rolling the App Out for Testing

91.13 Uploading New App Bundle Revisions

91.14 Analyzing the App Bundle File

91.15 Summary

92. An Overview of Android In-App Billing

92.1 Preparing a Project for In-App Purchasing

92.2 Creating In-App Products and Subscriptions

92.3 Billing Client Initialization

92.4 Connecting to the Google Play Billing Library

92.5 Querying Available Products

92.6 Starting the Purchase Process

92.7 Completing the Purchase

92.8 Querying Previous Purchases

92.9 Summary

93. An Android In-App Purchasing Tutorial

93.1 About the In-App Purchasing Example Project

93.2 Creating the InAppPurchase Project

93.3 Adding Libraries to the Project

93.4 Designing the User Interface

93.5 Adding the App to the Google Play Store

93.6 Creating an In-App Product

93.7 Enabling License Testers

93.8 Initializing the Billing Client

93.9 Querying the Product

93.10 Launching the Purchase Flow

93.11 Handling Purchase Updates

93.12 Consuming the Product

93.13 Restoring a Previous Purchase

93.14 Testing the App

93.15 Troubleshooting

93.16 Summary

94. Accessing Cloud Storage using the Android Storage Access Framework

94.1 The Storage Access Framework

94.2 Working with the Storage Access Framework

94.3 Filtering Picker File Listings

94.4 Handling Intent Results

94.5 Reading the Content of a File

94.6 Writing Content to a File

94.7 Deleting a File

94.8 Gaining Persistent Access to a File

94.9 Summary

95. An Android Storage Access Framework Example

95.1 About the Storage Access Framework Example

95.2 Creating the Storage Access Framework Example

95.3 Designing the User Interface

95.4 Adding the Activity Launchers

95.5 Creating a New Storage File

95.6 Saving to a Storage File

95.7 Opening and Reading a Storage File

95.8 Testing the Storage Access Application

95.9 Summary

96. An Android Studio Primary/Detail Flow Tutorial

96.1 The Primary/Detail Flow

96.2 Creating a Primary/Detail Flow Activity

96.3 Adding the Primary/Detail Flow Activity

96.4 Modifying the Primary/Detail Flow Template

96.5 Changing the Content Model

96.6 Changing the Detail Pane

96.7 Modifying the ItemDetailFragment Class

96.8 Modifying the ItemListFragment Class

96.9 Adding Manifest Permissions

96.10 Running the Application

96.11 Summary

97. Working with Material Design 3 Theming

97.1 Material Design 2 vs. Material Design 3

97.2 Understanding Material Design Theming

97.3 Material Design 3 Theming

97.4 Building a Custom Theme

97.5 Summary

98. A Material Design 3 Theming and Dynamic Color Tutorial

98.1 Creating the ThemeDemo Project

98.2 Designing the User Interface

98.3 Building a New Theme

98.4 Adding the Theme to the Project

98.5 Enabling Dynamic Color Support

98.6 Previewing Dynamic Colors

98.7 Summary

99. An Overview of Gradle in Android Studio

99.1 An Overview of Gradle

99.2 Gradle and Android Studio

99.2.1 Sensible Defaults

99.2.2 Dependencies

99.2.3 Build Variants

99.2.4 Manifest Entries

99.2.5 APK Signing

99.2.6 ProGuard Support

99.3 The Property and Settings Gradle Build File

99.4 The Top-level Gradle Build File

99.5 Module Level Gradle Build Files

99.6 Configuring Signing Settings in the Build File

99.7 Running Gradle Tasks from the Command Line

99.8 Summary

Index

1. Introduction

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

This book begins with the basics and outlines how to set up an Android development and testing environment, followed by an introduction to programming in Kotlin, including data types, control flow, functions, lambdas, and object-oriented programming. Asynchronous programming using Kotlin coroutines and flow is also covered in detail.

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 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/jellyfishkotlin/

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 [e-mail].

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/jellyfishkotlin

If you find an error not listed in the errata, please let us know by emailing our technical support team at [e-mail]. 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), the Kotlin plug-in 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 Jellyfish 2023.3.1 using the Android API 34 SDK (UpsideDownCake), 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 Jellyfish” 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 Jellyfish 2023.3.1 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 Jellyfish, this is Android UpsideDownCake (API Level 34). 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 UpsideDownCake (API Level 34) 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-34

*Note that the Intel x86 Emulator Accelerator (HAXM installer) cannot be installed on Apple silicon-based Macs.

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 Kotlinand 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