In this topic you will learn someinformation about Android process management. First let’s take a look atthe launched processes during Android booting.
USER PID PPID VSIZE RSS WCHAN PC NAME
root 1 0 264 176 c00acc6c 0000c36c S /init
root 28 1 724 308 c0051354 afe0c4cc S /system/bin/sh
system 30 1 796 248 c026516c afe0b74c S/system/bin/servicemanager
root 31 1 1824 316 ffffffff afe0b50c S /system/bin/mountd
root 32 1 652 248 c02976e0 afe0c0bc S /system/bin/debuggerd
radio 33 1 5344 664 ffffffff afe0bdbc S /system/bin/rild
root 34 1 71028 18828 c00ad308 afe0b874 S zygote
media 37 1 16812 3456 ffffffff afe0b74c S /system/bin/mediaserver
root 39 1 788 288 c02f9ae4 afe0b50c S /system/bin/installd
system 86 34 187756 21836 ffffffff afe0b74c S system_server
radio 118 34 103476 13896 ffffffff afe0c824 S com.android.phone
app_4 124 34 117848 19248 ffffffff afe0c824 Sandroid.process.acore
app_5 139 34 98672 11516 ffffffff afe0c824 S com.android.mms
app_3 151 34 92096 10976 ffffffff afe0c824 Scom.android.alarmclock
app_6 161 34 94436 12616 ffffffff afe0c824 S com.android.calendar
app_9 173 34 93248 11728 ffffffff afe0c824 Sandroid.process.media
app_15 182 34 91848 9764 ffffffff afe0c824 Scom.android.voicedialer
app_16 190 34 94524 10812 ffffffff afe0c824 S android.process.im
They can be divided into three kinds.
Root Process
init is the first process after kernel booting. The major task itperforms:
l Parser and execute init.rc and init.%hardware%.rc
l Automatically generate device node under /dev
l Start log and property service
l Monitor for device, property set and child process exit events
Native Application Process
According to init.rc, init will fork the following native applicationprocess.
console : star a shell.
servicemanager : start binder IPC service manager.
mountd : mount all fs defined in/system/etc/mountd.conf if started, receive commands through localsocket to mount any fs.
debuggerd : start debug system.
rild : start radio interface layer daemon.
zygote : start Android Java VM Runtime and startsystem server. It’s the most important process.
mediaserver : start AudioFlinger, MediaPlayerServiceand CameraService.
installd : start install package daemon.
JAVA Application Process
Every JAVA application process is forked from zygote process.system_server is a special JAVA process, which is directly forked fromzygote.. Other JAVA process is created from ActivityManagerService(runin system_server process) like this.
int pid = Process.start("android.app.ActivityThread",
mSimpleProcessManagement ? app.processName : null, uid, uid,
gids, ((app.info.flags&ApplicationInfo.FLAG_DEBUGGABLE) !=0), null);
While Process.java use UNIX domain socket to communicate with zygote.So the overall picture is shown as following.
System Server
It’s the first JAVA application launched by zygote. It starts thecore Android services, e.g. ActivityManager, WindowManager,PackageManager etc. It’s the Android core engine.
Persistent Application
During booting, ActivityManagerService.systemReady will start allpersistent applications.
List apps = ActivityThread.getPackageManager().
getPersistentApplications(PackageManager.GET_SHARED_LIBRARY_FILES);
if (apps != null) {
int N = apps.size();
int i;
for (i=0; i<N; i++) {
ApplicationInfo info
= (ApplicationInfo)apps.get(i);
if (info != null &&
!info.packageName.equals("android")) {
addAppLocked(info);
}
}
}
Currently only Phone application is registered as a persistent app inAndroidManifest.xml like this.
<application android:name="PhoneApp"
android:persistent="true"
android:label="@string/dialerIconLabel"
android:icon="@drawable/ic_launcher_phone">
So during booting, only phone application is automatically launched.It’s the “com.android.phone” process.
The First Activity
The first activity is launched by senting Intent.CATEGORY_HOME intentfrom ActivityManagerService.
Intent intent = new Intent(
mTopAction,
mTopData != null ? Uri.parse(mTopData) : null);
intent.setComponent(mTopComponent);
if (mFactoryTest != SystemServer.FACTORY_TEST_LOW_LEVEL) {
intent.addCategory(Intent.CATEGORY_HOME);
}
ActivityInfo aInfo =
intent.resolveActivityInfo(mContext.getPackageManager(),
PackageManager.GET_SHARED_LIBRARY_FILES);
if (aInfo != null) {
intent.setComponent(new ComponentName(
aInfo.applicationInfo.packageName, aInfo.name));
// Don't do this if the home app is currently being
// instrumented.
ProcessRecord app = getProcessRecordLocked(aInfo.processName,
aInfo.applicationInfo.uid);
if (app == null || app.instrumentationClass == null) {
intent.setFlags(intent.getFlags() |Intent.FLAG_ACTIVITY_NEW_TASK);
startActivityLocked(null, intent, null, null, 0, aInfo,
null, null, 0, 0, 0, false);
}
}
It’s the “android.process.acore” process. (The process name isdefined in AndroidManifest.xml)
Auto-launched Application After Booting
When activity idle is detected in ActivityManagerService, it willbroadcast ACTION_BOOT_COMPLETED intent at the first time.
if (mFactoryTest != SystemServer.FACTORY_TEST_LOW_LEVEL) {
// Tell anyone interested that we are done booting!
synchronized (this) {
broadcastIntentLocked(null, null,
new Intent(Intent.ACTION_BOOT_COMPLETED,null),
null, null, 0, null, null,
android.Manifest.permission.RECEIVE_BOOT_COMPLETED,
false, false, MY_PID, Process.SYSTEM_UID);
}
}
Currently, MMS, AlarmClock, Calendar, MediaProvider, VoiceDialer andIM have registered as a receiver for ACTION_BOOT_COMPLETED intent intheir AndroidManifest.xml. So they will be automatically launched. (Thisexplains the remained JAVA process.)
Email also registers as a receiver for ACTION_BOOT_COMPLETED intentin its AndroidManifest.xml, but it defines android:enable=”false”. So itwon’t be launched.
<receiver android:name=".service.BootReceiver"
android:enabled="false"
>
<intent-filter>
<action android:name="android.intent.action.BOOT_COMPLETED"/>
</intent-filter>
<intent-filter>
<actionandroid:name="android.intent.action.DEVICE_STORAGE_LOW" />
</intent-filter>
<intent-filter>
<action android:name="android.intent.action.DEVICE_STORAGE_OK"/>
</intent-filter>
</receiver>
DownloadProvider also registers as a receiver forACTION_BOOT_COMPLETED intent in its AndroidManifest.xml, but it definesandroid:exported=”false”. So it won’t be launched.
<receiver android:name=".DownloadReceiver" android:exported="false">
<intent-filter>
<action android:name="android.intent.action.BOOT_COMPLETED"/>
<action android:name="android.net.conn.CONNECTIVITY_CHANGE"/>
</intent-filter>
</receiver>
Behind the JAVA process
system_server is a special case. It calls ActivityThread.java’ssystemMain static function, which creates an instance of ActivityThread.ActivityThread then creates an instance of ApplicationThread,Application and ApplicationContext.
Every other JAVA process works in a different way. It’s controlled bysystem_server while forked by zygote. When any JAVA process other thansystem_server is forked from zygote, it automatically callsActivityThread.java’s main static function(See Process.java and thefollowing code snippet).
try {
ZygoteInit.invokeStaticMain(cloader, className, mainArgs);
} catch (RuntimeException ex) {
logAndPrintError (newStderr, "Error starting. ", ex);
}
The ActivityThread.java’s main function creates an instance ofActivityThread. ActivityThread then creates an instance ofApplicationThread. The ApplicationThread will work as an IBinder objectto interact with ActivityManagerService in system_server. The newprocess does nothting at this time other than waiting IPC call fromsystem_server. The Application and ApplicationContext object won’t becreated at this time. Actually it’s deferred to when the process reallyworks, eg. start an activity, receive intent or start a service.
For example, when start an activity, ActivityManagerService knowwhich process the to-be-launched activity should run in, so it will RPCcall ApplicationThread’s scheduleLaunchActivity to launch a new activityin that process. ApplicationThread then post a message to letActivityThread know it needs to start an activity. ActivityThread thencreates Application and ApplicationContext object. After that, it callsInstrumentation, then Instrumentation finally calls JAVA dalvik VM toreally create an activity JAVA object.
