Elements of Android Jetpack

• Preface
  • Acknowledgments
• Introducing Android
  • Focus: Apps, Not Operating Systems
  • What You Need
  • How This Book Is Organized
• Setting Up the Tools
  • But First, Some Notes About Android’s Emulator
  • Step #1: Install Android Studio
  • Step #2: Running Android Studio for the First Time
• Getting Your First Project
  • Step #1: Importing the Project
  • Step #2: Get Ready for the x86 Emulator
  • Step #3: Set Up the AVD
  • Step #4: Set Up the Device
  • Step #5: Running the Project
• Taking a Tour of Android Studio
  • The Project Tree
  • The Editing Pane
  • The Docked Views
  • Popular Menu and Toolbar Options
  • Android Studio and Release Channels
• Examining Your Code
  • The Top Level
  • The Project Contents
  • The App Module Contents
  • The Generated Source Sets
  • Language Differences
  • Introducing the Activity
  • Other Things in the Project Tree
• Exploring Your Resources
  • What You See in res/
  • OS Versions and API Levels
  • Decoding Resource Directory Names
  • Our Initial Resource Types
  • About That R Thingy
  • The Resource Manager
• Inspecting Your Manifest
  • The Root Element
  • The Application Element
  • The Activity Element (And Its Children)
• Reviewing Your Gradle Scripts
  • Gradle: The Big Questions
  • Obtaining Gradle
  • Examining the Gradle Files
  • Requesting Plugins
  • Android Plugin for Gradle Configuration
  • Other Stuff in the android Closure
  • Libraries and Dependencies
• Inspecting the Compiled App
  • What We Build
  • Where They Go
  • Building the APK
  • Analyzing the APK
• Touring the Tests
  • Instrumented Tests
  • Unit Tests
• Introducing Jetpack
  • What, Exactly, is Jetpack?
  • Um, OK, So, What’s the Point?
  • Key Elements of Jetpack
  • What Came Before: the Android Support Library
• Introducing the Sampler Projects
  • The Projects
  • Getting a Sampler Project
  • The Modules
  • Running the Samples
• Starting Simple: TextView and Button
  • First, Some Terminology
  • Introducing the Graphical Layout Editor
  • TextView: Assigning Labels
  • Button: Reacting to Input
  • The Curious Case of the Missing R
• Debugging Your App
  • Get Thee To a Stack Trace
  • Running Your App in the Debugger
  • So, Where Did We Go Wrong?
• Introducing ConstraintLayout
  • The Role of Containers
  • Layouts and Adapter-Based Containers
  • ConstraintLayout: One Layout To Rule Them All
  • Getting ConstraintLayout
  • Using Widgets and Containers from Libraries
  • A Quick RTL Refresher
  • Simple Rows with ConstraintLayout
  • Starting from Scratch
  • ConstraintLayout and the Attributes Pane
  • EditText: Making Users Type Stuff
  • More Complex Forms
  • Turning Back to RTL
  • More Fun with ConstraintLayout
  • Notes on the Classic Containers
• Integrating Common Form Widgets
  • ImageView and ImageButton
  • Compound Buttons
  • SeekBar
  • ScrollView: Making It All Fit
  • Other Notes About the Sample
• Contemplating Contexts
  • It’s Not an OMG Object, But It’s Close
  • The Major Types of Context
  • Key Context Features
  • Know Your Context
  • Context Anti-Patterns
• Icons
  • App Icons… And Everything Else
  • Creating an App Icon with the Asset Studio
  • Creating Other Icons with the Asset Studio
• Adding Libraries
  • Depending on a Local JAR
  • Artifacts and Repositories
  • Requesting Dependencies
• Employing RecyclerView
  • Recap: Layouts vs. Adapter-Based Containers
  • The Challenge: Memory
  • Enter RecyclerView
  • A Trivial List
  • Hey, What About ListView?
  • Gesture Navigation and Scrolling Widgets
• Coping with Configurations
  • What’s a Configuration? And How Do They Change?
  • Configurations and Resource Sets
  • Implementing Resource Sets
  • Resource Set Rules
  • Activity Lifecycles
  • When Activities Die
  • Context Anti-Pattern: Outliving It
• Integrating ViewModel
  • Configuration Changes
  • What We Want… and What We Do Not Want
  • Enter the ViewModel
  • Applying ViewModel
  • ViewModel and the Lifecycle
  • Changing Data in the ViewModel
  • ViewModel and AndroidViewModel
  • ViewModelFactory
• Understanding Processes
  • When Processes Are Created
  • What Is In Your Process
  • BACK, HOME, and Your Process
  • Termination
  • Foreground Means “I Love You”
  • Tasks and Your App
  • Instance State
  • Pondering Parcelable
  • A State-Aware ViewModel
• Binding Your Data
  • The Basic Steps
  • Why Bother?
  • The Other Common “Gimme the Views” Options
• Defining and Using Styles
  • Styles: DIY DRY
  • Elements of Style
  • Themes: Would a Style By Any Other Name…
  • Android 10 Dark Mode
  • The DayNight Solution
  • The Material Components for Android
  • Context Anti-Pattern: Using Application Everywhere
• Configuring the App Bar
  • So. Many. Bars.
  • Vector Drawables
  • Menu Resources
  • Using Toolbar Directly
  • Using Toolbar as the Action Bar
  • Having Fun at Bars
• Implementing Multiple Activities
  • Multiple Activities, and Your App
  • Creating Your Second (and Third and…) Activity
  • Starting Your Own Activity
  • Extra! Extra!
  • Seeing This In Action
  • Using Implicit Intents
  • Activities and Results
  • The Inverse: <intent-filter>
• Adding Library Modules
  • Reasons for Library Modules
  • Consuming a Library Module
• Adopting Fragments
  • The Six Questions
  • Where You Get Your Fragments From
  • Static vs. Dynamic Fragments
  • Fragments, and What You Have Seen Already
  • ToDo, or Not ToDo? That Is the Question
  • The Fragment Lifecycle Methods
  • View Binding and Fragments
  • Context Anti-Pattern: Assuming Certain Types
• Navigating Your App
  • What We Get from the Navigation Component
  • Elements of Navigation
  • A Navigation-ized To-Do List
  • So… Was It Worth It?
  • The Next Wave: Kotlin DSL
• Dialogs
  • A Tale of Four Dialogs
  • Using AlertDialog and DialogFragment
• Writing an App Widget
  • Writing a… What?
  • Challenges with App Widgets
  • Introducing Broadcasts and Receivers
  • Pieces of the App Widget
  • Colors in an App Widget
  • Actions and App Widgets
• Thinking About Threads and LiveData
  • The Main Application Thread
  • The UI Thread is for UI
  • Introducing LiveData
  • Colors… Live!
  • Sources of Owners
  • Where Do Threads Come From? Um, Besides From Me?
  • Coroutines and ViewModel
  • The End of LiveData?!?
• Adding Some Architecture
  • Repositories
  • Unidirectional Data Flow
  • A UDF Implementation
  • The Kotlin LiveData Alternative: StateFlow
  • States and Events
• Working with Content
  • The Storage Access Framework
  • Android 11+ Restrictions
• Using Preferences
  • The Preferred Preferences
  • Collecting Preferences with PreferenceFragmentCompat
  • Types of Preferences
  • Working with SharedPreferences
• Requesting Permissions
  • Frequently-Asked Questions About Permissions
  • Dangerous Permissions: Request at Runtime
• Handling Files
  • The Three Types of File Storage
  • What the User Sees
  • Storage, Permissions, and Access
  • Reading, Writing, and Debugging Storage
  • Serving Files with FileProvider
  • What You Should Use
• Accessing the Internet
  • An API Roundup
  • Android’s Restrictions
  • Forecasting the Weather
• Inverting Your Dependencies
  • The Problem: Test Control
  • The Solution: Dependency Inversion
  • Dependency Inversion in Android
  • Applying Koin
• Storing Data in a Room
  • Room Requirements
  • Room Furnishings
  • Other Fun Stuff in the App
  • What Else Does Room Offer?
  • Examining Your Database
• Testing Your Changes
  • A Quick Recap
  • Which Tests Should I Write?
  • Writing Unit Tests
  • Employing Mocks
  • Writing Instrumented Tests
  • Writing Basic Espresso Tests
  • Another Option: UI Automator
  • Again: What Should I Be Using?
• Working with WorkManager
  • The Role of WorkManager
  • WorkManager Dependencies
  • Workers: They Do Work
  • Performing Simple Work
  • Work Inputs
  • Constrained Work
  • Tagged Work
  • Monitoring Work
  • Canceling Work
  • Delayed Work
  • Parallel Work
  • Chained Work
  • Periodic Work
  • Unique Work
  • Testing Work
  • Inspecting Work
  • WorkManager and Side Effects
• Creating a New Project
  • Key Decisions That You Need to Make
  • The New-Project Wizard
  • Copying an Existing Project
  • Creating a Library Module
• Signing Your App
  • Role of Code Signing
  • What Happens In Debug Mode
  • Production Signing Keys
• Shrinking Your App
  • Why We Care
  • Identify What to Attack
  • Shrinking Your Dependencies
  • Shrinking Your Code
  • Removing Unused Resources
  • Optimizing Bitmaps
  • Hey, What About App Bundles?
• Using the AVD Manager and the Emulator
  • Notable AVD Configuration Options
  • The Emulator Sidebar
  • Emulator Window Operations
  • In-IDE Emulator
• Using the SDK Manager
  • Installing Platform Pieces
  • Installing and Upgrading Tools
  • Adding Third-Party SDK Suppliers
• Configuring Your Project
  • Risks and Rewards
  • The Project Category
  • The SDK Location
  • The Variables
  • The Modules
  • Dependencies
  • Build Variants
  • Suggestions
• Configuring Android Studio
  • Searching for Settings
  • Themes and Colors
  • Fonts. And Other Fonts.
  • Code Styles
  • Inlay Hints
  • Other Settings of Note
• Coping with New Android Versions
  • The March of the Versions
  • The Typical Release Process
  • Things to Worry About
• Deciding Where to Go From Here
  • The Rest of the Books
  • Android Developer Support
  • Major Conferences

---

This book is licensed under the Creative Commons Attribution-ShareAlike 4.0 International license.