Java Code Examples for android.os.Process#killProcess()

private ActivityStateListener createActivityStateListener() {
    return new ActivityStateListener() {
        @Override
        public void onActivityStateChange(Activity activity, int newState) {
            if (newState == ActivityState.CREATED || newState == ActivityState.DESTROYED) {
                // Android destroys Activities at some point after a locale change, but doesn't
                // kill the process.  This can lead to a bug where Chrome is halfway RTL, where
                // stale natively-loaded resources are not reloaded (http://crbug.com/552618).
                if (!mInitialLocale.equals(Locale.getDefault())) {
                    Log.e(TAG, "Killing process because of locale change.");
                    Process.killProcess(Process.myPid());
                }

                DeviceFormFactor.resetValuesIfNeeded(mApplication);
            }
        }
    };
}
 

/**
 * Restart the application by setting a PendingIntent on the AlarmManager and then killing the
 * current process.
 *
 * @param context any current context from the application
 */
public static void restartApp(Context context) {
  Context appContext = context.getApplicationContext();
  final Intent launchIntent =
      appContext
          .getPackageManager()
          .getLaunchIntentForPackage(appContext.getPackageName())
          .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
  // Can be anything so long as it's unique. This part of the sha1sum of "buck"
  int id = 0xe354735f;
  final int flags =
      PendingIntent.FLAG_CANCEL_CURRENT
          | PendingIntent.FLAG_IMMUTABLE
          | PendingIntent.FLAG_ONE_SHOT;
  PendingIntent pendingIntent = PendingIntent.getActivity(appContext, id, launchIntent, flags);
  AlarmManager am = appContext.getSystemService(AlarmManager.class);
  long deadline = System.currentTimeMillis() + 500L;
  am.setExact(AlarmManager.RTC_WAKEUP, deadline, pendingIntent);
  Process.killProcess(Process.myPid());
}
 

@Override
public void onStop() {
    super.onStop();
    if (mServiceNeedsRestart) {
        Process.killProcess(Process.myPid());
    }
}
 

public boolean killBackgroundProcesses(String pluginPackageName) throws RemoteException {
    boolean success = false;
    for (RunningAppProcessInfo info : ((ActivityManager) this.mContext.getSystemService("activity")).getRunningAppProcesses()) {
        if (info.pkgList != null) {
            String[] pkgListCopy = (String[]) Arrays.copyOf(info.pkgList, info.pkgList.length);
            Arrays.sort(pkgListCopy);
            if (Arrays.binarySearch(pkgListCopy, pluginPackageName) >= 0 && info.pid != Process.myPid()) {
                Log.i(TAG, "killBackgroundProcesses(%s),pkgList=%s,pid=%s", pluginPackageName, Arrays.toString(info.pkgList), Integer.valueOf(info.pid));
                Process.killProcess(info.pid);
                success = true;
            }
        }
    }
    return success;
}
 

/**
 * Kill midlet process.
 */
public static void notifyDestroyed() {
	MicroActivity activity = currentActivity.get();
	if (activity != null) {
		activity.finish();
	}
	Process.killProcess(Process.myPid());
}
 

public void onClick(View v) {
    // To kill the process hosting our service, we need to know its
    // PID.  Conveniently our service has a call that will return
    // to us that information.
    if (mSecondaryService != null) {
        try {
            int pid = mSecondaryService.getPid();
            // 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
            // are actually able to kill.  Typically this means only
            // the process running your application and any additional
            // processes created by that app as shown here; packages
            // sharing a common UID will also be able to kill each
            // other's processes.
            Process.killProcess(pid);
            mCallbackText.setText("Killed service process.");
        } catch (RemoteException ex) {
            // Recover gracefully from the process hosting the
            // server dying.
            // Just for purposes of the sample, put up a notification.
            Toast.makeText(Binding.this,
                    R.string.remote_call_failed,
                    Toast.LENGTH_SHORT).show();
        }
    }
}
 

public static <T> T crash(RemoteException e) throws RuntimeException {
    e.printStackTrace();
    if (VirtualCore.get().isVAppProcess()) {
        Process.killProcess(Process.myPid());
        System.exit(0);
    }
    throw new DeadServerException(e);
}
 

public void uncaughtException(Thread thread, Throwable ex) {
    try {
        LogInfo.log("king", "uncaughtException");
        throw new Exception(ex);
    } catch (Exception e) {
        e.printStackTrace();
        if (handleException(ex) || this.mDefaultHandler == null) {
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e2) {
                LogInfo.log(TAG, "Error : " + e2);
            }
            PreferencesManager.getInstance().setCrashCount(PreferencesManager.getInstance().getCrashCount() + 1);
            if (PreferencesManager.getInstance().getDownloadFlag() != 1) {
                ((NotificationManager) LetvApplication.getInstance().getSystemService("notification")).cancel(1000);
            }
            DownloadManager.pauseAllDownload();
            LetvCacheMannager.getInstance().destroy();
            if (LetvConfig.isUmeng()) {
                MobclickAgent.onKillProcess(LetvApplication.getInstance());
            }
            Process.killProcess(Process.myPid());
            System.exit(1);
            return;
        }
        this.mDefaultHandler.uncaughtException(thread, ex);
        PreferencesManager.getInstance().setCrashCount(PreferencesManager.getInstance().getCrashCount() + 1);
    }
}
 

public void uncaughtException(Thread thread, Throwable ex) {
    if (handleException(ex) || this.mDefaultHandler == null) {
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            Log.e(TAG, "error : ", e);
        }
        Process.killProcess(Process.myPid());
        System.exit(1);
        return;
    }
    this.mDefaultHandler.uncaughtException(thread, ex);
}
 

public void disableContext(Context context) {
    NotificationManagerCompat notificationManagerCompat = NotificationManagerCompat.from(context);
    notificationManagerCompat.cancel(1);
    if (Build.VERSION.SDK_INT>=Build.VERSION_CODES.O) {
        NotificationManager notificationManager = (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
        notificationManager.deleteNotificationChannel("channel_01");
    }
    Process.killProcess(Process.myPid());
}
 

public void wipe()
{
	String action = PreferenceManager.getDefaultSharedPreferences(this).getString(Preferences.Keys.PANIC_ACTION, "0");
	boolean wipeEntireApp = (Integer.parseInt(action) == 1);
	
	dataWipe();
	if (wipeEntireApp)
	{
		deleteApp();
	}
	else
	{
		Process.killProcess(Process.myPid());
	}
}
 

public void killApp(final Task task) {
    ActivityManager activityManager = (ActivityManager)
            mContext.getSystemService(Context.ACTIVITY_SERVICE);
    activityManager.killBackgroundProcesses(task.getPackageInfo().packageName);
    for (int pid : task.getProcesses()) {
        Process.killProcess(pid);
    }
}
 

@Override
public void onDestroy() {
  super.onDestroy();

  // Workaround for the fact that that "am force-stop" doesn't work on Gingerbread.
  if (Build.VERSION.SDK_INT < Build.VERSION_CODES.ICE_CREAM_SANDWICH) {
    Process.killProcess(Process.myPid());
  }
}
 

@Override
public void handleMessage(Message message) {
    Process.killProcess(Process.myPid());
}
 

public void run() {

            //通过定时器启动提高重新启动应用的成功率
            Context context = MiddlewareActivity.this;

            Intent intent = context.getPackageManager().getLaunchIntentForPackage(context.getPackageName());
            intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_NEW_TASK);

            PendingIntent pendingIntent = PendingIntent.getActivity(context, 0, intent, 0);

            AlarmManager mgr = (AlarmManager) getSystemService(Context.ALARM_SERVICE);
            mgr.set(AlarmManager.RTC, System.currentTimeMillis() + DELAY_TIME, pendingIntent);

            Log.d(TAG, "kill process: " + Process.myPid());
            Process.killProcess(Process.myPid());
        }
 

@Override
public void crashIntentionallyForTesting() {
    Process.killProcess(Process.myPid());
}
 

public void onClick(View v) {
    // This is to simulate the service being killed while it is
    // running in the background.
    Process.killProcess(Process.myPid());
}
 

public void handleMessage(Message message) {
    Process.killProcess(Process.myPid());
}
 

private boolean handleAppCrashInActivityController(ProcessRecord r,
                                                   ApplicationErrorReport.CrashInfo crashInfo,
                                                   String shortMsg, String longMsg,
                                                   String stackTrace, long timeMillis,
                                                   int callingPid, int callingUid) {
    if (mService.mController == null) {
        return false;
    }

    try {
        String name = r != null ? r.processName : null;
        int pid = r != null ? r.pid : callingPid;
        int uid = r != null ? r.info.uid : callingUid;
        if (!mService.mController.appCrashed(name, pid,
                shortMsg, longMsg, timeMillis, crashInfo.stackTrace)) {
            if ("1".equals(SystemProperties.get(SYSTEM_DEBUGGABLE, "0"))
                    && "Native crash".equals(crashInfo.exceptionClassName)) {
                Slog.w(TAG, "Skip killing native crashed app " + name
                        + "(" + pid + ") during testing");
            } else {
                Slog.w(TAG, "Force-killing crashed app " + name
                        + " at watcher's request");
                if (r != null) {
                    if (!makeAppCrashingLocked(r, shortMsg, longMsg, stackTrace, null))
                    {
                        r.kill("crash", true);
                    }
                } else {
                    // Huh.
                    Process.killProcess(pid);
                    ActivityManagerService.killProcessGroup(uid, pid);
                }
            }
            return true;
        }
    } catch (RemoteException e) {
        mService.mController = null;
        Watchdog.getInstance().setActivityController(null);
    }
    return false;
}
 

@Override
public void onAppCrash(Thread t, Throwable e) {
    Process.killProcess(Process.myPid());
}