Difference between task and process in Android

I'm a bit confused about the difference between a task and a process in Android.

If I understand correctly a task is just a stack of activities. From what I read so far I think a task could look like this:

| Activity A running in Process P1 |
| Activity B running in Process P2 |
| Activity C running in Process P3 |

So basically activities from different processes can be contained in the same stack. Am I correct?

Another question: What is the real meaning of "application context"? The process or the task?

And final question: The application class (which is basically a singleton) represents the process or the task?

Everything I've ever learned about it, I've learned on this page.

Edit: I also just stumbled upon Activity and Task Design Guidelines. It looks to cover the exact topic you asked about. I learned a lot :)

> So basically activities from different > processes can be contained in the same > stack. Am I correct?

Based on my understanding, you are correct. My grasp is that Processes are the units of actual execution while Tasks are about association to get things done. As an example from the aforementioned page, if you create an intent that opens a webpage, the Activity that it creates is created on the web browsers process but is associated with your applications Task. A task, therefore, becomes a virtual stack of Activities running on different processes depending on the application that provided the Activity.

---

> Another question: What is the real > meaning of "application context"? The > process or the task?

This is a good question. Based on reading the page above, my understanding is that an Applications context is associated with the process. I'm basing that on the interpretation of this line from that page, but there may be other info:

> Normally, a new instance of an > activity is launched into the process > of the application that defined it, so > all instances of the activity run in > the same process

---

> And final question: The application > class (which is basically a singleton) > represents the process or the task?

With the same interpretation as above, my guess as to why an Application object represents a Singleton is because all of your applications activities get run on a single process and that process is tied to the Application. I don't know that this is a design point, but it appears to be, at the least, a consequence of the current design.

Edit: There are some caveats to this. It appears that your application can be spread across multiple processes so, my guess is that the Application Object and context act as a mechanism for tethering all the processes together. I'm pretty sure your mental model already allowed for this, assuming the processes were from different applications, so its only a small difference to allow it inside a single process.

The manifest element has the attribute android:process with the description as follows: > The name of the > process in which the activity should > run. Normally, all components of an > application run in the default process > created for the application. It has > the same name as the application > package. The element's > process attribute can set a different > default for all components. But each > component can override the default, > allowing you to spread your > application across multiple processes. > If the name assigned to this attribute > begins with a colon (':'), a new > process, private to the application, > is created when it's needed and the > activity runs in that process. If the > process name begins with a lowercase > character, the activity will run in a > global process of that name, provided > that it has permission to do so. This > allows components in different > applications to share a process, > reducing resource usage.

Process: When an application component starts and the application does not have any other components running, the Android system starts a new Linux process for the application with a single thread of execution. By default, all components of the same application run in the same process and thread (called the "main" thread).Every application runs in its own process and all components of the application run in that process, by default.

for detail process: http://developer.android.com/guide/components/processes-and-threads.html

Tasks: A task is a collection of activities that users interact with when performing a certain job. The activities are arranged in a stack (the "back stack"), in the order in which each activity is opened. An activity can even start activities that exist in other applications on the device. For example, if your application wants to send an email, you can define an intent to perform a "send" action and include some data, such as an email address and a message. An activity from another application that declares itself to handle this kind of intent then opens. In this case, the intent is to send an email, so an email application's "compose" activity starts (if multiple activities support the same intent, then the system lets the user select which one to use). When the email is sent, your activity resumes and it seems as if the email activity was part of your application. Even though the activities may be from different applications, Android maintains this seamless user experience by keeping both activities in the same task.

for detail task-http://developer.android.com/guide/components/tasks-and-back-stack.html

An important note from Android Developer :

> A common misunderstanding about Android multitasking is the difference > between a process and an application. In Android these are not tightly > coupled entities: applications may seem present to the user without an > actual process currently running the app; multiple applications may > share processes, or one application may make use of multiple processes > depending on its needs; the process(es) of an application may be kept > around by Android even when that application is not actively doing > something.