При выходе из системы очистите стек истории действий, чтобы кнопка «Назад» не открывала действия, в которых только вы вошли.

Я могу предложить вам другой подход, ИМХО, более надежный. В основном вам нужно транслировать сообщение о выходе для всех ваших действий, которые должны оставаться в состоянии входа в систему. Таким образом, вы можете использовать sendBroadcast и установить BroadcastReceiver во всех ваших Actvities. Что-то вроде этого:

/** on your logout method:**/
Intent broadcastIntent = new Intent();
broadcastIntent.setAction("com.package.ACTION_LOGOUT");
sendBroadcast(broadcastIntent);

Получатель (защищенная активность):

protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    /**snip **/
    IntentFilter intentFilter = new IntentFilter();
    intentFilter.addAction("com.package.ACTION_LOGOUT");
    registerReceiver(new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            Log.d("onReceive","Logout in progress");
            //At this point you should start the login activity and finish this one
            finish();
        }
    }, intentFilter);
    //** snip **//
}

Кажется, это обряд посвящения, когда новый программист Android проводит день, исследуя эту проблему и читая все эти темы StackOverflow. Сейчас я новичок и оставляю здесь след своего скромного опыта, чтобы помочь будущему паломнику.

Во-первых, согласно моему исследованию, не существует очевидного или немедленного способа сделать это (as of September 2012). Вы могли бы подумать, что можете просто startActivity(new Intent(this, LoginActivity.class), CLEAR_STACK), но нет.

Вы МОЖЕТЕ сделать startActivity(new Intent(this, LoginActivity.class)) с FLAG_ACTIVITY_CLEAR_TOP - и это заставит фреймворк искать вниз по стеку, находить ваш более ранний исходный экземпляр LoginActivity, воссоздавать его и очищать остальную часть (вверх) стека. А поскольку логин предположительно находится внизу стека, теперь у вас пустой стек, а кнопка «Назад» просто закрывает приложение.

НО - это работает только в том случае, если вы ранее оставили активным исходный экземпляр LoginActivity в основе вашего стека. Если, как и многие программисты, вы выбрали finish() этот LoginActivity после того, как пользователь успешно вошел в систему, тогда он больше не находится на основе стека и семантика FLAG_ACTIVITY_CLEAR_TOP не применяется ... вы в конечном итоге создаете новый LoginActivity поверх существующий стек. Это почти наверняка НЕ ​​то, что вы хотите (странное поведение, когда пользователь может «вернуться» из входа на предыдущий экран).

Итак, если вы ранее finish() использовали LoginActivity, вам необходимо разработать какой-то механизм для очистки вашего стека и последующего запуска нового LoginActivity. Похоже, что ответ @doreamon в этой ветке - лучшее решение (по крайней мере, на мой скромный взгляд):

https://stackoverflow.com/a/9580057/614880

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

Удачи.

ОБНОВЛЕНИЕ

метод super finishAffinity() поможет уменьшить код, но добиться того же. Он завершит текущее действие, а также все действия в стеке, используйте getActivity().finishAffinity(), если вы находитесь во фрагменте.

finishAffinity(); 
startActivity(new Intent(mActivity, LoginActivity.class));

ОРИГИНАЛЬНЫЙ ОТВЕТ

Предположим, что LoginActivity -> HomeActivity -> ... -> SettingsActivity call signOut ():

void signOut() {
    Intent intent = new Intent(this, HomeActivity.class);
    intent.putExtra("finish", true);
    intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP); // To clean up all activities
    startActivity(intent);
    finish();
}

Главная Деятельность:

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    boolean finish = getIntent().getBooleanExtra("finish", false);
    if (finish) {
        startActivity(new Intent(mContext, LoginActivity.class));
        finish();
        return;
    }
    initializeView();
}

Это работает для меня, надеюсь, что это будет полезно и для вас. :)

Если вы используете API 11 или выше, вы можете попробовать следующее: FLAG_ACTIVITY_CLEAR_TASK - кажется чтобы решить именно вашу проблему. Очевидно, что толпе, предшествовавшей API 11, пришлось бы использовать какую-то комбинацию, чтобы все действия проверяли дополнительную, как предлагает @doreamon, или какой-то другой трюк.

(Также обратите внимание: чтобы использовать это, вы должны передать FLAG_ACTIVITY_NEW_TASK)

Intent intent = new Intent(this, LoginActivity.class);
intent.putExtra("finish", true); // if you are checking for this in your other Activities
intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP | 
                Intent.FLAG_ACTIVITY_CLEAR_TASK |
                Intent.FLAG_ACTIVITY_NEW_TASK);
startActivity(intent);
finish();

Я тоже потратил на это несколько часов ... и согласен, что FLAG_ACTIVITY_CLEAR_TOP звучит так, как вам нужно: очистить весь стек, за исключением запущенного действия, поэтому кнопка «Назад» закрывает приложение. Однако, как упоминал Майк Репасс, FLAG_ACTIVITY_CLEAR_TOP работает только тогда, когда действие, которое вы запускаете, уже находится в стеке; когда активности нет, флаг ничего не делает.

Что делать? Поместите запускаемое действие в стек с помощью FLAG_ACTIVITY_NEW_TASK, что делает это действие - начало новой задачи в стеке истории. Затем добавьте флаг FLAG_ACTIVITY_CLEAR_TOP.

Теперь, когда FLAG_ACTIVITY_CLEAR_TOP найдет новое действие в стеке, оно будет там и будет извлечено до того, как все остальное будет очищено.

Вот моя функция выхода из системы; Параметр View - это кнопка, к которой прикреплена функция.

public void onLogoutClick(final View view) {
    Intent i = new Intent(this, Splash.class);
    i.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK);
    startActivity(i);
    finish();
}

Множество ответов. Может быть, это тоже поможет-

Intent intent = new Intent(activity, SignInActivity.class)
                .addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK)
                .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
this.startActivity(intent);
this.finish();

Версия Котлина-

Intent(this, SignInActivity::class.java).apply {
    addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK)
    addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
}.also { startActivity(it) }
finish()

Используйте это, это должно быть вам полезно. Слегка измененный ответ xbakesx.

Intent intent = new Intent(this, LoginActivity.class);
if(Build.VERSION.SDK_INT >= 11) {
    intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_CLEAR_TASK);
} else {
    intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TOP);
}
startActivity(intent);

Принятое решение неверно, у него есть проблемы, так как использование широковещательного приемника не является хорошей идеей для решения этой проблемы. Если ваша активность уже вызвала метод onDestroy (), вы не получите получателя. Лучшее решение - иметь логическое значение в ваших общих предпочтениях и проверять его в методе onCreate () вашей активности. Если он не должен вызываться, когда пользователь не вошел в систему, завершите действие. Вот пример кода для этого. Так просто и работает для любых условий.

protected void onResume() {
  super.onResume();
  if (isAuthRequired()) {
    checkAuthStatus();
  }
}

private void checkAuthStatus() {
  //check your shared pref value for login in this method
  if (checkIfSharedPrefLoginValueIsTrue()) {
    finish();
  }
}

boolean isAuthRequired() {
  return true;
}

Иногда finish() не работает

Я решил эту проблему с помощью

finishAffinity()

Вот решение, которое я придумал в своем приложении.

В моем LoginActivity после успешной обработки входа в систему я запускаю следующий по-разному, в зависимости от уровня API.

Intent i = new Intent(this, MainActivity.class);
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
    startActivity(i);
    finish();
} else {
    startActivityForResult(i, REQUEST_LOGIN_GINGERBREAD);
}

Затем в моем методе LoginActivity onActivityForResult:

if (Build.VERSION.SDK_INT < Build.VERSION_CODES.HONEYCOMB &&
        requestCode == REQUEST_LOGIN_GINGERBREAD &&
        resultCode == Activity.RESULT_CANCELED) {
    moveTaskToBack(true);
}

Наконец, после обработки выхода из любого другого действия:

Intent i = new Intent(this, LoginActivity.class);
i.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK);
startActivity(i);

Когда я использую Gingerbread, делает это так, что если я нажимаю кнопку возврата из MainActivity, LoginActivity сразу скрывается. В Honeycomb и более поздних версиях я просто завершаю LoginActivity после обработки входа в систему, и он правильно воссоздается после обработки выхода.

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

@Override
public void onBackPressed() {
    // disable going back to the MainActivity
    moveTaskToBack(true);
}

Я предполагаю, что LoginActivity завершается сразу после того, как пользователь входит в систему, поэтому он не может вернуться к нему позже, нажав кнопку «Назад». Вместо этого пользователь должен нажать кнопку выхода внутри приложения, чтобы выйти из системы должным образом. Эта кнопка выхода из системы будет реализовывать простое намерение, как показано ниже:

Intent intent = new Intent(this, LoginActivity.class);
startActivity(intent);
finish();

Все предложения приветствуются.

Выбранный ответ умный и хитрый. Вот как я это сделал:

LoginActivity - это корневое действие задачи, установите для него android: noHistory = "true" в Manifest.xml; Скажем, вы хотите выйти из SettingsActivity, вы можете сделать это, как показано ниже:

    Intent i = new Intent(SettingsActivity.this, LoginActivity.class);
    i.addFlags(IntentCompat.FLAG_ACTIVITY_CLEAR_TASK
            | Intent.FLAG_ACTIVITY_NEW_TASK);
    startActivity(i);

Это сработало для меня:

     // After logout redirect user to Loing Activity
    Intent i = new Intent(_context, MainActivity.class);
    // Closing all the Activities
    i.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
    i.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK);

    // Add new Flag to start new Activity
    i.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);

    // Staring Login Activity
    _context.startActivity(i);

Начните свою деятельность с StartActivityForResult, и пока вы выходите из системы, установите свой результат и в соответствии с вашим результатом завершите свою деятельность

intent.setFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP);
startActivityForResult(intent, BACK_SCREEN);

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    switch (requestCode) {
    case BACK_SCREEN:
        if (resultCode == REFRESH) {
            setResult(REFRESH);
            finish();
        }
        break;
    }
@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
    if (keyCode == KeyEvent.KEYCODE_BACK) {
        AlertDialog.Builder builder = new AlertDialog.Builder(this);
        AlertDialog alertDialog = builder.create();

        alertDialog
                .setTitle((String) getResources().getText(R.string.home));
        alertDialog.setMessage((String) getResources().getText(
                R.string.gotoHome));
        alertDialog.setButton(DialogInterface.BUTTON_POSITIVE, "Yes",
                new DialogInterface.OnClickListener() {
                    public void onClick(DialogInterface dialog,
                            int whichButton) {

                        setResult(REFRESH);
                        finish();
                    }

                });

        alertDialog.setButton(DialogInterface.BUTTON_NEGATIVE, "No",
                new DialogInterface.OnClickListener() {
                    public void onClick(DialogInterface dialog,
                            int whichButton) {
                    }
                });
        alertDialog.show();
        return true;
    } else
        return super.onKeyDown(keyCode, event);

}

Предоставленное @doreamon решение отлично работает во всех случаях, кроме одного:

Если после входа в систему пользователь экрана Killing Login перешел прямо на средний экран. например В потоке A-> B-> C перемещайтесь как: Вход в систему -> B -> C -> Нажмите ярлык на главную. Использование FLAG_ACTIVITY_CLEAR_TOP очищает только активность C, поскольку Home (A) не находится в истории стека. Нажатие Back на экране A приведет нас обратно к B.

Чтобы решить эту проблему, мы можем сохранить стек действий (Arraylist), и при нажатии кнопки home мы должны убить все действия в этом стеке.

Это возможно, установив флаг в SharedPreferences или в Application Activity.

При запуске приложения (на экране-заставке) установите флаг = false; В событии Logout Click просто установите флаг true, а в OnResume () каждого действия проверьте, установлен ли флаг true, затем вызовите finish ().

Работает как часы :)

при нажатии кнопки «Выход» вы можете вызвать это

private void GoToPreviousActivity() {
    setResult(REQUEST_CODE_LOGOUT);
    this.finish();
}

onActivityResult () предыдущего действия вызовите этот код еще раз, пока не завершите все действия.

Один из вариантов состоит в том, чтобы onCreate каждого действия проверял состояние входа в систему и finish (), если вход не выполнен. Мне не нравится этот вариант, так как кнопка «Назад» по-прежнему будет доступна для использования, позволяя возвращаться назад, когда действия закрываются.

Что вы хотите сделать, так это вызвать logout () и finish () в ваших методах onStop () или onPause (). Это заставит Android вызывать onCreate () при возобновлении активности, поскольку она больше не будет находиться в стеке активности. Затем сделайте, как вы говорите, в onCreate () проверьте статус входа в систему и перейдите к экрану входа в систему, если вы не вошли в систему.

Еще одна вещь, которую вы можете сделать, - это проверить статус входа в систему в onResume (), и, если вы не вошли в систему, finish () и запустить активность входа в систему.