Everand Logo

Welcome to Everand!

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

    From $11.99/month after trial. Cancel anytime.

    Android Studio 3.2 Development Essentials - Android 9 Edition: Developing Android 9 Apps Using Android Studio 3.2, Java and Android Jetpack
    Android Studio 3.2 Development Essentials - Android 9 Edition: Developing Android 9 Apps Using Android Studio 3.2, Java and Android Jetpack
    Android Studio 3.2 Development Essentials - Android 9 Edition: Developing Android 9 Apps Using Android Studio 3.2, Java and Android Jetpack
    Ebook1,741 pages11 hours

    Android Studio 3.2 Development Essentials - Android 9 Edition: Developing Android 9 Apps Using Android Studio 3.2, Java and Android Jetpack

    By Neil Smyth

    ()

    Read preview

    About this ebook

    Fully updated for Android Studio 3.2, Android 9, Android Jetpack and the modern architectural guidelines and components, the goal of this book is to teach the skills necessary to develop Android-based applications using the Java programming language.

    An overview of Android Studio is included covering areas such as tool windows, the code ed

    LanguageEnglish
    PublisherPayload Media, Inc.
    Release dateDec 27, 2018
    ISBN9780960010950
    Android Studio 3.2 Development Essentials - Android 9 Edition: Developing Android 9 Apps Using Android Studio 3.2, Java and Android Jetpack

    Read more from Neil Smyth

    Related to Android Studio 3.2 Development Essentials - Android 9 Edition

    Related ebooks

    Programming For You

    View More
    View More

    Related podcast episodes

    Related categories

    Reviews for Android Studio 3.2 Development Essentials - Android 9 Edition

    0 ratings

    0 ratings0 reviews

    What did you think?

    Tap to rate

    Review must be at least 10 words

      Book preview

      Android Studio 3.2 Development Essentials - Android 9 Edition - Neil Smyth

      android_studio_3.2_front_cover_large.png

      Android Studio 3.2

      Development Essentials

      Android 9 Edition

      Android Studio 3.2 Development Essentials – Android 9 Edition

      ISBN-13: 978-0960010950

      © 2018 Neil Smyth / Payload Media, Inc. All Rights Reserved.

      This book is provided for personal use only. Unauthorized use, reproduction and/or distribution strictly prohibited. All rights reserved.

      The content of this book is provided for informational purposes only. Neither the publisher nor the author offers any warranties or representation, express or implied, with regard to the accuracy of information contained in this book, nor do they accept any liability for any loss or damage arising from any errors or omissions.

      This book contains trademarked terms that are used solely for editorial purposes and to the benefit of the respective trademark owner. The terms used within this book are not intended as infringement of any trademarks.

      Rev: 1.0

      Table of Contents

      1. Introduction

      1.1 Downloading the Code Samples

      1.2 Feedback

      1.3 Errata

      2. Setting up an Android Studio Development Environment

      2.1 System Requirements

      2.2 Downloading the Android Studio Package

      2.3 Installing Android Studio

      2.3.1 Installation on Windows

      2.3.2 Installation on macOS

      2.3.3 Installation on Linux

      2.4 The Android Studio Setup Wizard

      2.5 Installing Additional Android SDK Packages

      2.6 Making the Android SDK Tools Command-line Accessible

      2.6.1 Windows 7

      2.6.2 Windows 8.1

      2.6.3 Windows 10

      2.6.4 Linux

      2.6.5 macOS

      2.7 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 Defining the Project and SDK Settings

      3.4 Creating an Activity

      3.5 Modifying the Example Application

      3.6 Reviewing the Layout and Resource Files

      3.7 Adding Interaction

      3.8 Summary

      4. Creating an Android Virtual Device (AVD) in Android Studio

      4.1 About Android Virtual Devices

      4.2 Creating a New AVD

      4.3 Starting the Emulator

      4.4 Running the Application in the AVD

      4.5 Run/Debug Configurations

      4.6 Stopping a Running Application

      4.7 AVD Command-line Creation

      4.8 Android Virtual Device Configuration Files

      4.9 Moving and Renaming an Android Virtual Device

      4.10 Summary

      5. Using and Configuring the Android Studio AVD Emulator

      5.1 The Emulator Environment

      5.2 The Emulator Toolbar Options

      5.3 Working in Zoom Mode

      5.4 Resizing the Emulator Window

      5.5 Extended Control Options

      5.5.1 Location

      5.5.2 Cellular

      5.5.3 Camera

      5.5.4 Battery

      5.5.5 Phone

      5.5.6 Directional Pad

      5.5.7 Microphone

      5.5.8 Fingerprint

      5.5.9 Virtual Sensors

      5.5.10 Snapshots

      5.5.11 Screen Record

      5.5.12 Google Play

      5.5.13 Settings

      5.5.14 Help

      5.6 Working with Snapshots

      5.7 Drag and Drop Support

      5.8 Configuring Fingerprint Emulation

      5.9 Summary

      6. A Tour of the Android Studio User Interface

      6.1 The Welcome Screen

      6.2 The Main Window

      6.3 The Tool Windows

      6.4 Android Studio Keyboard Shortcuts

      6.5 Switcher and Recent Files Navigation

      6.6 Changing the Android Studio Theme

      6.7 Summary

      7. Testing Android Studio Apps on a Physical Android Device

      7.1 An Overview of the Android Debug Bridge (ADB)

      7.2 Enabling ADB on Android based Devices

      7.2.1 macOS ADB Configuration

      7.2.2 Windows ADB Configuration

      7.2.3 Linux adb Configuration

      7.3 Testing the adb Connection

      7.4 Summary

      8. The Basics of the Android Studio Code Editor

      8.1 The Android Studio Editor

      8.2 Splitting the Editor Window

      8.3 Code Completion

      8.4 Statement Completion

      8.5 Parameter Information

      8.6 Parameter Name Hints

      8.7 Code Generation

      8.8 Code Folding

      8.9 Quick Documentation Lookup

      8.10 Code Reformatting

      8.11 Finding Sample Code

      8.12 Summary

      9. An Overview of the Android Architecture

      9.1 The Android Software Stack

      9.2 The Linux Kernel

      9.3 Android Runtime – ART

      9.4 Android Libraries

      9.4.1 C/C++ Libraries

      9.5 Application Framework

      9.6 Applications

      9.7 Summary

      10. The Anatomy of an Android Application

      10.1 Android Activities

      10.2 Android Fragments

      10.3 Android Intents

      10.4 Broadcast Intents

      10.5 Broadcast Receivers

      10.6 Android Services

      10.7 Content Providers

      10.8 The Application Manifest

      10.9 Application Resources

      10.10 Application Context

      10.11 Summary

      11. Understanding Android Application and Activity Lifecycles

      11.1 Android Applications and Resource Management

      11.2 Android Process States

      11.2.1 Foreground Process

      11.2.2 Visible Process

      11.2.3 Service Process

      11.2.4 Background Process

      11.2.5 Empty Process

      11.3 Inter-Process Dependencies

      11.4 The Activity Lifecycle

      11.5 The Activity Stack

      11.6 Activity States

      11.7 Configuration Changes

      11.8 Handling State Change

      11.9 Summary

      12. Handling Android Activity State Changes

      12.1 New vs. Old Lifecycle Techniques

      12.2 The Activity and Fragment Classes

      12.3 Dynamic State vs. Persistent State

      12.4 The Android Lifecycle Methods

      12.5 Lifetimes

      12.6 Disabling Configuration Change Restarts

      12.7 Lifecycle Method Limitations

      12.8 Summary

      13. Android Activity State Changes by Example

      13.1 Creating the State Change Example Project

      13.2 Designing the User Interface

      13.3 Overriding the Activity Lifecycle Methods

      13.4 Filtering the Logcat Panel

      13.5 Running the Application

      13.6 Experimenting with the Activity

      13.7 Summary

      14. Saving and Restoring the State of an Android Activity

      14.1 Saving Dynamic State

      14.2 Default Saving of User Interface State

      14.3 The Bundle Class

      14.4 Saving the State

      14.5 Restoring the State

      14.6 Testing the Application

      14.7 Summary

      15. Understanding Android Views, View Groups and Layouts

      15.1 Designing for Different Android Devices

      15.2 Views and View Groups

      15.3 Android Layout Managers

      15.4 The View Hierarchy

      15.5 Creating User Interfaces

      15.6 Summary

      16. A Guide to the Android Studio Layout Editor Tool

      16.1 Basic vs. Empty Activity Templates

      16.2 The Android Studio Layout Editor

      16.3 Design Mode

      16.4 The Palette

      16.5 Design and Layout Views

      16.6 Text Mode

      16.7 Setting Attributes

      16.8 Configuring Favorite Attributes

      16.9 Converting Views

      16.10 Displaying Sample Data

      16.11 Creating a Custom Device Definition

      16.12 Changing the Current Device

      16.13 Summary

      17. A Guide to the Android ConstraintLayout

      17.1 How ConstraintLayout Works

      17.1.1 Constraints

      17.1.2 Margins

      17.1.3 Opposing Constraints

      17.1.4 Constraint Bias

      17.1.5 Chains

      17.1.6 Chain Styles

      17.2 Baseline Alignment

      17.3 Working with Guidelines

      17.4 Configuring Widget Dimensions

      17.5 Working with Barriers

      17.6 Ratios

      17.7 ConstraintLayout Advantages

      17.8 ConstraintLayout Availability

      17.9 Summary

      18. A Guide to using ConstraintLayout in Android Studio

      18.1 Design and Layout Views

      18.2 Autoconnect Mode

      18.3 Inference Mode

      18.4 Manipulating Constraints Manually

      18.5 Adding Constraints in the Inspector

      18.6 Deleting Constraints

      18.7 Adjusting Constraint Bias

      18.8 Understanding ConstraintLayout Margins

      18.9 The Importance of Opposing Constraints and Bias

      18.10 Configuring Widget Dimensions

      18.11 Adding Guidelines

      18.12 Adding Barriers

      18.13 Widget Group Alignment and Distribution

      18.14 Converting other Layouts to ConstraintLayout

      18.15 Summary

      19. Working with ConstraintLayout Chains and Ratios in Android Studio

      19.1 Creating a Chain

      19.2 Changing the Chain Style

      19.3 Spread Inside Chain Style

      19.4 Packed Chain Style

      19.5 Packed Chain Style with Bias

      19.6 Weighted Chain

      19.7 Working with Ratios

      19.8 Summary

      20. An Android Studio Layout Editor ConstraintLayout Tutorial

      20.1 An Android Studio Layout Editor Tool Example

      20.2 Creating a New Activity

      20.3 Preparing the Layout Editor Environment

      20.4 Adding the Widgets to the User Interface

      20.5 Adding the Constraints

      20.6 Testing the Layout

      20.7 Using the Layout Inspector

      20.8 Summary

      21. Manual XML Layout Design in Android Studio

      21.1 Manually Creating an XML Layout

      21.2 Manual XML vs. Visual Layout Design

      21.3 Summary

      22. Managing Constraints using Constraint Sets

      22.1 Java Code vs. XML Layout Files

      22.2 Creating Views

      22.3 View Attributes

      22.4 Constraint Sets

      22.4.1 Establishing Connections

      22.4.2 Applying Constraints to a Layout

      22.4.3 Parent Constraint Connections

      22.4.4 Sizing Constraints

      22.4.5 Constraint Bias

      22.4.6 Alignment Constraints

      22.4.7 Copying and Applying Constraint Sets

      22.4.8 ConstraintLayout Chains

      22.4.9 Guidelines

      22.4.10 Removing Constraints

      22.4.11 Scaling

      22.4.12 Rotation

      22.5 Summary

      23. An Android ConstraintSet Tutorial

      23.1 Creating the Example Project in Android Studio

      23.2 Adding Views to an Activity

      23.3 Setting View Attributes

      23.4 Creating View IDs

      23.5 Configuring the Constraint Set

      23.6 Adding the EditText View

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

      23.8 Summary

      24. A Guide to using Instant Run in Android Studio

      24.1 Introducing Instant Run

      24.2 Understanding Instant Run Swapping Levels

      24.3 Enabling and Disabling Instant Run

      24.4 Using Instant Run

      24.5 An Instant Run Tutorial

      24.6 Triggering an Instant Run Hot Swap

      24.7 Triggering an Instant Run Warm Swap

      24.8 Triggering an Instant Run Cold Swap

      24.9 The Run Button

      24.10 Summary

      25. An Overview and Example of Android Event Handling

      25.1 Understanding Android Events

      25.2 Using the android:onClick Resource

      25.3 Event Listeners and Callback Methods

      25.4 An Event Handling Example

      25.5 Designing the User Interface

      25.6 The Event Listener and Callback Method

      25.7 Consuming Events

      25.8 Summary

      26. Android Touch and Multi-touch Event Handling

      26.1 Intercepting Touch Events

      26.2 The MotionEvent Object

      26.3 Understanding Touch Actions

      26.4 Handling Multiple Touches

      26.5 An Example Multi-Touch Application

      26.6 Designing the Activity User Interface

      26.7 Implementing the Touch Event Listener

      26.8 Running the Example Application

      26.9 Summary

      27. Detecting Common Gestures using the Android Gesture Detector Class

      27.1 Implementing Common Gesture Detection

      27.2 Creating an Example Gesture Detection Project

      27.3 Implementing the Listener Class

      27.4 Creating the GestureDetectorCompat Instance

      27.5 Implementing the onTouchEvent() Method

      27.6 Testing the Application

      27.7 Summary

      28. Implementing Custom Gesture and Pinch Recognition on Android

      28.1 The Android Gesture Builder Application

      28.2 The GestureOverlayView Class

      28.3 Detecting Gestures

      28.4 Identifying Specific Gestures

      28.5 Building and Running the Gesture Builder Application

      28.6 Creating a Gestures File

      28.7 Creating the Example Project

      28.8 Extracting the Gestures File from the SD Card

      28.9 Adding the Gestures File to the Project

      28.10 Designing the User Interface

      28.11 Loading the Gestures File

      28.12 Registering the Event Listener

      28.13 Implementing the onGesturePerformed Method

      28.14 Testing the Application

      28.15 Configuring the GestureOverlayView

      28.16 Intercepting Gestures

      28.17 Detecting Pinch Gestures

      28.18 A Pinch Gesture Example Project

      28.19 Summary

      29. An Introduction to Android Fragments

      29.1 What is a Fragment?

      29.2 Creating a Fragment

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

      29.4 Adding and Managing Fragments in Code

      29.5 Handling Fragment Events

      29.6 Implementing Fragment Communication

      29.7 Summary

      30. Using Fragments in Android Studio - An Example

      30.1 About the Example Fragment Application

      30.2 Creating the Example Project

      30.3 Creating the First Fragment Layout

      30.4 Creating the First Fragment Class

      30.5 Creating the Second Fragment Layout

      30.6 Adding the Fragments to the Activity

      30.7 Making the Toolbar Fragment Talk to the Activity

      30.8 Making the Activity Talk to the Text Fragment

      30.9 Testing the Application

      30.10 Summary

      31. Modern Android App Architecture with Jetpack

      31.1 What is Android Jetpack?

      31.2 The Old Architecture

      31.3 Modern Android Architecture

      31.4 The ViewModel Component

      31.5 The LiveData Component

      31.6 LiveData and Data Binding

      31.7 Android Lifecycles

      31.8 Repository Modules

      31.9 Summary

      32. An Android Jetpack ViewModel Tutorial

      32.1 About the Project

      32.2 Creating the ViewModel Example Project

      32.3 Reviewing the Project

      32.3.1 The Main Activity

      32.3.2 The Content Fragment

      32.3.3 The ViewModel

      32.4 Designing the Fragment Layout

      32.5 Implementing the View Model

      32.6 Associating the Fragment with the View Model

      32.7 Modifying the Fragment

      32.8 Accessing the ViewModel Data

      32.9 Testing the Project

      32.10 Summary

      33. An Android Jetpack LiveData Tutorial

      33.1 LiveData - A Recap

      33.2 Adding LiveData to the ViewModel

      33.3 Implementing the Observer

      33.4 Summary

      34. An Overview of Android Jetpack Data Binding

      34.1 An Overview of Data Binding

      34.2 The Key Components of Data Binding

      34.2.1 The Project Build Configuration

      34.2.2 The Data Binding Layout File

      34.2.3 The Layout File Data Element

      34.2.4 The Binding Classes

      34.2.5 Data Binding Variable Configuration

      34.2.6 Binding Expressions (One-Way)

      34.2.7 Binding Expressions (Two-Way)

      34.2.8 Event and Listener Bindings

      34.3 Summary

      35. An Android Jetpack Data Binding Tutorial

      35.1 Removing the Redundant Code

      35.2 Enabling Data Binding

      35.3 Adding the Layout Element

      35.4 Adding the Data Element to Layout File

      35.5 Working with the Binding Class

      35.6 Assigning the ViewModel Instance to the Data Binding Variable

      35.7 Adding Binding Expressions

      35.8 Adding the Conversion Method

      35.9 Adding a Listener Binding

      35.10 Testing the App

      35.11 Summary

      36. Working with Android Lifecycle-Aware Components

      36.1 Lifecycle Awareness

      36.2 Lifecycle Owners

      36.3 Lifecycle Observers

      36.4 Lifecycle States and Events

      36.5 Summary

      37. An Android Jetpack Lifecycle Awareness Tutorial

      37.1 Creating the Example Lifecycle Project

      37.2 Creating a Lifecycle Observer

      37.3 Adding the Observer

      37.4 Testing the Observer

      37.5 Creating a Lifecycle Owner

      37.6 Testing the Custom Lifecycle Owner

      37.7 Summary

      38. An Overview of the Navigation Architecture Component

      38.1 Understanding Navigation

      38.2 Declaring a Navigation Host

      38.3 The Navigation Graph

      38.4 Accessing the Navigation Controller

      38.5 Triggering a Navigation Action

      38.6 Passing Arguments

      38.7 Summary

      39. An Android Jetpack Navigation Component Tutorial

      39.1 Creating the NavigationDemo Project

      39.2 Adding Navigation to the Build Configuration

      39.3 Creating the Navigation Graph Resource File

      39.4 Declaring a Navigation Host

      39.5 Adding Navigation Destinations

      39.6 Designing the Destination Fragment Layouts

      39.7 Adding an Action to the Navigation Graph

      39.8 Implement the OnFragmentInteractionListener

      39.9 Triggering the Action

      39.10 Passing Data Using Safeargs

      39.11 Summary

      40. Creating and Managing Overflow Menus on Android

      40.1 The Overflow Menu

      40.2 Creating an Overflow Menu

      40.3 Displaying an Overflow Menu

      40.4 Responding to Menu Item Selections

      40.5 Creating Checkable Item Groups

      40.6 Menus and the Android Studio Menu Editor

      40.7 Creating the Example Project

      40.8 Designing the Menu

      40.9 Modifying the onOptionsItemSelected() Method

      40.10 Testing the Application

      40.11 Summary

      41. Animating User Interfaces with the Android Transitions Framework

      41.1 Introducing Android Transitions and Scenes

      41.2 Using Interpolators with Transitions

      41.3 Working with Scene Transitions

      41.4 Custom Transitions and TransitionSets in Code

      41.5 Custom Transitions and TransitionSets in XML

      41.6 Working with Interpolators

      41.7 Creating a Custom Interpolator

      41.8 Using the beginDelayedTransition Method

      41.9 Summary

      42. An Android Transition Tutorial using beginDelayedTransition

      42.1 Creating the Android Studio TransitionDemo Project

      42.2 Preparing the Project Files

      42.3 Implementing beginDelayedTransition Animation

      42.4 Customizing the Transition

      42.5 Summary

      43. Implementing Android Scene Transitions – A Tutorial

      43.1 An Overview of the Scene Transition Project

      43.2 Creating the Android Studio SceneTransitions Project

      43.3 Identifying and Preparing the Root Container

      43.4 Designing the First Scene

      43.5 Designing the Second Scene

      43.6 Entering the First Scene

      43.7 Loading Scene 2

      43.8 Implementing the Transitions

      43.9 Adding the Transition File

      43.10 Loading and Using the Transition Set

      43.11 Configuring Additional Transitions

      43.12 Summary

      44. Working with the Floating Action Button and Snackbar

      44.1 The Material Design

      44.2 The Design Library

      44.3 The Floating Action Button (FAB)

      44.4 The Snackbar

      44.5 Creating the Example Project

      44.6 Reviewing the Project

      44.7 Changing the Floating Action Button

      44.8 Adding the ListView to the Content Layout

      44.9 Adding Items to the ListView

      44.10 Adding an Action to the Snackbar

      44.11 Summary

      45. Creating a Tabbed Interface using the TabLayout Component

      45.1 An Introduction to the ViewPager

      45.2 An Overview of the TabLayout Component

      45.3 Creating the TabLayoutDemo Project

      45.4 Creating the First Fragment

      45.5 Duplicating the Fragments

      45.6 Adding the TabLayout and ViewPager

      45.7 Creating the Pager Adapter

      45.8 Performing the Initialization Tasks

      45.9 Testing the Application

      45.10 Customizing the TabLayout

      45.11 Displaying Icon Tab Items

      45.12 Summary

      46. Working with the RecyclerView and CardView Widgets

      46.1 An Overview of the RecyclerView

      46.2 An Overview of the CardView

      46.3 Adding the Libraries to the Project

      46.4 Summary

      47. An Android RecyclerView and CardView Tutorial

      47.1 Creating the CardDemo Project

      47.2 Removing the Floating Action Button

      47.3 Adding the RecyclerView and CardView Libraries

      47.4 Designing the CardView Layout

      47.5 Adding the RecyclerView

      47.6 Creating the RecyclerView Adapter

      47.7 Adding the Image Files

      47.8 Initializing the RecyclerView Component

      47.9 Testing the Application

      47.10 Responding to Card Selections

      47.11 Summary

      48. A Layout Editor Sample Data Tutorial

      48.1 Adding Sample Data to a Project

      48.2 Using Custom Sample Data

      48.3 Summary

      49. Working with the AppBar and Collapsing Toolbar Layouts

      49.1 The Anatomy of an AppBar

      49.2 The Example Project

      49.3 Coordinating the RecyclerView and Toolbar

      49.4 Introducing the Collapsing Toolbar Layout

      49.5 Changing the Title and Scrim Color

      49.6 Summary

      50. Implementing an Android Navigation Drawer

      50.1 An Overview of the Navigation Drawer

      50.2 Opening and Closing the Drawer

      50.3 Responding to Drawer Item Selections

      50.4 Using the Navigation Drawer Activity Template

      50.5 Creating the Navigation Drawer Template Project

      50.6 The Template Layout Resource Files

      50.7 The Header Coloring Resource File

      50.8 The Template Menu Resource File

      50.9 The Template Code

      50.10 Running the App

      50.11 Summary

      51. An Android Studio Master/Detail Flow Tutorial

      51.1 The Master/Detail Flow

      51.2 Creating a Master/Detail Flow Activity

      51.3 The Anatomy of the Master/Detail Flow Template

      51.4 Modifying the Master/Detail Flow Template

      51.5 Changing the Content Model

      51.6 Changing the Detail Pane

      51.7 Modifying the WebsiteDetailFragment Class

      51.8 Modifying the WebsiteListActivity Class

      51.9 Adding Manifest Permissions

      51.10 Running the Application

      51.11 Summary

      52. An Overview of Android Intents

      52.1 An Overview of Intents

      52.2 Explicit Intents

      52.3 Returning Data from an Activity

      52.4 Implicit Intents

      52.5 Using Intent Filters

      52.6 Checking Intent Availability

      52.7 Summary

      53. Android Explicit Intents – A Worked Example

      53.1 Creating the Explicit Intent Example Application

      53.2 Designing the User Interface Layout for ActivityA

      53.3 Creating the Second Activity Class

      53.4 Designing the User Interface Layout for ActivityB

      53.5 Reviewing the Application Manifest File

      53.6 Creating the Intent

      53.7 Extracting Intent Data

      53.8 Launching ActivityB as a Sub-Activity

      53.9 Returning Data from a Sub-Activity

      53.10 Testing the Application

      53.11 Summary

      54. Android Implicit Intents – A Worked Example

      54.1 Creating the Android Studio Implicit Intent Example Project

      54.2 Designing the User Interface

      54.3 Creating the Implicit Intent

      54.4 Adding a Second Matching Activity

      54.5 Adding the Web View to the UI

      54.6 Obtaining the Intent URL

      54.7 Modifying the MyWebView Project Manifest File

      54.8 Installing the MyWebView Package on a Device

      54.9 Testing the Application

      54.10 Summary

      55. Android Broadcast Intents and Broadcast Receivers

      55.1 An Overview of Broadcast Intents

      55.2 An Overview of Broadcast Receivers

      55.3 Obtaining Results from a Broadcast

      55.4 Sticky Broadcast Intents

      55.5 The Broadcast Intent Example

      55.6 Creating the Example Application

      55.7 Creating and Sending the Broadcast Intent

      55.8 Creating the Broadcast Receiver

      55.9 Registering the Broadcast Receiver

      55.10 Testing the Broadcast Example

      55.11 Listening for System Broadcasts

      55.12 Summary

      56. A Basic Overview of Threads and AsyncTasks

      56.1 An Overview of Threads

      56.2 The Application Main Thread

      56.3 Thread Handlers

      56.4 A Basic AsyncTask Example

      56.5 Subclassing AsyncTask

      56.6 Testing the App

      56.7 Canceling a Task

      56.8 Summary

      57. An Overview of Android Started and Bound Services

      57.1 Started Services

      57.2 Intent Service

      57.3 Bound Service

      57.4 The Anatomy of a Service

      57.5 Controlling Destroyed Service Restart Options

      57.6 Declaring a Service in the Manifest File

      57.7 Starting a Service Running on System Startup

      57.8 Summary

      58. Implementing an Android Started Service – A Worked Example

      58.1 Creating the Example Project

      58.2 Creating the Service Class

      58.3 Adding the Service to the Manifest File

      58.4 Starting the Service

      58.5 Testing the IntentService Example

      58.6 Using the Service Class

      58.7 Creating the New Service

      58.8 Modifying the User Interface

      58.9 Running the Application

      58.10 Creating an AsyncTask for Service Tasks

      58.11 Summary

      59. Android Local Bound Services – A Worked Example

      59.1 Understanding Bound Services

      59.2 Bound Service Interaction Options

      59.3 An Android Studio Local Bound Service Example

      59.4 Adding a Bound Service to the Project

      59.5 Implementing the Binder

      59.6 Binding the Client to the Service

      59.7 Completing the Example

      59.8 Testing the Application

      59.9 Summary

      60. Android Remote Bound Services – A Worked Example

      60.1 Client to Remote Service Communication

      60.2 Creating the Example Application

      60.3 Designing the User Interface

      60.4 Implementing the Remote Bound Service

      60.5 Configuring a Remote Service in the Manifest File

      60.6 Launching and Binding to the Remote Service

      60.7 Sending a Message to the Remote Service

      60.8 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 Creating and Issuing a Basic Notification

      61.7 Launching an Activity from a Notification

      61.8 Adding Actions to a Notification

      61.9 Bundled Notifications

      61.10 Summary

      62. An Android Direct Reply Notification Tutorial

      62.1 Creating the DirectReply Project

      62.2 Designing the User Interface

      62.3 Creating the Notification Channel

      62.4 Building the RemoteInput Object

      62.5 Creating the PendingIntent

      62.6 Creating the Reply Action

      62.7 Receiving Direct Reply Input

      62.8 Updating the Notification

      62.9 Summary

      63. An Introduction to Android Multi-Window Support

      63.1 Split-Screen, Freeform and Picture-in-Picture Modes

      63.2 Entering Multi-Window Mode

      63.3 Enabling Freeform Support

      63.4 Checking for Freeform Support

      63.5 Enabling Multi-Window Support in an App

      63.6 Specifying Multi-Window Attributes

      63.7 Detecting Multi-Window Mode in an Activity

      63.8 Receiving Multi-Window Notifications

      63.9 Launching an Activity in Multi-Window Mode

      63.10 Configuring Freeform Activity Size and Position

      63.11 Summary

      64. An Android Studio Multi-Window Split-Screen and Freeform Tutorial

      64.1 Creating the Multi-Window Project

      64.2 Designing the FirstActivity User Interface

      64.3 Adding the Second Activity

      64.4 Launching the Second Activity

      64.5 Enabling Multi-Window Mode

      64.6 Testing Multi-Window Support

      64.7 Launching the Second Activity in a Different Window

      64.8 Summary

      65. An Overview of Android SQLite Databases

      65.1 Understanding Database Tables

      65.2 Introducing Database Schema

      65.3 Columns and Data Types

      65.4 Database Rows

      65.5 Introducing Primary Keys

      65.6 What is SQLite?

      65.7 Structured Query Language (SQL)

      65.8 Trying SQLite on an Android Virtual Device (AVD)

      65.9 The Android Room Persistence Library

      65.10 Summary

      66. The Android Room Persistence Library

      66.1 Revisiting Modern App Architecture

      66.2 Key Elements of Room Database Persistence

      66.2.1 Repository

      66.2.2 Room Database

      66.2.3 Data Access Object (DAO)

      66.2.4 Entities

      66.2.5 SQLite Database

      66.3 Understanding Entities

      66.4 Data Access Objects

      66.5 The Room Database

      66.6 The Repository

      66.7 In-Memory Databases

      66.8 Summary

      67. An Android TableLayout and TableRow Tutorial

      67.1 The TableLayout and TableRow Layout Views

      67.2 Creating the Room Database Project

      67.3 Converting to a LinearLayout

      67.4 Adding the TableLayout to the User Interface

      67.5 Configuring the TableRows

      67.6 Adding the Button Bar to the Layout

      67.7 Adding the RecyclerView

      67.8 Adjusting the Layout Margins

      67.9 Summary

      68. An Android Room Database and Repository Tutorial

      68.1 About the RoomDemo Project

      68.2 Modifying the Build Configuration

      68.3 Building the Entity

      68.4 Creating the Data Access Object

      68.5 Adding the Room Database

      68.6 Adding the Repository

      68.7 Modifying the ViewModel

      68.8 Creating the Product Item Layout

      68.9 Adding the RecyclerView Adapter

      68.10 Preparing the Main Fragment

      68.11 Adding the Button Listeners

      68.12 Adding LiveData Observers

      68.13 Initializing the RecyclerView

      68.14 Testing the RoomDemo App

      68.15 Summary

      69. Accessing Cloud Storage using the Android Storage Access Framework

      69.1 The Storage Access Framework

      69.2 Working with the Storage Access Framework

      69.3 Filtering Picker File Listings

      69.4 Handling Intent Results

      69.5 Reading the Content of a File

      69.6 Writing Content to a File

      69.7 Deleting a File

      69.8 Gaining Persistent Access to a File

      69.9 Summary

      70. An Android Storage Access Framework Example

      70.1 About the Storage Access Framework Example

      70.2 Creating the Storage Access Framework Example

      70.3 Designing the User Interface

      70.4 Declaring Request Codes

      70.5 Creating a New Storage File

      70.6 The onActivityResult() Method

      70.7 Saving to a Storage File

      70.8 Opening and Reading a Storage File

      70.9 Testing the Storage Access Application

      70.10 Summary

      71. Implementing Video Playback on Android using the VideoView and MediaController Classes

      71.1 Introducing the Android VideoView Class

      71.2 Introducing the Android MediaController Class

      71.3 Creating the Video Playback Example

      71.4 Designing the VideoPlayer Layout

      71.5 Configuring the VideoView

      71.6 Adding Internet Permission

      71.7 Adding the MediaController to the Video View

      71.8 Setting up the onPreparedListener

      71.9 Summary

      72. Android Picture-in-Picture Mode

      72.1 Picture-in-Picture Features

      72.2 Enabling Picture-in-Picture Mode

      72.3 Configuring Picture-in-Picture Parameters

      72.4 Entering Picture-in-Picture Mode

      72.5 Detecting Picture-in-Picture Mode Changes

      72.6 Adding Picture-in-Picture Actions

      72.7 Summary

      73. An Android Picture-in-Picture Tutorial

      73.1 Adding Picture-in-Picture Support to the Manifest

      73.2 Adding a Picture-in-Picture Button

      73.3 Entering Picture-in-Picture Mode

      73.4 Detecting Picture-in-Picture Mode Changes

      73.5 Adding a Broadcast Receiver

      73.6 Adding the PiP Action

      73.7 Testing the Picture-in-Picture Action

      73.8 Summary

      74. Video Recording and Image Capture on Android using Camera Intents

      74.1 Checking for Camera Support

      74.2 Calling the Video Capture Intent

      74.3 Calling the Image Capture Intent

      74.4 Creating an Android Studio Video Recording Project

      74.5 Designing the User Interface Layout

      74.6 Checking for the Camera

      74.7 Launching the Video Capture Intent

      74.8 Handling the Intent Return

      74.9 Testing the Application

      74.10 Summary

      75. Making Runtime Permission Requests in Android

      75.1 Understanding Normal and Dangerous Permissions

      75.2 Creating the Permissions Example Project

      75.3 Checking for a Permission

      75.4 Requesting Permission at Runtime

      75.5 Providing a Rationale for the Permission Request

      75.6 Testing the Permissions App

      75.7 Summary

      76. Android Audio Recording and Playback using MediaPlayer and MediaRecorder

      76.1 Playing Audio

      76.2 Recording Audio and Video using the MediaRecorder Class

      76.3 About the Example Project

      76.4 Creating the AudioApp Project

      76.5 Designing the User Interface

      76.6 Checking for Microphone Availability

      76.7 Performing the Activity Initialization

      76.8 Implementing the recordAudio() Method

      76.9 Implementing the stopAudio() Method

      76.10 Implementing the playAudio() method

      76.11 Configuring and Requesting Permissions

      76.12 Testing the Application

      76.13 Summary

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

      77.1 The Elements of the Google Maps Android API

      77.2 Creating the Google Maps Project

      77.3 Obtaining Your Developer Signature

      77.4 Adding the Apache HTTP Legacy Library Requirement

      77.5 Testing the Application

      77.6 Understanding Geocoding and Reverse Geocoding

      77.7 Adding a Map to an Application

      77.8 Requesting Current Location Permission

      77.9 Displaying the User’s Current Location

      77.10 Changing the Map Type

      77.11 Displaying Map Controls to the User

      77.12 Handling Map Gesture Interaction

      77.12.1 Map Zooming Gestures

      77.12.2 Map Scrolling/Panning Gestures

      77.12.3 Map Tilt Gestures

      77.12.4 Map Rotation Gestures

      77.13 Creating Map Markers

      77.14 Controlling the Map Camera

      77.15 Summary

      78. Printing with the Android Printing Framework

      78.1 The Android Printing Architecture

      78.2 The Print Service Plugins

      78.3 Google Cloud Print

      78.4 Printing to Google Drive

      78.5 Save as PDF

      78.6 Printing from Android Devices

      78.7 Options for Building Print Support into Android Apps

      78.7.1 Image Printing

      78.7.2 Creating and Printing HTML Content

      78.7.3 Printing a Web Page

      78.7.4 Printing a Custom Document

      78.8 Summary

      79. An Android HTML and Web Content Printing Example

      79.1 Creating the HTML Printing Example Application

      79.2 Printing Dynamic HTML Content

      79.3 Creating the Web Page Printing Example

      79.4 Removing the Floating Action Button

      79.5 Designing the User Interface Layout

      79.6 Loading the Web Page into the WebView

      79.7 Adding the Print Menu Option

      79.8 Summary

      80. A Guide to Android Custom Document Printing

      80.1 An Overview of Android Custom Document Printing

      80.1.1 Custom Print Adapters

      80.2 Preparing the Custom Document Printing Project

      80.3 Creating the Custom Print Adapter

      80.4 Implementing the onLayout() Callback Method

      80.5 Implementing the onWrite() Callback Method

      80.6 Checking a Page is in Range

      80.7 Drawing the Content on the Page Canvas

      80.8 Starting the Print Job

      80.9 Testing the Application

      80.10 Summary

      81. An Introduction to Android App Links

      81.1 An Overview of Android App Links

      81.2 App Link Intent Filters

      81.3 Handling App Link Intents

      81.4 Associating the App with a Website

      81.5 Summary

      82. An Android Studio App Links Tutorial

      82.1 About the Example App

      82.2 The Database Schema

      82.3 Loading and Running the Project

      82.4 Adding the URL Mapping

      82.5 Adding the Intent Filter

      82.6 Adding Intent Handling Code

      82.7 Testing the App Link

      82.8 Associating an App Link with a Web Site

      82.9 Summary

      83. An Introduction to Android Instant Apps

      83.1 An Overview of Android Instant Apps

      83.2 Instant App Feature Modules

      83.3 Instant App Project Structure

      83.4 The Application and Feature Build Plugins

      83.5 Installing the Instant Apps Development SDK

      83.6 Summary

      84. An Android Instant App Tutorial

      84.1 Creating the Instant App Project

      84.2 Reviewing the Project

      84.3 Testing the Installable App

      84.4 Testing the Instant App

      84.5 Reviewing the Instant App APK Files

      84.6 Summary

      85. Adapting an Android Studio Project for Instants Apps

      85.1 Getting Started

      85.2 Adding the Application APK Module

      85.3 Adding an Instant App Module

      85.4 Testing the Instant App

      85.5 Summary

      86. A Guide to the Android Studio Profiler

      86.1 Accessing the Android Profiler

      86.2 Enabling Advanced Profiling

      86.3 The Android Profiler Tool Window

      86.4 The Sessions Panel

      86.5 The CPU Profiler

      86.6 Memory Profiler

      86.7 Network Profiler

      86.8 Energy Profiler

      86.9 Summary

      87. An Android Biometric Authentication Tutorial

      87.1 An Overview of Biometric Authentication

      87.2 Creating the Biometric Authentication Project

      87.3 Configuring Device Fingerprint Authentication

      87.4 Adding the Biometric Permission to the Manifest File

      87.5 Designing the User Interface

      87.6 Adding a Toast Convenience Method

      87.7 Checking the Security Settings

      87.8 Configuring the Authentication Callbacks

      87.9 Adding the CancellationSignal

      87.10 Starting the Biometric Prompt

      87.11 Testing the Project

      87.12 Summary

      88. Creating, Testing and Uploading an Android App Bundle

      88.1 The Release Preparation Process

      88.2 Android App Bundles

      88.3 Register for a Google Play Developer Console Account

      88.4 Configuring the App in the Console

      88.5 Enabling Google Play App Signing

      88.6 Enabling ProGuard

      88.7 Creating a Keystore File

      88.8 Creating the Android App Bundle

      88.9 Generating Test APK Files

      88.10 Uploading the App Bundle to the Google Play Developer Console

      88.11 Exploring the App Bundle

      88.12 Managing Testers

      88.13 Uploading Instant App Bundles

      88.14 Uploading New App Bundle Revisions

      88.15 Analyzing the App Bundle File

      88.16 Enabling Google Play Signing for an Existing App

      88.17 Summary

      89. An Overview of Gradle in Android Studio

      89.1 An Overview of Gradle

      89.2 Gradle and Android Studio

      89.2.1 Sensible Defaults

      89.2.2 Dependencies

      89.2.3 Build Variants

      89.2.4 Manifest Entries

      89.2.5 APK Signing

      89.2.6 ProGuard Support

      89.3 The Top-level Gradle Build File

      89.4 Module Level Gradle Build Files

      89.5 Configuring Signing Settings in the Build File

      89.6 Running Gradle Tasks from the Command-line

      89.7 Summary

      Index

      1. Introduction

      In 2018 Google introduced Android Jetpack to the developer community. Designed to make it quicker and easier to develop modern and reliable Android apps, Jetpack consists of a set of tools, libraries and architectural guidelines. The main elements of Android Jetpack consist of the Android Studio Integrated Development Environment (IDE), the Android Architecture Components and the Modern App Architecture Guidelines, all of which are covered in this latest edition of Android Studio Development Essentials.

      Fully updated for Android Studio 3.2 and Android 9, the goal of this book is to teach the skills necessary to develop Android based applications using the Java programming language.

      Beginning with the basics, this book provides an outline of the steps necessary to set up an Android development and testing environment. An overview of Android Studio is included covering areas such as tool windows, the code editor and the Layout Editor tool. An introduction to the architecture of Android is followed by an in-depth look at the design of Android applications and user interfaces using the Android Studio environment.

      Chapters are also included covering the Android Architecture Components including view models, lifecycle management, Room database access, app navigation, live data and data binding.

      More advanced topics such as intents are also covered, as are touch screen handling, gesture recognition, camera access and the playback and recording of both video and audio. This edition of the book also covers printing, transitions and cloud-based file storage.

      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.

      In addition to covering general Android development techniques, the book also includes Google Play specific topics such as implementing maps using the Google Maps Android API, and submitting apps to the Google Play Developer Console.

      Other key features of Android Studio 3.2 and Android 9 are also covered in detail including the Layout Editor, the ConstraintLayout and ConstraintSet classes, constraint chains and barriers, direct reply notifications and multi-window support.

      Chapters also cover advanced features of Android Studio such as App Links, Instant Apps, the Android Studio Profiler and Gradle build configuration.

      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 ideas for some apps to develop, you are ready to get started.

      1.1 Downloading the Code Samples

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

      https://www.ebookfrenzy.com/retail/androidstudio32/index.php

      The steps to load a project from the code samples into Android Studio are as follows:

      1. From the Welcome to Android Studio dialog, select the Open an existing Android Studio project option.

      2. In the project selection dialog, navigate to and select the folder containing the project to be imported and click on OK.

      1.2 Feedback

      We want you to be satisfied with your purchase of this book. If you find any errors in the book, or have any comments, questions or concerns please contact us at [email protected].

      1.3 Errata

      While we make every effort to ensure the accuracy of the content of this book, it is inevitable that a book covering a subject area of this size and complexity may include some errors and oversights. Any known issues with the book will be outlined, together with solutions, at the following URL:

      https://www.ebookfrenzy.com/errata/androidstudio32.html

      In the event that you find an error not listed in the errata, please let us know by emailing our technical support team at [email protected]. They are there to help you and will work to resolve any problems you may encounter.

      2. Setting up an Android Studio Development Environment

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

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

      2.1 System Requirements

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

      •Windows 7/8/10 (32-bit or 64-bit)

      •macOS 10.10 or later (Intel based systems only)

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

      •Minimum of 3GB of RAM (8GB is preferred)

      •Approximately 4GB of available disk space

      •1280 x 800 minimum screen resolution

      2.2 Downloading the Android Studio Package

      Most of the work involved in developing applications for Android will be performed using the Android Studio environment. The content and examples in this book were created based on Android Studio version 3.2 which, at the time writing is the current version.

      Android Studio is, however, subject to frequent updates so a newer version may have been released since this book was published.

      The latest release of Android Studio may be downloaded from the primary download page which can be found at the following URL:

      https://developer.android.com/studio/index.html

      If this page provides instructions for downloading a newer version of Android Studio it is important to note that there may be some minor differences between this book and the software. A web search for Android Studio 3.2 should provide the option to download the older version in the event that these differences become a problem.

      2.3 Installing Android Studio

      Once downloaded, the exact steps to install Android Studio differ depending on the operating system on which the installation is being performed.

      2.3.1 Installation on Windows

      Locate the downloaded Android Studio installation executable file (named android-studio-ide--windows.exe) in a Windows Explorer window and double-click on it to start the installation process, clicking the Yes button in the User Account Control dialog if it appears.

      Once the Android Studio setup wizard appears, work through the various screens to configure the installation to meet your requirements in terms of the file system location into which Android Studio should be installed and whether or not it should be made available to other users of the system. When prompted to select the components to install, make sure that the Android Studio, Android SDK and Android Virtual Device options are all selected.

      Although there are no strict rules on where Android Studio should be installed on the system, the remainder of this book will assume that the installation was performed into C:\Program Files\Android\Android Studio and that the Android SDK packages have been installed into the user’s AppData\Local\Android\sdk sub-folder. Once the options have been configured, click on the Install button to begin the installation process.

      On versions of Windows with a Start menu, the newly installed Android Studio can be launched from the entry added to that menu during the installation. The executable may be pinned to the task bar for easy access by navigating to the Android Studio\bin directory, right-clicking on the executable and selecting the Pin to Taskbar menu option. Note that the executable is provided in 32-bit (studio) and 64-bit (studio64) executable versions. If you are running a 32-bit system be sure to use the studio executable.

      2.3.2 Installation on macOS

      Android Studio for macOS is downloaded in the form of a disk image (.dmg) file. Once the android-studio-ide--mac.dmg file has been downloaded, locate it in a Finder window and double-click on it to open it as shown in Figure 2-1:

      Figure 2-1

      To install the package, simply drag the Android Studio icon and drop it onto the Applications folder. The Android Studio package will then be installed into the Applications folder of the system, a process which will typically take a few minutes to complete.

      To launch Android Studio, locate the executable in the Applications folder using a Finder window and double-click on it.

      For future easier access to the tool, drag the Android Studio icon from the Finder window and drop it onto the dock.

      2.3.3 Installation on Linux

      Having downloaded the Linux Android Studio package, open a terminal window, change directory to the location where Android Studio is to be installed and execute the following command:

      unzip //android-studio-ide--linux.zip

      Note that the Android Studio bundle will be installed into a sub-directory named android-studio. Assuming, therefore, that the above command was executed in /home/demo, the software packages will be unpacked into /home/demo/android-studio.

      To launch Android Studio, open a terminal window, change directory to the android-studio/bin sub-directory and execute the following command:

      ./studio.sh

      When running on a 64-bit Linux system, it will be necessary to install some 32-bit support libraries before Android Studio will run. On Ubuntu these libraries can be installed using the following command:

      sudo apt-get install libc6:i386 libncurses5:i386 libstdc++6:i386 lib32z1 libbz2-1.0:i386

      On Red Hat and Fedora based 64-bit systems, use the following command:

      sudo yum install zlib.i686 ncurses-libs.i686 bzip2-libs.i686

      2.4 The Android Studio Setup Wizard

      The first time that Android Studio is launched after being installed, a dialog will appear providing the option to import settings from a previous Android Studio version. If you have settings from a previous version and would like to import them into the latest installation, select the appropriate option and location. Alternatively, indicate that you do not need to import any previous settings and click on the OK button to proceed.

      Next, the setup wizard may appear as shown in Figure 2-2 though this dialog does not appear on all platforms:

      Figure 2-2

      If the wizard appears, click on the Next button, choose the Standard installation option and click on Next once again.

      Android Studio will proceed to download and configure the latest Android SDK and some additional components and packages. Once this process has completed, click on the Finish button in the Downloading Components dialog at which point the Welcome to Android Studio screen should then appear:

      Figure 2-3

      2.5 Installing Additional Android SDK Packages

      The steps performed so far have installed Java, the Android Studio IDE and the current set of default Android SDK packages. Before proceeding, it is worth taking some time to verify which packages are installed and to install any missing or updated packages.

      This task can be performed using the Android SDK Settings screen, which may be launched from within the Android Studio tool by selecting the Configure -> SDK Manager option from within the Android Studio welcome dialog. Once invoked, the Android SDK screen of the default settings dialog will appear as shown in Figure 2-4:

      Figure 2-4

      Immediately after installing Android Studio for the first time it is likely that only the latest released version of the Android SDK has been installed. To install older versions of the Android SDK simply select the checkboxes corresponding to the versions and click on the Apply button.

      It is also possible that updates will be listed as being available for the latest SDK. To access detailed information about the packages that are available for update, enable the Show Package Details option located in the lower right-hand corner of the screen. This will display information similar to that shown in Figure 2-5:

      Figure 2-5

      The above figure highlights the availability of an update. To install the updates, enable the checkbox to the left of the item name and click on the Apply button.

      In addition to the Android SDK packages, a number of tools are also installed for building Android applications. To view the currently installed packages and check for updates, remain within the SDK settings screen and select the SDK Tools tab as shown in Figure 2-6:

      Figure 2-6

      Within the Android SDK Tools screen, make sure that the following packages are listed as Installed in the Status column:

      •Android SDK Build-tools

      •Android Emulator

      •Android SDK Platform-tools

      •Android SDK Tools

      •Google Play Services

      •Instant Apps Development SDK

      •Intel x86 Emulator Accelerator (HAXM installer)

      •ConstraintLayout for Android

      •Solver for ConstraintLayout

      •Android Support Repository

      •Google Repository

      •Google USB Driver (Windows only)

      In the event that any of the above packages are listed as Not Installed or requiring an update, simply select the checkboxes next to those packages and click on the Apply button to initiate the installation process.

      Once the installation is complete, review the package list and make sure that the selected packages are now listed as Installed in the Status column. If any are listed as Not installed, make sure they are selected and click on the Apply button again.

      2.6 Making the Android SDK Tools Command-line Accessible

      Most of the time, the underlying tools of the Android SDK will be accessed from within the Android Studio environment. That being said, however, there will also be instances where it will be useful to be able to invoke those tools from a command prompt or terminal window. In order for the operating system on which you are developing to be able to find these tools, it will be necessary to add them to the system’s PATH environment variable.

      Regardless of operating system, the PATH variable needs to be configured to include the following paths (where represents the file system location into which the Android SDK was installed):

      /sdk/tools

      /sdk/tools/bin

      /sdk/platform-tools

      The location of the SDK on your system can be identified by launching the SDK Manager and referring to the Android SDK Location: field located at the top of the settings panel as highlighted in Figure 2-7:

      Figure 2-7

      Once the location of the SDK has been identified, the steps to add this to the PATH variable are operating system dependent:

      2.6.1 Windows 7

      1. Right-click on Computer in the desktop start menu and select Properties from the resulting menu.

      2. In the properties panel, select the Advanced System Settings link and, in the resulting dialog, click on the Environment Variables… button.

      3. In the Environment Variables dialog, locate the Path variable in the System variables list, select it and click on Edit…. Locate the end of the current variable value string and append the path to the Android platform tools to the end, using a semicolon to separate the path from the preceding values. For example, assuming the Android SDK was installed into C:\Users\demo\AppData\Local\Android\sdk, the following would be appended to the end of the current Path value:

      ;C:\Users\demo\AppData\Local\Android\sdk\platform-tools; C:\Users\demo\AppData\Local\Android\sdk\tools; C:\Users\demo\AppData\Local\Android\sdk\tools\bin

      4. Click on OK in each dialog box and close the system properties control panel.

      Once the above steps are complete, verify that the path is correctly set by opening a Command Prompt window (Start -> All Programs -> Accessories -> Command Prompt) and at the prompt enter:

      echo %Path%

      The returned path variable value should include the paths to the Android SDK platform tools folders. Verify that the platform-tools value is correct by attempting to run the adb tool as follows:

      adb

      The tool should output a list of command line options when executed.

      Similarly, check the tools path setting by attempting to launch the AVD Manager command line tool (don’t worry if the avdmanager tool reports a problem with Java - this will be addressed later):

      avdmanager

      In the event that a message similar to the following message appears for one or both of the commands, it is most likely that an incorrect path was appended to the Path environment variable:

      'adb' is not recognized as an internal or external command,

      operable program or batch file.

      2.6.2 Windows 8.1

      1. On the start screen, move the mouse to the bottom right-hand corner of the screen and select Search from the resulting menu. In the search box, enter Control Panel. When the Control Panel icon appears in the results area, click on it to launch the tool on the desktop.

      2. Within the Control Panel, use the Category menu to change the display to Large Icons. From the list of icons select the one labeled System.

      3. Follow the steps outlined for Windows 7 starting from step 2 through to step 4.

      Open the command prompt window (move the mouse to the bottom right-hand corner of the screen, select the Search option and enter cmd into the search box). Select Command Prompt from the search results.

      Within the Command Prompt window, enter:

      echo %Path%

      The returned path variable value should include the paths to the Android SDK platform tools folders. Verify that the platform-tools value is correct by attempting to run the adb tool as follows:

      adb

      The tool should output a list of command line options when executed.

      Similarly, check the tools path setting by attempting to run the AVD Manager command line tool (don’t worry if the avdmanager tool reports a problem with Java - this will be addressed later):

      avdmanager

      In the event that a message similar to the following message appears for one or both of the commands, it is most likely that an incorrect path was appended to the Path environment variable:

      'adb' is not recognized as an internal or external command,

      operable program or batch file.

      2.6.3 Windows 10

      Right-click on the Start menu, select Settings from the resulting menu and enter Edit the system environment variables into the Find a setting text field. In the System Properties dialog, click the Environment Variables... button. Follow the steps outlined for Windows 7 starting from step 3.

      2.6.4 Linux

      On Linux, this configuration can typically be achieved by adding a command to the .bashrc file in your home directory (specifics may differ depending on the particular Linux distribution in use). Assuming that the Android SDK bundle package was installed into /home/demo/Android/sdk, the export line in the .bashrc file would read as follows:

      export PATH=/home/demo/Android/sdk/platform-tools:/home/demo/Android/sdk/tools:/home/demo/Android/sdk/tools/bin:/home/demo/android-studio/bin:$PATH

      Note also that the above command adds the android-studio/bin directory to the PATH variable. This will enable the studio.sh script to be executed regardless of the current directory within a terminal window.

      2.6.5 macOS

      A number of techniques may be employed to modify the $PATH environment variable on macOS. Arguably the cleanest method is to add a new file in the /etc/paths.d directory containing the paths to be added to $PATH. Assuming an Android SDK installation location of /Users/demo/Library/Android/sdk, the path may be configured by creating a new file named android-sdk in the /etc/paths.d directory containing the following lines:

      /Users/demo/Library/Android/sdk/tools

      /Users/demo/Library/Android/sdk/tools/bin

      /Users/demo/Library/Android/sdk/platform-tools

      Note that since this is a system directory it will be necessary to use the sudo command when creating the file. For example:

      sudo vi /etc/paths.d/android-sdk

      2.7 Updating Android Studio and the SDK

      From time to time new versions of Android Studio and the Android SDK are released. New versions of the SDK are installed using the Android SDK Manager. Android Studio will typically notify you when an update is ready to be installed.

      To manually check for Android Studio updates, click on the Configure -> Check for Update menu option within the Android Studio welcome screen, or use the Help -> Check for Update menu option accessible from within the Android Studio main window.

      2.8 Summary

      Prior to beginning the development of Android based applications, the first step is to set up a suitable development environment. This consists of the Android SDKs and Android Studio IDE (which also includes the OpenJDK development environment). In this chapter, we have covered the steps necessary to install these packages on Windows, macOS and Linux.

      3. Creating an Example Android App in Android Studio

      The preceding chapters of this book have covered the steps necessary to configure an environment suitable for the development of Android applications using the Android Studio IDE. Before moving on to slightly more advanced topics, now is a good time to validate that all of the required development packages are installed and functioning correctly. The best way to achieve this goal is to create an Android application and compile and run it. This chapter will cover the creation of a simple Android application project using Android Studio. Once the project has been created, a later chapter will explore the use of the Android emulator environment to perform a test run of the application.

      3.1 About the Project

      The project created in this chapter takes the form of a very simple currency conversion calculator (so simple, in fact, that it only converts from dollars to euros and does so using an estimated conversion rate). The project will also make use of the most basic of Android Studio project templates. This simplicity allows us to introduce some of the key aspects of Android app development without overwhelming the beginner by trying to introduce too many concepts, such as the recommended app architecture and Android architecture components, at once. When following the tutorial in this chapter, rest assured that all of the techniques and code used in this initial example project will be covered in much greater detail in later chapters.

      3.2 Creating a New Android Project

      The first step in the application development process is to create a new project within the Android Studio environment. Begin, therefore, by launching Android Studio so that the Welcome to Android Studio screen appears as illustrated in Figure 3-1:

      Figure 3-1

      Once this window appears, Android Studio is ready for a new project to be created. To create the new project, simply click on the Start a new Android Studio project option to display the first screen of the New Project wizard as shown in Figure 3-2:

      Figure 3-2

      3.3 Defining the Project and SDK Settings

      In the New Project window, set the Application 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 is used to uniquely identify the application within the Android application ecosystem. Although this can be set to any string that uniquely identifies your app, it is traditionally based on the reversed URL of your domain name followed by the name of the application. For example, if your domain is www.mycompany.com, and the application has been named AndroidSample, then the package name might be specified as follows:

      com.mycompany.androidsample

      If you do not have a domain name you can enter any other string into the Company Domain field, or you may use example.com for the purposes of testing, though this will need to be changed before an application can be published:

      com.example.androidsample

      The Project 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 button to the right of the text field containing the current path setting.

      Click Next to proceed. On the form factors screen, enable the Phone and Tablet option and set the minimum SDK setting to API 26: Android 8.0 (Oreo). This is the SDK that will be used in most of the projects created in this book unless a necessary feature is only available in a more recent version. While Android Studio allows older SDK versions to be selected, many of the security and privacy features built into Android were only introduced after the API 25 SDK was released. To improve app security, Google announced that starting in August 2018 the Google Play store will only accept new apps built using API 26 or newer. This same restriction is also applied to updates of existing apps after October 2018. Since the project is not intended for Google TV, Android Auto or wearable devices, leave the remaining options disabled before clicking Next. Instant Apps will not be covered until later in this book so make sure that the Include Android Instant App support option is disabled.

      3.4 Creating an Activity

      The next step is to define the type of initial activity that is to be created for the application. A range of different activity types is available when developing Android applications, many of which will be covered extensively in later chapters. For the purposes of this example, however, simply select the option to create a Basic Activity. The Basic Activity option creates a template user interface consisting of an app bar, menu, content area and a single floating action button.

      Figure 3-3

      With the Basic Activity option selected, click Next. On the final screen (Figure 3-4) name the activity and title AndroidSampleActivity. The activity will consist of a single user interface screen layout which, for the purposes of this example, should be named activity_android_sample. Finally, enter My Android App into the title field as shown in Figure 3-4:

      Figure 3-4

      Click on Finish to initiate the project creation process.

      3.5 Modifying the Example Application

      At this point, Android Studio has created a minimal example application project and opened the main window.

      Figure 3-5

      The newly created project and references to associated files are listed in the Project tool window located on the left-hand side of the main project window. The Project tool window has a number of modes in which information can be displayed. By default, this panel will be in Android mode. This setting is controlled by the menu at the top of the panel as highlighted in Figure 3-6. If the panel is not currently in Android mode, use the menu to switch mode:

      Figure 3-6

      The example project created for us when we selected the option to create an activity consists of a user interface containing a label that will read Hello World! when the application is executed.

      The next step in this tutorial is to modify the user interface of our application so that it displays a larger text view object with a different message to the one provided for us by Android Studio.

      The user interface design for our activity is stored in a file named activity_android_sample.xml which, in turn, is located under app -> res -> layout in the project file hierarchy. This layout file includes the app bar (also known as an action bar) that appears across the top of the device screen (marked A in Figure 3-7) and the floating action button (the email button marked B). In addition to these items, the activity_android_sample.xml layout file contains a reference to a second file containing the content layout (marked C):

      Figure 3-7

      By default, the content layout is contained within a file named content_android_sample.xml and it is within this file that changes to the layout of the activity are made. Using the Project tool window, locate this file as illustrated in Figure 3-8:

      Figure 3-8

      Once located, 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-9

      In the toolbar across the top of the Layout Editor window is a menu (currently set to Nexus 4 in the above figure) which is reflected in the visual representation of the device within the Layout Editor panel. A wide range of other device options are available for selection by clicking on this menu.

      To change the orientation of the device representation between landscape and portrait simply use the drop down menu immediately to the left of the device selection menu showing the icon.

      As can be seen in the device screen, the content layout already includes a label that displays a Hello World! message. Running down the left-hand side of the panel is a palette containing different categories of user interface components that may be used to construct a user interface, such as buttons, labels and text fields. It should be noted, however, that not all user interface components are obviously visible to the user. One such category consists of layouts. Android supports a variety of layouts that provide different levels of control over how visual user interface components are positioned and managed on the screen. Though it is difficult to tell from looking at the visual representation of the user interface, the current design has been created using a ConstraintLayout. This can be confirmed by reviewing the information in the Component Tree panel which, by default, is located in the lower left-hand corner of the Layout Editor panel and is shown in Figure 3-10:

      Figure 3-10

      As we can see from the component tree hierarchy, the user interface layout consists of a ConstraintLayout parent with a single child in the form of a TextView object.

      Before proceeding, check that the Layout Editor’s Autoconnect mode is enabled. This means that as components are

      Enjoying the preview?
      Page 1 of 1