Bagaimana cara menutup aplikasi Android?

Saya ingin menutup aplikasi saya, sehingga tidak lagi berjalan di latar belakang.

Bagaimana cara melakukannya? Apakah ini praktik yang baik di platform Android?

Jika saya mengandalkan tombol "kembali", itu menutup aplikasi, tetapi tetap di latar belakang. Bahkan ada aplikasi bernama "TaskKiller" hanya untuk mematikan aplikasi tersebut di latar belakang.

Android memiliki mekanisme untuk menutup aplikasi dengan aman sesuai dokumentasinya. Di Aktivitas terakhir yang keluar (biasanya Aktivitas utama yang pertama kali muncul ketika aplikasi dimulai) cukup tempatkan beberapa baris dalam metode onDestroy (). Panggilan ke System.runFinalizersOnExit (true) memastikan bahwa semua objek akan selesai dan sampah dikumpulkan ketika aplikasi keluar. Anda juga dapat mematikan aplikasi dengan cepat melalui android.os.Process.killProcess (android.os.Process.myPid ()) jika diinginkan. Cara terbaik untuk melakukan ini adalah meletakkan metode seperti berikut di kelas pembantu dan kemudian menyebutnya kapan pun aplikasi perlu dibunuh. Misalnya dalam metode hancurkan aktivitas root (dengan anggapan bahwa aplikasi tidak pernah membunuh aktivitas ini):

Android juga tidak akan memberi tahu aplikasi acara tombol HOME , jadi Anda tidak bisa menutup aplikasi saat tombol HOME ditekan. Android menyimpan peristiwa utama HOME untuk dirinya sendiri sehingga pengembang tidak dapat mencegah pengguna meninggalkan aplikasi mereka. Namun Anda dapat menentukan dengan tombol HOME ditekan dengan mengatur flag ke true dalam kelas helper yang mengasumsikan bahwa tombol HOME telah ditekan, kemudian mengubah flag ke false ketika suatu peristiwa terjadi yang menunjukkan bahwa tombol HOME tidak ditekan lalu memeriksa untuk melihat tombol HOME yang ditekan pada metode aktivitas onStop () .

Jangan lupa untuk menangani tombol HOME untuk menu apa pun dan dalam aktivitas yang dimulai oleh menu. Hal yang sama berlaku untuk kunci PENCARIAN . Di bawah ini adalah beberapa contoh kelas untuk diilustrasikan:

Berikut adalah contoh aktivitas root yang membunuh aplikasi saat dihancurkan:

package android.example;

/**
 * @author Danny Remington - MacroSolve
 */

public class HomeKey extends CustomActivity {

    public void onDestroy() {
        super.onDestroy();

        /*
         * Kill application when the root activity is killed.
         */
        UIHelper.killApp(true);
    }

}

Berikut adalah aktivitas abstrak yang dapat diperluas untuk menangani kunci HOME untuk semua aktivitas yang memperpanjangnya:

package android.example;

/**
 * @author Danny Remington - MacroSolve
 */

import android.app.Activity;
import android.view.Menu;
import android.view.MenuInflater;

/**
 * Activity that includes custom behavior shared across the application. For
 * example, bringing up a menu with the settings icon when the menu button is
 * pressed by the user and then starting the settings activity when the user
 * clicks on the settings icon.
 */
public abstract class CustomActivity extends Activity {
    public void onStart() {
        super.onStart();

        /*
         * Check if the app was just launched. If the app was just launched then
         * assume that the HOME key will be pressed next unless a navigation
         * event by the user or the app occurs. Otherwise the user or the app
         * navigated to this activity so the HOME key was not pressed.
         */

        UIHelper.checkJustLaunced();
    }

    public void finish() {
        /*
         * This can only invoked by the user or the app finishing the activity
         * by navigating from the activity so the HOME key was not pressed.
         */
        UIHelper.homeKeyPressed = false;
        super.finish();
    }

    public void onStop() {
        super.onStop();

        /*
         * Check if the HOME key was pressed. If the HOME key was pressed then
         * the app will be killed. Otherwise the user or the app is navigating
         * away from this activity so assume that the HOME key will be pressed
         * next unless a navigation event by the user or the app occurs.
         */
        UIHelper.checkHomeKeyPressed(true);
    }

    public boolean onCreateOptionsMenu(Menu menu) {
        MenuInflater inflater = getMenuInflater();
        inflater.inflate(R.menu.settings_menu, menu);

        /*
         * Assume that the HOME key will be pressed next unless a navigation
         * event by the user or the app occurs.
         */
        UIHelper.homeKeyPressed = true;

        return true;
    }

    public boolean onSearchRequested() {
        /*
         * Disable the SEARCH key.
         */
        return false;
    }
}

Berikut adalah contoh layar menu yang menangani tombol HOME :

/**
 * @author Danny Remington - MacroSolve
 */

package android.example;

import android.os.Bundle;
import android.preference.PreferenceActivity;

/**
 * PreferenceActivity for the settings screen.
 * 
 * @see PreferenceActivity
 * 
 */
public class SettingsScreen extends PreferenceActivity {
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        addPreferencesFromResource(R.layout.settings_screen);
    }

    public void onStart() {
        super.onStart();

        /*
         * This can only invoked by the user or the app starting the activity by
         * navigating to the activity so the HOME key was not pressed.
         */
        UIHelper.homeKeyPressed = false;
    }

    public void finish() {
        /*
         * This can only invoked by the user or the app finishing the activity
         * by navigating from the activity so the HOME key was not pressed.
         */
        UIHelper.homeKeyPressed = false;
        super.finish();
    }

    public void onStop() {
        super.onStop();

        /*
         * Check if the HOME key was pressed. If the HOME key was pressed then
         * the app will be killed either safely or quickly. Otherwise the user
         * or the app is navigating away from the activity so assume that the
         * HOME key will be pressed next unless a navigation event by the user
         * or the app occurs.
         */
        UIHelper.checkHomeKeyPressed(true);
    }

    public boolean onSearchRequested() {
        /*
         * Disable the SEARCH key.
         */
        return false;
    }

}

Berikut adalah contoh kelas pembantu yang menangani kunci HOME di seluruh aplikasi:

package android.example;

/**
 * @author Danny Remington - MacroSolve
 *
 */

/**
 * Helper class to help handling of UI.
 */
public class UIHelper {
    public static boolean homeKeyPressed;
    private static boolean justLaunched = true;

    /**
     * Check if the app was just launched. If the app was just launched then
     * assume that the HOME key will be pressed next unless a navigation event
     * by the user or the app occurs. Otherwise the user or the app navigated to
     * the activity so the HOME key was not pressed.
     */
    public static void checkJustLaunced() {
        if (justLaunched) {
            homeKeyPressed = true;
            justLaunched = false;
        } else {
            homeKeyPressed = false;
        }
    }

    /**
     * Check if the HOME key was pressed. If the HOME key was pressed then the
     * app will be killed either safely or quickly. Otherwise the user or the
     * app is navigating away from the activity so assume that the HOME key will
     * be pressed next unless a navigation event by the user or the app occurs.
     * 
     * @param killSafely
     *            Primitive boolean which indicates whether the app should be
     *            killed safely or quickly when the HOME key is pressed.
     * 
     * @see {@link UIHelper.killApp}
     */
    public static void checkHomeKeyPressed(boolean killSafely) {
        if (homeKeyPressed) {
            killApp(true);
        } else {
            homeKeyPressed = true;
        }
    }

    /**
     * Kill the app either safely or quickly. The app is killed safely by
     * killing the virtual machine that the app runs in after finalizing all
     * {@link Object}s created by the app. The app is killed quickly by abruptly
     * killing the process that the virtual machine that runs the app runs in
     * without finalizing all {@link Object}s created by the app. Whether the
     * app is killed safely or quickly the app will be completely created as a
     * new app in a new virtual machine running in a new process if the user
     * starts the app again.
     * 
     * <P>
     * <B>NOTE:</B> The app will not be killed until all of its threads have
     * closed if it is killed safely.
     * </P>
     * 
     * <P>
     * <B>NOTE:</B> All threads running under the process will be abruptly
     * killed when the app is killed quickly. This can lead to various issues
     * related to threading. For example, if one of those threads was making
     * multiple related changes to the database, then it may have committed some
     * of those changes but not all of those changes when it was abruptly
     * killed.
     * </P>
     * 
     * @param killSafely
     *            Primitive boolean which indicates whether the app should be
     *            killed safely or quickly. If true then the app will be killed
     *            safely. Otherwise it will be killed quickly.
     */
    public static void killApp(boolean killSafely) {
        if (killSafely) {
            /*
             * Notify the system to finalize and collect all objects of the app
             * on exit so that the virtual machine running the app can be killed
             * by the system without causing issues. NOTE: If this is set to
             * true then the virtual machine will not be killed until all of its
             * threads have closed.
             */
            System.runFinalizersOnExit(true);

            /*
             * Force the system to close the app down completely instead of
             * retaining it in the background. The virtual machine that runs the
             * app will be killed. The app will be completely created as a new
             * app in a new virtual machine running in a new process if the user
             * starts the app again.
             */
            System.exit(0);
        } else {
            /*
             * Alternatively the process that runs the virtual machine could be
             * abruptly killed. This is the quickest way to remove the app from
             * the device but it could cause problems since resources will not
             * be finalized first. For example, all threads running under the
             * process will be abruptly killed when the process is abruptly
             * killed. If one of those threads was making multiple related
             * changes to the database, then it may have committed some of those
             * changes but not all of those changes when it was abruptly killed.
             */
            android.os.Process.killProcess(android.os.Process.myPid());
        }

    }
}

IYA! Anda tentu saja dapat menutup aplikasi Anda sehingga tidak lagi berjalan di latar belakang. Seperti yang dikomentari oleh orang lain finish()adalah cara yang disarankan Google itu tidak berarti program Anda ditutup.

System.exit(0);

Itu di sana akan menutup aplikasi Anda tanpa meninggalkan apa pun yang berjalan di latar belakang. Namun, gunakan ini dengan bijak dan jangan biarkan file terbuka, database menangani terbuka, dll. Hal-hal ini biasanya akan dibersihkan melalui finish()perintah.

Saya pribadi BENCI ketika saya memilih Keluar di suatu aplikasi dan itu tidak benar-benar keluar.

Inilah cara saya melakukannya:

Saya hanya menempatkan

Intent intent = new Intent(Main.this, SOMECLASSNAME.class);
Main.this.startActivityForResult(intent, 0);

di dalam metode yang membuka aktivitas, lalu di dalam metode SOMECLASSNAME yang dirancang untuk menutup aplikasi yang saya masukkan:

setResult(0);
finish();

Dan saya menempatkan yang berikut di kelas Utama saya:

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    if(resultCode == 0) {
        finish();
    }
}

Hanya untuk menjawab pertanyaan saya sendiri sekarang setelah sekian lama (karena CommonsWare mengomentari jawaban paling populer yang mengatakan kita TIDAK boleh melakukan ini):

Ketika saya ingin keluar dari aplikasi:

1. Saya memulai aktivitas pertama saya (baik layar splash, atau aktivitas apa pun yang saat ini ada di bagian bawah tumpukan aktivitas) dengan FLAG_ACTIVITY_CLEAR_TOP(yang akan keluar dari semua aktivitas lain yang dimulai setelahnya, yang berarti - semuanya). Jadikan saja aktivitas ini ada di tumpukan aktivitas (jangan selesaikan karena alasan tertentu sebelumnya).
2. Saya memanggil finish()kegiatan ini

Ini dia, bekerja cukup baik untuk saya.

Cukup tulis kode ini di klik tombol EXIT Anda.

Intent intent = new Intent(getApplicationContext(), MainActivity.class);
intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
intent.putExtra("LOGOUT", true);
startActivity(intent);

Dan pada metode onCreate () dari MainActivity.class Anda, tulis kode di bawah ini sebagai baris pertama,

if (getIntent().getBooleanExtra("LOGOUT", false))
{
    finish();
}

Tidak mungkin menggunakan kerangka API. Merupakan kebijaksanaan sistem operasi (Android) untuk memutuskan kapan suatu proses harus dihapus atau tetap dalam memori. Ini untuk alasan efisiensi: jika pengguna memutuskan untuk meluncurkan kembali aplikasi, maka aplikasi itu sudah ada di sana tanpa harus dimuat ke dalam memori.

Jadi tidak, tidak hanya berkecil hati , tidak mungkin melakukannya.

Untuk keluar dari cara aplikasi:

Cara 1:

panggil finish();dan timpa onDestroy();. Masukkan kode berikut onDestroy():

System.runFinalizersOnExit(true)

atau

android.os.Process.killProcess(android.os.Process.myPid());

Cara 2:

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

Cara 3:

Quit();

protected void Quit() {
    super.finish();
}

Cara 4:

Intent intent = new Intent(getApplicationContext(), LoginActivity.class);
intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
intent.putExtra("EXIT", true);
startActivity(intent);

if (getIntent().getBooleanExtra("EXIT", false)) {
     finish();
}

Cara 5:

Terkadang panggilan finish()hanya akan keluar dari aktivitas saat ini, bukan seluruh aplikasi. Namun, ada solusi untuk ini. Setiap kali Anda memulai activity, mulai gunakan startActivityForResult(). Ketika Anda ingin menutup seluruh aplikasi, Anda dapat melakukan sesuatu seperti berikut ini:

setResult(RESULT_CLOSE_ALL);
finish();

Kemudian tentukan onActivityResult(...)callback setiap aktivitas sehingga ketika sebuah nilai activitydikembalikan RESULT_CLOSE_ALL, ia juga memanggil finish():

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    switch(resultCode){
        case RESULT_CLOSE_ALL:{
            setResult(RESULT_CLOSE_ALL);
            finish();
        }
    }
    super.onActivityResult(requestCode, resultCode, data);
}

Beginilah cara kerja Windows Mobile untuk ... yah ... pernah! Inilah yang dikatakan Microsoft tentang masalah ini:

http://blogs.msdn.com/windowsmobile/archive/2006/10/05/The-Emperor-Has-No-Close.aspx (apakah menyedihkan bahwa saya ingat judul posting blog sepanjang tahun 2006? Saya menemukan artikel di Google dengan mencari "kaisar tidak memiliki tutup" lol)

Pendeknya:

Jika sistem membutuhkan lebih banyak memori saat aplikasi di latar belakang, itu akan menutup aplikasi. Tetapi, jika sistem tidak membutuhkan lebih banyak memori, aplikasi akan tetap menggunakan RAM dan siap untuk kembali dengan cepat saat berikutnya pengguna membutuhkannya.

Banyak komentar dalam pertanyaan ini di O'Reilly menyarankan bahwa Android berperilaku dengan cara yang sama, menutup aplikasi yang belum pernah digunakan hanya ketika Android membutuhkan memori yang mereka gunakan.

Karena ini adalah fitur standar, maka mengubah perilaku untuk menutup paksa akan mengubah pengalaman pengguna. Banyak pengguna akan terbiasa dengan pemberhentian yang lembut dari aplikasi Android mereka sehingga ketika mereka mengabaikan satu dengan tujuan kembali ke sana setelah melakukan beberapa tugas lain, mereka mungkin agak frustrasi karena keadaan aplikasi diatur ulang, atau bahwa itu membutuhkan waktu lebih lama membuka. Saya akan tetap dengan perilaku standar karena itulah yang diharapkan.

Memanggil finish()metode pada Aktivitas memiliki efek yang Anda inginkan pada aktivitas saat ini.

tidak satu pun dari semua jawaban di atas yang berfungsi baik di aplikasi saya

ini kode kerja saya

pada tombol keluar Anda:

Intent intent = new Intent(getApplicationContext(), MainActivity.class);
ComponentName cn = intent.getComponent();
Intent mainIntent = IntentCompat.makeRestartActivityTask(cn);
mainIntent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_NEW_TASK);
mainIntent.addFlags(Intent.FLAG_ACTIVITY_NO_HISTORY);
mainIntent.putExtra("close", true);
startActivity(mainIntent);
finish();

kode itu adalah untuk menutup aktivitas lain dan membawa MainActivity di atas sekarang di MainActivity Anda:

if( getIntent().getBooleanExtra("close", false)){
    finish();
}

Letakkan finish();pernyataan seperti di bawah ini:

myIntent.putExtra("key1", editText2.getText().toString());

finish();

LoginActivity.this.startActivity(myIntent);

Di setiap aktivitas.

@Override
    protected void onPause() {

        super.onPause();

        System.exit(0);

    }

Salin kode di bawah ini dan tempel file AndroidManifest.xml di bawah Tag Aktivitas Pertama.

<activity                        
            android:name="com.SplashActivity"
            android:clearTaskOnLaunch="true" 
            android:launchMode="singleTask"
            android:excludeFromRecents="true">              
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER"
                />
            </intent-filter>
        </activity>     

Juga Tambahkan kode di bawah ini di semua di bawah Tag Aktivitas di file AndroidManifest.xml

 android:finishOnTaskLaunch="true"

Tidak mungkin dengan 2.3. Saya mencari banyak, dan mencoba banyak aplikasi. Solusi terbaik adalah menginstal keduanya (go taskmanager) dan (fast reboot). Saat menggunakannya bersama-sama itu akan bekerja, dan akan membebaskan memori. Pilihan lain adalah meng-upgrade ke sandwich es krim Android 4.0.4 yang memungkinkan kontrol (tutup) aplikasi.

saya ingin kembali ke layar beranda perangkat android saya, jadi saya hanya menggunakan:

moveTaskToBack(true);

Penggunaan finishAffinity()mungkin merupakan opsi yang baik jika Anda ingin menutup semua Aktivitas aplikasi. Sesuai Android Documents-

Finish this activity as well as all activities immediately below it in the current task that have the same affinity.

public class CloseAppActivity extends AppCompatActivity
{
    public static final void closeApp(Activity activity)
    {
        Intent intent = new Intent(activity, CloseAppActivity.class);
        intent.addCategory(Intent.CATEGORY_HOME);
        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK |
                IntentCompat.FLAG_ACTIVITY_CLEAR_TASK);
        activity.startActivity(intent);
    }

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

dan dalam manifes:

<activity
     android:name=".presenter.activity.CloseAppActivity"
     android:noHistory="true"
     android:clearTaskOnLaunch="true"/>

Kemudian Anda dapat menelepon CloseAppActivity.closeApp(fromActivity)dan aplikasi akan ditutup.

Cukup tulis kode berikut di onBackPressed:

@Override
public void onBackPressed() {
    // super.onBackPressed();

    //Creating an alert dialog to logout
    AlertDialog.Builder alertDialogBuilder = new AlertDialog.Builder(this);
    alertDialogBuilder.setMessage("Do you want to Exit?");
    alertDialogBuilder.setPositiveButton("Yes",
            new DialogInterface.OnClickListener() {
                @Override
                public void onClick(DialogInterface arg0, int arg1) {
                    Intent intent = new Intent(Intent.ACTION_MAIN);
                    intent.addCategory(Intent.CATEGORY_HOME);
                    startActivity(intent);
                }
            });

    alertDialogBuilder.setNegativeButton("No",
            new DialogInterface.OnClickListener() {
                @Override
                public void onClick(DialogInterface arg0, int arg1) {

                }
            });

    //Showing the alert dialog
    AlertDialog alertDialog = alertDialogBuilder.create();
    alertDialog.show();
}

dengan memanggil finish (); di tombol OnClick atau pada menu

case R.id.menu_settings:

      finish();
     return true;

Saya pikir ini akan menutup aktivitas Anda dan semua Sub aktivitas yang terkait dengannya.

public boolean onOptionsItemSelected(MenuItem item) {

        int id = item.getItemId();]
        if (id == R.id.Exit) {
            this.finishAffinity();
            return true;
        }

        return super.onOptionsItemSelected(item);
    }

Cara terbaik dan terpendek untuk menggunakan tabel System.exit.

System.exit(0);

VM menghentikan eksekusi lebih lanjut dan program akan keluar.

Gunakan " this.FinishAndRemoveTask();" - itu menutup aplikasi dengan benar