Efficient android threading pdf

Ваш IP заблокирован

Убедитесь, что Вы не используете анонимайзеры/прокси/VPN или другие подобные средства (TOR, friGate, ZenMate и т.п.) для доступа к сайту.

Отправьте письмо на abuse[at]twirpx.club если Вы уверены, что эта блокировка ошибочна.

В письме укажите следующие сведения о блокировке:

Кроме того, пожалуйста, уточните:

1. Каким Интернет-провайдером Вы пользуетесь?
2. Какие плагины установлены в Вашем браузере?
3. Проявляется ли проблема если отключить все плагины?
4. Проявляется ли проблема в другим браузере?
5. Какое программное обеспечение для организации VPN/прокси/анонимизации Вы обычно используете? Проявляется ли проблема если их отключить?
6. Давно ли в последний раз проверяли компьютер на вирусы?

Your IP is blocked

Ensure that you do not use anonymizers/proxy/VPN or similar tools (TOR, friGate, ZenMate etc.) to access the website.

Contact abuse[at]twirpx.club if you sure this block is a mistake.

Attach following text in your email:

Please specify also:

1. What Internet provider (ISP) do you use?
2. What plugins and addons are installed to your browser?
3. Is it still blocking if you disable all plugins installed to your browser?
4. Is it still blocking if you use another browser?
5. What software do you often use for VPN/proxy/anonymization? Is it still blocking if you disable it?
6. How long ago have you checked your computer for viruses?

Источник

Efficient Android Threading: Asynchronous Processing Techniques for Android Applications

Название: Efficient Android Threading: Asynchronous Processing Techniques for Android Applications
Издательство: OREILLY
Автор:Anders Goransson
Год: 2014
Количество страниц:280
Язык:English
Формат: EPUB, MOBI, PDF
Размер:23,7 Mb

Multithreading is essential if you want to create an Android app with a great user experience, but how do you know which techniques can help solve your problem?This practical book describes many asynchronous mechanisms available in the Android SDK, and provides guidelines for selecting the ones most appropriate for the app you’re building.
Author Anders Goransson demonstrates the advantages and disadvantages of each technique, with sample code and detailed explanations for using it efficiently. The first part of the book describes the building blocks of asynchronous processing, and the second part covers Android libraries and constructs for developing fast, responsive, and well-structured apps.

Understand multithreading basics in Java and on the Android platform
Learn how threads communicate within and between processes
Use strategies to reduce the risk of memory leaks
Manage the lifecycle of a basic thread
Run tasks sequentially in the background with HandlerThread
Use Java’s Executor Framework to control or cancel threads
Handle background task execution with AsyncTask and IntentService
Access content providers with AsyncQueryHandler
Use loaders to update the UI with new data

Источник

Android-er

For Android development, from beginner to beginner.

Saturday, May 31, 2014

Efficient Android Threading: Asynchronous Processing Techniques for Android Applications

Multithreading is essential if you want to create an Android app with a great user experience, but how do you know which techniques can help solve your problem? This practical book describes many asynchronous mechanisms available in the Android SDK, and provides guidelines for selecting the ones most appropriate for the app you’re building.

Author Anders Goransson demonstrates the advantages and disadvantages of each technique, with sample code and detailed explanations for using it efficiently. The first part of the book describes the building blocks of asynchronous processing, and the second part covers Android libraries and constructs for developing fast, responsive, and well-structured apps.

• Understand multithreading basics in Java and on the Android platform
• Learn how threads communicate within and between processes
• Use strategies to reduce the risk of memory leaks
• Manage the lifecycle of a basic thread
• Run tasks sequentially in the background with HandlerThread
• Use Java’s Executor Framework to control or cancel threads
• Handle background task execution with AsyncTask and IntentService
• Access content providers with AsyncQueryHandler
• Use loaders to update the UI with new data

Источник

Efficient Android Threading

Explore a preview version of Efficient Android Threading right now.

O’Reilly members get unlimited access to live online training experiences, plus books, videos, and digital content from 200+ publishers.

Book description

Multithreading is essential if you want to create an Android app with a great user experience, but how do you know which techniques can help solve your problem? This practical book describes many asynchronous mechanisms available in the Android SDK, and provides guidelines for selecting the ones most appropriate for the app you’re building.

Publisher resources

Table of contents

Product information

• Title: Efficient Android Threading
• Author(s): Anders Goransson
• Release date: June 2014
• Publisher(s): O’Reilly Media, Inc.
• ISBN: 9781449364137

You might also like

40 Algorithms Every Programmer Should Know

Learn algorithms for solving classic computer science problems with this concise guide covering everything from fundamental …

Android Cookbook, 2nd Edition

by Ian F. Darwin

Jump in and build working Android apps with the help of more than 230 tested recipes. …

Android High Performance Programming

by Enrique López Mañas, Diego Grancini

Build fast and efficient Android apps that run as reliably as clockwork in a multi-device world …

Software Engineering at Google

by Titus Winters, Tom Manshreck, Hyrum Wright

Today, software engineers need to know not only how to program effectively but also how to …

About O’Reilly

Support

Download the O’Reilly App

Take O’Reilly with you and learn anywhere, anytime on your phone and tablet.

Watch on your big screen

View all O’Reilly videos, Superstream events, and Meet the Expert sessions on your home TV.

Do not sell my personal information

© 2021, O’Reilly Media, Inc. All trademarks and registered trademarks appearing on oreilly.com are the property of their respective owners.

We are a participant in the Amazon Services LLC Associates Program, an affiliate advertising program designed to provide a means for us to earn fees by linking to Amazon.com and affiliated sites.

Don’t leave empty-handed

Get Mark Richards’s Software Architecture Patterns ebook to better understand how to design components—and how they should interact.

Источник

Efficient Android Threading — X-Files

Efficient Android Threading

Efficient Android Threading by Anders Göransson Copyright © 2014 Anders Göransson. All rights reserved. Printed in the United States of America. Published by O’Reilly Media, Inc., 1005 Gravenstein Highway North, Sebastopol, CA 95472. O’Reilly books may be purchased for educational, business, or sales promotional use. Online editions are also available for most titles (http://my.safaribooksonline.com). For more information, contact our corporate/ institutional sales department: 800-998-9938 or [email protected]

Editors: Andy Oram and Rachel Roumeliotis Production Editor: Melanie Yarbrough Copyeditor: Eliahu Sussman Proofreader: Amanda Kersey May 2014:

Indexer: Ellen Troutman-Zaig Cover Designer: Karen Montgomery Interior Designer: David Futato Illustrator: Rebecca Demarest

Revision History for the First Edition: 2014-05-21:

See http://oreilly.com/catalog/errata.csp?isbn=9781449364137 for release details. Nutshell Handbook, the Nutshell Handbook logo, and the O’Reilly logo are registered trademarks of O’Reilly Media, Inc. Efficient Android Threading, the cover image of mahi-mahi, and related trade dress are trade‐ marks of O’Reilly Media, Inc. Many of the designations used by manufacturers and sellers to distinguish their products are claimed as trademarks. Where those designations appear in this book, and O’Reilly Media, Inc. was aware of a trademark claim, the designations have been printed in caps or initial caps. While every precaution has been taken in the preparation of this book, the publisher and author assume no responsibility for errors or omissions, or for damages resulting from the use of the information contained herein.

ISBN: 978-1-449-36413-7 [LSI]

To Anna, Fabian, and Ida.

Table of Contents

Preface. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xi 1. Android Components and the Need for Multiprocessing. . . . . . . . . . . . . . . . . . . . . . . . . . . 1 Android Software Stack Application Architecture Application Components Application Execution Linux Process Lifecycle Structuring Applications for Performance Creating Responsive Applications Through Threads Summary

1 2 3 3 5 6 6 9 9 11

2. Multithreading in Java. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15 Thread Basics Execution Single-Threaded Application Multithreaded Application Thread Safety Intrinsic Lock and Java Monitor Synchronize Access to Shared Resources Example: Consumer and Producer Task Execution Strategies Concurrent Execution Design

15 15 17 17 19 20 22 24 26 27

3. Threads on Android. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29 Android Application Threads UI Thread Binder Threads Background Threads The Linux Process and Threads Scheduling Summary

29 29 30 30 31 34 37

4. Thread Communication. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39 Pipes Basic Pipe Use Example: Text Processing on a Worker Thread Shared Memory Signaling BlockingQueue Android Message Passing Example: Basic Message Passing Classes Used in Message Passing Message Looper Handler Removing Messages from the Queue Observing the Message Queue Communicating with the UI Thread Summary

39 40 42 44 45 46 47 49 51 55 58 60 68 70 73 74

5. Interprocess Communication. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75 Android RPC Binder AIDL Synchronous RPC Asynchronous RPC Message Passing Using the Binder One-Way Communication Two-Way Communication Summary

75 76 77 79 81 83 84 86 87

6. Memory Management. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89 Garbage Collection

Table of Contents

Thread-Related Memory Leaks Thread Execution Thread Communication Avoiding Memory Leaks Use Static Inner Classes Use Weak References Stop Worker Thread Execution Retain Worker Threads Clean Up the Message Queue Summary

91 92 98 101 101 101 102 102 102 103

7. Managing the Lifecycle of a Basic Thread. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107 Basics Lifecycle Interruptions Uncaught Exceptions Thread Management Definition and Start Retention Summary

107 107 108 110 112 112 114 119

8. HandlerThread: A High-Level Queueing Mechanism. . . . . . . . . . . . . . . . . . . . . . . . . . . . 121 Fundamentals Lifecycle Use Cases Repeated Task Execution Related Tasks Task Chaining Conditional Task Insertion Summary

121 123 124 125 125 128 131 131

9. Control over Thread Execution Through the Executor Framework. . . . . . . . . . . . . . . . . 133 Executor Thread Pools Predefined Thread Pools Custom Thread Pools Designing a Thread Pool Lifecycle Shutting Down the Thread Pool

133 136 136 137 138 142 143

Table of Contents

Thread Pool Uses Cases and Pitfalls Task Management Task Representation Submitting Tasks Rejecting Tasks ExecutorCompletionService Summary

145 146 146 147 151 152 154

10. Tying a Background Task to the UI Thread with AsyncTask. . . . . . . . . . . . . . . . . . . . . . . 157 Fundamentals Creation and Start Cancellation States Implementing the AsyncTask Example: Downloading Images Background Task Execution Application Global Execution Execution Across Platform Versions Custom Execution AsyncTask Alternatives When an AsyncTask Is Trivially Implemented Background Tasks That Need a Looper Local Service Using execute(Runnable) Summary

157 160 161 162 163 164 167 169 170 172 173 173 174 174 174 175

11. Services. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177 Why Use a Service for Asynchronous Execution? Local, Remote, and Global Services Creation and Execution Lifecycle Started Service Implementing onStartCommand Options for Restarting User-Controlled Service Task-Controlled Service Bound Service Local Binding Choosing an Asynchronous Technique Summary

177 179 181 181 183 184 184 186 190 192 194 197 198

12. IntentService. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 199 viii

Table of Contents

Fundamentals Good Ways to Use an IntentService Sequentially Ordered Tasks Asynchronous Execution in BroadcastReceiver IntentService Versus Service Summary

199 201 201 204 207 207

13. Access ContentProviders with AsyncQueryHandler. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 209 Brief Introduction to ContentProvider Justification for Background Processing of a ContentProvider Using the AsyncQueryHandler Example: Expanding Contact List Understanding the AsyncQueryHandler Limitations Summary

209 211 212 214 217 218 218

14. Automatic Background Execution with Loaders. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219 Loader Framework LoaderManager LoaderCallbacks AsyncTaskLoader Painless Data Loading with CursorLoader Using the CursorLoader Example: Contact list Adding CRUD Support Implementing Custom Loaders Loader Lifecycle Background Loading Content Management Delivering Cached Results Example: Custom File Loader Handling Multiple Loaders Summary

220 221 224 225 226 227 227 229 233 233 234 236 237 238 241 242

15. Summary: Selecting an Asynchronous Technique. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 243 Keep It Simple Thread and Resource Management Message Communication for Responsiveness Avoid Unexpected Task Termination Easy Access to ContentProviders

244 244 245 246 247

A. Bibliography. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 249 Table of Contents

Table of Contents

Efficient Android Threading explores how to achieve robust and reliable multithreaded Android applications. We’ll look at the asynchronous mechanisms that are available in the Android SDK and determine appropriate implementations to achieve fast, respon‐ sive, and well-structured applications. Let’s face it: multithreading is required to create applications with a great user experi‐ ence, but it also increases the complexity of the application and the likelihood of runtime errors. The complexity partly comes from the built-in difficulty of execution on multiple threads and from applications that aren’t utilizing the Android platform efficiently. This book aims to guide application developers to selecting an asynchronous mecha‐ nism based on an understanding of its advantages and difficulties. By using the right asynchronous mechanism at the right time, much of the complexity is transferred from the application to the platform, making the application code more maintainable and less error prone. As a rule of thumb, asynchronous execution should not induce more complexity to the code than necessary, which is achieved through a wise choice from the palette of asynchronous mechanisms in Android. Although a high-level asynchronous mechanism can be very convenient to use, it still needs to be understood—not only used—or the application may suffer from equally difficult runtime errors, performance degradation, or memory leaks. Therefore, this book not only contains practical guidelines and examples, but also explores the under‐ lying enablers for asynchronous execution on Android.

Audience This book is for Java programmers who have learned the basics of Android program‐ ming. The book introduces techniques that are fundamental to writing robust and re‐ sponsive applications, using standard Android libraries.

Contents of This Book This book contains two main parts: Part I and Part II. The first part describes the foun‐ dation for threads on Android—i.e., Java, Linux, Handlers—and its impact on the ap‐ plication. The second part is more hands-on, looking into the asynchronous mecha‐ nisms that an application has at its disposal. Part I describes how Java handles threads. As an Android programmer, you will some‐ times use these libraries directly, and understanding their behavior is important for using the higher-level constructs in Part II correctly. Chapter 1 Explains how the structure of the Android runtime and how the various compo‐ nents of an Android application affect the use of threads and multiprocessing. Chapter 2 Covers the fundamentals of concurrent execution in Java. Chapter 3 Describes how Android handles threads and how the application threads execute in the Linux OS. It includes important topics like scheduling and control groups, as well as their impact on responsiveness. Chapter 4 Covers basic communication between threads, such as shared memory, signals, and the commonly used Android messages. Chapter 5 Shows how Android enhances the IPC mechanisms in Linux with mechanisms such as RPC and messaging. Chapter 6 Explains how to avoid leaks, which can cause apps to degrade the system and be uninstalled by users. Part II covers the higher-level libraries and constructs in Android that make program‐ ming with threads safer and easier. Chapter 7 Describes the most basic asynchronous construction, i.e, java.lang.Thread, and how to handle the various states and problems that can occur. Chapter 8 Shows a convenient way to run tasks sequentially in the background. Chapter 9 Offers techniques for dealing with scheduling, errors, and other aspects of thread handling, such as thread pools. xii

Chapter 10 Covers the AsyncTask—probably the most popular asynchronous technique—and how to use it correctly to avoid its pitfalls. Chapter 11 Covers the essential Service component, which is useful for functionality that you want to offer to multiple applications or to keep the application alive during back‐ ground execution. Chapter 12 Builds on the previous chapter with a discussion of a useful technique for executing off the main UI thread. Chapter 13 A high-level mechanism that simplifies fast asynchronous access to content pro‐ viders. Chapter 14 Discover how the UI can be updated with loaders, where new data is delivered asynchronously whenever the content changes. Chapter 15 Given all the techniques described throughout this book, how do you choose the right one for your app? This chapter offers guidelines for making this choice.

Conventions Used in this Book The following typographical conventions are used in this book: Italic Used for emphasis, new terms, URLs, commands and utilities, and file and directory names. Constant width

Indicates variables, functions, types, objects, and other programming constructs. Constant width italic

Indicates place-holders in code or commands that should be replaced by appro‐ priate values. This element signifies a tip, suggestion, or a general note.

This element indicates a trap or pitfall to watch out for, typically something that isn’t immediately obvious.

Using Code Examples Supplemental material (code examples, exercises, etc.) is available for download at https://github.com/andersgoransson/eatbookexamples. This book is here to help you get your job done. In general, you may use the code in this book in your programs and documentation. You do not need to contact us for permission unless you are reproducing a significant portion of the code. For example, writing a program that uses several chunks of code from this book does not require permission. Selling or distributing a CD-ROM of examples from O’Reilly books does require permission. Answering a question by citing this book and quoting example code does not require permission. Incorporating a significant amount of example code from this book into your product’s documentation does require permission. We appreciate attribution. An attribution usually includes the title, author, publisher, and ISBN. If you believe that your use of code examples falls outside of fair use or the permission given above, feel free to contact us at [email protected] Examples will be maintained at: [email protected]:andersgoransson/eatbookexamples.git

Safari® Books Online Safari Books Online is an on-demand digital library that delivers expert content in both book and video form from the world’s leading authors in technology and business. Technology professionals, software developers, web designers, and business and crea‐ tive professionals use Safari Books Online as their primary resource for research, prob‐ lem solving, learning, and certification training. Safari Books Online offers a range of product mixes and pricing programs for organi‐ zations, government agencies, and individuals. Subscribers have access to thousands of books, training videos, and prepublication manuscripts in one fully searchable database from publishers like O’Reilly Media, Prentice Hall Professional, Addison-Wesley Pro‐ fessional, Microsoft Press, Sams, Que, Peachpit Press, Focal Press, Cisco Press, John Wiley & Sons, Syngress, Morgan Kaufmann, IBM Redbooks, Packt, Adobe Press, FT Press, Apress, Manning, New Riders, McGraw-Hill, Jones & Bartlett, Course Technol‐

ogy, and dozens more. For more information about Safari Books Online, please visit us online.

How to Contact Us Please address comments and questions concerning this book to the publisher: O’Reilly Media, Inc. 1005 Gravenstein Highway North Sebastopol, CA 95472 800-998-9938 (in the United States or Canada) 707-829-0515 (international or local) 707-829-0104 (fax) We have a web page for this book, where we list errata, examples, and any additional information. You can access this page at http://bit.ly/efficient-android-threading. To comment or ask technical questions about this book, send email to bookques [email protected] For more information about our books, courses, conferences, and news, see our website at http://bit.ly/efficient-android-threading. Find us on Facebook: http://facebook.com/oreilly Follow us on Twitter: http://twitter.com/oreillymedia Watch us on YouTube: http://www.youtube.com/oreillymedia

Acknowledgements The writing of a book may often be seen as a lonely task, but that only holds for the latenight hours when you just want to get that last paragraph written before you absolutely have to get some sleep. In truth, the writing is surrounded by people who made the book possible. First of all, I would like to thank Rachel Roumeliotis at O’Reilly for approaching me with an idea to write a book and helping out with all the initial steps in the writing process. In fact, all the people at O’Reilly whom I’ve had the pleasure to work with have shown great professionalism and helpfulness throughout the writing of this book, which made it easy for me to focus on the writing. In particular, I would like to thank editor Andy Oram, who has played a key role in making this book a reality. He has patiently worked with me on this project, always challenging my drafts and providing invaluable feedback.

Just like writing complex software, the writing of a book includes a lot of bugs along the way, and every chapter undergoes a bugfixing and stabilization period before a final release. I’ve had the best of help to pinpoint problems in the drafts by technical reviewers Jeff Six and Ian Darwin, who have provided numerous comments that ranged from missing commas to coding errors and structural improvements. Thanks a lot! A book can’t be written without a supportive family. Thanks for putting up with my late-night working hours. Truth be told, I hold it as unlikely that this book will ever be read by you; nevertheless, I hope it will be a part of your future bookshelf…

Android Components and the Need for Multiprocessing

Before we immerse ourselves in the world of threading, we will start with an introduc‐ tion to the Android platform, the application architecture, and the application’s execu‐ tion. This chapter provides a baseline of knowledge required for an effective discussion of threading in the rest of the book, but a complete information on the Android platform can be found in the official documentation or in most of the numerous Android pro‐ gramming books on the market.

Android Software Stack Applications run on top of a software stack that is based on a Linux kernel, native C/C++ libraries, and a runtime that executes the application code (Figure 1-1).

Figure 1-1. Android software stack The major building blocks of the Android software stack are:

Applications Android applications that are implemented in Java. They utilize both Java and An‐ droid framework libraries. Core Java The core Java libraries used by applications and the application framework. It is not a fully compliant Java SE or ME implementation, but a subset of the retired Apache Harmony implementation, based on Java 5. It provides the fundamental Java threading mechanisms: the java.lang.Thread class and java.util.concurrent package. Application framework The Android classes that handle the window system, UI toolkit, resources, and so on—basically everything that is required to write an Android application in Java. The framework defines and manages the lifecycles of the Android components and their intercommunication. Furthermore, it defines a set of Android-specific asyn‐ chronous mechanisms that applications can utilize to simplify the thread manage‐ ment: HandlerThread, AsyncTask, IntentService, AsyncQueryHandler, and Load ers. All these mechanisms will be described in this book. Native libraries C/C++ libraries that handle graphics, media, database, fonts, OpenGL, etc. Java applications normally don’t interact directly with the native libraries because the Application framework provides Java wrappers for the native code. Runtime Sandboxed runtime environment that executes compiled Android application code in a virtual machine, with an internal byte code representation. Every application executes in its own runtime, either Dalvik or ART (Android Runtime). The latter was added in KitKat (API level 19) as an optional runtime that can be enabled by the user, but Dalvik is the default runtime at the time of writing. Linux kernel Underlying operating system that allows applications to use the hardware functions of the device: sound, network, camera, etc. It also manages processes and threads. A process is started for every application, and every process holds a runtime with a running application. Within the process, multiple threads can execute the appli‐ cation code. The kernel splits the available CPU execution time for processes and their threads through scheduling.

Application Architecture The cornerstones of an application are the Application object and the Android com‐ ponents: Activity, Service, BroadcastReceiver, and ContentProvider.

Chapter 1: Android Components and the Need for Multiprocessing

Application The representation of an executing application in Java is the android.app.Applica tion object, which is instantiated upon application start and destroyed when the ap‐ plication stops (i.e., an instance of the Application class lasts for the lifetime of the Linux process of the application). When the process is terminated and restarted, a new Application instance is created.

Components The fundamental pieces of an Android application are the components managed by the runtime: Activity, Service, BroadcastReceiver, and ContentProvider. The config‐ uration and interaction of these components define the application’s behavior. These entities have different responsibilities and lifecycles, but they all represent application entry points, where the application can be started. Once a component is started, it can trigger another component, and so on, throughout the application’s lifecycle. A com‐ ponent is trigged to start with an Intent, either within the application or between ap‐ plications. The Intent specifies actions for the receiver to act upon—for instance, sending an email or taking a photograph—and can also provide data from the sender to the receiver. An Intent can be explicit or implicit: Explicit Intent Defines the fully classified name of the component, which is known within the application at compile time. Implicit Intent A runtime binding to a component that has defined a set of characteristics in an IntentFilter. If the Intent matches the characteristics of a component’s Intent Filter, the component can be started. Components and their lifecycles are Android-specific terminologies, and they are not directly matched by the underlying Java objects. A Java object can outlive its component, and the runtime can contain multiple Java objects related to the same live component. This is a source of confusion, and as we will see in Chapter 6, it poses a risk for memory leaks. An application implements a component by subclassing it, and all components in an application must be registered in the AndroidManifest.xml file.

Activity An Activity is a screen—almost always taking up the device’s full screen—shown to the user. It displays information, handles user input, and so on. It contains the UI com‐ ponents—buttons, texts, images, and so forth—shown on the screen and holds an object

reference to the view hierarchy with all the View instances. Hence, the memory footprint of an Activity can grow large. When the user navigates between screens, Activity instances form a stack. Navigation to a new screen pushes an Activity to the stack, whereas backward navigation causes a corresponding pop. In Figure 1-2, the user has started an initial Activity A and navigated to B while A was finished, then on to C and D. A, B, and C are full-screen, but D covers only a part of the display. Thus, A is destroyed, B is totally obscured, C is partly shown, and D is fully shown at the top of the stack. Hence, D has focus and receives user input. The position in the stack determines the state of each Activity: • Active in the foreground: D • Paused and partly visible: C • Stopped and invisible: B • Inactive and destroyed: A

Figure 1-2. Activity stack The state of an application’s topmost Activity has an impact on the application’s system priority—also known as process rank—which in turn affects both the chances of ter‐ minating an application (“Application termination” on page 7) and the scheduled exe‐ cution time of the application threads (Chapter 3). An Activity lifecycle ends either when the user navigates back—for example, presses the back button—or when the Activity explicitly calls finish().

Chapter 1: Android Components and the Need for Multiprocessing

Service A Service can execute invisibly in the background without direct user interaction. It is typically used to offload execution from other components, when the operations can outlive their lifetime. A Service can be executed in either a started or a bound mode: Started Service The Service is started with a call to Context.startService(Intent) with an ex‐ plicit or implicit Intent. It terminates when Context.stopService(Intent) is called. Bound Service Multiple components can bind to a Service through Context.bindService(In tent, ServiceConnection, int) with explicit or implicit Intent parameters. Af‐ ter the binding, a component can interact with the Service through the Service Connection interface, and it unbinds from the Service through Context.unbind Service(ServiceConnection). When the last component unbinds from the Ser vice, it is destroyed.

ContentProvider An application that wants to share substantial amounts of data within or between ap‐ plications can utilize a ContentProvider. It can provide access to any data source, but it is most commonly used in collaboration with SQLite databases, which are always private to an application. With the help of a ContentProvider, an application can pub‐ lish that data to applications that execute in remote processes.

BroadcastReceiver This component has a very restricted function: it listens for intents sent from within the application, remote applications, or the platform. It filters incoming intents to determine which ones are sent to the BroadcastReceiver. A BroadcastReceiver should be reg‐ istered dynamically when you want to start listening for intents, and unregistered when it stops listening. If it is statically registered in the AndroidManifest, it listens for intents while the application is installed. Thus, the BroadcastReceiver can start its associated application if an Intent matches the filter.

Application Execution Android is a multiuser, multitasking system that can run multiple applications at the same time and let the user switch between applications without noticing a significant delay. The Linux kernel handles the multitasking, and application execution is based on Linux processes.

Linux Process Linux assigns every user a unique user ID, basically a number tracked by the OS to keep the users apart. Every user has access to private resources protected by permissions, and no user (except root, the super user, which does not concern us here) can access another user’s private resources. Thus, sandboxes are created to isolate users. In Android, every application package has a unique user ID; for example, an application in Android cor‐ responds to a unique user in Linux and cannot access other applications’ resources. What Android adds to each process is a runtime execution environment, such as the Dalvik virtual machine, for each instance of an application. Figure 1-3 shows the rela‐ tionship between the Linux process model, the VM, and the application.

Figure 1-3. Applications execute in different processes and VMs By default, applications and processes have a one-to-one relationship, but if required, it is possible for an application to run in several processes, or for several applications to run in the same process.

Lifecycle The application lifecycle is encapsulated within its Linux process, which, in Java, maps to the android.app.Application class. The Application object for each app starts when the runtime calls its onCreate() method. Ideally, the app terminates with a call by the runtime to its onTerminate(), but an application cannot rely upon this. The underlying Linux process may have been killed before the runtime had a chance to call onTerminate(). The Application object is the first component to be instantiated in a process and the last to be destroyed.

Application start An application is started when one of its components is initiated for execution. Any component can be the entry point for the application, and once the first component is triggered to start, a Linux process is started—unless it is already running—leading to the following startup sequence: 1. Start Linux process. 6

Chapter 1: Android Components and the Need for Multiprocessing

2. Create runtime. 3. Create Application instance. 4. Create the entry point component for the application. Setting up a new Linux process and the runtime is not an instantaneous operation. It can degrade performance and have a noticeable impact on the user experience. Thus, the system tries to shorten the startup time for Android applications by starting a special process called Zygote on system boot. Zygote has the entire set of core libraries preloa‐ ded. New application processes are forked from the Zygote process without copying the core libraries, which are shared across all applications.

Application termination A process is created at the start of the application and finishes when the system wants to free up resources. Because a user may request an application at any later time, the runtime avoids destroying all its resources until the number of live applications leads to an actual shortage of resources across the system. Hence, an application isn’t auto‐ matically terminated even when all of its components have been destroyed. When the system is low on resources, it’s up to the runtime to decide which process should be killed. To make this decision, the system imposes a ranking on each process depending on the application’s visibility and the components that are currently execut‐ ing. In the following ranking, the bottom-ranked processes are forced to quit before the higher-ranked ones. With the highest first, the process ranks are: Foreground Application has a visible component in front, Service is bound to an Activity in front in a remote process, or BroadcastReceiver is running. Visible Application has a visible component but is partly obscured. Service Service is executing in the background and is not tied to a visible component. Background A nonvisible Activity. This is the process level that contains most applications. Empty A process without active components. Empty processes are kept around to improve startup times, but they are the first to be terminated when the system reclaims resources. In practice, the ranking system ensures that no visible applications will be terminated by the platform when it runs out of resources.

Lifecycles of Two Interacting Applications This example illustrates the lifecycles of two processes, P1 and P2, that interact in a typical way (Figure 1-4). P1 is a client application that invokes a Service in P2, a server application. The client process, P1, starts when it is triggered by a broadcasted Intent. At startup, the process starts both a BroadcastReceiver and the Application instance. After a while, an Activity is started, and during all of this time, P1 has the highest possible process rank: Foreground.

Figure 1-4. Client application starts Service in other process The Activity offloads work to a Service that runs in process P2, which starts the Service and the associated Application instance. Therefore, the application has split the work into two different processes. The P1 Activity can terminate while the P2 Service keeps running. Once all components have finished—the user has navigated back from the Activity in P1, and the Service in P2 is asked by some other process or the runtime to stop—both processes are ranked as empty, making them plausible candidates for termination by the system when it requires resources. A detailed list of the process ranks during the execution appears in Table 1-1.

Chapter 1: Android Components and the Need for Multiprocessing

Table 1-1. Process rank transitions Application state

P1 process rank

P2 process rank

P1 starts with BroadcastReceiver entry point

Источник