Programming Android with Kotlin: Achieving Structured Concurrency with Coroutines

Description

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 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