Як я можу програмно "перезапустити" додаток для Android?

По-перше, я знаю, що дійсно не слід вбивати / перезапускати додаток на Android. У моєму випадку використання я хочу відновити заводські налаштування своєї програми в конкретному випадку, коли сервер надсилає клієнту конкретну інформацію.

Користувач може увійти на сервер лише з одним екземпляром програми (тобто кілька пристроїв заборонено). Якщо інший екземпляр отримує цей "вхід" -блок, то всі інші екземпляри цього користувача повинні видалити свої дані (скинути заводські налаштування), щоб зберегти послідовність.

Блокування можна примусово отримати, оскільки користувач може видалити додаток та перевстановити його, що призведе до іншого ідентифікатора інстанції, і користувач більше не зможе звільнити замок. Тому замок можна насильно дістати.

Через таку силу сили нам потрібно завжди перевіряти в конкретному випадку, що він має замок. Це робиться на (майже) кожному запиті до сервера. Сервер може надіслати "неправильний код блокування". Якщо це виявлено, клієнтська програма повинна все видалити.

Це був випадок використання.

У мене є ActivityA, який запускає ActivityL або вхід у систему ActivityB, залежно від значення sharedPrefs. Після запуску L або B він закривається таким чином, що працює тільки L або B. Так що у випадку, якщо користувач увійшов у систему вже працює B.

B починає дзвонити C. C startServiceдля IntentServiceD. Це результати в цьому стеку:

(A)> B> C> D

З методу onHandleIntent D подія надсилається ResultReceiver R.

R тепер обробляє цю подію, надаючи користувачеві діалогове вікно, де він може вибрати заводські скидання програми (видалити базу даних, sharedPrefs тощо)

Після скидання до заводських налаштувань я хочу перезапустити програму (закрити всі дії) і лише запустити A ще раз, який потім запустить логін ActivityL та завершить:

(A)> L

Метод onClick Dialog виглядає приблизно так:

@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, оскільки ServiceIntentD може бути викликаний також із фонового завдання, яке запускається AlarmManager.

Тож як я міг вирішити це, щоб стек активності став (A)> L?

Ви можете використовувати 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.

Якщо ви дійсно хочете перезапустити свою діяльність, включаючи вбивство поточного процесу, спробуйте наступний код. Помістіть його в HelperClass або там, де вам це потрібно.

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-класи та всі статичні екземпляри.

Нещодавно Джейк Уортон опублікував свою бібліотеку ProcessPhoenix , яка робить це надійно. Вам потрібно лише зателефонувати:

ProcessPhoenix.triggerRebirth(context);

Бібліотека автоматично завершить дію виклику, знищить процес подання заявки та після цього перезапустить активність програми за замовчуванням.

Я трохи змінив відповідь Ilya_Gazman для використання нових API (IntentCompat застарілий, починаючи API 26). Runtime.getRuntime (). Вихід (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);
}

IntentCompat.makeRestartActivityTask

Новий спосіб зробити це за допомогою IntentCompat.makeRestartActivityTask

Зробіть наміри, які можна використовувати для повторного запуску завдання програми у його базовому стані. Це як makeMainActivity (ComponentName), але також встановлює прапорці Intent.FLAG_ACTIVITY_NEW_TASK та FLAG_ACTIVITY_CLEAR_TASK.

PackageManager packageManager = context.getPackageManager();
Intent intent = packageManager.getLaunchIntentForPackage(context.getPackageName());
ComponentName componentName = intent.getComponent();
Intent mainIntent = IntentCompat.makeRestartActivityTask(componentName);
context.startActivity(mainIntent);
System.exit(0);

Є справді приємний трюк. Моя проблема полягала в тому, що деякі справді старі бібліотеки 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 щось змінилося.

Моє рішення не перезапускає процес / додаток. Це лише дозволяє додатку "перезапустити" домашню діяльність (і відмовитись від усіх інших заходів). Це виглядає як перезавантаження для користувачів, але процес той самий. Я думаю, що в деяких випадках люди хочуть досягти цього ефекту, тому я просто залишаю це FYI.

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

Гаразд, я відновив свою програму, і я не закінчу автоматично 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);
}

Все одно, дякую!

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

Єдиний код, який не викликав "Ваш додаток несподівано закрився", полягає в наступному. Це також непридатний код, який не потребує зовнішньої бібліотеки. Також не потрібен таймер.

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);
}

Я виявив, що це працює в 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, але я не знайшов це так. Я підтвердив, що об’єкт Application в моєму додатку заново створений, тому вважаю, що процес справді був убитий і перезапущений.

Єдина мета, для якої я це використовую, - це перезапустити додаток після того, як користувач увімкнув або вимкнув звіт про аварійну ситуацію для Firebase Crashlytics. Відповідно до їхніх документів, додаток має бути перезапущено (процес знищено та заново створено), щоб ці зміни вступили в силу.

Найкращий спосіб повністю перезапустити додаток - це перезапустити його, а не просто перейти до активності з FLAG_ACTIVITY_CLEAR_TOPта FLAG_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);
}

Приклад перезапуску використання або запуску програмиA із 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;
}

Примітка . Я знаю, що ця відповідь трохи не відповідає темі, але вона може бути дуже корисною для когось.

Мій найкращий спосіб перезапустити додаток - це використання, 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);
}

Сподіваюся, це допомагає.

Спробуйте використовувати FLAG_ACTIVITY_CLEAR_TASK

Ось приклад перезапустити додаток загальним способом за допомогою PackageManager:

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

спробуйте це:

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

Безпосередньо запустіть початковий екран із FLAG_ACTIVITY_CLEAR_TASKта FLAG_ACTIVITY_NEW_TASK.

Мені довелося додати обробник, щоб затримати вихід:

 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);

Використання:

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

Це працює, починаючи з рівня 16 (4.1) API, я вважаю.

Ви можете використовувати startInstrumentationметод Activity. Вам потрібно виконати порожній Instrumentationта вказаний у маніфесті. Після цього ви можете викликати цей метод для перезавантаження програми. Подобається це:

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щоб перезавантажити додаток. Прочитайте опис цього методу. Але це не може бути безпечно, якщо діяти як програму kill.

Програма, над якою я працюю, повинна надавати користувачеві можливість вибирати фрагменти для відображення (фрагменти динамічно змінюються під час виконання). Найкращим рішенням для мене було повністю перезапустити програму.

Тому я спробував безліч рішень, і жодне з них не працювало на мене, але це:

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

Сподіваючись, що допоможе комусь іншому!

спробуйте це:

private void restartApp() {
    Intent intent = new Intent(getApplicationContext(), YourStarterActivity.class);
    int mPendingIntentId = MAGICAL_NUMBER;
    PendingIntent mPendingIntent = PendingIntent.getActivity(getApplicationContext(), mPendingIntentId, intent, PendingIntent.FLAG_CANCEL_CURRENT);
    AlarmManager mgr = (AlarmManager) getApplicationContext().getSystemService(Context.ALARM_SERVICE);
    mgr.set(AlarmManager.RTC, System.currentTimeMillis() + 100, mPendingIntent);
    System.exit(0);
}

З бібліотекою Process Phoenix . Діяльність, яку потрібно відновити, називається "A".

Ява смак

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

Котлін аромат

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

Ви можете перезапустити поточну діяльність так:

Фрагмент:

activity?.recreate()

Діяльність:

recreate()