Developing applications for the Android mobile operating system can seem daunting, particularly if it requires learning a new programming language: Kotlin, now Androidâ??s officialdevelopment language. With this practical book, Android developers will learn how to make the transition from Java to Kotlin, including how Kotlin provides a true advantage for gaining control over asynchronous computations.
Authors Pierre-Olivier Laurence, Amanda Hinchman-Dominguez, G. Blake Meike, and Mike Dunn explore implementations of the most common tasks in native Android development, and show you how Kotlin can help you solve concurrency problems. With a focus on structured concurrency, a new asynchronous programming paradigm, this book will guide you through one of Kotlin's most powerful constructs, coroutines.
• Learn about Kotlin essentials and the Kotlin Collections Framework
• Explore Android fundamentals: the operating system and the application container and its components
• Learn about thread safety and how to handle concurrency
• Write sequential, asynchronous work at a low cost
• Examine structured concurrency with coroutines, and learn how channels make coroutines communicate
• Learn how to use flows for asynchronous data processing
• Understand performance considerations using Android profiling tools
• Use performance optimizations to trim resource consumption
Author(s): Pierre-Olivier Laurence, Amanda Hinchman-Dominguez, G. Blake Meike, Mike Dunn
Edition: 1
Publisher: O'Reilly Media
Year: 2021
Language: English
Commentary: Vector PDF
Pages: 354
City: Sebastopol, CA
Tags: Programming; Multithreading; Concurrency; Android; Callback Functions; Coroutines; Performance; Kotlin
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
