Po wylogowaniu wyczyść stos historii aktywności, zapobiegając otwieraniu przycisku „wstecz” tylko dla zalogowanych działań

Wszystkie działania w mojej aplikacji wymagają zalogowania użytkownika, aby wyświetlić. Użytkownicy mogą wylogować się z niemal każdej aktywności. Jest to wymóg aplikacji. W dowolnym momencie, jeśli użytkownik wyloguje się, chcę wysłać użytkownika do Loginu Activity. W tym momencie chcę, aby ta aktywność była na dole stosu historii, więc naciśnięcie przycisku „wstecz” powoduje powrót użytkownika do ekranu głównego Androida.

Widziałem to pytanie zadane w kilku różnych miejscach, na wszystkie odpowiedziały podobne odpowiedzi (które tutaj zarysowuję), ale chcę je zadać tutaj, aby zebrać opinie.

Próbowałem otworzyć działanie logowania, ustawiając jego Intentflagi, FLAG_ACTIVITY_CLEAR_TOPktóre wydają się robić tak, jak opisano w dokumentacji, ale nie osiągam celu, jakim jest umieszczenie działania logowania na dole stosu historii i uniemożliwienie użytkownikowi powrotu do poprzedniej strony do wcześniej zarejestrowanych zalogowanych działań. Próbowałem również użyć android:launchMode="singleTop"do zalogowania się w manifeście, ale to również nie osiąga mojego celu (i wydaje się, że i tak nie ma żadnego efektu).

Uważam, że muszę wyczyścić stos historii lub zakończyć wszystkie wcześniej otwarte działania.

Jedną z opcji jest onCreatestatus kontroli każdego działania zalogowany, a finish()jeśli nie zalogowany. Nie podoba mi się ta opcja, ponieważ przycisk Wstecz będzie nadal dostępny do użycia, nawigując wstecz w miarę zamykania się działań.

Kolejną opcją jest utrzymanie a LinkedListodniesień do wszystkich otwartych działań, które są dostępne statycznie zewsząd (być może przy użyciu słabych odniesień). Po wylogowaniu uzyskam dostęp do tej listy i powtarzam wszystkie wcześniej otwarte działania, wywołując finish()każdą z nich. Prawdopodobnie zacznę wkrótce wdrażać tę metodę.

Wolę jednak użyć pewnych Intentsztuczek z flagą, aby to osiągnąć. Z przyjemnością stwierdzę, że mogę spełnić wymagania mojej aplikacji bez konieczności korzystania z jednej z dwóch opisanych powyżej metod.

Czy istnieje sposób na osiągnięcie tego poprzez użycie Intentlub manifestowanie ustawień, czy też moja druga opcja, utrzymywanie LinkedListotwartych działań, jest najlepszą opcją? Czy jest jeszcze inna opcja, którą całkowicie pomijam?

Mogę zaproponować Ci inne podejście IMHO bardziej solidne. Zasadniczo musisz wysłać komunikat wylogowania do wszystkich swoich działań, które muszą pozostać w stanie zalogowania. Możesz więc użyć sendBroadcasti zainstalować BroadcastReceiverwe wszystkich swoich działaniach. Coś takiego:

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

Odbiorca (zabezpieczone działanie):

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 **//
}

Wydaje się, że nowy programista dla Androida spędza dzień na badaniu tego problemu i czytaniu wszystkich wątków StackOverflow. Jestem teraz nowo wtajemniczony i zostawiam tutaj ślad mojego skromnego doświadczenia, aby pomóc przyszłemu pielgrzymowi.

Po pierwsze, nie ma oczywistego ani bezpośredniego sposobu, aby to zrobić na podstawie moich badań. (as of September 2012).Można by pomyśleć, że można to zrobić w prosty sposób, startActivity(new Intent(this, LoginActivity.class), CLEAR_STACK)ale nie .

MOŻESZ zrobić startActivity(new Intent(this, LoginActivity.class))z FLAG_ACTIVITY_CLEAR_TOP- a to spowoduje, że framework przeszuka stos, odszuka wcześniejszą instancję LoginActivity, odtworzy ją i wyczyści resztę stosu (w górę). A ponieważ Login prawdopodobnie znajduje się na dole stosu, masz teraz pusty stos, a przycisk Wstecz tylko wychodzi z aplikacji.

ALE - działa to tylko wtedy, gdy wcześniej pozostawiłeś żywy egzemplarz LoginActivity u podstawy stosu. Jeśli, podobnie jak wielu programistów, wybrałeś finish()to LoginActivitypo pomyślnym zalogowaniu się użytkownika, nie jest on już oparty na stosie i FLAG_ACTIVITY_CLEAR_TOPsemantyka nie ma zastosowania ... w końcu tworzysz nowyLoginActivity na istniejącym stosie. Co prawie na pewno NIE jest tym, czego chcesz (dziwne zachowanie, w którym użytkownik może „cofnąć się” po zalogowaniu do poprzedniego ekranu).

Więc jeśli już finish()to LoginActivityzrobiłeś, musisz zastosować jakiś mechanizm, aby wyczyścić swój stos, a następnie rozpocząć nowy LoginActivity. Wydaje się, że odpowiedź @doreamonw tym wątku jest najlepszym rozwiązaniem (przynajmniej moim skromnym okiem):

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

Podejrzewam, że skomplikowane konsekwencje pozostawienia przy życiu LoginActivity powodują wiele zamieszania.

Powodzenia.

AKTUALIZACJA

super finishAffinity()metoda pomoże zredukować kod, ale osiągnie to samo. Zakończy bieżącą aktywność, a także wszystkie działania na stosie, użyj, getActivity().finishAffinity()jeśli jesteś we fragmencie.

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

ORYGINALNA ODPOWIEDŹ

Załóżmy, że LoginActivity -> HomeActivity -> ... -> SettingsActivity call callOut ():

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

HomeActivity:

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

To działa dla mnie, mam nadzieję, że to też jest pomocne. :)

Jeśli używasz interfejsu API 11 lub nowszego, możesz spróbować: - FLAG_ACTIVITY_CLEAR_TASKwydaje się, że rozwiązuje dokładnie ten sam problem. Oczywiście tłum przed API 11 musiałby użyć kombinacji sprawdzania wszystkich działań dodatkowo, jak sugeruje @doreamon, lub innej sztuczki.

(Uwaga: aby z tego skorzystać, musisz przekazać 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();

Spędziłem nad tym także kilka godzin ... i zgadzam się, że FLAG_ACTIVITY_CLEAR_TOP brzmi tak, jakbyś chciał: wyczyść cały stos, z wyjątkiem uruchomionej aktywności, więc przycisk Wstecz wychodzi z aplikacji. Jednak, jak wspomniał Mike Repass , FLAG_ACTIVITY_CLEAR_TOP działa tylko wtedy, gdy aktywność, którą uruchamiasz, znajduje się już na stosie; gdy działania nie ma, flaga nic nie robi.

Co robić? Umieść uruchamiane działanie w stosie za pomocą FLAG_ACTIVITY_NEW_TASK , co powoduje, że działanie to rozpoczyna nowe zadanie na stosie historii. Następnie dodaj flagę FLAG_ACTIVITY_CLEAR_TOP.

Teraz, gdy FLAG_ACTIVITY_CLEAR_TOP pójdzie znaleźć nową aktywność na stosie, będzie tam i zostanie podniesiona, zanim wszystko inne zostanie wyczyszczone.

Oto moja funkcja wylogowania; parametr View to przycisk, do którego dołączona jest funkcja.

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

Wiele odpowiedzi. Być może ten pomoże również-

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

Wersja Kotlin

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

Użyj tego, to powinno ci pomóc. Nieznacznie zmodyfikowana odpowiedź 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);

Zaakceptowane rozwiązanie jest nieprawidłowe, ma problemy, ponieważ używanie odbiornika nie jest dobrym pomysłem na ten problem. Jeśli twoja aktywność wywołała już metodę onDestroy (), nie otrzymasz odbiornika. Najlepszym rozwiązaniem jest ustawienie wartości logicznej na wspólnych preferencjach i sprawdzenie jej w metodzie onCreate () Twojej aktywności. Jeśli nie należy go wywoływać, gdy użytkownik nie jest zalogowany, zakończ działanie. Oto przykładowy kod do tego. Tak prosty i działa w każdych warunkach.

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

Czasami finish() nie działa

Rozwiązałem ten problem z

finishAffinity()

Sugerowałbym inne podejście do tego pytania. Może nie jest to najbardziej wydajny, ale myślę, że jest najłatwiejszy do zastosowania i wymaga bardzo małego kodu. Zapisanie następnego kodu w pierwszej aktywności (logowanie aktywności, w moim przypadku) nie pozwoli użytkownikowi powrócić do poprzednio uruchomionych działań po wylogowaniu.

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

Zakładam, że funkcja LoginActivity jest zakończona zaraz po zalogowaniu użytkownika, aby nie mógł do niej wrócić później, naciskając przycisk Wstecz. Zamiast tego użytkownik musi nacisnąć przycisk wylogowania w aplikacji, aby poprawnie się wylogować. To, co zastosowałby ten przycisk wylogowania, to prosta intencja:

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

Wszystkie sugestie są mile widziane.

Wybrana odpowiedź jest sprytna i podchwytliwa. Oto jak to zrobiłem:

LoginActivity jest główną aktywnością zadania, ustaw android: noHistory = "true" w Manifest.xml; Załóżmy, że chcesz się wylogować z Ustawień Aktywności, możesz to zrobić w następujący sposób:

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

Oto rozwiązanie, które wymyśliłem w mojej aplikacji.

W mojej LoginActivity, po pomyślnym przetworzeniu loginu, uruchamiam następny w różny sposób, w zależności od poziomu 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);
}

Następnie w metodzie onActivityForResult mojej LoginActivity:

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

Wreszcie po przetworzeniu wylogowania w innym działaniu:

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

W przypadku Gingerbread sprawia, że ​​jeśli kliknę przycisk Wstecz w MainActivity, LoginActivity zostanie natychmiast ukryty. W Honeycomb i nowszych właśnie kończę LoginActivity po przetworzeniu loginu i jest on poprawnie odtwarzany po przetworzeniu loginu.

To działało dla mnie:

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

Rozpocznij swoją aktywność za pomocą StartActivityForResult i podczas wylogowywania ustaw swój wynik i zgodnie z nim zakończ swoją aktywność

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

}

Podane rozwiązanie @doreamon działa dobrze we wszystkich przypadkach oprócz jednego:

Jeśli po zalogowaniu użytkownik ekranu Killing Login przejdzie bezpośrednio do środkowego ekranu. np. W strumieniu A-> B-> C nawiguj w następujący sposób: Zaloguj się -> B -> C -> Naciśnij skrót do strony głównej. Użycie FLAG_ACTIVITY_CLEAR_TOP usuwa tylko aktywność C, ponieważ strona główna (A) nie znajduje się w historii stosu. Naciśnięcie przycisku Wstecz na ekranie doprowadzi nas z powrotem do B.

Aby rozwiązać ten problem, możemy zachować stos aktywności (Arraylist), a gdy naciśniesz przycisk Home, musimy zabić wszystkie działania na tym stosie.

Jest to możliwe poprzez zarządzanie flagą w SharedPreferences lub w Aktywności aplikacji.

Po uruchomieniu aplikacji (na ekranie powitalnym) ustaw flag = false; W przypadku zdarzenia Logout Click wystarczy ustawić flagę true, a w OnResume () każdej aktywności sprawdzić, czy flaga jest true, a następnie wywołać metodę finish ().

To działa jak urok :)

po kliknięciu Wyloguj możesz to nazwać

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

onActivityResult () z poprzedniego działania wywołuje ten kod ponownie, dopóki nie zakończysz wszystkich działań.

Jedną z opcji jest posiadanie statusu zalogowanej kontroli każdego działania i zakończenie (), jeśli nie jest zalogowany. Nie podoba mi się ta opcja, ponieważ przycisk Wstecz będzie nadal dostępny do użycia, nawigując wstecz w miarę zamykania się działań.

To, co chcesz zrobić, to wywołanie funkcji wylogowania () i zakończenia () w metodach onStop () lub onPause (). Zmusi to Androida do wywołania funkcji onCreate () po przywróceniu działania, ponieważ nie będzie go już na stosie działania. Następnie rób, co mówisz, w onCreate () sprawdź status zalogowanego użytkownika i przejdź do ekranu logowania, jeśli nie jesteś zalogowany.

Inną rzeczą, którą możesz zrobić, to sprawdzić status zalogowanego w onResume (), a jeśli nie zalogowany, zakończ () i uruchom aktywność logowania.