1.1 ActivityManager::forceStopPackage
/**
* Have the system perform a force stop of everything associated with
* the given application package. All processes that share its uid // 同UID
* will be killed, all services it has running stopped, all activities // service activity
* removed, etc. In addition, a {@link Intent#ACTION_PACKAGE_RESTARTED} //ACTION_PACKAGE_RESTARTED廣播
* broadcast will be sent, so that any of its registered alarms can // alarm notifications
* be stopped, notifications removed, etc.
*
* <p>You must hold the permission
* {@link android.Manifest.permission#FORCE_STOP_PACKAGES} to be able to
* call this method.
*
* @param packageName The name of the package to be stopped.
* @param userId The user for which the running package is to be stopped.
*
* @hide This is not available to third party applications due to
* it allowing them to break other applications by stopping their
* services, removing their alarms, etc.
*/
public void forceStopPackageAsUser(String packageName, int userId) {
try {
ActivityManagerNative.getDefault().forceStopPackage(packageName, userId);
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
調用此方法，（FORCE_STOP_PACKAGES權限需要系統(tǒng)簽名）
- 系統(tǒng)會強制停止與指定包關聯(lián)的所有事情，
- 將會殺死使用同一個
uid的所有進程，停止所有服務，移除所有activity； - 所有注冊的定時器和通知也會移除；
- 還可以達到禁止開機自啟動和后臺自啟動的目的；
1.2 PackageManagerService::setPackageStoppedState 設置包停止狀態(tài)
/**
* Set whether the given package should be considered stopped, making
* it not visible to implicit intents that filter out stopped packages.
*/
void setPackageStoppedState(String packageName, boolean stopped, int userId);
1.3 Settings::setPackageStoppedStateLPw
boolean setPackageStoppedStateLPw(PackageManagerService pm, String packageName,
boolean stopped, boolean allowedByPermission, int uid, int userId) {
int appId = UserHandle.getAppId(uid);
final PackageSetting pkgSetting = mPackages.get(packageName);
... // 參數(shù)檢查
if (pkgSetting.getStopped(userId) != stopped) {
pkgSetting.setStopped(stopped, userId);
// pkgSetting.pkg.mSetStopped = stopped;
if (pkgSetting.getNotLaunched(userId)) {
if (pkgSetting.installerPackageName != null) {
pm.notifyFirstLaunch(pkgSetting.name, pkgSetting.installerPackageName, userId);
}
pkgSetting.setNotLaunched(false, userId);
}
return true;
}
return false;
}
1.4 PackageUserState代表一個應用狀態(tài)
// PackageUserState
public PackageUserState(PackageUserState o) {
ceDataInode = o.ceDataInode;
installed = o.installed;
stopped = o.stopped; // force-stopped
notLaunched = o.notLaunched;
hidden = o.hidden;
suspended = o.suspended;
blockUninstall = o.blockUninstall;
enabled = o.enabled;
lastDisableAppCaller = o.lastDisableAppCaller;
domainVerificationStatus = o.domainVerificationStatus;
appLinkGeneration = o.appLinkGeneration;
disabledComponents = ArrayUtils.cloneOrNull(o.disabledComponents);
enabledComponents = ArrayUtils.cloneOrNull(o.enabledComponents);
}
1.5 Stop相關Flag
/**
* If set, this intent will not match any components in packages that
* are currently stopped. If this is not set, then the default behavior
* is to include such applications in the result.
*/
public static final int FLAG_EXCLUDE_STOPPED_PACKAGES = 0x00000010;
/**
* If set, this intent will always match any components in packages that
* are currently stopped. This is the default behavior when
* {@link #FLAG_EXCLUDE_STOPPED_PACKAGES} is not set. If both of these
* flags are set, this one wins (it allows overriding of exclude for
* places where the framework may automatically set the exclude flag).
*/
public static final int FLAG_INCLUDE_STOPPED_PACKAGES = 0x00000020;
廣播默認添加FLAG_EXCLUDE_STOPPED_PACKAGES
1.6 關于forcestop中的Alarm
AlarmManagerService處理Intent#ACTION_PACKAGE_RESTARTED廣播
class UninstallReceiver extends BroadcastReceiver {
public UninstallReceiver() {
IntentFilter filter = new IntentFilter();
filter.addAction(Intent.ACTION_PACKAGE_REMOVED);
filter.addAction(Intent.ACTION_PACKAGE_RESTARTED);
filter.addAction(Intent.ACTION_QUERY_PACKAGE_RESTART);
filter.addDataScheme("package");
getContext().registerReceiver(this, filter);
// Register for events related to sdcard installation.
IntentFilter sdFilter = new IntentFilter();
sdFilter.addAction(Intent.ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE);
sdFilter.addAction(Intent.ACTION_USER_STOPPED);
sdFilter.addAction(Intent.ACTION_UID_REMOVED);
getContext().registerReceiver(this, sdFilter);
}
@Override
public void onReceive(Context context, Intent intent) {
...
if (pkgList != null && (pkgList.length > 0)) {
for (String pkg : pkgList) {
removeLocked(pkg); // 移除鬧鐘相關
mPriorities.remove(pkg);
for (int i=mBroadcastStats.size()-1; i>=0; i--) {
ArrayMap<String, BroadcastStats> uidStats = mBroadcastStats.valueAt(i);
if (uidStats.remove(pkg) != null) {
if (uidStats.size() <= 0) {
mBroadcastStats.removeAt(i);
}
}
}
}
}
}
}
AlarmManagerService里面會接收這個廣播，判斷這個廣播的 package name，如果在設置過了的 alarm list 中，就會把對應的 alarm 給刪掉（AlarmManagerSerivce 用了幾個 ArrayList 來保存不同 type 的 alarm）。
2.1 killBackgroundProcesses
/**
* Have the system immediately kill all background processes associated
* with the given package. This is the same as the kernel killing those // 與在內核用kill -9
* processes to reclaim memory; the system will take care of restarting // 進程可能重啟
* these processes in the future as needed.
*
* <p>You must hold the permission
* {@link android.Manifest.permission#KILL_BACKGROUND_PROCESSES} to be able to
* call this method.
*
* @param packageName The name of the package whose processes are to
* be killed.
*/
public void killBackgroundProcesses(String packageName) {
try {
ActivityManagerNative.getDefault().killBackgroundProcesses(packageName,
UserHandle.myUserId());
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
-
ActivityManager的killBackgroundProcesses方法，可以立即殺死與指定包相關聯(lián)的所有后臺進程，這與內核殺死那些進程回收內存是一樣的(binderDied處理)，但這些進程如果在將來某一時刻需要使用，會重新啟動。 - 該方法需要權限
android.permission.KILL_BACKGROUND_PROCESSES。
2.2 Process::killProcessQuiet
/**
* @hide
* Private impl for avoiding a log message... DO NOT USE without doing
* your own log, or the Android Illuminati will find you some night and
* beat you up.
*/
public static final void killProcessQuiet(int pid) {
sendSignalQuiet(pid, SIGNAL_KILL);
}
2.3 Process::killProcess
/**
* Kill the process with the given PID.
* Note that, though this API allows us to request to
* kill any process based on its PID, the kernel will
* still impose standard restrictions on which PIDs you // 把標準的限制加于想要kill的pid
* are actually able to kill. Typically(通常) this means only
* the process running the caller's packages/application 調用者進程
* and any additional processes created by that app; packages
* sharing a common UID will also be able to kill each // 同一個Uid下
* other's processes.
*/
public static final void killProcess(int pid) {
sendSignal(pid, SIGNAL_KILL);
}
2.4 Process::sendSignal
void android_os_Process_sendSignal(JNIEnv* env, jobject clazz, jint pid, jint sig)
{
if (pid > 0) {
ALOGI("Sending signal. PID: %" PRId32 " SIG: %" PRId32, pid, sig); // 區(qū)別
kill(pid, sig);
}
}
void android_os_Process_sendSignalQuiet(JNIEnv* env, jobject clazz, jint pid, jint sig)
{
if (pid > 0) {
kill(pid, sig);
}
}
sendSignal和sendSignalQuiet的唯一區(qū)別就是在于是否有ALOGI()這一行代碼。
Process.kill通過內核kill -9殺死進程，通過該進程的IBinder.DeathRecipient進行進程信息清理
