Background
Tasks and processes are different in Android. I am going to discuss the same in this post. I ran into this question when I was trying to figure out the difference between the calls
final List<RunningTaskInfo> runningTasks = activityManager.getRunningTasks(Integer.MAX_VALUE);
and
final List<RunningAppProcessInfo> runningProcesses = activityManager.getRunningAppProcesses();
So lets see the difference.
Running Task and Running Process in Android
Android has Linux kernel. So process is similar to processes in Linux. Each process can have multiple threads. When a process starts it is single thread execution by default. This thread is called the main thread or UI thread. You may have other worker or asynchronous threads running in a process.
Task or Application on the other hand can be visualized as set of activities in an application. It is possible that each activity in the task is configured to run in different processes. Same goes for other entitles of Android - services, providers etc. Infact components of different tasks/applications can run in same process (provided that the applications share the same Linux user ID and are signed with the same certificates).
When System memory is low of running application an older process is killed. Again note this may have components of different application.
Above will give you Running tasks or rather lets call it application consisting of set of activities. (List of RunningTaskInfo objects). This in turn will have two main things.
Task or Application on the other hand can be visualized as set of activities in an application. It is possible that each activity in the task is configured to run in different processes. Same goes for other entitles of Android - services, providers etc. Infact components of different tasks/applications can run in same process (provided that the applications share the same Linux user ID and are signed with the same certificates).
When System memory is low of running application an older process is killed. Again note this may have components of different application.
activityManager.getRunningTasks(Integer.MAX_VALUE)
Above will give you Running tasks or rather lets call it application consisting of set of activities. (List of RunningTaskInfo objects). This in turn will have two main things.
- baseActivity : component launched as the first activity in the task
- topActivity : activity component at the top of the history stack of the task
and
activityManager.getRunningAppProcesses()
Above will give all running processes in the System. Since it is a process it will have associated pid (processId) and `uid (userId). Some of the important fields here are -
- processName : The name of the process that this object is associated with
- pid : The pid of this process; 0 if none
- uid : The user id of this process.
- pkgList : All packages that have been loaded into the process.
To get all running app name we do something like -
public List<String> getRunningApps() {
ActivityManager activityManager = (ActivityManager) getSystemService(Context.ACTIVITY_SERVICE);
PackageManager packageManager = getPackageManager();
final List<RunningAppProcessInfo> runningProcesses = activityManager.getRunningAppProcesses();
List<String> runningAppNames = new ArrayList<String>();
for(RunningAppProcessInfo processInfo : runningProcesses) {
CharSequence appName = null;
try {
appName = packageManager.getApplicationLabel(packageManager.getApplicationInfo(processInfo.processName, PackageManager.GET_META_DATA));
runningAppNames.add(appName.toString());
} catch (NameNotFoundException e) {
Log.e(TAG,"Application info not found for process : " + processInfo.processName,e);
}
}
return runningAppNames;
}
In above code we are essentially getting information about all running processes. Then with the help of process name of each such process we are getting corresponding application package.
Interesting Read
First of all you need to understand what you can kill and what not. By android's point of view an application is not like other OSes. An android application consists of many components (activities, broadcast receivers, services, most important tasks etc) which are packed in a package. A package can have more that one processes running depending on its components running.
Now the interesting part is that an android package isn't considered (by android) "killed" or "stopped" if any or all of its processes have killed, in fact a package can still running even with no processes running at all.
You can see this effect if you start an emulator start a program (i.e. Browser) and then kill its process via DDMS, after that go to the application's package settings (Settings --> Applications --> Manage Applications --> All --> Browser), you can see the "Force Stop" button enabled, this means that the application is still running (from android's point of view).
What happened here is that the application has one or more tasks "frozen". That is, android has saved the state of the application's activities (task or tasks) and so the package is still running or better if the user returns to it he will land on the last thing he was doing. Now if you click the "Force Stop" button, android will discard all of these "frozen" tasks and when the user returns to the application he will see the first activity.
A Task is something you cannot kill (since froyo) only the user (from "Force Stop" button), the system or a third party application which is signed with the same key of the system can do that (and maybe a root capable application but I have not confirmed this). On the other hand a Process is something you can kill and reclaim the memory it uses, as long as you follow some restrictions:
- You have the "android.permission.KILL_BACKGROUND_PROCESSES" permission.
- The processes are not system or root processes.
- The process is not belonging to a component which is persistent.
- The process is not a critical for the system to operate by any other means.
Besides the no 1 rule you do not have to do something about them, android will take care of this.
ActivityManager has a handy function you can use in order to kill all of the processes a package has at once. When you invoke it android will kill any process can be killed and thus freeing up some memory. However the state of the tasks for this package will be saved and when the user returns to the application he will see the last thing he was doing unless the system itself has killed them. This can occur either because it needs resources or the state was saved long time ago (about 30 minutes). The side-effect is that because users are thinking that all applications are like in desktop operating systems, they do not believe that the application is really closed but this is the life with android.
(Source - SO)
No comments:
Post a Comment