Programming Android with Kotlin: Achieving Structured Concurrency with Coroutines

Cover
Copyright
Table of Contents
Preface
	Who Should Read This Book
	Why We Wrote This Book
	Navigating This Book
	Conventions Used in This Book
	Using Code Examples
	O’Reilly Online Learning
	How to Contact Us
	Acknowledgments
Chapter 1. Kotlin Essentials
	The Kotlin Type System
		Primitive Types
		Null Safety
		The Unit Type
		Function Types
		Generics
	Variables and Functions
		Variables
		Lambdas
		Extension Functions
	Classes
		Class Initialization
		Properties
		lateinit Properties
		Lazy Properties
		Delegates
		Companion Objects
		Data Classes
		Enum Classes
		Sealed Classes
	Visibility Modifiers
	Summary
Chapter 2. The Kotlin Collections Framework
	Collection Basics
		Java Interoperability
		Mutability
		Overloaded Operators
		Creating Containers
	Functional Programming
		Functional Versus Procedural: A Simple Example
		Functional Android
	Kotlin Transformation Functions
		The Boolean Functions
		Filter Functions
		Map
		flatMap
		Grouping
		Iterators Versus Sequences
	An Example
		The Problem
		The Implementation
	Summary
Chapter 3. Android Fundamentals
	The Android Stack
		Hardware
		Kernel
		System Services
		Android Runtime Environment
		Applications
	The Android Application Environment
		Intents and Intent Filters
		Context
	Android Application Components: The Building Blocks
		The Activity and Its Friends
		Services
		Content Providers
		Broadcast Receivers
	Android Application Architectures
		MVC: The Foundation
		Widgets
		The Local Model
	Android Patterns
		Model–View–Intent
		Model–View–Presenter
		Model–View–ViewModel
	Summary
Chapter 4. Concurrency in Android
	Thread Safety
		Atomicity
		Visibility
	The Android Threading Model
	Dropped Frames
	Memory Leaks
	Tools for Managing Threads
		Looper/Handler
		Executors and ExecutorServices
	Tools for Managing Jobs
		JobScheduler
		WorkManager
	Summary
Chapter 5. Thread Safety
	An Example of a Thread Issue
	Invariants
		Mutexes
		Thread-Safe Collections
	Thread Confinement
	Thread Contention
	Blocking Call Versus Nonblocking Call
	Work Queues
	Back Pressure
	Summary
Chapter 6. Handling Concurrency Using Callbacks
	Example-of-Purchase Feature
	Creating the App
		View-Model
		View
		Implement the Logic
		Discussion
	Limitations of the Threading Model
	Summary
Chapter 7. Coroutines Concepts
	What Exactly Is a Coroutine?
		Your First Coroutine
		The async Coroutine Builder
	A Quick Detour About Structured Concurrency
	The Parent-Child Relationship in Structured Concurrency
	CoroutineScope and CoroutineContext
	Suspending Functions
	Suspending Functions Under the Hood
	Using Coroutines and Suspending Functions: A Practical Example
	Don’t Be Mistaken About the suspend Modifier
	Summary
Chapter 8. Structured Concurrency with Coroutines
	Suspending Functions
		Set the Scene
		Traditional Approach Using java.util.concurrent.ExecutorService
		A Reminder About HandlerThread
		Using Suspending Functions and Coroutines
		Summary of Suspending Functions Versus Traditional Threading
	Cancellation
		Coroutine Lifecycle
		Cancelling a Coroutine
		Cancelling a Task Delegated to a Third-Party Library
		Coroutines That Are Cooperative with Cancellation
		delay Is Cancellable
		Handling Cancellation
		Causes of Cancellation
	Supervision
	supervisorScope Builder
	Parallel Decomposition
	Automatic Cancellation
	Exception Handling
		Unhandled Versus Exposed Exceptions
		Exposed Exceptions
		Unhandled Exceptions
	Summary
	Closing Thoughts
Chapter 9. Channels
	Channels Overview
		Rendezvous Channel
		Unlimited Channel
		Conflated Channel
		Buffered Channel
		Channel Producers
	Communicating Sequential Processes
		Model and Architecture
		A First Implementation
		The select Expression
		Putting It All Together
		Fan-Out and Fan-In
		Performance Test
		Back Pressure
		Similarities with the Actor Model
		Execution Is Sequential Inside a Process
		Final Thoughts
	Deadlock in CSP
	TL;DR
	Limitations of Channels
	Channels Are Hot
	Summary
Chapter 10. Flows
	An Introduction to Flows
		A More Realistic Example
		Operators
		Terminal Operators
	Examples of Cold Flow Usage
		Use Case #1: Interface with a Callback-Based API
		Use Case #2: Concurrently Transform a Stream of Values
		What Happens in Case of Error?
		Final Thoughts
		Use Case #3: Create a Custom Operator
		Usage
	Error Handling
		The try/catch Block
		Separation of Concern Is Important
		Exception Transparency Violation
		The catch Operator
		Materialize Your Exceptions
	Hot Flows with SharedFlow
		Create a SharedFlow
		Register a Subscriber
		Send Values to the SharedFlow
		Using SharedFlow to Stream Data
		Using SharedFlow as an Event Bus
		StateFlow: A Specialized SharedFlow
		An Example of StateFlow Usage
	Summary
Chapter 11. Performance Considerations with Android Profiling Tools
	Android Profiler
		Network Profiler
		CPU Profiler
		Energy Profiler
		Memory Profiler
	Detecting Memory Leaks with LeakCanary
	Summary
Chapter 12. Trimming Down Resource Consumption with Performance Optimizations
	Achieving Flatter View Hierarchy with ConstraintLayout
	Reducing Programmatic Draws with Drawables
	Minimizing Asset Payload in Network Calls
	Bitmap Pooling and Caching
	Reducing Unnecessary Work
	Using Static Functions
	Minification and Obfuscation with R8 and ProGuard
	Summary
Index
About the Authors
Colophon