Cara keluar dari aplikasi android secara terprogram

Saya menemukan beberapa kode untuk keluar dari aplikasi Android secara terprogram. Dengan memanggil salah satu dari kode berikut di onDestroy () apakah itu akan sepenuhnya berhenti dari aplikasi?

1. System.runFinalizersOnExit(true)
   (ATAU)
2. android.os.Process.killProcess(android.os.Process.myPid());

Saya tidak ingin menjalankan aplikasi saya di latar belakang setelah mengklik tombol berhenti. Tolong sarankan saya dapat menggunakan salah satu dari kode ini untuk keluar dari aplikasi saya? Jika demikian, kode mana yang dapat saya gunakan? Apakah ini cara yang baik untuk keluar dari aplikasi di Android?

Karena API 16 Anda dapat menggunakan metode finishAffinity, yang tampaknya cukup dekat dengan menutup semua aktivitas terkait dengan namanya dan deskripsi Javadoc:

this.finishAffinity();

Selesaikan aktivitas ini dan juga semua aktivitas tepat di bawahnya dalam tugas saat ini yang memiliki afinitas yang sama. Ini biasanya digunakan ketika aplikasi dapat diluncurkan ke tugas lain (seperti dari ACTION_VIEW jenis konten yang dimengerti) dan pengguna telah menggunakan navigasi atas untuk beralih dari tugas saat ini dan ke tugasnya sendiri. Dalam hal ini, jika pengguna telah menavigasi ke aktivitas lain dari aplikasi kedua, semua itu harus dihapus dari tugas asli sebagai bagian dari pengalih tugas.

Perhatikan bahwa penyelesaian ini tidak memungkinkan Anda untuk memberikan hasil ke aktivitas sebelumnya, dan pengecualian akan dilemparkan jika Anda mencoba melakukannya.

Karena API 21 Anda dapat menggunakan perintah yang sangat mirip

finishAndRemoveTask();

Selesaikan semua aktivitas dalam tugas ini dan hapus dari daftar tugas terbaru.

getActivity().finish();
System.exit(0);

ini adalah cara terbaik untuk keluar dari aplikasi Anda. !!!

Solusi terbaik untuk saya.

finishAffinity();

System.exit(0);

Jika Anda hanya akan menggunakan finishAffinity();tanpa System.exit(0);aplikasi Anda akan berhenti tetapi memori yang dialokasikan masih akan digunakan oleh ponsel Anda, jadi ... jika Anda ingin aplikasi yang bersih dan benar-benar keluar, gunakan keduanya.

Ini adalah metode paling sederhana dan bekerja di mana saja, keluar dari aplikasi secara nyata, Anda dapat memiliki banyak aktivitas yang dibuka masih akan berhenti semua tanpa masalah.

contoh pada klik tombol

public void exitAppCLICK (View view) {

    finishAffinity();
    System.exit(0);

}

atau jika Anda menginginkan sesuatu yang baik, misalnya dengan dialog peringatan dengan 3 tombol YA TIDAK dan BATAL

// alertdialog for exit the app
AlertDialog.Builder alertDialogBuilder = new AlertDialog.Builder(this);

// set the title of the Alert Dialog
alertDialogBuilder.setTitle("your title");

// set dialog message
alertDialogBuilder
        .setMessage("your message")
        .setCancelable(false)
        .setPositiveButton("YES"),
                new DialogInterface.OnClickListener() {
                    public void onClick(DialogInterface dialog,
                                        int id) {
                        // what to do if YES is tapped
                        finishAffinity();
                        System.exit(0);
                    }
                })

        .setNeutralButton("CANCEL"),
                new DialogInterface.OnClickListener() {
                    public void onClick(DialogInterface dialog,
                                        int id) {
                        // code to do on CANCEL tapped
                        dialog.cancel();
                    }
                })

        .setNegativeButton("NO"),
                new DialogInterface.OnClickListener() {
                    public void onClick(DialogInterface dialog,
                                        int id) {
                        // code to do on NO tapped
                        dialog.cancel();
                    }
                });

AlertDialog alertDialog = alertDialogBuilder.create();

alertDialog.show();

Tolong pikirkan sangat keras jika Anda perlu mematikan aplikasi: mengapa tidak membiarkan OS mencari tahu di mana dan kapan untuk membebaskan sumber daya?

Kalau tidak, jika Anda benar-benar yakin, gunakan

finish();

Sebagai reaksi terhadap komentar @dave appleton: Hal pertama baca kombo pertanyaan / jawaban besar @ gabriel yang diposting: Apakah berhenti dari aplikasi tidak disukai?

Sekarang dengan asumsi kita memiliki itu, pertanyaan di sini masih memiliki jawaban, adalah kode yang Anda butuhkan jika Anda melakukan sesuatu dengan berhenti finish(). Jelas Anda dapat memiliki lebih dari satu kegiatan dll, tetapi bukan itu intinya. Mari kita jalankan oleh beberapa use case

1. Anda ingin membiarkan pengguna menghentikan semuanya karena penggunaan memori dan "tidak berjalan di latar belakang? Diragukan. Biarkan pengguna menghentikan aktivitas tertentu di latar belakang, tetapi biarkan OS membunuh sumber daya yang tidak diperlukan.
2. Anda ingin pengguna tidak pergi ke aktivitas aplikasi sebelumnya? Baik, konfigurasikan agar tidak, atau Anda perlu opsi tambahan. Jika sebagian besar waktu kembali = aktivitas sebelumnya bekerja, tidak akan pengguna hanya menekan rumah jika dia ingin melakukan sesuatu yang lain?
3. Jika Anda memerlukan semacam pengaturan ulang, Anda dapat mengetahui apakah / bagaimana / dll aplikasi Anda berhenti, dan jika aktivitas Anda kembali menjadi fokus, Anda dapat mengambil tindakan atas hal itu, menampilkan layar baru alih-alih memulai kembali di tempat Anda sebelumnya.

Jadi pada akhirnya, tentu saja, finish()tidak membunuh segalanya, tapi itu masih alat yang saya butuhkan. Jika ada usecase untuk "bunuh semua aktivitas", saya belum menemukannya.

Saya pikir aplikasi itu harus dimatikan dalam beberapa kasus. Misalnya, ada aplikasi yang hanya bisa digunakan setelah login. Aktivitas login memiliki dua tombol, 'login' dan 'cancel'. Ketika Anda mengklik tombol 'batal', itu pasti berarti 'Hentikan aplikasi'. Tidak ada yang ingin aplikasi hidup di latar belakang. Jadi saya setuju bahwa beberapa kasus perlu mematikan aplikasi.

Buat ExitActivitydan nyatakan dalam manifes. Dan panggilan ExitActivity.exit(context)untuk keluar dari aplikasi.

public class ExitActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        finish();
    }

    public static void exit(Context context) {
        Intent intent = new Intent(context, ExitActivity.class);
        intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
        intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK);
        context.startActivity(intent);
    }

}

Tidak ada aplikasi yang berhenti di android , SampleActivity.this.finish (); akan menyelesaikan aktivitas saat ini.

Ketika Anda beralih dari satu aktivitas ke aktivitas lainnya, terus selesaikan aktivitas sebelumnya

Intent homeintent = new Intent(SampleActivity.this,SecondActivity.class);
startActivity(homeintent);
SampleActivity.this.finish();

Pertama-tama, pendekatan ini membutuhkan min Api 16.

Saya akan membagi solusi ini menjadi 3 bagian untuk menyelesaikan masalah ini secara lebih luas.

1. Jika Anda ingin keluar dari aplikasi dalam suatu Aktivitas, gunakan snipet kode ini:

if(Build.VERSION.SDK_INT>=16 && Build.VERSION.SDK_INT<21){
    finishAffinity();
} else if(Build.VERSION.SDK_INT>=21){
    finishAndRemoveTask();
}

2. Jika Anda ingin keluar dari aplikasi dalam kelas non Activity yang memiliki akses ke Activity, gunakan snipet kode ini:

if(Build.VERSION.SDK_INT>=16 && Build.VERSION.SDK_INT<21){
    getActivity().finishAffinity();
} else if(Build.VERSION.SDK_INT>=21){
    getActivity().finishAndRemoveTask();
}

3. Jika Anda ingin keluar dari aplikasi dalam kelas non Activity dan tidak dapat mengakses Aktivitas seperti Layanan, saya sarankan Anda untuk menggunakan BroadcastReceiver. Anda dapat menambahkan pendekatan ini ke semua Kegiatan Anda di proyek Anda.

Buat variabel instance LocalBroadcastManager dan BroadcastReceiver. Anda dapat mengganti getPackageName () + ". Closeapp" jika mau.

LocalBroadcastManager mLocalBroadcastManager;
BroadcastReceiver mBroadcastReceiver = new BroadcastReceiver() {
    @Override
    public void onReceive(Context context, Intent intent) {
        if(intent.getAction().equals(getPackageName()+".closeapp")){
            if(Build.VERSION.SDK_INT>=16 && Build.VERSION.SDK_INT<21){
                finishAffinity();
            } else if(Build.VERSION.SDK_INT>=21){
                finishAndRemoveTask();
            }
        }
    }
};

Tambahkan ini ke metode Kegiatan onCreate ().

mLocalBroadcastManager = LocalBroadcastManager.getInstance(this);
IntentFilter mIntentFilter = new IntentFilter();
mIntentFilter.addAction(getPackageName()+".closeapp");
mLocalBroadcastManager.registerReceiver(mBroadcastReceiver, mIntentFilter);

Juga, jangan lupa untuk memanggil penerima yang tidak terdaftar di metode Aktivitas onDestroy ()

mLocalBroadcastManager.unregisterReceiver(mBroadcastReceiver);

Untuk keluar dari aplikasi, Anda harus mengirim siaran menggunakan LocalBroadcastManager yang saya gunakan di kelas PlayService saya yang memperluas Layanan.

LocalBroadcastManager localBroadcastManager = LocalBroadcastManager.getInstance(PlayService.this);
localBroadcastManager.sendBroadcast(new Intent(getPackageName() + ".closeapp"));

Anda dapat menggunakan finishAndRemoveTask ()dari API 21

public void finishAndRemoveTask ()

Selesaikan semua aktivitas dalam tugas ini dan hapus dari daftar tugas terbaru.

Itu tergantung pada seberapa cepat Anda ingin menutup aplikasi Anda.

Cara aman untuk menutup aplikasi Anda adalah finishAffinity ();

Ini menutup aplikasi Anda setelah semua proses selesai diproses. Ini mungkin perlu waktu. Jika Anda menutup aplikasi dengan cara ini, dan memulai kembali setelah beberapa saat, mungkin aplikasi baru Anda berjalan dalam proses yang sama. Dengan semua proses yang belum selesai dan objek tunggal dari aplikasi lama.

Jika Anda ingin memastikan, bahwa aplikasi Anda ditutup sepenuhnya gunakan System.exit (0);

Ini akan menutup aplikasi Anda dengan segera. Tetapi mungkin saja, Anda merusak file yang telah dibuka aplikasi Anda atau edit pada preferensi bersama tidak selesai. Jadi gunakan ini dengan hati-hati.

Jika Anda menggunakan anjing penjaga dalam kombinasi dengan tugas yang berjalan lama, Anda dapat melihat pengaruh dari berbagai metode.

new ANRWatchDog(2000).setANRListener(new ANRWatchDog.ANRListener() {
    public void onAppNotResponding(ANRError error) {
        MainActivity.this.finishAffinity();
        System.exit(0);
    }
}).start();
for(int i = 0; i < 10; ++i){
    --i;
}

Ini membunuh aplikasi Anda setelah 2 detik tanpa menampilkan dialog PPA atau sesuatu seperti itu. Jika Anda menghapus System.exit (0) , jalankan kode ini dan mulai ulang aplikasi setelah ditutup, Anda akan mengalami beberapa perilaku aneh, karena loop tak berujung masih berjalan.

Anda sebaiknya menggunakan finish()jika Anda berada di Activity, atau getActivity().finish()jika Anda berada di Fragment.

Jika Anda ingin keluar sepenuhnya dari aplikasi, maka gunakan:

getActivity().finish();
System.exit(0);

Cara mudah dan sederhana untuk keluar dari aplikasi

Intent homeIntent = new Intent(Intent.ACTION_MAIN);
homeIntent.addCategory(Intent.CATEGORY_HOME);
homeIntent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
startActivity(homeIntent);

Kami ingin kode yang kuat dan sederhana. Solusi ini berfungsi pada perangkat lama dan perangkat yang lebih baru.

    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
        getActivity().finishAffinity();
    } else{
        getActivity().finish();
        System.exit( 0 );
    }

Saya pikir apa yang Anda cari adalah ini

activity.moveTaskToBack(Boolean nonRoot);

public void quit() {
        int pid = android.os.Process.myPid();
        android.os.Process.killProcess(pid);
        System.exit(0);
    }

Mirip dengan @MobileMateo, tetapi di Kotlin

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
    this.finishAffinity()
} else{
    this.finish()
    System.exit(0)
}

Saya tidak yakin apakah ini disukai atau tidak, tetapi ini adalah bagaimana saya melakukannya ...

Langkah 1 - Saya biasanya memiliki kelas yang berisi metode dan variabel yang ingin saya akses secara global. Dalam contoh ini saya akan menyebutnya kelas "App". Buat variabel Aktivitas statis di dalam kelas untuk setiap aktivitas yang dimiliki aplikasi Anda. Kemudian buat metode statis yang disebut "tutup" yang akan menjalankan finish()metode pada masing-masing variabel Aktivitas jika mereka TIDAK nol . Jika Anda memiliki aktivitas utama / orang tua, tutuplah yang terakhir:

public class App
{
    ////////////////////////////////////////////////////////////////
    // INSTANTIATED ACTIVITY VARIABLES
    ////////////////////////////////////////////////////////////////

        public static Activity activity1;
        public static Activity activity2;
        public static Activity activity3;

    ////////////////////////////////////////////////////////////////
    // CLOSE APP METHOD
    ////////////////////////////////////////////////////////////////

        public static void close()
        {
            if (App.activity3 != null) {App.activity3.finish();}
            if (App.activity2 != null) {App.activity2.finish();}
            if (App.activity1 != null) {App.activity1.finish();}
        }
}

Langkah 2 - di setiap aktivitas Anda, timpa onStart()dan onDestroy()metode. Di onStart(), setel variabel statis di kelas Aplikasi Anda sama dengan " this". Di onDestroy(), set sama dengan null. Misalnya, di kelas "Activity1":

@Override
public void onStart()
{
    // RUN SUPER | REGISTER ACTIVITY AS INSTANTIATED IN APP CLASS

        super.onStart();
        App.activity1 = this;
}

@Override
public void onDestroy()
{
    // RUN SUPER | REGISTER ACTIVITY AS NULL IN APP CLASS

        super.onDestroy();
        App.activity1 = null;
}

Langkah 3 - Ketika Anda ingin menutup aplikasi Anda, cukup telepon App.close()dari mana saja. Semua kegiatan instantiated akan ditutup! Karena Anda hanya menutup kegiatan dan tidak mematikan aplikasi itu sendiri (seperti dalam contoh Anda), Android bebas untuk mengambil alih dari sana dan melakukan pembersihan yang diperlukan.

Sekali lagi, saya tidak tahu apakah ini akan disukai karena alasan apa pun. Jika demikian, saya ingin membaca komentar tentang mengapa itu dan bagaimana hal itu dapat ditingkatkan!

Apakah berhenti dari aplikasi tidak disukai? . Pergi melalui tautan ini. Itu menjawab pertanyaan Anda. Sistem melakukan tugas membunuh aplikasi.

Misalkan Anda memiliki dua aktivitas A dan B. Anda menavigasi dari A ke B. Ketika Anda mengklik tombol kembali aktivitas Anda B muncul dari backstack dan dihancurkan. Aktivitas sebelumnya dalam aktivitas tumpukan belakang A mengambil fokus.

Anda harus menyerahkannya ke sistem untuk memutuskan kapan harus mematikan aplikasi.

kekosongan publik finish()

Sebut ini ketika aktivitas Anda selesai dan harus ditutup.

Misalkan Anda memiliki banyak kegiatan. Anda dapat menggunakan bilah Tindakan. Pada klik ikon rumah naviagate ke MainActivity aplikasi Anda. Di MainActivity klik tombol kembali untuk keluar dari aplikasi.

Untuk keluar dari aplikasi Anda, Anda dapat menggunakan yang berikut:

getActivity().finish();
Process.killProcess(Process.myPid());
System.exit(1);

Juga untuk menghentikan layanan, panggil metode berikut:

private void stopServices() {        
    final ActivityManager activityManager = SystemServices.getActivityManager(context);
    final List<ActivityManager.RunningServiceInfo> runningServices = activityManager.getRunningServices(Integer.MAX_VALUE);
    final int pid = Process.myPid();
    for (ActivityManager.RunningServiceInfo serviceInfo : runningServices) {
        if (serviceInfo.pid == pid && !SenderService.class.getName().equals(serviceInfo.service.getClassName())) {
            try {
                final Intent intent = new Intent();
                intent.setComponent(serviceInfo.service);
                context.stopService(intent);
            } catch (SecurityException e) { 
                 // handle exception
            }
        }
    }
}

Ini mungkin sangat terlambat dan juga sesuai dengan pedoman Anda tidak seharusnya menangani proses siklus hidup sendiri (seperti yang dilakukan os untuk Anda). Sarannya adalah Anda mendaftarkan penerima siaran di semua aktivitas Anda dengan " finish()" di onReceive() & "kapan saja mereka mau", Anda dapat dengan mudah menyampaikan maksud yang menunjukkan bahwa semua kegiatan harus ditutup ..... Meskipun pastikan Anda melakukannya " batalkan pendaftaran "penerima dalam onDestroy()metode Anda .

Itu bukan keputusan yang baik, karena itu bertentangan dengan prinsip-prinsip pemrosesan aplikasi Android. Android tidak mematikan proses apa pun kecuali itu benar-benar tak terhindarkan. Ini membantu aplikasi memulai lebih cepat, karena selalu tersimpan di memori. Jadi Anda perlu alasan yang sangat khusus untuk mematikan proses aplikasi Anda.

Solusi yang benar dan tepat untuk keluar dari aplikasi pada klik tombol menggunakan kode di bawah ini:

// Pada Tombol Kembali acara ditekan

public void onBackPressed()
{ 
   moveTaskToBack(true);
   finish();
}

Jika Anda menggunakan Kotlin, cara yang tepat untuk keluar dari aplikasi dan alternatifnya System.exit()adalah metode bawaan

exitProcess(0)

Lihat dokumentasi .

Angka 0sebagai parameter berarti jalan keluar dimaksudkan dan tidak ada kesalahan terjadi.

Ini akan membunuh apa pun;)

int p = android.os.Process.myPid();
android.os.Process.killProcess(p);

Coba ini

int pid = android.os.Process.myPid();
android.os.Process.killProcess(pid);

Cara termudah yang saya temukan untuk keluar dari suatu aplikasi dari suatu aktivitas, tanpa melanggar logika Android dan tanpa menambahkan lebih banyak kode dalam aktivitas yang ada dan memberikan tambahan adalah sebagai berikut:

public static void quitApplication (Activity currentActivity) {
    Intent intent = new Intent (currentActivity, QuitApplicationActivity.class);
    intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK | Intent.FLAG_ACTIVITY_CLEAR_TOP);

    currentActivity.startActivity (intent);
    currentActivity.finish ();
}

yang QuitApplicationActivitymakhluk:

public class QuitApplicationActivity extends AppCompatActivity {

    @Override
    protected void onCreate (Bundle savedInstanceState) {
        super.onCreate (savedInstanceState);

        finish ();
    }
}

Jawaban @Sivi menutup aplikasi. Tetapi pada gilirannya, jika Anda memiliki beberapa kegiatan anak, kegiatan lain yang belum selesai mungkin dibuka. Saya menambahkan noHistory:trueke aktivitas saya sehingga aplikasi kembali dimulai dari MainActivity.

<activity 
      android:name=".MainActivity"
      android:noHistory="true">
</activity>

Hanya dengan menambahkan satu ke daftar metode brutal untuk mengakhiri suatu Aplikasi:

Process.sendSignal(Process.myPid(), Process.SIGNAL_KILL);

Anda dapat menghentikan aplikasi lengkap Anda. jadi

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

ini akan bekerja 100%. Semoga berhasil!

Cukup gunakan finish () pada tombol kembali tekan onKeypressed ()