Pada saat logout, kosongkan tumpukan Riwayat aktivitas, cegah tombol “kembali” dari membuka Aktivitas yang hanya masuk

Semua aktivitas dalam aplikasi saya mengharuskan pengguna untuk masuk untuk melihat. Pengguna dapat keluar dari hampir semua aktivitas. Ini adalah persyaratan aplikasi. Kapan saja jika pengguna log-out, saya ingin mengirim pengguna ke Login Activity. Pada titik ini saya ingin kegiatan ini berada di bagian bawah tumpukan riwayat sehingga menekan tombol "kembali" mengembalikan pengguna ke layar beranda Android.

Saya telah melihat pertanyaan ini menanyakan beberapa tempat yang berbeda, semua menjawab dengan jawaban yang sama (yang saya uraikan di sini), tetapi saya ingin mengajukannya di sini untuk mengumpulkan umpan balik.

Saya sudah mencoba membuka aktivitas Login dengan mengatur Intentbenderanya FLAG_ACTIVITY_CLEAR_TOPyang tampaknya melakukan seperti yang dijelaskan dalam dokumentasi, tetapi tidak mencapai tujuan saya menempatkan aktivitas Login di bagian bawah tumpukan riwayat, dan mencegah pengguna menavigasi kembali untuk aktivitas masuk yang sebelumnya terlihat. Saya juga mencoba menggunakan android:launchMode="singleTop"untuk aktivitas Login di manifes, tetapi ini juga tidak mencapai tujuan saya (dan sepertinya tidak berpengaruh).

Saya percaya saya harus menghapus tumpukan sejarah, atau menyelesaikan semua kegiatan yang sebelumnya dibuka.

Salah satu opsi adalah memiliki onCreatestatus masuk log aktivitas masing-masing , dan finish()jika tidak login. Saya tidak suka opsi ini, karena tombol kembali masih akan tersedia untuk digunakan, menavigasi kembali ketika kegiatan menutup diri.

Opsi berikutnya adalah mempertahankan LinkedListreferensi untuk semua aktivitas terbuka yang dapat diakses secara statis dari mana saja (mungkin menggunakan referensi yang lemah). Pada logout saya akan mengakses daftar ini dan mengulangi semua kegiatan yang sebelumnya dibuka, meminta finish()masing-masing. Saya mungkin akan segera mulai menerapkan metode ini.

Saya lebih suka menggunakan beberapa Intentflag trickery untuk melakukan hal ini. Saya akan sangat senang menemukan bahwa saya dapat memenuhi persyaratan aplikasi saya tanpa harus menggunakan salah satu dari dua metode yang telah saya uraikan di atas.

Apakah ada cara untuk mencapai ini dengan menggunakan Intentatau memanifestasikan pengaturan, atau apakah opsi kedua saya, mempertahankan LinkedListaktivitas terbuka adalah pilihan terbaik? Atau ada opsi lain yang sepenuhnya saya abaikan?

Saya dapat menyarankan Anda pendekatan lain IMHO lebih kuat. Pada dasarnya Anda perlu menyiarkan pesan logout ke semua Aktivitas Anda yang perlu tetap dalam status login. Jadi, Anda dapat menggunakan sendBroadcastdan menginstal BroadcastReceiverdi semua aktivitas Anda. Sesuatu seperti ini:

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

Penerima (Aktivitas aman):

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

Tampaknya sebuah ritus perikop yang seorang programmer Android baru habiskan sehari untuk meneliti masalah ini dan membaca semua utas StackOverflow ini. Saya sekarang baru diinisiasi dan meninggalkan jejak pengalaman sederhana saya di sini untuk membantu peziarah masa depan.

Pertama, tidak ada cara yang jelas atau langsung untuk melakukan ini per penelitian saya (as of September 2012).Anda akan berpikir Anda bisa sederhana startActivity(new Intent(this, LoginActivity.class), CLEAR_STACK)tetapi tidak .

Anda BISA lakukan startActivity(new Intent(this, LoginActivity.class))dengan FLAG_ACTIVITY_CLEAR_TOP- dan ini akan menyebabkan kerangka kerja untuk mencari ke bawah tumpukan, menemukan contoh asli Anda sebelumnya dari LoginActivity, membuatnya kembali dan menghapus sisa tumpukan (ke atas). Dan karena Login mungkin ada di bagian bawah tumpukan, Anda sekarang memiliki tumpukan kosong dan tombol Kembali baru saja keluar dari aplikasi.

TETAPI - ini hanya berfungsi jika Anda sebelumnya membiarkan instance asli LoginActivity hidup di dasar tumpukan Anda. Jika, seperti banyak programmer, Anda memilih finish()itu LoginActivitysetelah pengguna berhasil masuk, maka itu tidak lagi di dasar tumpukan dan FLAG_ACTIVITY_CLEAR_TOPsemantik tidak berlaku ... Anda akhirnya membuat yang baru LoginActivitydi atas tumpukan yang ada. Yang hampir pasti BUKAN apa yang Anda inginkan (perilaku aneh di mana pengguna dapat 'kembali' keluar dari login ke layar sebelumnya).

Jadi, jika sebelumnya Anda telah finish()melakukannya LoginActivity, Anda perlu mengejar beberapa mekanisme untuk membersihkan tumpukan Anda dan kemudian memulai yang baru LoginActivity. Sepertinya jawaban @doreamondi utas ini adalah solusi terbaik (setidaknya bagi mata saya yang rendah hati):

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

Saya sangat curiga bahwa implikasi rumit dari apakah Anda membiarkan LoginActivity hidup-hidup menyebabkan banyak kebingungan ini.

Semoga berhasil.

MEMPERBARUI

finishAffinity()metode super akan membantu mengurangi kode tetapi mencapai hal yang sama. Ini akan menyelesaikan aktivitas saat ini serta semua aktivitas di tumpukan, gunakan getActivity().finishAffinity()jika Anda berada dalam sebuah fragmen.

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

JAWABAN ASLI

Asumsikan LoginActivity -> HomeActivity -> ... -> SettingsActivity panggilan 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();
}

BerandaAktivitas:

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

Ini bekerja untuk saya, semoga bermanfaat bagi Anda juga. :)

Jika Anda menggunakan API 11 atau lebih tinggi, Anda dapat mencoba ini: - FLAG_ACTIVITY_CLEAR_TASKsepertinya mengatasi masalah yang Anda alami. Jelas kerumunan pra-API 11 harus menggunakan beberapa kombinasi dari semua aktivitas untuk memeriksa tambahan, seperti yang disarankan @doreamon, atau tipuan lainnya.

(Perhatikan juga: untuk menggunakan ini, Anda harus masuk 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();

Saya menghabiskan beberapa jam untuk hal ini juga ... dan setuju bahwa FLAG_ACTIVITY_CLEAR_TOP terdengar seperti yang Anda inginkan: kosongkan seluruh tumpukan, kecuali untuk aktivitas yang diluncurkan, jadi tombol Kembali keluar dari aplikasi. Namun seperti yang disebutkan Mike Repass , FLAG_ACTIVITY_CLEAR_TOP hanya berfungsi ketika aktivitas yang Anda luncurkan sudah ada di tumpukan; ketika aktivitas tidak ada di sana, bendera tidak melakukan apa-apa.

Apa yang harus dilakukan? Letakkan aktivitas yang diluncurkan di tumpukan dengan FLAG_ACTIVITY_NEW_TASK , yang menjadikan aktivitas itu sebagai awal dari tugas baru di tumpukan riwayat. Kemudian tambahkan flag FLAG_ACTIVITY_CLEAR_TOP.

Sekarang, ketika FLAG_ACTIVITY_CLEAR_TOP pergi untuk mencari aktivitas baru di stack, itu akan ada di sana dan ditarik sebelum semua yang lain dihapus.

Inilah fungsi logout saya; parameter View adalah tombol yang dilampirkan fungsi.

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

Banyak jawaban. Mungkin yang ini juga akan membantu-

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

Versi Kotlin-

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

Gunakan ini harus membantu Anda. Jawaban xbakesx sedikit dimodifikasi.

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

Solusi yang diterima tidak benar, ia memiliki masalah karena menggunakan penerima siaran bukan ide yang baik untuk masalah ini. Jika aktivitas Anda telah memanggil metode onDestroy (), Anda tidak akan mendapatkan penerima. Solusi terbaik adalah memiliki nilai boolean pada preferensi bersama Anda, dan memeriksanya dalam metode onCreate () aktivitas Anda. Jika tidak boleh dipanggil saat pengguna tidak masuk, maka selesaikan aktivitas. Berikut ini contoh kode untuk itu. Sangat sederhana dan berfungsi untuk setiap kondisi.

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

Beberapa waktu finish() tidak berfungsi

Saya telah memecahkan masalah itu dengan

finishAffinity()

Saya menyarankan pendekatan yang berbeda untuk pertanyaan ini. Mungkin ini bukan yang paling efisien, tapi saya pikir ini yang paling mudah untuk diterapkan dan hanya membutuhkan sedikit kode. Menulis kode berikutnya dalam aktivitas pertama Anda (aktivitas login, dalam kasus saya) tidak akan membiarkan pengguna kembali ke aktivitas yang diluncurkan sebelumnya setelah keluar.

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

Saya berasumsi bahwa LoginActivity selesai tepat setelah pengguna masuk, sehingga ia tidak dapat kembali lagi nanti dengan menekan tombol kembali. Sebagai gantinya, pengguna harus menekan tombol logout di dalam aplikasi agar dapat logout dengan benar. Apa yang diterapkan tombol keluar ini adalah maksud sederhana sebagai berikut:

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

Semua saran dipersilahkan.

Jawaban yang dipilih cerdas dan rumit. Begini cara saya melakukannya:

LoginActivity adalah aktivitas root dari tugas, set android: noHistory = "true" untuk itu di Manifest.xml; Katakanlah Anda ingin keluar dari SettingsActivity, Anda dapat melakukannya seperti di bawah ini:

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

Inilah solusi yang saya buat di aplikasi saya.

Di LoginActivity saya, setelah berhasil memproses login, saya memulai yang berikutnya tergantung pada level 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);
}

Kemudian dalam metode onActivityForResult LoginActivity saya:

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

Akhirnya, setelah memproses logout di Aktivitas lain:

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

Ketika di Gingerbread, membuatnya jadi jika saya menekan tombol kembali dari MainActivity, LoginActivity segera disembunyikan. Di Honeycomb dan yang lebih baru, saya baru saja menyelesaikan LoginActivity setelah memproses login dan dibuat kembali dengan benar setelah memproses logout.

Ini bekerja untuk saya:

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

Mulai aktivitas Anda dengan StartActivityForResult dan saat Anda logout atur hasil Anda dan sesuai dengan hasil Anda selesaikan aktivitas Anda

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

}

Solusi @doreamon yang disediakan berfungsi dengan baik untuk semua kasus kecuali satu:

Jika Setelah login, pengguna layar Killing Login menavigasi langsung ke layar tengah. mis. Dalam aliran A-> B-> C, navigasikan seperti: Login -> B -> C -> Tekan pintasan ke rumah. Menggunakan FLAG_ACTIVITY_CLEAR_TOP hanya menghapus aktivitas C, Karena Beranda (A) tidak ada di riwayat tumpukan. Menekan Kembali pada layar A akan membawa kita kembali ke B.

Untuk mengatasi masalah ini, Kami dapat menyimpan setumpuk aktivitas (Arraylist) dan ketika rumah ditekan, kami harus membunuh semua aktivitas dalam tumpukan ini.

Itu dimungkinkan dengan mengelola bendera di SharedPreferences atau dalam Aktivitas Aplikasi.

Pada awal aplikasi (pada Layar Splash) atur flag = false; Pada acara Klik Keluar, tetapkan flag true dan di OnResume () dari setiap aktivitas, periksa apakah flag benar, lalu panggil finish ().

Ini bekerja seperti pesona :)

pada klik Logout Anda dapat memanggil ini

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

onActivityResult () dari Aktivitas sebelumnya memanggil kode di atas ini lagi sampai Anda menyelesaikan semua aktivitas.

Salah satu opsi adalah meminta status aktivitas login onCreate masing-masing aktivitas, dan selesai () jika tidak login. Saya tidak suka opsi ini, karena tombol kembali masih akan tersedia untuk digunakan, menavigasi kembali ketika kegiatan menutup diri.

Yang ingin Anda lakukan adalah panggilan keluar () dan selesai () pada metode onStop () atau onPause () Anda. Ini akan memaksa Android untuk memanggil onCreate () saat aktivitas dijalankan kembali karena ia tidak akan memilikinya lagi di tumpukan aktivitasnya. Kemudian lakukan seperti yang Anda katakan, di onCreate () periksa status masuk dan teruskan ke layar masuk jika tidak masuk.

Hal lain yang dapat Anda lakukan adalah memeriksa status masuk di onResume (), dan jika tidak masuk, selesai () dan luncurkan aktivitas masuk.