Android关键字persistent详细分析

<attr name="persistent" format="boolean" />

<application
 android:persistent="true|false">


</application>

private boolean parseBaseApplication(Package owner, Resources res,

  XmlResourceParser parser, int flags, String[] outError)

 throws XmlPullParserException, IOException {

final ApplicationInfo ai = owner.applicationInfo;

 //.......................

 

 if ((flags&PARSE_IS_SYSTEM) != 0) {

  if (sa.getBoolean(

   com.android.internal.R.styleable.AndroidManifestApplication_persistent,

   false)) {

  ai.flags |= ApplicationInfo.FLAG_PERSISTENT;

  }

 }





//.............








}

public void systemReady(final Runnable goingCallback) {

......

synchronized (this) {

  // Only start up encryption-aware persistent apps; once user is

  // unlocked we'll come back around and start unaware apps

  startPersistentApps(PackageManager.MATCH_DIRECT_BOOT_AWARE);



  // Start up initial activity.

  mBooting = true;

  // Enable home activity for system user, so that the system can always boot

  if (UserManager.isSplitSystemUser()) {

  ComponentName cName = new ComponentName(mContext, SystemUserHomeActivity.class);

  try {

   AppGlobals.getPackageManager().setComponentEnabledSetting(cName,

    PackageManager.COMPONENT_ENABLED_STATE_ENABLED, 0,

    UserHandle.USER_SYSTEM);

  } catch (RemoteException e) {

   throw e.rethrowAsRuntimeException();

  }

  }

......

}

private void startPersistentApps(int matchFlags) {

 if (mFactoryTest == FactoryTest.FACTORY_TEST_LOW_LEVEL) return;



 synchronized (this) {

  try {

  final List<ApplicationInfo> apps = AppGlobals.getPackageManager()

   .getPersistentApplications(STOCK_PM_FLAGS | matchFlags).getList();

  for (ApplicationInfo app : apps) {

   if (!"android".equals(app.packageName)) {

   addAppLocked(app, false, null );

   }

  }

  } catch (RemoteException ex) {

  }

 }

 }

 final ProcessRecord addAppLocked(ApplicationInfo info, boolean isolated,

  String abiOverride) {

 ProcessRecord app;

 //传递进来的isolated=false，所有一定会调用getProcessRecordLocked方法，但是由于是第一次启动，所有返回的app = null

 if (!isolated) {

  app = getProcessRecordLocked(info.processName, info.uid, true);

 } else {

  app = null;

 }



 if (app == null) {

  //为新的app创建新的ProcessRecord对象

  app = newProcessRecordLocked(info, null, isolated, 0);

  updateLruProcessLocked(app, false, null);

  updateOomAdjLocked();

 }



 // This package really, really can not be stopped.

 try {

  //由于是开机第一次启动，所以新的app的启动状态是将要被启动状态，所以

  //该app的停止状态stoped被设置为false

  AppGlobals.getPackageManager().setPackageStoppedState(

   info.packageName, false, UserHandle.getUserId(app.uid));

 } catch (RemoteException e) {

 } catch (IllegalArgumentException e) {

  Slog.w(TAG, "Failed trying to unstop package "

   + info.packageName + ": " + e);

 }

 

 //在这里对persistent的app进行过滤，只有既是系统app，persistent为true的app才会在

 //异常死亡之后被重启

 if ((info.flags & PERSISTENT_MASK) == PERSISTENT_MASK) {

  app.persistent = true;

  app.maxAdj = ProcessList.PERSISTENT_PROC_ADJ;

 }

 //如果该app已经启动了，则不用处理，否则调用startProcessLocked方法启动app。

 //由于启动app是异步进行的，会将正在启动而还没有启动完成的app添加到

 //mPersistentStartingProcesses列表中。当启动完成后 再移除

 if (app.thread == null && mPersistentStartingProcesses.indexOf(app) < 0) {

  mPersistentStartingProcesses.add(app);

  //启动该app

  startProcessLocked(app, "added application", app.processName, abiOverride,

   null , null );

 }



 return app;

 }

}

 |

 |——appDiedLocked

   |

   |——handleAppDiedLocked

     |

     |——cleanUpApplicationRecordLocked

private final boolean cleanUpApplicationRecordLocked(ProcessRecord app,

  boolean restarting, boolean allowRestart, int index, boolean replacingPid) {

...............
 //非persistent的app被杀死后就被清理掉


 if (!app.persistent || app.isolated) {

  if (DEBUG_PROCESSES || DEBUG_CLEANUP) Slog.v(TAG_CLEANUP,

   "Removing non-persistent process during cleanup: " + app);

  if (!replacingPid) {

  removeProcessNameLocked(app.processName, app.uid, app);

  }

  if (mHeavyWeightProcess == app) {

  mHandler.sendMessage(mHandler.obtainMessage(CANCEL_HEAVY_NOTIFICATION_MSG,

   mHeavyWeightProcess.userId, 0));

  mHeavyWeightProcess = null;

  }

 } else if (!app.removed) {

  // This app is persistent, so we need to keep its record around.

  // If it is not already on the pending app list, add it there

  // and start a new process for it.

  

 //该app是persistent的，需要对其进行重启，并把它添加到正在启动的列表中，并

  //设置restart=true

  if (mPersistentStartingProcesses.indexOf(app) < 0) {

  mPersistentStartingProcesses.add(app);

  restart = true;

  }

 }

....

//经过上面的过滤，会调用这个分支条件重启persistent为true的app

 if (restart && !app.isolated) {

  // We have components that still need to be running in the

  // process, so re-launch it.

  if (index < 0) {

  ProcessList.remove(app.pid);

  }

  addProcessNameLocked(app);

  startProcessLocked(app, "restart", app.processName);

  return true;

 } else if (app.pid > 0 && app.pid != MY_PID) {

  // Goodbye!

  boolean removed;

  synchronized (mPidsSelfLocked) {

  mPidsSelfLocked.remove(app.pid);

  mHandler.removeMessages(PROC_START_TIMEOUT_MSG, app);

  }

  mBatteryStatsService.noteProcessFinish(app.processName, app.info.uid);

  if (app.isolated) {

  mBatteryStatsService.removeIsolatedUid(app.uid, app.info.uid);

  }

  app.setPid(0);

 }

 return false;



}