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

235

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?

skyler
źródło

Odpowiedzi:

213

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 **//
}
Francesco Laurita
źródło
27
@Christopher, każde działanie rejestruje się w transmisji, gdy zostanie utworzone. Kiedy przejdzie do tła (tj. Nowa aktywność znajdzie się na górze stosu), jego onStop () zostanie wywołany, ale nadal może odbierać transmisje. Musisz tylko upewnić się, że wywołujesz unregisterReceiver () w onDestroy () zamiast w onStop ().
Russell Davis
9
Czy to działa, jeśli system operacyjny zamknął jakieś działanie na stosie w celu odzyskania pamięci? To znaczy. czy system uzna, że ​​jest naprawdę skończony po wysłaniu powyższej transmisji, i nie odtworzy go po naciśnięciu przycisku Wstecz?
Jan Żankowski,
5
Chociaż wydaje się to eleganckim rozwiązaniem, należy zauważyć, że nie jest to synchroniczne.
Che Jami,
34
Przyjemne rozwiązanie, ale zamiast rejestrowania odbiornika Broadcast zgodnie z powyższym kodem należy użyć LocalBroadcastManager.getInstance (this) .registerReceiver (...) i LocalBroadcastManager.getInstance (this) .unregisterReceiver (..) . Otherwiser twoja aplikacja może odbierać zamiary z dowolnej innej aplikacji (problem bezpieczeństwa)
Uku Loskit
5
@Warlock Masz rację. Pułapką takiego podejścia jest zniszczenie przez system działania z tylnego stosu (może się to zdarzyć z różnych powodów, takich jak zanotowany scenariusz braku pamięci). W takim przypadku instancja działania nie będzie w pobliżu, aby odebrać transmisję. Ale system nadal będzie nawigował wstecz przez to działanie, odtwarzając je ponownie. Można to przetestować / odtworzyć, włączając ustawienie programisty „Don't Keep Activities”
Eric Schlenz
151

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.

Mike Repass
źródło
5
Dobra odpowiedź. Sztuczka FLAG_ACTIVITY_CLEAR_TOP, z której radzi się większość osób, po prostu nie działa, jeśli zakończysz logowanie.
Konsumierer,
Dzięki za odpowiedź. Innym scenariuszem jest sytuacja, w której istnieje sesja (np. Fb), nawet nie wywołujemy aktywności związanej z logowaniem, więc nie ma sensu logować się na stosie. Zatem wyżej wspomniane podejście jest bezużyteczne.
Prashanth Debbadwar
118

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. :)

thanhbinh84
źródło
1
Myślę, że twoje rozwiązanie zakłada, że ​​użytkownik kliknie signOut i wróci do tylko jednego działania (HomeActivity). Co jeśli masz 10 działań na stosie?
IgorGanapolsky
11
Jeśli masz 10 działań na szczycie HomeActivity, flaga FLAG_ACTIVITY_CLEAR_TOP pomoże wyczyścić je wszystkie.
thanhbinh84,
1
Może to działać tylko wtedy, gdy uruchamiając HomeActivity, otrzymasz OnCreate of HomeActivity. Samo rozpoczęcie aktywności domowej niekoniecznie ją odtworzy, chyba że zostało już zakończone lub zniszczone. Jeśli HomeActivity nie będzie musiało zostać odtworzone, OnCreate nie zostanie wywołany, a po wylogowaniu będziesz siedział przy aktywności domowej.
topwik
1
Jest to możliwe rozwiązanie, które wymaga znacznie mniej kodowania prostej (dla użytkownika) funkcji, takiej jak wylogowanie.
Subin Sebastian,
2
Flaga Intent.FLAG_ACTIVITY_CLEAR_TOP pomaga wyczyścić wszystkie działania, w tym HomeActivity, dlatego metoda onCreate () zostanie wywołana po ponownym uruchomieniu tego działania.
thanhbinh84,
73

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();
xbakesx
źródło
1
Działa jak urok. Dziękuję Ci bardzo! Gdy opracowuję min API 14, to jedyna rzecz do zaimplementowania.
AndyB
1
Myślę, że nie potrzebujemy FLAG_ACTIVITY_CLEAR_TOP podczas korzystania z tego rozwiązania dla LoginActivity.
Bharat Dodeja
Myślę, że po prostu finish();wykonam zadanie, aby zapobiec powrotowi po wylogowaniu. Po co ustawiać flagi?
Pankaj,
Stwarza to wyjątek Wywołanie startActivity () spoza kontekstu działania wymaga flagi FLAG_ACTIVITY_NEW_TASK
Aman
31

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();
}
Christinac
źródło
1
Nie będzie działać na API <= 10, ponieważ FLAG_ACTIVITY_CLEAR_TASKnie został jeszcze dodany
Youans
1
@christinac Mówisz o FLAG_ACTIVITY_CLEAR_TOP, a Twój fragment kodu ma FLAG_ACTIVITY_CLEAR_TASK; co jest wtedy ważne?
Marian Paździoch,
10

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()
Gulszan
źródło
4

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);
Mohamed Ibrahim
źródło
4

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;
}
Yekmer Simsek
źródło
1
Minęły lata, ale wierzę, że zrobiłem oba. Każde działanie rozszerzało LoggedInActivity, które sprawdzało status zalogowanego użytkownika w funkcji onCreate (). LoggedInActivity również nasłuchiwało transmisji „użytkownik wylogowany” i robił wszystko, co musiał, aby na to odpowiedzieć.
skyler
2
najprawdopodobniej powinieneś umieścić checkAuthStatus w metodzie onResume(). Ponieważ po naciśnięciu przycisku Wstecz działanie jest bardziej prawdopodobne, że zostanie wznowione niż utworzone.
maysi
1
@maysi Dzięki za sugestię, tak, ten przycisk wstecz również będzie działał poprawnie, zaktualizowałem wpis
Yekmer Simsek
4

Czasami finish() nie działa

Rozwiązałem ten problem z

finishAffinity()

AJay
źródło
3

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.

Zero
źródło
2

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);
t-gao
źródło
2

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.

Seastland
źródło
To nie działa dla mnie. W moim przypadku użyłem fragmentaktyki. Metoda Onactivityresult nie jest wywoływana.
Mohamed Ibrahim,
1

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);
Preetansh
źródło
Czy mógłby Pan uściślić swoją odpowiedź, dodając nieco więcej opisu oferowanego rozwiązania?
abarisone
0

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

}
Eby
źródło
0

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.

Surendra Kumar
źródło
0

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

MrDumb
źródło
0

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ń.

Mak
źródło
1
Oznacza to, że musi on przechodzić przez wszystkie działania liniowo, zamiast nadawać wykończenie () naraz?
IgorGanapolsky
@Igor G. tak, jest to alternatywny sposób na ukończenie sekwencyjnie
Mak
-1

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.

Ricardo Villamil
źródło
Wolałbym nie wylogowywać się przy każdej pauzie lub zatrzymaniu aktywności. Ponadto aplikacja inicjuje wylogowanie lub logowanie, więc nie muszę sprawdzać, czy naprawdę się zalogowałem.
skyler
@Ricardo: czy twoje rozwiązanie nie wymaga BroadcastReceiver?
IgorGanapolsky