我如何以编程方式“重启”;Android应用程序?

首先,我知道在Android上不应该真正地关闭/重启应用程序。在我的用例中,我想在服务器向客户机发送一条特定信息的特定情况下对应用程序进行工厂重置。

用户只能使用应用程序的一个实例在服务器上登录(即不允许多个设备)。如果另一个实例得到了“login -in -lock”,那么该用户的所有其他实例都必须删除他们的数据(factory-reset),以保持一致性。

强制获取锁是可能的,因为用户可能会删除应用程序并重新安装它,这将导致不同的实例id,用户将无法再释放锁。因此,可以强制获取锁。

由于这种强制的可能性,我们需要始终检查一个具体实例是否拥有锁。这是在(几乎)对服务器的每个请求上完成的。服务器可能会发送一个“error -lock-id”。如果检测到这种情况,客户机应用程序必须删除所有内容。


这就是用例。

我有一个Activity A,它开始登录Activity L或应用程序的主Activity B,这取决于一个sharedPrefs值。在启动L或B之后,它关闭自己,以便只有L或B在运行。在用户已经登录的情况下,B正在运行。

C为IntentService d调用startService,结果是这样的堆栈:

(一)比;B在C比;D

从D的onHandleIntent方法,一个事件被发送到ResultReceiver R。

R现在通过向用户提供一个对话框来处理该事件,在该对话框中,用户可以选择对应用程序进行工厂重置(删除数据库、sharedPrefs等)。

在工厂重置后,我想重新启动应用程序(关闭所有活动),只再次启动A,然后启动登录Activity L并完成自己:

(一)比;l

对话框的onclick方法是这样的:

@Override
public void onClick(DialogInterface dialog, int which) {


// Will call onCancelListener
MyApplication.factoryReset(); // (Deletes the database, clears sharedPrefs, etc.)
Intent i = new Intent(MyApp.getContext(), A.class);
i.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
i.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
MyApp.getContext().startActivity(i);
}

这就是MyApp类:

public class MyApp extends Application {
private static Context context;


@Override
public void onCreate() {
super.onCreate();
context = getApplicationContext();
}


public static Context getContext() {
return context;
}


public static void factoryReset() {
// ...
}
}

问题是,如果我使用FLAG_ACTIVITY_NEW_TASK,活动B和C仍在运行。如果我点击登录Activity上的返回按钮,我看到C,但我想回到主屏幕。

如果我没有设置FLAG_ACTIVITY_NEW_TASK,我会得到错误:

07-07 12:27:12.272: ERROR/AndroidRuntime(9512): android.util.AndroidRuntimeException: Calling startActivity() from outside of an Activity  context requires the FLAG_ACTIVITY_NEW_TASK flag. Is this really what you want?

我不能使用活动的Context,因为ServiceIntent D也可能从由AlarmManager启动的后台任务中调用。

那么我如何解决这个问题使活动堆栈变成(A) >L ?

339981 次浏览

尝试使用FLAG_ACTIVITY_CLEAR_TASK

好吧,我重构了我的应用程序,我不会自动完成A。我让它一直运行,并通过onActivityResult事件完成它。 这样,我可以使用FLAG_ACTIVITY_CLEAR_TOP + FLAG_ACTIVITY_NEW_TASK标志来得到我想要的:

public class A extends Activity {


@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
super.onActivityResult(requestCode, resultCode, data);
finish();
}


protected void onResume() {
super.onResume();
// ...
if (loggedIn) {
startActivityForResult(new Intent(this, MainActivity.class), 0);
} else {
startActivityForResult(new Intent(this, LoginActivity.class), 0);
}
}
}

ResultReceiver

@Override
public void onClick(DialogInterface dialog, int which) {
MyApp.factoryReset();
Intent i = new Intent(MyApp.getContext(), A.class);
i.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
i.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
MyApp.getContext().startActivity(i);
}

谢谢!

有一个非常好的技巧。我的问题是一些非常老的c++ jni库泄露了资源。在某一时刻,它停止了运作。用户试图退出应用程序并再次启动它——但没有结果,因为完成一个活动并不等同于完成(或终止)进程。(顺便说一下,用户可以进入正在运行的应用程序列表并从那里停止它——这是可行的,但用户只是不知道如何终止应用程序。)

如果你想观察这个特性的效果,在你的活动中添加一个static变量,并在每次按键时增加它。如果退出应用程序活动,然后再次调用应用程序,则此静态变量将保持其值。(如果应用程序真的退出了,变量将被分配初始值。)

(并且我必须说明为什么我不想修复这个错误。这个库是几十年前编写的,从那时起就泄露了资源。管理层认为它总是工作成本提供修复而不是解决方案…我想,你们应该明白了。)

现在,我怎么能重置一个jni共享(又名动态,.so)库到初始状态? 我选择重新启动应用程序作为一个新的进程

诀窍是System.exit()关闭当前活动,Android重新创建应用程序时少了一个活动。

所以代码是:

/** This activity shows nothing; instead, it restarts the android process */
public class MagicAppRestart extends Activity {
// Do not forget to add it to AndroidManifest.xml
// <activity android:name="your.package.name.MagicAppRestart"/>
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
System.exit(0);
}
public static void doRestart(Activity anyActivity) {
anyActivity.startActivity(new Intent(anyActivity.getApplicationContext(), MagicAppRestart.class));
}
}

调用活动只执行代码MagicAppRestart.doRestart(this);,执行调用活动的onPause(),然后重新创建流程。不要忘记在AndroidManifest.xml中提到这个活动

这种方法的优点是没有延迟。

UPD:它在Android 2上运行。x,但在Android 4有一些变化。

Intent i = getBaseContext().getPackageManager().getLaunchIntentForPackage( getBaseContext().getPackageName() );
i.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
startActivity(i);

使用:

navigateUpTo(new Intent(this, MainActivity.class));

我相信它可以从API级别16(4.1)开始工作。

你可以使用PendingIntent来设置将来启动你的启动活动,然后关闭你的应用程序

Intent mStartActivity = new Intent(context, StartActivity.class);
int mPendingIntentId = 123456;
PendingIntent mPendingIntent = PendingIntent.getActivity(context, mPendingIntentId,    mStartActivity, PendingIntent.FLAG_CANCEL_CURRENT);
AlarmManager mgr = (AlarmManager)context.getSystemService(Context.ALARM_SERVICE);
mgr.set(AlarmManager.RTC, System.currentTimeMillis() + 100, mPendingIntent);
System.exit(0);

你可以简单地调用:

public static void triggerRebirth(Context context, Intent nextIntent) {
Intent intent = new Intent(context, YourClass.class);
intent.addFlags(FLAG_ACTIVITY_NEW_TASK);
intent.putExtra(KEY_RESTART_INTENT, nextIntent);
context.startActivity(intent);
if (context instanceof Activity) {
((Activity) context).finish();
}


Runtime.getRuntime().exit(0);
}

ProcessPhoenix库中使用的是哪个


作为替代:

这是@Oleg Koshkin的回答的改进版本。

如果您真的想重新启动活动,包括终止当前进程,请尝试以下代码。把它放在一个helper类或者你需要它的地方。

public static void doRestart(Context c) {
try {
//check if the context is given
if (c != null) {
//fetch the packagemanager so we can get the default launch activity
// (you can replace this intent with any other activity if you want
PackageManager pm = c.getPackageManager();
//check if we got the PackageManager
if (pm != null) {
//create the intent with the default start activity for your application
Intent mStartActivity = pm.getLaunchIntentForPackage(
c.getPackageName()
);
if (mStartActivity != null) {
mStartActivity.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
//create a pending intent so the application is restarted after System.exit(0) was called.
// We use an AlarmManager to call this intent in 100ms
int mPendingIntentId = 223344;
PendingIntent mPendingIntent = PendingIntent
.getActivity(c, mPendingIntentId, mStartActivity,
PendingIntent.FLAG_CANCEL_CURRENT);
AlarmManager mgr = (AlarmManager) c.getSystemService(Context.ALARM_SERVICE);
mgr.set(AlarmManager.RTC, System.currentTimeMillis() + 100, mPendingIntent);
//kill the application
System.exit(0);
} else {
Log.e(TAG, "Was not able to restart application, mStartActivity null");
}
} else {
Log.e(TAG, "Was not able to restart application, PM null");
}
} else {
Log.e(TAG, "Was not able to restart application, Context null");
}
} catch (Exception ex) {
Log.e(TAG, "Was not able to restart application");
}
}

这也将重新初始化jni类和所有静态实例。

Jake Wharton最近发布了他的ProcessPhoenix库,它以一种可靠的方式做到了这一点。你基本上只需要调用:

ProcessPhoenix.triggerRebirth(context);

库将自动完成调用活动,终止应用程序进程,然后重新启动默认的应用程序活动。

完全重新启动应用程序的最好方法是重新启动它,而不仅仅是跳转到带有FLAG_ACTIVITY_CLEAR_TOPFLAG_ACTIVITY_NEW_TASK的活动。所以我的解决方案是从你的应用程序,甚至从另一个应用程序,唯一的条件是知道应用程序包的名称(例如:'com.example.myProject')

 public static void forceRunApp(Context context, String packageApp){
Intent launchIntent = context.getPackageManager().getLaunchIntentForPackage(packageApp);
launchIntent.setFlags(Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS | Intent.FLAG_ACTIVITY_NEW_TASK);
context.startActivity(launchIntent);
}

appB重新启动或启动光电的使用示例:

forceRunApp(mContext, "com.example.myProject.appA");

您可以检查应用程序是否正在运行:

 public static boolean isAppRunning(Context context, String packageApp){
ActivityManager activityManager = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
List<ActivityManager.RunningAppProcessInfo> procInfos = activityManager.getRunningAppProcesses();
for (int i = 0; i < procInfos.size(); i++) {
if (procInfos.get(i).processName.equals(packageApp)) {
return true;
}
}
return false;
}

请注意:我知道这个答案有点离题,但它对某人来说真的很有帮助。

我的解决方案没有重新启动进程/应用程序。它只允许应用程序“重启”home活动(并解散所有其他活动)。对用户来说,这看起来像是重新启动,但过程是一样的。我认为在某些情况下,人们想要达到这种效果,所以我只是在这里供大家参考。

public void restart(){
Intent intent = new Intent(this, YourHomeActivity.class);
this.startActivity(intent);
this.finishAffinity();
}

IntentCompat.makeMainSelectorActivity -最后一次测试是在2020年11月

应用程序将与启动器活动一起恢复,旧进程将被杀死。

api15的作品。

public static void restart(Context context){
Intent mainIntent = IntentCompat.makeMainSelectorActivity(Intent.ACTION_MAIN, Intent.CATEGORY_LAUNCHER);
mainIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
context.getApplicationContext().startActivity(mainIntent);
System.exit(0);
}

你可以使用ActivitystartInstrumentation方法。你需要实现空的Instrumentation并在manifest中指向。之后,你可以调用这个方法重新启动你的应用程序。

try {
InstrumentationInfo info = getPackageManager().queryInstrumentation(getPackageName(), 0).get(0);
ComponentName component = new ComponentName(this, Class.forName(info.name));
startInstrumentation(component, null, null);
} catch (Throwable e) {
new RuntimeException("Failed restart with Instrumentation", e);
}

我动态地获得Instrumentation类名,但是你可以硬编码它。有些是这样的:

try {
startInstrumentation(new ComponentName(this, RebootInstrumentation.class), null, null);
} catch (Throwable e) {
new RuntimeException("Failed restart with Instrumentation", e);
}

调用startInstrumentation重新加载你的应用程序。阅读这个方法的描述。但如果像杀人程序一样,它可能是不安全的。

直接使用FLAG_ACTIVITY_CLEAR_TASK和FLAG_ACTIVITY_NEW_TASK启动初始屏幕。

我正在开发的应用程序必须允许用户选择要显示哪些片段(片段在运行时动态更改)。对我来说最好的解决方案是重启完全应用程序。

所以我尝试了很多解决方案,没有一个对我有效,但是这个:

final Intent mStartActivity = new Intent(SettingsActivity.this, Splash.class);
final int mPendingIntentId = 123456;
final PendingIntent mPendingIntent = PendingIntent.getActivity(SettingsActivity.this, mPendingIntentId, mStartActivity,
PendingIntent.FLAG_CANCEL_CURRENT);
final AlarmManager mgr = (AlarmManager) SettingsActivity.this.getSystemService(Context.ALARM_SERVICE);
mgr.set(AlarmManager.RTC, System.currentTimeMillis() + 100, mPendingIntent);
this.finishAffinity(); //notice here
Runtime.getRuntime().exit(0); //notice here

希望这能帮助到其他人!

我必须添加一个Handler来延迟退出:

 mgr.set(AlarmManager.RTC, System.currentTimeMillis() + 200, mPendingIntent);
final Handler handler = new Handler();
handler.postDelayed(new Runnable() {
@Override
public void run() {
Runtime.getRuntime().exit(0);
}
}, 100);

试试这个:

Intent intent = getPackageManager().getLaunchIntentForPackage(getPackageName());
intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
startActivity(intent);

我稍微修改了Ilya_Gazman答案以使用新的API (IntentCompat从API 26开始已弃用)。Runtime.getRuntime().exit(0)似乎比System.exit(0)更好。

 public static void triggerRebirth(Context context) {
PackageManager packageManager = context.getPackageManager();
Intent intent = packageManager.getLaunchIntentForPackage(context.getPackageName());
ComponentName componentName = intent.getComponent();
Intent mainIntent = Intent.makeRestartActivityTask(componentName);
context.startActivity(mainIntent);
Runtime.getRuntime().exit(0);
}

唯一没有触发“您的应用程序意外关闭”的代码如下。它也是不需要外部库的非弃用代码。它也不需要计时器。

public static void triggerRebirth(Context context, Class myClass) {
Intent intent = new Intent(context, myClass);
intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK);
context.startActivity(intent);
Runtime.getRuntime().exit(0);
}

你可以像这样重新启动你的当前活动:

片段:

activity?.recreate()

活动:

recreate()
我重启应用程序的最好方法是使用finishAffinity();
因为finishAffinity();只能在JELLY BEAN版本上使用,所以我们可以在较低的版本上使用ActivityCompat.finishAffinity(YourCurrentActivity.this);

然后使用Intent来启动第一个活动,所以代码看起来像这样:

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
finishAffinity();
Intent intent = new Intent(getApplicationContext(), YourFirstActivity.class);
startActivity(intent);
} else {
ActivityCompat.finishAffinity(YourCurrentActivity.this);
Intent intent = new Intent(getApplicationContext(), YourFirstActivity.class);
startActivity(intent);
}

希望能有所帮助。

我发现这适用于API 29及以后的版本——目的是杀死并重新启动应用程序,就像用户在应用程序未运行时启动它一样。

public void restartApplication(final @NonNull Activity activity) {
// Systems at 29/Q and later don't allow relaunch, but System.exit(0) on
// all supported systems will relaunch ... but by killing the process, then
// restarting the process with the back stack intact. We must make sure that
// the launch activity is the only thing in the back stack before exiting.
final PackageManager pm = activity.getPackageManager();
final Intent intent = pm.getLaunchIntentForPackage(activity.getPackageName());
activity.finishAffinity(); // Finishes all activities.
activity.startActivity(intent);    // Start the launch activity
System.exit(0);    // System finishes and automatically relaunches us.
}

这是在应用程序中的启动器活动时完成的:

<intent-filter>
<action android:name="android.intent.action.VIEW"/>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>

我看到一些评论声称需要一个DEFAULT类别,但我没有发现情况是这样的。我已经确认我的应用程序中的应用程序对象是重新创建的,所以我相信进程真的已经被杀死并重新启动。

我使用这个的唯一目的是在用户启用或禁用Firebase Crashlytics崩溃报告后重新启动应用程序。根据他们的文档,应用程序必须重新启动(进程终止并重新创建)才能生效。

使用Process Phoenix库。您想要重新启动的活动名为“A”。

Java的味道

// Java
public void restart(){
ProcessPhoenix.triggerRebirth(context);
}

芬兰湾的科特林风味

// kotlin
fun restart() {
ProcessPhoenix.triggerRebirth(context)
}

Kotlin版本的答案:

val intent = Intent(this, YourActivity::class.java)
intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK or Intent.FLAG_ACTIVITY_CLEAR_TASK)
startActivity(intent)
Runtime.getRuntime().exit(0)

在MainActivity调用restartActivity方法:

public static void restartActivity(Activity mActivity) {
Intent mIntent = mActivity.getIntent();
mActivity.finish();
mActivity.startActivity(mIntent);
}

在我的案例中,Mikepenz的备选答案需要一些改变。< a href = " https://stackoverflow.com/a/22345538/12021422 " > https://stackoverflow.com/a/22345538/12021422 主要归功于Mikepenz的答案,我可以修改

这是对我有用的即插即用静态功能。

只要传递应用程序的上下文,这个函数就会处理重启。

    public static void doRestart(Context c) {
try {
// check if the context is given
if (c != null) {
// fetch the package manager so we can get the default launch activity
// (you can replace this intent with any other activity if you want
PackageManager pm = c.getPackageManager();
// check if we got the PackageManager
if (pm != null) {
// create the intent with the default start activity for your application
Intent mStartActivity = pm.getLaunchIntentForPackage(c.getPackageName());
if (mStartActivity != null) {
mStartActivity.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
                        

c.getApplicationContext().startActivity(mStartActivity);
// kill the application
System.exit(0);
}
}
}
} catch (Exception e) {
e.printStackTrace();
Log.e("restart", "Could not Restart");
}
}
fun triggerRestart(context: Activity) {
val intent = Intent(context, MainActivity::class.java)
intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
context.startActivity(intent)
if (context is Activity) {
(context as Activity).finish()
}
Runtime.getRuntime().exit(0)
}

嘿,兄弟,如果你想重新启动你的应用程序点击一个按钮,所以写这段代码,记得改变重置与你的按钮的名称,如果你将运行这段代码,它将无法工作,因为我已经选择了javascript,它是java语言

reset.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
finish();


startActivity(getIntent());
}
});

仍在工作

 public void resetApplication() {
Intent resetApplicationIntent = context.getPackageManager().getLaunchIntentForPackage(context.getPackageName());
if (resetApplicationIntent != null) {
resetApplicationIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK);
}
context.startActivity(resetApplicationIntent);
((Activity) context).overridePendingTransition(R.anim.fade_in, R.anim.fade_out);
}

应用延迟重启

startDelay启动延迟时间(单位:毫秒)

 public static void reStartApp(Context context, long startDelay) {
//Obtain the startup Intent of the application with the package name of the application
Intent intent = context.getPackageManager().getLaunchIntentForPackage(context.getPackageName());
PendingIntent restartIntent = PendingIntent.getActivity(context.getApplicationContext(), -1, intent, PendingIntent.FLAG_CANCEL_CURRENT);


AlarmManager mgr = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
if (mgr != null) {
mgr.set(AlarmManager.RTC, System.currentTimeMillis() + startDelay, restartIntent);
}
}
val i = baseContext.packageManager.getLaunchIntentForPackage(baseContext.packageName)
i!!.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP)
startActivity(i)
finish()

我是这样的。

Intent i = getBaseContext().getPackageManager().getLaunchIntentForPackage(
getBaseContext().getPackageName() );
i.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
startActivity(i);
finish();