Location via proxy:   [ UP ]  
[Report a bug]   [Manage cookies]                
Everand Logo

Welcome to Everand!

  • Discover millions of ebooks, audiobooks, and so much more with a free trial

    From $11.99/month after trial. Cancel anytime.

    Android Studio Hedgehog Essentials - Java Edition: Developing Android Apps Using Android Studio 2023.1.1 and Java
    Android Studio Hedgehog Essentials - Java Edition: Developing Android Apps Using Android Studio 2023.1.1 and Java
    Android Studio Hedgehog Essentials - Java Edition: Developing Android Apps Using Android Studio 2023.1.1 and Java
    Ebook1,787 pages35 hours

    Android Studio Hedgehog Essentials - Java Edition: Developing Android Apps Using Android Studio 2023.1.1 and Java

    By Neil Smyth

    ()

    Read preview

    About this ebook

    Fully updated for Android Studio Hedgehog (2023.1.1) and the new UI, this book teaches you how to develop Android-based applications using the Java programming language.


    This book begins with the basics and outlines how to set up an Android development and testing environment, followed by an overview of areas such as tool windo

    LanguageEnglish
    PublisherPayload Media, Inc.
    Release dateDec 8, 2023
    ISBN9798869057259
    Android Studio Hedgehog Essentials - Java Edition: Developing Android Apps Using Android Studio 2023.1.1 and Java

    Read more from Neil Smyth

    Related to Android Studio Hedgehog Essentials - Java Edition

    Related ebooks

    Programming For You

    View More
    View More

    Related podcast episodes

    Related categories

    Reviews for Android Studio Hedgehog Essentials - Java Edition

    0 ratings

    0 ratings0 reviews

    What did you think?

    Tap to rate

    Review must be at least 10 words

      Book preview

      Android Studio Hedgehog Essentials - Java Edition - Neil Smyth

      java_hedgehog_front_cover_large.png

      Android Studio Hedgehog

      Essentials

      Java Edition

      Title

      Android Studio Hedgehog Essentials – Java Edition

      © 2023 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

      Find more books at https://www.payloadbooks.com.

      Copyright

      "

      Table of Contents

      1. Introduction

      1.1 Downloading the Code Samples

      1.2 Feedback

      1.3 Errata

      2. Setting up an Android Studio Development Environment

      2.1 System requirements

      2.2 Downloading the Android Studio package

      2.3 Installing Android Studio

      2.3.1 Installation on Windows

      2.3.2 Installation on macOS

      2.3.3 Installation on Linux

      2.4 The Android Studio setup wizard

      2.5 Installing additional Android SDK packages

      2.6 Installing the Android SDK Command-line Tools

      2.6.1 Windows 8.1

      2.6.2 Windows 10

      2.6.3 Windows 11

      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 Enabling the New Android Studio UI

      3.6 Modifying the Example Application

      3.7 Modifying the User Interface

      3.8 Reviewing the Layout and Resource Files

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

      10.1 Android Activities

      10.2 Android Fragments

      10.3 Android Intents

      10.4 Broadcast Intents

      10.5 Broadcast Receivers

      10.6 Android Services

      10.7 Content Providers

      10.8 The Application Manifest

      10.9 Application Resources

      10.10 Application Context

      10.11 Summary

      11. An Overview of Android View Binding

      11.1 Find View by Id

      11.2 View Binding

      11.3 Converting the AndroidSample project

      11.4 Enabling View Binding

      11.5 Using View Binding

      11.6 Choosing an Option

      11.7 View Binding in the Book Examples

      11.8 Migrating a Project to View Binding

      11.9 Summary

      12. Understanding Android Application and Activity Lifecycles

      12.1 Android Applications and Resource Management

      12.2 Android Process States

      12.2.1 Foreground Process

      12.2.2 Visible Process

      12.2.3 Service Process

      12.2.4 Background Process

      12.2.5 Empty Process

      12.3 Inter-Process Dependencies

      12.4 The Activity Lifecycle

      12.5 The Activity Stack

      12.6 Activity States

      12.7 Configuration Changes

      12.8 Handling State Change

      12.9 Summary

      13. Handling Android Activity State Changes

      13.1 New vs. Old Lifecycle Techniques

      13.2 The Activity and Fragment Classes

      13.3 Dynamic State vs. Persistent State

      13.4 The Android Lifecycle Methods

      13.5 Lifetimes

      13.6 Foldable Devices and Multi-Resume

      13.7 Disabling Configuration Change Restarts

      13.8 Lifecycle Method Limitations

      13.9 Summary

      14. Android Activity State Changes by Example

      14.1 Creating the State Change Example Project

      14.2 Designing the User Interface

      14.3 Overriding the Activity Lifecycle Methods

      14.4 Filtering the Logcat Panel

      14.5 Running the Application

      14.6 Experimenting with the Activity

      14.7 Summary

      15. Saving and Restoring the State of an Android Activity

      15.1 Saving Dynamic State

      15.2 Default Saving of User Interface State

      15.3 The Bundle Class

      15.4 Saving the State

      15.5 Restoring the State

      15.6 Testing the Application

      15.7 Summary

      16. Understanding Android Views, View Groups and Layouts

      16.1 Designing for Different Android Devices

      16.2 Views and View Groups

      16.3 Android Layout Managers

      16.4 The View Hierarchy

      16.5 Creating User Interfaces

      16.6 Summary

      17. A Guide to the Android Studio Layout Editor Tool

      17.1 Basic vs. Empty Views Activity Templates

      17.2 The Android Studio Layout Editor

      17.3 Design Mode

      17.4 The Palette

      17.5 Design Mode and Layout Views

      17.6 Night Mode

      17.7 Code Mode

      17.8 Split Mode

      17.9 Setting Attributes

      17.10 Transforms

      17.11 Tools Visibility Toggles

      17.12 Converting Views

      17.13 Displaying Sample Data

      17.14 Creating a Custom Device Definition

      17.15 Changing the Current Device

      17.16 Layout Validation

      17.17 Summary

      18. A Guide to the Android ConstraintLayout

      18.1 How ConstraintLayout Works

      18.1.1 Constraints

      18.1.2 Margins

      18.1.3 Opposing Constraints

      18.1.4 Constraint Bias

      18.1.5 Chains

      18.1.6 Chain Styles

      18.2 Baseline Alignment

      18.3 Configuring Widget Dimensions

      18.4 Guideline Helper

      18.5 Group Helper

      18.6 Barrier Helper

      18.7 Flow Helper

      18.8 Ratios

      18.9 ConstraintLayout Advantages

      18.10 ConstraintLayout Availability

      18.11 Summary

      19. A Guide to Using ConstraintLayout in Android Studio

      19.1 Design and Layout Views

      19.2 Autoconnect Mode

      19.3 Inference Mode

      19.4 Manipulating Constraints Manually

      19.5 Adding Constraints in the Inspector

      19.6 Viewing Constraints in the Attributes Window

      19.7 Deleting Constraints

      19.8 Adjusting Constraint Bias

      19.9 Understanding ConstraintLayout Margins

      19.10 The Importance of Opposing Constraints and Bias

      19.11 Configuring Widget Dimensions

      19.12 Design Time Tools Positioning

      19.13 Adding Guidelines

      19.14 Adding Barriers

      19.15 Adding a Group

      19.16 Working with the Flow Helper

      19.17 Widget Group Alignment and Distribution

      19.18 Converting other Layouts to ConstraintLayout

      19.19 Summary

      20. Working with ConstraintLayout Chains and Ratios in Android Studio

      20.1 Creating a Chain

      20.2 Changing the Chain Style

      20.3 Spread Inside Chain Style

      20.4 Packed Chain Style

      20.5 Packed Chain Style with Bias

      20.6 Weighted Chain

      20.7 Working with Ratios

      20.8 Summary

      21. An Android Studio Layout Editor ConstraintLayout Tutorial

      21.1 An Android Studio Layout Editor Tool Example

      21.2 Preparing the Layout Editor Environment

      21.3 Adding the Widgets to the User Interface

      21.4 Adding the Constraints

      21.5 Testing the Layout

      21.6 Using the Layout Inspector

      21.7 Summary

      22. Manual XML Layout Design in Android Studio

      22.1 Manually Creating an XML Layout

      22.2 Manual XML vs. Visual Layout Design

      22.3 Summary

      23. Managing Constraints using Constraint Sets

      23.1 Java Code vs. XML Layout Files

      23.2 Creating Views

      23.3 View Attributes

      23.4 Constraint Sets

      23.4.1 Establishing Connections

      23.4.2 Applying Constraints to a Layout

      23.4.3 Parent Constraint Connections

      23.4.4 Sizing Constraints

      23.4.5 Constraint Bias

      23.4.6 Alignment Constraints

      23.4.7 Copying and Applying Constraint Sets

      23.4.8 ConstraintLayout Chains

      23.4.9 Guidelines

      23.4.10 Removing Constraints

      23.4.11 Scaling

      23.4.12 Rotation

      23.5 Summary

      24. An Android ConstraintSet Tutorial

      24.1 Creating the Example Project in Android Studio

      24.2 Adding Views to an Activity

      24.3 Setting View Attributes

      24.4 Creating View IDs

      24.5 Configuring the Constraint Set

      24.6 Adding the EditText View

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

      24.8 Summary

      25. A Guide to Using Apply Changes in Android Studio

      25.1 Introducing Apply Changes

      25.2 Understanding Apply Changes Options

      25.3 Using Apply Changes

      25.4 Configuring Apply Changes Fallback Settings

      25.5 An Apply Changes Tutorial

      25.6 Using Apply Code Changes

      25.7 Using Apply Changes and Restart Activity

      25.8 Using Run App

      25.9 Summary

      26. An Overview and Example of Android Event Handling

      26.1 Understanding Android Events

      26.2 Using the android:onClick Resource

      26.3 Event Listeners and Callback Methods

      26.4 An Event Handling Example

      26.5 Designing the User Interface

      26.6 The Event Listener and Callback Method

      26.7 Consuming Events

      26.8 Summary

      27. Android Touch and Multi-touch Event Handling

      27.1 Intercepting Touch Events

      27.2 The MotionEvent Object

      27.3 Understanding Touch Actions

      27.4 Handling Multiple Touches

      27.5 An Example Multi-Touch Application

      27.6 Designing the Activity User Interface

      27.7 Implementing the Touch Event Listener

      27.8 Running the Example Application

      27.9 Summary

      28. Detecting Common Gestures Using the Android Gesture Detector Class

      28.1 Implementing Common Gesture Detection

      28.2 Creating an Example Gesture Detection Project

      28.3 Implementing the Listener Class

      28.4 Creating the GestureDetectorCompat Instance

      28.5 Implementing the onTouchEvent() Method

      28.6 Testing the Application

      28.7 Summary

      29. Implementing Custom Gesture and Pinch Recognition on Android

      29.1 The Android Gesture Builder Application

      29.2 The GestureOverlayView Class

      29.3 Detecting Gestures

      29.4 Identifying Specific Gestures

      29.5 Installing and Running the Gesture Builder Application

      29.6 Creating a Gestures File

      29.7 Creating the Example Project

      29.8 Extracting the Gestures File from the SD Card

      29.9 Adding the Gestures File to the Project

      29.10 Designing the User Interface

      29.11 Loading the Gestures File

      29.12 Registering the Event Listener

      29.13 Implementing the onGesturePerformed Method

      29.14 Testing the Application

      29.15 Configuring the GestureOverlayView

      29.16 Intercepting Gestures

      29.17 Detecting Pinch Gestures

      29.18 A Pinch Gesture Example Project

      29.19 Summary

      30. An Introduction to Android Fragments

      30.1 What is a Fragment?

      30.2 Creating a Fragment

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

      30.4 Adding and Managing Fragments in Code

      30.5 Handling Fragment Events

      30.6 Implementing Fragment Communication

      30.7 Summary

      31. Using Fragments in Android Studio - An Example

      31.1 About the Example Fragment Application

      31.2 Creating the Example Project

      31.3 Creating the First Fragment Layout

      31.4 Migrating a Fragment to View Binding

      31.5 Adding the Second Fragment

      31.6 Adding the Fragments to the Activity

      31.7 Making the Toolbar Fragment Talk to the Activity

      31.8 Making the Activity Talk to the Text Fragment

      31.9 Testing the Application

      31.10 Summary

      32. Modern Android App Architecture with Jetpack

      32.1 What is Android Jetpack?

      32.2 The Old Architecture

      32.3 Modern Android Architecture

      32.4 The ViewModel Component

      32.5 The LiveData Component

      32.6 ViewModel Saved State

      32.7 LiveData and Data Binding

      32.8 Android Lifecycles

      32.9 Repository Modules

      32.10 Summary

      33. An Android ViewModel Tutorial

      33.1 About the Project

      33.2 Creating the ViewModel Example Project

      33.3 Removing Unwanted Project Elements

      33.4 Designing the Fragment Layout

      33.5 Implementing the View Model

      33.6 Associating the Fragment with the View Model

      33.7 Modifying the Fragment

      33.8 Accessing the ViewModel Data

      33.9 Testing the Project

      33.10 Summary

      34. An Android Jetpack LiveData Tutorial

      34.1 LiveData - A Recap

      34.2 Adding LiveData to the ViewModel

      34.3 Implementing the Observer

      34.4 Summary

      35. An Overview of Android Jetpack Data Binding

      35.1 An Overview of Data Binding

      35.2 The Key Components of Data Binding

      35.2.1 The Project Build Configuration

      35.2.2 The Data Binding Layout File

      35.2.3 The Layout File Data Element

      35.2.4 The Binding Classes

      35.2.5 Data Binding Variable Configuration

      35.2.6 Binding Expressions (One-Way)

      35.2.7 Binding Expressions (Two-Way)

      35.2.8 Event and Listener Bindings

      35.3 Summary

      36. An Android Jetpack Data Binding Tutorial

      36.1 Removing the Redundant Code

      36.2 Enabling Data Binding

      36.3 Adding the Layout Element

      36.4 Adding the Data Element to Layout File

      36.5 Working with the Binding Class

      36.6 Assigning the ViewModel Instance to the Data Binding Variable

      36.7 Adding Binding Expressions

      36.8 Adding the Conversion Method

      36.9 Adding a Listener Binding

      36.10 Testing the App

      36.11 Summary

      37. An Android ViewModel Saved State Tutorial

      37.1 Understanding ViewModel State Saving

      37.2 Implementing ViewModel State Saving

      37.3 Saving and Restoring State

      37.4 Adding Saved State Support to the ViewModelDemo Project

      37.5 Summary

      38. Working with Android Lifecycle-Aware Components

      38.1 Lifecycle Awareness

      38.2 Lifecycle Owners

      38.3 Lifecycle Observers

      38.4 Lifecycle States and Events

      38.5 Summary

      39. An Android Jetpack Lifecycle Awareness Tutorial

      39.1 Creating the Example Lifecycle Project

      39.2 Creating a Lifecycle Observer

      39.3 Adding the Observer

      39.4 Testing the Observer

      39.5 Creating a Lifecycle Owner

      39.6 Testing the Custom Lifecycle Owner

      39.7 Summary

      40. An Overview of the Navigation Architecture Component

      40.1 Understanding Navigation

      40.2 Declaring a Navigation Host

      40.3 The Navigation Graph

      40.4 Accessing the Navigation Controller

      40.5 Triggering a Navigation Action

      40.6 Passing Arguments

      40.7 Summary

      41. An Android Jetpack Navigation Component Tutorial

      41.1 Creating the NavigationDemo Project

      41.2 Adding Navigation to the Build Configuration

      41.3 Creating the Navigation Graph Resource File

      41.4 Declaring a Navigation Host

      41.5 Adding Navigation Destinations

      41.6 Designing the Destination Fragment Layouts

      41.7 Adding an Action to the Navigation Graph

      41.8 Implement the OnFragmentInteractionListener

      41.9 Adding View Binding Support to the Destination Fragments

      41.10 Triggering the Action

      41.11 Passing Data Using Safeargs

      41.12 Summary

      42. An Introduction to MotionLayout

      42.1 An Overview of MotionLayout

      42.2 MotionLayout

      42.3 MotionScene

      42.4 Configuring ConstraintSets

      42.5 Custom Attributes

      42.6 Triggering an Animation

      42.7 Arc Motion

      42.8 Keyframes

      42.8.1 Attribute Keyframes

      42.8.2 Position Keyframes

      42.9 Time Linearity

      42.10 KeyTrigger

      42.11 Cycle and Time Cycle Keyframes

      42.12 Starting an Animation from Code

      42.13 Summary

      43. An Android MotionLayout Editor Tutorial

      43.1 Creating the MotionLayoutDemo Project

      43.2 ConstraintLayout to MotionLayout Conversion

      43.3 Configuring Start and End Constraints

      43.4 Previewing the MotionLayout Animation

      43.5 Adding an OnClick Gesture

      43.6 Adding an Attribute Keyframe to the Transition

      43.7 Adding a CustomAttribute to a Transition

      43.8 Adding Position Keyframes

      43.9 Summary

      44. A MotionLayout KeyCycle Tutorial

      44.1 An Overview of Cycle Keyframes

      44.2 Using the Cycle Editor

      44.3 Creating the KeyCycleDemo Project

      44.4 Configuring the Start and End Constraints

      44.5 Creating the Cycles

      44.6 Previewing the Animation

      44.7 Adding the KeyFrameSet to the MotionScene

      44.8 Summary

      45. Working with the Floating Action Button and Snackbar

      45.1 The Material Design

      45.2 The Design Library

      45.3 The Floating Action Button (FAB)

      45.4 The Snackbar

      45.5 Creating the Example Project

      45.6 Reviewing the Project

      45.7 Removing Navigation Features

      45.8 Changing the Floating Action Button

      45.9 Adding an Action to the Snackbar

      45.10 Summary

      46. Creating a Tabbed Interface using the TabLayout Component

      46.1 An Introduction to the ViewPager2

      46.2 An Overview of the TabLayout Component

      46.3 Creating the TabLayoutDemo Project

      46.4 Creating the First Fragment

      46.5 Duplicating the Fragments

      46.6 Adding the TabLayout and ViewPager2

      46.7 Performing the Initialization Tasks

      46.8 Testing the Application

      46.9 Customizing the TabLayout

      46.10 Summary

      47. Working with the RecyclerView and CardView Widgets

      47.1 An Overview of the RecyclerView

      47.2 An Overview of the CardView

      47.3 Summary

      48. An Android RecyclerView and CardView Tutorial

      48.1 Creating the CardDemo Project

      48.2 Modifying the Basic Views Activity Project

      48.3 Designing the CardView Layout

      48.4 Adding the RecyclerView

      48.5 Adding the Image Files

      48.6 Creating the RecyclerView Adapter

      48.7 Initializing the RecyclerView Component

      48.8 Testing the Application

      48.9 Responding to Card Selections

      48.10 Summary

      49. A Layout Editor Sample Data Tutorial

      49.1 Adding Sample Data to a Project

      49.2 Using Custom Sample Data

      49.3 Summary

      50. Working with the AppBar and Collapsing Toolbar Layouts

      50.1 The Anatomy of an AppBar

      50.2 The Example Project

      50.3 Coordinating the RecyclerView and Toolbar

      50.4 Introducing the Collapsing Toolbar Layout

      50.5 Changing the Title and Scrim Color

      50.6 Summary

      51. An Android Studio Primary/Detail Flow Tutorial

      51.1 The Primary/Detail Flow

      51.2 Creating a Primary/Detail Flow Activity

      51.3 Adding the Primary/Detail Flow Activity

      51.4 Modifying the Primary/Detail Flow Template

      51.5 Changing the Content Model

      51.6 Changing the Detail Pane

      51.7 Modifying the ItemDetailFragment Class

      51.8 Modifying the ItemListFragment Class

      51.9 Adding Manifest Permissions

      51.10 Running the Application

      51.11 Summary

      52. An Overview of Android Services

      52.1 Intent Service

      52.2 Bound Service

      52.3 The Anatomy of a Service

      52.4 Controlling Destroyed Service Restart Options

      52.5 Declaring a Service in the Manifest File

      52.6 Starting a Service Running on System Startup

      52.7 Summary

      53. An Overview of Android Intents

      53.1 An Overview of Intents

      53.2 Explicit Intents

      53.3 Returning Data from an Activity

      53.4 Implicit Intents

      53.5 Using Intent Filters

      53.6 Automatic Link Verification

      53.7 Manually Enabling Links

      53.8 Checking Intent Availability

      53.9 Summary

      54. Android Explicit Intents – A Worked Example

      54.1 Creating the Explicit Intent Example Application

      54.2 Designing the User Interface Layout for MainActivity

      54.3 Creating the Second Activity Class

      54.4 Designing the User Interface Layout for SecondActivity

      54.5 Reviewing the Application Manifest File

      54.6 Creating the Intent

      54.7 Extracting Intent Data

      54.8 Launching SecondActivity as a Sub-Activity

      54.9 Returning Data from a Sub-Activity

      54.10 Testing the Application

      54.11 Summary

      55. Android Implicit Intents – A Worked Example

      55.1 Creating the Android Studio Implicit Intent Example Project

      55.2 Designing the User Interface

      55.3 Creating the Implicit Intent

      55.4 Adding a Second Matching Activity

      55.5 Adding the Web View to the UI

      55.6 Obtaining the Intent URL

      55.7 Modifying the MyWebView Project Manifest File

      55.8 Installing the MyWebView Package on a Device

      55.9 Testing the Application

      55.10 Manually Enabling the Link

      55.11 Automatic Link Verification

      55.12 Summary

      56. Android Broadcast Intents and Broadcast Receivers

      56.1 An Overview of Broadcast Intents

      56.2 An Overview of Broadcast Receivers

      56.3 Obtaining Results from a Broadcast

      56.4 Sticky Broadcast Intents

      56.5 The Broadcast Intent Example

      56.6 Creating the Example Application

      56.7 Creating and Sending the Broadcast Intent

      56.8 Creating the Broadcast Receiver

      56.9 Registering the Broadcast Receiver

      56.10 Testing the Broadcast Example

      56.11 Listening for System Broadcasts

      56.12 Summary

      57. Android Local Bound Services – A Worked Example

      57.1 Understanding Bound Services

      57.2 Bound Service Interaction Options

      57.3 A Local Bound Service Example

      57.4 Adding a Bound Service to the Project

      57.5 Implementing the Binder

      57.6 Binding the Client to the Service

      57.7 Completing the Example

      57.8 Testing the Application

      57.9 Summary

      58. Android Remote Bound Services – A Worked Example

      58.1 Client to Remote Service Communication

      58.2 Creating the Example Application

      58.3 Designing the User Interface

      58.4 Implementing the Remote Bound Service

      58.5 Configuring a Remote Service in the Manifest File

      58.6 Launching and Binding to the Remote Service

      58.7 Sending a Message to the Remote Service

      58.8 Summary

      59. An Overview of Java Threads, Handlers and Executors

      59.1 The Application Main Thread

      59.2 Thread Handlers

      59.3 A Threading Example

      59.4 Building the App

      59.5 Creating a New Thread

      59.6 Implementing a Thread Handler

      59.7 Passing a Message to the Handler

      59.8 Java Executor Concurrency

      59.9 Working with Runnable Tasks

      59.10 Shutting down an Executor Service

      59.11 Working with Callable Tasks and Futures

      59.12 Handling a Future Result

      59.13 Scheduling Tasks

      59.14 Summary

      60. Making Runtime Permission Requests in Android

      60.1 Understanding Normal and Dangerous Permissions

      60.2 Creating the Permissions Example Project

      60.3 Checking for a Permission

      60.4 Requesting Permission at Runtime

      60.5 Providing a Rationale for the Permission Request

      60.6 Testing the Permissions App

      60.7 Summary

      61. An Android Notifications Tutorial

      61.1 An Overview of Notifications

      61.2 Creating the NotifyDemo Project

      61.3 Designing the User Interface

      61.4 Creating the Second Activity

      61.5 Creating a Notification Channel

      61.6 Requesting Notification Permission

      61.7 Creating and Issuing a Notification

      61.8 Launching an Activity from a Notification

      61.9 Adding Actions to a Notification

      61.10 Bundled Notifications

      61.11 Summary

      62. An Android Direct Reply Notification Tutorial

      62.1 Creating the DirectReply Project

      62.2 Designing the User Interface

      62.3 Requesting Notification Permission

      62.4 Creating the Notification Channel

      62.5 Building the RemoteInput Object

      62.6 Creating the PendingIntent

      62.7 Creating the Reply Action

      62.8 Receiving Direct Reply Input

      62.9 Updating the Notification

      62.10 Summary

      63. Foldable Devices and Multi-Window Support

      63.1 Foldables and Multi-Window Support

      63.2 Using a Foldable Emulator

      63.3 Entering Multi-Window Mode

      63.4 Enabling and using Freeform Support

      63.5 Checking for Freeform Support

      63.6 Enabling Multi-Window Support in an App

      63.7 Specifying Multi-Window Attributes

      63.8 Detecting Multi-Window Mode in an Activity

      63.9 Receiving Multi-Window Notifications

      63.10 Launching an Activity in Multi-Window Mode

      63.11 Configuring Freeform Activity Size and Position

      63.12 Summary

      64. An Overview of Android SQLite Databases

      64.1 Understanding Database Tables

      64.2 Introducing Database Schema

      64.3 Columns and Data Types

      64.4 Database Rows

      64.5 Introducing Primary Keys

      64.6 What is SQLite?

      64.7 Structured Query Language (SQL)

      64.8 Trying SQLite on an Android Virtual Device (AVD)

      64.9 The Android Room Persistence Library

      64.10 Summary

      65. The Android Room Persistence Library

      65.1 Revisiting Modern App Architecture

      65.2 Key Elements of Room Database Persistence

      65.2.1 Repository

      65.2.2 Room Database

      65.2.3 Data Access Object (DAO)

      65.2.4 Entities

      65.2.5 SQLite Database

      65.3 Understanding Entities

      65.4 Data Access Objects

      65.5 The Room Database

      65.6 The Repository

      65.7 In-Memory Databases

      65.8 Database Inspector

      65.9 Summary

      66. An Android TableLayout and TableRow Tutorial

      66.1 The TableLayout and TableRow Layout Views

      66.2 Creating the Room Database Project

      66.3 Converting to a LinearLayout

      66.4 Adding the TableLayout to the User Interface

      66.5 Configuring the TableRows

      66.6 Adding the Button Bar to the Layout

      66.7 Adding the RecyclerView

      66.8 Adjusting the Layout Margins

      66.9 Summary

      67. An Android Room Database and Repository Tutorial

      67.1 About the RoomDemo Project

      67.2 Modifying the Build Configuration

      67.3 Building the Entity

      67.4 Creating the Data Access Object

      67.5 Adding the Room Database

      67.6 Adding the Repository

      67.7 Adding the ViewModel

      67.8 Creating the Product Item Layout

      67.9 Adding the RecyclerView Adapter

      67.10 Preparing the Main Activity

      67.11 Adding the Button Listeners

      67.12 Adding LiveData Observers

      67.13 Initializing the RecyclerView

      67.14 Testing the RoomDemo App

      67.15 Using the Database Inspector

      67.16 Summary

      68. Accessing Cloud Storage using the Android Storage Access Framework

      68.1 The Storage Access Framework

      68.2 Working with the Storage Access Framework

      68.3 Filtering Picker File Listings

      68.4 Handling Intent Results

      68.5 Reading the Content of a File

      68.6 Writing Content to a File

      68.7 Deleting a File

      68.8 Gaining Persistent Access to a File

      68.9 Summary

      69. An Android Storage Access Framework Example

      69.1 About the Storage Access Framework Example

      69.2 Creating the Storage Access Framework Example

      69.3 Designing the User Interface

      69.4 Adding the Activity Launchers

      69.5 Creating a New Storage File

      69.6 Saving to a Storage File

      69.7 Opening and Reading a Storage File

      69.8 Testing the Storage Access Application

      69.9 Summary

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

      70.1 Introducing the Android VideoView Class

      70.2 Introducing the Android MediaController Class

      70.3 Creating the Video Playback Example

      70.4 Designing the VideoPlayer Layout

      70.5 Downloading the Video File

      70.6 Configuring the VideoView

      70.7 Adding the MediaController to the Video View

      70.8 Setting up the onPreparedListener

      70.9 Summary

      71. Android Picture-in-Picture Mode

      71.1 Picture-in-Picture Features

      71.2 Enabling Picture-in-Picture Mode

      71.3 Configuring Picture-in-Picture Parameters

      71.4 Entering Picture-in-Picture Mode

      71.5 Detecting Picture-in-Picture Mode Changes

      71.6 Adding Picture-in-Picture Actions

      71.7 Summary

      72. An Android Picture-in-Picture Tutorial

      72.1 Adding Picture-in-Picture Support to the Manifest

      72.2 Adding a Picture-in-Picture Button

      72.3 Entering Picture-in-Picture Mode

      72.4 Detecting Picture-in-Picture Mode Changes

      72.5 Adding a Broadcast Receiver

      72.6 Adding the PiP Action

      72.7 Testing the Picture-in-Picture Action

      72.8 Summary

      73. Android Audio Recording and Playback using MediaPlayer and MediaRecorder

      73.1 Playing Audio

      73.2 Recording Audio and Video using the MediaRecorder Class

      73.3 About the Example Project

      73.4 Creating the AudioApp Project

      73.5 Designing the User Interface

      73.6 Checking for Microphone Availability

      73.7 Initializing the Activity

      73.8 Implementing the recordAudio() Method

      73.9 Implementing the stopAudio() Method

      73.10 Implementing the playAudio() method

      73.11 Configuring and Requesting Permissions

      73.12 Testing the Application

      73.13 Summary

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

      74.1 The Elements of the Google Maps Android API

      74.2 Creating the Google Maps Project

      74.3 Creating a Google Cloud Billing Account

      74.4 Creating a New Google Cloud Project

      74.5 Enabling the Google Maps SDK

      74.6 Generating a Google Maps API Key

      74.7 Adding the API Key to the Android Studio Project

      74.8 Testing the Application

      74.9 Understanding Geocoding and Reverse Geocoding

      74.10 Adding a Map to an Application

      74.11 Requesting Current Location Permission

      74.12 Displaying the User’s Current Location

      74.13 Changing the Map Type

      74.14 Displaying Map Controls to the User

      74.15 Handling Map Gesture Interaction

      74.15.1 Map Zooming Gestures

      74.15.2 Map Scrolling/Panning Gestures

      74.15.3 Map Tilt Gestures

      74.15.4 Map Rotation Gestures

      74.16 Creating Map Markers

      74.17 Controlling the Map Camera

      74.18 Summary

      75. Printing with the Android Printing Framework

      75.1 The Android Printing Architecture

      75.2 The Print Service Plugins

      75.3 Google Cloud Print

      75.4 Printing to Google Drive

      75.5 Save as PDF

      75.6 Printing from Android Devices

      75.7 Options for Building Print Support into Android Apps

      75.7.1 Image Printing

      75.7.2 Creating and Printing HTML Content

      75.7.3 Printing a Web Page

      75.7.4 Printing a Custom Document

      75.8 Summary

      76. An Android HTML and Web Content Printing Example

      76.1 Creating the HTML Printing Example Application

      76.2 Printing Dynamic HTML Content

      76.3 Creating the Web Page Printing Example

      76.4 Removing the Floating Action Button

      76.5 Removing Navigation Features

      76.6 Designing the User Interface Layout

      76.7 Accessing the WebView from the Main Activity

      76.8 Loading the Web Page into the WebView

      76.9 Adding the Print Menu Option

      76.10 Summary

      77. A Guide to Android Custom Document Printing

      77.1 An Overview of Android Custom Document Printing

      77.1.1 Custom Print Adapters

      77.2 Preparing the Custom Document Printing Project

      77.3 Creating the Custom Print Adapter

      77.4 Implementing the onLayout() Callback Method

      77.5 Implementing the onWrite() Callback Method

      77.6 Checking a Page is in Range

      77.7 Drawing the Content on the Page Canvas

      77.8 Starting the Print Job

      77.9 Testing the Application

      77.10 Summary

      78. An Introduction to Android App Links

      78.1 An Overview of Android App Links

      78.2 App Link Intent Filters

      78.3 Handling App Link Intents

      78.4 Associating the App with a Website

      78.5 Summary

      79. An Android Studio App Links Tutorial

      79.1 About the Example App

      79.2 The Database Schema

      79.3 Loading and Running the Project

      79.4 Adding the URL Mapping

      79.5 Adding the Intent Filter

      79.6 Adding Intent Handling Code

      79.7 Testing the App

      79.8 Creating the Digital Asset Links File

      79.9 Testing the App Link

      79.10 Summary

      80. An Android Biometric Authentication Tutorial

      80.1 An Overview of Biometric Authentication

      80.2 Creating the Biometric Authentication Project

      80.3 Configuring Device Fingerprint Authentication

      80.4 Adding the Biometric Permission to the Manifest File

      80.5 Designing the User Interface

      80.6 Adding a Toast Convenience Method

      80.7 Checking the Security Settings

      80.8 Configuring the Authentication Callbacks

      80.9 Adding the CancellationSignal

      80.10 Starting the Biometric Prompt

      80.11 Testing the Project

      80.12 Summary

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

      81.1 The Release Preparation Process

      81.2 Android App Bundles

      81.3 Register for a Google Play Developer Console Account

      81.4 Configuring the App in the Console

      81.5 Enabling Google Play App Signing

      81.6 Creating a Keystore File

      81.7 Creating the Android App Bundle

      81.8 Generating Test APK Files

      81.9 Uploading the App Bundle to the Google Play Developer Console

      81.10 Exploring the App Bundle

      81.11 Managing Testers

      81.12 Rolling the App Out for Testing

      81.13 Uploading New App Bundle Revisions

      81.14 Analyzing the App Bundle File

      81.15 Summary

      82. An Overview of Android In-App Billing

      82.1 Preparing a Project for In-App Purchasing

      82.2 Creating In-App Products and Subscriptions

      82.3 Billing Client Initialization

      82.4 Connecting to the Google Play Billing Library

      82.5 Querying Available Products

      82.6 Starting the Purchase Process

      82.7 Completing the Purchase

      82.8 Querying Previous Purchases

      82.9 Summary

      83. An Android In-App Purchasing Tutorial

      83.1 About the In-App Purchasing Example Project

      83.2 Creating the InAppPurchase Project

      83.3 Adding Libraries to the Project

      83.4 Designing the User Interface

      83.5 Adding the App to the Google Play Store

      83.6 Creating an In-App Product

      83.7 Enabling License Testers

      83.8 Initializing the Billing Client

      83.9 Querying the Product

      83.10 Launching the Purchase Flow

      83.11 Handling Purchase Updates

      83.12 Consuming the Product

      83.13 Restoring a Previous Purchase

      83.14 Testing the App

      83.15 Troubleshooting

      83.16 Summary

      84. Creating and Managing Overflow Menus on Android

      84.1 The Overflow Menu

      84.2 Creating an Overflow Menu

      84.3 Displaying an Overflow Menu

      84.4 Responding to Menu Item Selections

      84.5 Creating Checkable Item Groups

      84.6 Menus and the Android Studio Menu Editor

      84.7 Creating the Example Project

      84.8 Designing the Menu

      84.9 Modifying the onOptionsItemSelected() Method

      84.10 Testing the Application

      84.11 Summary

      85. Working with Material Design 3 Theming

      85.1 Material Design 2 vs. Material Design 3

      85.2 Understanding Material Design Theming

      85.3 Material Design 3 Theming

      85.4 Building a Custom Theme

      85.5 Summary

      86. A Material Design 3 Theming and Dynamic Color Tutorial

      86.1 Creating the ThemeDemo Project

      86.2 Designing the User Interface

      86.3 Building a New Theme

      86.4 Adding the Theme to the Project

      86.5 Enabling Dynamic Color Support

      86.6 Previewing Dynamic Colors

      86.7 Summary

      87. An Overview of Gradle in Android Studio

      87.1 An Overview of Gradle

      87.2 Gradle and Android Studio

      87.2.1 Sensible Defaults

      87.2.2 Dependencies

      87.2.3 Build Variants

      87.2.4 Manifest Entries

      87.2.5 APK Signing

      87.2.6 ProGuard Support

      87.3 The Property and Settings Gradle Build File

      87.4 The Top-level Gradle Build File

      87.5 Module Level Gradle Build Files

      87.6 Configuring Signing Settings in the Build File

      87.7 Running Gradle Tasks from the Command Line

      87.8 Summary

      Index

      1. Introduction

      Fully updated for Android Studio Hedgehog (2023.1.1) and the new UI, this book teaches you how to develop Android-based applications using the Java programming language.

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

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

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

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

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

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

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

      1.1 Downloading the Code Samples

      The source code and Android Studio project files for the examples contained in this book are available for download at:

      https://www.payloadbooks.com/product/hedgehogjava

      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 info@payloadbooks.com.

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

      If you find an error not listed in the errata, please let us know by emailing our technical support team at info@payloadbooks.com. They are there to help you and will work to resolve any problems you may encounter.

      2. Setting up an Android Studio Development Environment

      Before any work can begin on developing an Android application, the first step is to configure a computer system to act as the development platform. This involves several steps consisting of installing the Android Studio Integrated Development Environment (IDE), including the Android Software Development Kit (SDK) and the OpenJDK Java development environment.

      This chapter will cover the steps necessary to install the requisite components for Android application development on Windows, macOS, and Linux-based systems.

      2.1 System requirements

      Android application development may be performed on any of the following system types:

      •Windows 8/10/11 64-bit

      •macOS 10.14 or later running on Intel or Apple silicon

      •Chrome OS device with Intel i5 or higher

      •Linux systems with version 2.31 or later of the GNU C Library (glibc)

      •Minimum of 8GB of RAM

      •Approximately 8GB of available disk space

      •1280 x 800 minimum screen resolution

      2.2 Downloading the Android Studio package

      Most of the work involved in developing applications for Android will be performed using the Android Studio environment. The content and examples in this book were created based on Android Studio Hedgehog 2023.1.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 Hedgehog 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 Hedgehog 2023.1.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--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 system users. When prompted to select the components to install, ensure 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 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 taskbar for easy access by navigating to the Android Studio\bin directory, right-clicking on the studio64 executable, and selecting the Pin to Taskbar menu option (on Windows 11, this option can be found by selecting Show more options from the menu).

      2.3.2 Installation on macOS

      Android Studio for macOS is downloaded as a disk image (.dmg) file. Once the android-studio--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 //android-studio--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 The Android Studio setup wizard

      If you have previously installed an earlier version of Android Studio, the first time this new version is launched, a dialog may 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 the OK button to proceed.

      If you are installing Android Studio for the first time, the initial dialog that appears once the setup process starts may resemble that shown in Figure 2-2 below:

      Figure 2-2

      If this dialog appears, click the Next button to display the Install Type screen (Figure 2-3). On this screen, select the Standard installation option before clicking Next.

      Figure 2-3

      On the Select UI Theme screen, select either the Darcula or Light theme based on your preferences. After making a choice, click Next, and review the options in the Verify Settings screen before proceeding to the License Agreement screen. Select each license category and enable the Accept checkbox. Finally, click the Finish button to initiate the installation.

      After these initial setup steps have been taken, click the Finish button to display the Welcome to Android Studio screen using your chosen UI theme:

      Figure 2-4

      2.5 Installing additional Android SDK packages

      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-5:

      Figure 2-5

      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 Hedgehog, 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-6:

      Figure 2-6

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

      Figure 2-7

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

      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.6 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-9:

      Figure 2-9

      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 represents the file system location into which you installed the Android SDK):

      /sdk/cmdline-tools/latest/bin

      /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-10:

      Figure 2-10

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

      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-12 below:

      Figure 2-12

      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 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. To display the SDK Manager from within an open project, select the Tools -> SDK Manager... menu option from the main menu.

      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, use the Help -> Check for Updates... menu option from the Android Studio main window (Android Studio -> Check for Updates... on macOS).

      2.9 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 name uniquely 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 Java and select Kotlin DSL (build.gradle.kts) as the build configuration language before clicking Finish to create the project.

      3.5 Enabling the New Android Studio UI

      Android Studio is transitioning to a new, modern user interface that is not enabled by default in the Hedgehog version. If your installation of Android Studio resembles Figure 3-4 below, then you will need to enable the new UI before proceeding:

      Figure 3-4

      Enable the new UI by selecting the File -> Settings... menu option (Android Studio -> Settings... on macOS) and selecting the New UI option under Appearance and Behavior in the left-hand panel. From the main panel, turn on the Enable new UI checkbox before clicking Apply, followed by OK to commit the change:

      Figure 3-5

      When prompted, restart Android Studio to activate the new user interface.

      3.6 Modifying the Example Application

      Once Android Studio has restarted, the main window will reappear using the new UI and containing our AndroidSample project as illustrated in Figure 3-6 below:

      Figure 3-6

      The newly created project and references to associated files are listed in the Project tool window on 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-7. If the panel is not currently in Android mode, use the menu to switch mode:

      Figure 3-7

      3.7 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 the file 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-8

      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

      Enjoying the preview?
      Page 1 of 1