Table Of ContentElements of Android Jetpack
by Mark L. Murphy
Elements of Android Jetpack
by Mark L. Murphy
Copyright © 2019 CommonsWare, LLC. All Rights Reserved.
Printed in the United States of America.
Printing History:
March 2019: Version 0.3
The CommonsWare name and logo, “Busy Coder's Guide”, and related trade dress are trademarks of CommonsWare,
LLC.
All other trademarks referenced in this book are trademarks of their respective firms.
The publisher and author(s) assume no responsibility for errors or omissions or for damages resulting from the use of the
information contained herein.
Table of Contents
Headings formatted in bold-italic have changed since the last version.
• Preface
◦ Prerequisites ........................................................................................ vii
◦ About the Updates .............................................................................. vii
◦ What’s New in Version 0.3? ..................................................... viii
◦ Warescription ......................................................................... viii
◦ Book Bug Bounty .................................................................................. ix
◦ Source Code and Its License ................................................................. x
◦ Creative Commons and the Four-to-Free (42F) Guarantee ........ x
◦ Acknowledgments ................................................................................ xi
• Introducing Android
◦ Focus: Apps, Not Operating Systems ................................................... 1
◦ What You Need ...................................................................................... 1
◦ How This Book Is Organized ................................................................ 5
• Setting Up the Tools
◦ But First, Some Notes About Android’s Emulator ...................... 7
◦ Step #1: Install Android Studio ................................................... 8
◦ Step #2: Running Android Studio for the First Time ................ 10
• Getting Your First Project
◦ Step #1: Importing the Project .................................................. 19
◦ Step #2: Get Ready for the x86 Emulator ........................................... 20
◦ Step #3: Set Up the AVD ...................................................................... 21
◦ Step #4: Set Up the Device .................................................................. 26
◦ Step #5: Running the Project .............................................................. 32
• Taking a Tour of Android Studio
◦ The Project Tree ................................................................................... 36
◦ The Editing Pane ................................................................................. 39
◦ The Docked Views .............................................................................. 40
◦ Popular Menu and Toolbar Options .................................................. 41
◦ Android Studio and Release Channels ..................................... 49
• Examining Your Code
◦ The Top Level ....................................................................................... 53
◦ The Project Contents ........................................................................... 54
◦ The App Module Contents .................................................................. 55
◦ The Generated Source Sets ................................................................. 56
◦ Language Differences ......................................................................... 60
i
◦ Introducing the Activity ........................................................... 60
◦ Other Things in the Project Tree ....................................................... 64
• Exploring Your Resources
◦ What You See in res/ .......................................................................... 68
◦ OS Versions and API Levels ...................................................... 68
◦ Decoding Resource Directory Names ................................................ 71
◦ Our Initial Resource Types ........................................................ 71
◦ About That R Thingy ........................................................................... 77
• Inspecting Your Manifest
◦ The Root Element ................................................................................ 79
◦ The Application Element ................................................................... 80
◦ The Activity Element (And Its Children) ........................................... 81
• Reviewing Your Gradle Scripts
◦ Gradle: The Big Questions .................................................................. 83
◦ Obtaining Gradle ................................................................................ 84
◦ Examining the Gradle Files ................................................................ 86
◦ Requesting Plugins .............................................................................. 91
◦ Android Plugin for Gradle Configuration .......................................... 91
◦ Other Stuff in the android Closure ................................................... 94
◦ Libraries and Dependencies ..................................................... 94
• Inspecting the Compiled App
◦ What We Build .................................................................................... 97
◦ What We Run ...................................................................................... 98
◦ Where They Go .................................................................................. 100
◦ Building the APK ................................................................................ 101
◦ Analyzing the APK ................................................................... 102
• Test Tour
◦ Instrumented Tests .................................................................. 105
◦ Unit Tests ............................................................................................ 115
• Introducing Jetpack
◦ What, Exactly, is Jetpack? .................................................................. 121
◦ Um, OK, So, What’s the Point? .......................................................... 121
◦ Key Elements of Jetpack .......................................................... 122
◦ What Came Before: the Android Support Library ........................... 127
• Introducing the Sampler Projects
◦ The Projects ....................................................................................... 129
◦ Getting a Sampler Project ................................................................. 130
◦ The Modules ....................................................................................... 134
◦ Running the Samples ......................................................................... 134
• Starting Simple: TextView and Button
◦ First, Some Terminology .................................................................... 135
ii
◦ Introducing the Graphical Layout Editor ......................................... 141
◦ TextView: Assigning Labels .............................................................. 149
◦ Button: Reacting to Input ....................................................... 156
◦ The Curious Case of the Missing R .................................................. 163
• Debugging Your App
◦ Get Thee To a Stack Trace ................................................................. 168
◦ Running Your App in the Debugger .................................................. 171
◦ So, Where Did We Go Wrong? .......................................................... 177
• Introducing ConstraintLayout
◦ The Role of Containers ...................................................................... 180
◦ Layouts and Adapter-Based Containers ............................................ 181
◦ ConstraintLayout: One Layout To Rule Them All ........................... 182
◦ Getting ConstraintLayout .................................................................. 183
◦ Using Widgets and Containers from Libraries ................................. 183
◦ A Quick RTL Refresher ...................................................................... 185
◦ Simple Rows with ConstraintLayout ................................................ 186
◦ Starting from Scratch ........................................................................ 190
◦ ConstraintLayout and the Attributes Pane ...................................... 192
◦ EditText: Making Users Type Stuff ................................................... 193
◦ More Complex Forms ........................................................................ 194
◦ Turning Back to RTL .......................................................................... 201
◦ More Fun with ConstraintLayout ..................................................... 202
◦ Notes on the Classic Containers ....................................................... 203
• Integrating Common Form Widgets
◦ ImageView and ImageButton ........................................................... 207
◦ Compound Buttons ............................................................................ 212
◦ SeekBar .................................................................................... 225
◦ ScrollView: Making It All Fit ............................................................. 228
◦ Other Notes About the Sample ......................................................... 231
• Contemplating Contexts
◦ It’s Not an OMG Object, But It’s Close ............................................ 239
◦ The Major Types of Context .................................................... 240
◦ Key Context Features ......................................................................... 242
◦ Know Your Context ............................................................................ 244
◦ Context Anti-Patterns ....................................................................... 245
• Icons
◦ App Icons… And Everything Else ...................................................... 247
◦ Creating an App Icon with the Asset Studio ................................... 248
◦ Creating Other Icons with the Asset Studio .................................... 254
• Adding Libraries
◦ Depending on a Local JAR ................................................................ 255
iii
◦ Artifacts and Repositories ...................................................... 256
◦ Requesting Dependencies ................................................................. 257
• Employing RecyclerView
◦ Recap: Layouts vs. Adapter-Based Containers ................................. 261
◦ The Challenge: Memory .................................................................... 262
◦ Enter RecyclerView ............................................................................ 263
◦ A Trivial List ............................................................................ 264
◦ Hey, What About ListView? ............................................................. 280
• Coping with Configurations
◦ What’s a Configuration? And How Do They Change? .................... 283
◦ Configurations and Resource Sets .................................................... 284
◦ Implementing Resource Sets .................................................. 285
◦ Resource Set Rules ............................................................................ 288
◦ Activity Lifecycles ................................................................... 292
◦ When Activities Die ......................................................................... 296
◦ Context Anti-Pattern: Outliving It ................................................... 297
• Integrating ViewModel
◦ Configuration Changes ..................................................................... 299
◦ What We Want… and What We Do Not Want ............................... 300
◦ Enter the ViewModel ......................................................................... 301
◦ Applying ViewModel ................................................................ 301
◦ ViewModel and the Lifecycle .................................................. 305
◦ Changing Data in the ViewModel .......................................... 309
• Understanding Processes
◦ When Processes Are Created ............................................................ 323
◦ What Is In Your Process .................................................................... 324
◦ BACK, HOME, and Your Process ............................................. 324
◦ Termination ........................................................................................ 325
◦ Foreground Means “I Love You” ....................................................... 326
◦ Tasks and Your App ........................................................................... 327
◦ Instance State ......................................................................... 329
◦ Pondering Parcelable .......................................................................... 331
◦ A State-Aware ViewModel ........................................................ 337
• Binding Your Data
◦ The Basic Steps ........................................................................ 345
◦ Why Bother? ...................................................................................... 357
• Defining and Using Styles
◦ Styles: DIY DRY .................................................................................. 359
◦ Elements of Style ............................................................................... 360
◦ Themes: Would a Style By Any Other Name…......................... 364
◦ Context Anti-Pattern: Using Application Everywhere ........... 369
iv
• Configuring the App Bar
◦ So. Many. Bars. ................................................................................... 372
◦ Vector Drawables ............................................................................... 374
◦ Menu Resources ....................................................................... 379
◦ Using Toolbar Directly ...................................................................... 384
◦ Using Toolbar as the Action Bar ....................................................... 397
◦ Having Fun at Bars ........................................................................... 400
• Implementing Multiple Activities
◦ Multiple Activities, and Your App .................................................... 401
◦ Creating Your Second (and Third and…) Activity ........................... 402
◦ Starting Your Own Activity .............................................................. 404
◦ Extra! Extra! ........................................................................................ 405
◦ Seeing This In Action ........................................................................ 405
◦ Using Implicit Intents ............................................................ 410
◦ Asynchronicity and Results ..................................................... 412
◦ The Inverse: <intent-filter> ............................................................... 422
• Adopting Fragments
◦ The Six Questions ....................................................................425
◦ Where You Get Your Fragments From .................................... 429
◦ Static vs. Dynamic Fragments ................................................ 430
◦ Fragments, and What You Have Seen Already ........................ 431
◦ ToDo, or Not ToDo? That Is the Question ............................... 431
◦ The Fragment Lifecycle Methods............................................ 459
◦ Context Anti-Pattern: Assuming Certain Types ..................... 463
• Navigating Your App
◦ What We Get from the Navigation Component ..................... 465
◦ Elements of Navigation .......................................................... 469
◦ A Navigation-ized To-Do List................................................... 475
◦ So… Was It Worth It? ............................................................... 486
• Thinking About Threads and LiveData
◦ The Main Application Thread ................................................. 487
◦ The UI Thread is for UI ........................................................... 489
◦ Introducing LiveData ............................................................. 490
◦ Colors… Live! ........................................................................... 492
◦ Where Do Threads Come From? Um, Besides From Me? ........ 500
• Storing Data in a Room
• Requesting Permissions
• Working with Content
• Operating in the Background
• Injecting Your Dependencies
• Testing Your Changes
v
• Creating a New Project
• Shrinking Your App
• Using the SDK Manager
• Using the AVD Manager and the Emulator
• Configuring Your Project
• Configuring Android Studio
vi
Preface
Thanks!
Thanks for your interest in developing applications for Android! Android has grown
from nothing to the world’s most popular smartphone OS in a few short years.
Whether you are developing applications for the public, for your business or
organization, or are just experimenting on your own, I think you will find Android to
be an exciting and challenging area for exploration.
And, most of all, thanks for your interest in this book! I sincerely hope you find it
useful and at least occasionally entertaining.
Prerequisites
This book is written for developers with prior experience in Java or Kotlin. If you are
not familiar with either of these languages, it will be difficult for you to follow the
code samples in the book. The author of this book has published Elements of Kotlin.
If you obtained this book via the Warescription, you are eligible to download a copy
of Elements of Kotlin, along with the rest of the CommonsWare line of books.
This book is written for people who have used an Android device before. If you are
not familiar with basic Android concepts — such as the home screen and launcher,
the HOME button, the BACK button, and so on — you will want to spend time with
an Android device.
About the Updates
This book will be updated a few times per year, to reflect newer versions of Android,
vii
