INTRODUCTION xxxi
CHAPTER 1: HELLO, ANDROID 1
Android Application Development 1
A Little Background 2
The Not-So-Distant Past 3
Living in the Future 3
The Android Ecosystem 3
Pre-installed Android Applications 4
Android SDK Features 5
What Does Android Run On? 6
Why Develop for Mobile? 6
Why Develop for Android? 7
Introducing the Development Framework 7
What Comes in the Box 8
Understanding the Android Software Stack 8
The Android Run Time 10
Android Application Architecture 11
Android Libraries 12
CHAPTER 2: GETTING STARTED 13
Getting Started Developing Android Apps 14
Developing for Android 15
What You Need to Begin 15
Creating Your First Android Application 20
Getting Started Writing Android Apps Using Kotlin 35
Using the Android Support Library Package 36
Developing for Mobile and Embedded Devices 39
Hardware-Imposed Design Considerations 39
Considering the User's Environment 43
Developing for Android 44
Android Development Tools 48
Android Studio 49
The Android Virtual Device Manager 51
The Android Emulator 51
Android Profiler 52
The Android Debug Bridge 54
APK Analyzer 54
The Lint Tool 55
Monkey, Monkey Runner, and Espresso UI Testing 55
Gradle 56
CHAPTER 3: APPLICATIONS AND ACTIVITIES AND FRAGMENTS, OH MY! 57
Applications, Activities, and Fragments 58
The Components of an Android Application 58
The Android Application Life Cycle, Priority, and Process States 59
Introducing the Android Application Class 61
A Closer Look at Android Activities 61
Creating Activities 62
Using the AppCompatActivity 63
The Activity Life Cycle 64
Responding to Memory Pressure 71
Introducing Fragments 73
Creating New Fragments 73
The Fragment Life Cycle 74
Introducing the Fragment Manager 79
Adding Fragments to Activities 79
Communicating Between Fragments and Activities 85
Fragments without User Interfaces 86
Building an Earthquake Viewer Application 87
CHAPTER 4: DEFINING THE ANDROID MANIFEST AND GRADLE BUILD FILES, AND EXTERNALIZING RESOURCES 95
The Manifest, Build Files, and Resources 96
Introducing the Android Manifest 96
Configuring the Gradle Build 101
Gradle Settings File 101
Project Gradle Build File 102
Module Gradle Build Files 102
Externalizing Resources 107
Creating Resources 108
Using Resources 119
Creating Resources for Different Languages and Hardware 122
Runtime Configuration Changes 126
CHAPTER 5: BUILDING USER INTERFACES 129
Fundamental Android Design 130
Density-Independent Design 130
Android User Interface Fundamentals 131
Assigning User Interfaces to Activities 132
Introducing Layouts 132
Defining Layouts 134
Using Layouts to Create Device-Independent User Interfaces 136
Optimizing Layouts 139
The Android Widget Toolbox 143
Working with Lists and Grids 144
Recycler View and Layout Managers 145
Introducing Adapters 146
Returning to the Earthquake Viewer Application 149
Introducing Data Binding 150
Enabling Data Binding 151
Variables in Data Binding 152
Data Binding for the Earthquake Viewer Application 153
Creating New Views 155
Modifying Existing Views 155
Creating Compound Controls 159
Creating Simple Compound Controls as a Layout 161
Creating Custom Views 162
Using Custom Controls 176
CHAPTER 6: INTENTS AND BROADCAST RECEIVERS 177
Using Intents and Broadcast Receivers 178
Using Intents to Launch Activities 178
Explicitly Starting New Activities 179
Implicit Intents and Late Runtime Binding 179
Determining If an Intent Will Resolve 180
Returning Results from Activities 181
Using Platform-Native Actions to Launch Activities 184
Creating Intent Filters to Receive Implicit Intents 186
Defining an Intent Filter 186
Using Intent Filters for Plug-Ins and Extensibility 194
Introducing Linkify 198
Native Linkify Link Types 198
Creating Custom Link Strings 199
Using the Match Filter 200
Using the Transform Filter 200
Using Intents to Broadcast Events 200
Broadcasting Events with Intents 201
Listening for Intent Broadcasts with Broadcast Receivers 202
Registering Broadcast Receivers in Code 203
Registering Broadcast Receivers in Your Application Manifest 204
Managing Manifest Receivers at Run Time 204
Monitoring Device State Changes through Broadcast Intents 205
Introducing the Local Broadcast Manager 207
Introducing Pending Intents 208
CHAPTER 7: USING INTERNET RESOURCES 211
Connecting to the Internet 211
Connecting, Downloading, and Parsing Internet Resources 212
Why Build a Native Internet App? 212
Connecting to an Internet Resource 213
Performing Network Operations on Background Threads Using View Models, Live Data, and Asynchronous Tasks 214
Parsing XML Using the XML Pull Parser 219
Connecting the Earthquake Viewer to the Internet 220
Parsing JSON Using the JSON Parser 228
Using the Download Manager 233
Downloading Files 233
Customizing Download Manager Notifications 235
Specifying a Download Location 237
Canceling and Removing Downloads 238
Querying the Download Manager 238
Best Practices for Downloading Data without Draining the Battery 241
An Introduction to Internet Services and Cloud Computing 242
CHAPTER 8: FILES, SAVING STATE, AND USER PREFERENCES 245
Saving Files, States, and Preferences 246
Saving and Restoring Activity and Fragment Instance
State Using the Lifecycle Handlers 246
Retaining Instance State with Headless Fragments and View Models 248
View Models and Live Data 248
Headless Fragments 251
Creating and Saving Shared Preferences 252
Retrieving Shared Preferences 253
Introducing On Shared Preference Change Listeners 254
Configuring Auto Backup of Application Files and Shared Preferences 254
Building a Preference UI 256
Using the Preference Support Library 256
Defining a Preference Screen Layout in XML 257
Introducing the Preference Fragment 260
Creating a Settings Activity for the Earthquake Monitor 261
Including Static Files as Resources 267
Working with the Filesystem 267
File-Management Tools 267
Creating Files on Application-Specifi c Internal Storage 268
Creating Files on Application-Specifi c External Storage 268
Accessing Public Directories Using Scoped Directory Access 270
Sharing Files Using File Provider 274
Creating a File Provider 274
Sharing a File Using a File Provider 275
Receiving a File from a File Provider 275
Accessing Files from Other Applications Using the Storage Access Framework 275
Requesting Temporary Access to Files 276
Requesting Persistent Access to Files 277
Requesting Access to Directories 277
Creating New Files 278
Using URI-Based Permissions 278
CHAPTER 9: CREATING AND USING DATABASES 281
Introducing Structured Data Storage in Android 282
Storing Data Using the Room Persistence Library 282
Adding the Room Persistence Library 283
Defining a Room Database 284
Persisting Complex Objects Using Type Convertors 286
Defining Room Database Interactions Using Data Access Objects 288
Performing Room Database Interactions 291
Monitoring Query Result Changes with Live Data 292
Persisting Earthquakes to a Database with Room 294
Working with SQLite Databases 298
Input Validation and SQL Injection 299
Cursors and Content Values 299
Defining a Database Contract 300
Introducing the SQLiteOpenHelper 300
Opening Databases with the SQLite Open Helper 302
Opening and Creating Databases without the SQLite Open Helper 303
Adding, Updating, and Deleting Rows 303
Querying a Database 305
Extracting Values from a Cursor 307
Introducing the Firebase Realtime Database 308
Adding Firebase to Your App 309
Defining a Firebase Database and Defining Access Rules 311
Adding, Modifying, Deleting, and Querying Data from a Firebase Realtime Database 313
CHAPTER 10: CONTENT PROVIDERS AND SEARCH 317
Introducing Content Providers 318
Why Should I Use Content Providers? 318
Creating Content Providers 319
Creating the Content Provider's Database 320
Registering Content Providers 321
Publishing Your Content Provider's URI Address 321
Implementing Content Provider Queries 322
Content Provider Transactions 325
Sharing Files Using a Content Provider 327
Adding Permission Requirements to Content Providers 328
Accessing Content Providers with Content Resolvers 330
Querying Content Providers 330
Cancelling Queries 333
Querying for Content Asynchronously with a Cursor Loader 333
Adding, Deleting, and Updating Content 336
Accessing Files Stored in Content Providers 338
Accessing Permission-Restricted Content Providers 339
Using Native Android Content Providers 341
Accessing the Call Log 341
Using the Media Store Content Provider 342
Using the Contacts Content Provider 344
Using the Calendar Content Provider 351
Adding Search to Your Application 354
Defining Your Search Metadata 354
Creating a Search Results Activity 355
Searching a Content Provider 357
Using the Search View Widget 360
Providing Search Suggestions Using a Content Provider 362
CHAPTER 11: WORKING IN THE BACKGROUND 377
Working in the Background 378
Using Background Threads 379
Using Asynchronous Tasks to Run Tasks Asynchronously 379
Manual Thread Creation Using Handler Threads 383
Scheduling Background Jobs 385
Creating a Job Service for the Job Scheduler 386
Scheduling Jobs with the Job Scheduler 388
Scheduling Jobs with the Firebase Job Dispatcher 391
Scheduling Work with the Work Manager 393
An Earthquake-Monitoring Job Service Example 396
Using Notifications to Notify Users 401
Introducing the Notification Manager 401
Working with Notification Channels 402
Creating Notifications 403
Setting a Notification's Priority 407
Adding Notification Actions 411
Adding Direct Reply Actions 412
Grouping Multiple Notifications 413
Adding Notifications to the Earthquake Monitor 414
Using Firebase Cloud Messaging 417
Triggering Notifications Remotely with Firebase Notifications 418
Receiving Data with Firebase Cloud Messaging 421
Using Alarms 422
Creating, Setting, and Canceling Alarms 423
Setting an Alarm Clock 424
Introducing Services 424
Using Bound Services 425
Creating a Started Service 427
CHAPTER 12: IMPLEMENTING THE ANDROID
DESIGN PHILOSOPHY 433
Introducing the Android Design Philosophy 434
Designing for Every Screen 434
Resolution Independence 435
Supporting and Optimizing for Different Screen Sizes 436
Creating Scalable Graphics Assets 439
Introducing Material Design 445
Thinking in Terms of Paper and Ink 446
Using Color and Keylines as Guides 447
Continuity through Motion 449
Material Design UI Elements 452
The App Bar 452
Applying Material Design to the Earthquake Monitor 455
Using Cards to Display Content 456
Floating Action Buttons 460
CHAPTER 13: IMPLEMENTING A MODERN ANDROID USER EXPERIENCE 463
The Modern Android UI 464
Creating Consistent, Modern User Interfaces
Using AppCompat 464
Creating and Applying Themes Using AppCompat 465
Creating Theme Overlays for Specific Views 466
Adding a Menu and Actions to the App Bar 467
Defining a Menu Resource 467
Adding a Menu to an Activity 468
Adding a Menu to a Fragment 469
Updating Menu Items Dynamically 469
Handling Menu Selections 470
Adding Action Views and Action Providers 470
Going Beyond the Default App Bar 472
Replacing Your App Bar with a Toolbar 472
Advanced Scrolling Techniques for the Toolbar 473
Incorporating Menus without the App Bar 476
Improving the Earthquake Monitor's App Bar 477
App Navigation Patterns 479
Navigating with Tabs 479
Implementing a Bottom Navigation Bar 482
Using a Navigation Drawer 485
Combining Navigation Patterns 491
Adding Tabs to the Earthquake Monitor 492
Choosing the Right Level of Interruption 496
Initiating a Dialog 497
Let's Make a Toast 498
Inline Interruptions with Snackbars 499
CHAPTER 14: ADVANCED CUSTOMIZATION OF YOUR USER INTERFACE 501
Expanding the User Experience 502
Supporting Accessibility 502
Supporting Navigation without a Touch Screen 502
Providing a Textual Description of Each View 503
Introducing Android Text-to-Speech 503
Using Speech Recognition 505
Using Speech Recognition for Voice Input 506
Using Speech Recognition for Search 507
Controlling Device Vibration 508
Going Full Screen 508
Working with Property Animations 510
Enhancing Your Views 513
Advanced Canvas Drawing 514
Creating Interactive Controls 530
Composite Drawable Resources 536
Transformative Drawables 536
Layer Drawables 537
State List Drawables 537
Level List Drawables 538
Copy, Paste, and the Clipboard 539
Copying Data to the Clipboard 539
Pasting Clipboard Data 539
CHAPTER 15: LOCATION, CONTEXTUAL AWARENESS,AND MAPPING 541
Adding Location, Maps, and Contextual Awareness to Your
Applications 542
Introducing Google Play Services 542
Adding Google Play Services to Your Application 543
Determining the Availability of Google Play Services 545
Finding Device Location Using Google Location Services 546
Using the Emulator to Test Location-Based Functionality 548
Finding the Last Known Location 549
"Where Am I" Example 551
Requesting Location Change Updates 555
Changing Device Location Settings 560
Updating the Location in the "Where Am I" Example 563
Best Practices When Using Location 566
Setting and Managing Geofences 567
Using the Legacy Platform Location-Based Services 571
Selecting a Location Provider 572
Finding the Last Known Location 574
Requesting Location Change Updates 575
Best Practice for Using the Legacy Location-Based Services 577
Using the Geocoder 580
Reverse Geocoding 581
Forward Geocoding 582
Geocoding Where Am I 583
Creating Map-Based Activities 585
Getting Your Maps API Key 586
Creating a Map-Based Activity 586
Configuring Google Maps 589
Changing the Camera Position with Camera Updates 590
Mapping Where Am I 592
Displaying the Current Location with the My Location Layer 596
Displaying Interactive Map Markers 596
Adding Shapes to Google Maps 599
Adding Image Overlays to Google Maps 602
Adding Markers and Shapes to Where Am I 602
Mapping the Earthquake Example 605
Adding Contextual Awareness 609
Connecting to the Google Play Services API Client and Obtaining API Keys 610
Using Awareness Snapshots 612
Setting and Monitoring Awareness Fences 613
Awareness Best Practices 617
CHAPTER 16: HARDWARE SENSORS 619
Introducing Android Sensors 620
Using the Sensor Manager 620
Understanding the Android Sensors 621
Discovering and Identifying Sensors 623
Determining Sensor Capabilities 625
Wakeup and Non-Wakeup Sensors 627
Monitoring Sensor Results 627
Interpreting Sensor Values 632
Testing Sensors with the Android Virtual Device and Emulator 635
Best Practices for Working with Sensors 637
Monitoring a Device's Movement and Orientation 637
Determining the Natural Orientation of a Device 638
Introducing Accelerometers 639
Detecting Acceleration Changes 640
Creating a Gravitational Force Meter 642
Determining a Device's Orientation 645
Creating a Compass and Artificial Horizon 650
Using the Environmental Sensors 654
Using the Barometer Sensor 654
Creating a Weather Station 655
Using Body Sensors 659
User Activity Recognition 662
CHAPTER 17: AUDIO, VIDEO, AND USING THE CAMERA 665
Playing Audio and Video, and Using the Camera 666
Playing Audio and Video 666
Introducing the Media Player 667
Using Media Player for Video Playback 669
Using ExoPlayer for Video Playback 672
Requesting and Managing Audio Focus 674
Pausing Playback When the Output Changes 676
Responding to the Volume Controls 677
Working with a Media Session 678
Using the Media Router and Cast Application Framework 682
Background Audio Playback 686
Building an Audio Playback Service 686
Using a Media Browser to Connect Your Activity to a
Media Browser Service 688
Life Cycle of a Media Browser Service 690
Playing Audio as a Foreground Service 691
Creating Media Style Notifications 693
Using the Media Recorder to Record Audio 695
Using the Camera for Taking Pictures 697
Using Intents to Take Pictures 697
Controlling the Camera Directly 699
Reading and Writing JPEG EXIF Image Details 706
Recording Video 706
Using Intents to Record Video 707
Using the Media Recorder to Record Video 707
Adding Media to the Media Store 710
Inserting Media Using the Media Scanner 710
Inserting Media Manually 711
CHAPTER 18: COMMUNICATING WITH BLUETOOTH,NFC, AND WI-FI PEER-TO-PEER 713
Networking and Peer-to-Peer Communication 713
Transferring Data Using Bluetooth 714
Managing the Local Bluetooth Device Adapter 714
Being Discoverable and Remote Device Discovery 716
Bluetooth Communications 720
Bluetooth Profiles 725
Bluetooth Low Energy 726
Transferring Data Using Wi-Fi Peer-to-Peer 728
Initializing the Wi-Fi Peer-to-Peer Framework 729
Discovering Peers 731
Connecting with Peers 732
Transferring Data between Peers 733
Using Near Field Communication 735
Reading NFC Tags 735
Using the Foreground Dispatch System 736
Using Android Beam 738
Creating Android Beam Messages 739
Assigning the Android Beam Payload 740
Receiving Android Beam Messages 742
CHAPTER 19: INVADING THE HOME SCREEN 743
Customizing the Home Screen 743
Introducing Home Screen Widgets 744
Defining the Widget Layout 745
Defining Your Widget Size and Other Metadata 746
Implementing Your Widget 748
Updating the Widget UI Using the App Widget Manager and Remote Views 749
Forcing Refreshes of Your Widget Data and UI 753
Creating and Using a Widget Configuration Activity 756
Creating an Earthquake Widget 757
Introducing Collection View Widgets 763
Creating Collection View Widget Layouts 764
Updating Collection View Items with a Remote Views Factory 765
Updating Collection View Items with a Remote Views Service 767
Populating Collection View Widgets Using a Remote Views Service 768
Adding Interactivity to the Items within a Collection View Widget 769
Refreshing Your Collection View Widgets 770
Creating an Earthquake Collection View Widget 770
Creating Live Wallpaper 777
Creating a Live Wallpaper Definition Resource 778
Creating a Wallpaper Service Engine 778
Creating a Wallpaper Service 780
Creating App Shortcuts 781
Static Shortcuts 783
Dynamic Shortcuts 784
Tracking App Shortcut Use 785
CHAPTER 20: ADVANCED ANDROID DEVELOPMENT 787
Advanced Android 788
Paranoid Android 788
Linux Kernel Security 788
Re-introducing Permissions 789
Storing Keys in the Android Keystore 792
Using the Fingerprint Sensor 792
Dealing with Different Hardware and Software Availability 793
Specifying Required Hardware 794
Confirming Hardware Availability 795
Building Backward-Compatible Applications 795
Optimizing UI Performance with Strict Mode 797
Telephony and SMS 798
Telephony 799
Sending and Receiving SMS Messages 806
CHAPTER 21: RELEASING, DISTRIBUTING, AND MONITORING APPLICATIONS 825
Preparing for Release 826
Preparing Release Support Material 826
Preparing Your Code for a Release Build 827
Updating Application Metadata in Your Application Manifest 828
Reviewing Application Installation Restrictions 828
Application Versioning 830
Signing Production Builds of Your Application 830
Creating a Keystore and Signing Key with Android Studio 832
Obtaining API Keys Based on Your Private Release Key 833
Building and Signing a Production Release 834
Distributing Your Application on the Google Play Store 835
Introducing the Google Play Store 835
Getting Started with the Google Play Store 836
Creating an Application on the Google Play Store 837
Publishing Your Application 845
Monitoring Your Application in Production 848
An Introduction to Monetizing Applications 853
Application Marketing, Promotion, and Distribution Strategies 854
Application Launch Strategies 854
Internationalization 855
Using Firebase to Monitor Your Application 856
Adding Firebase to Your Application 856
Using Firebase Analytics 857
Firebase Performance Monitoring 860
INDEX 863
