Apakah berhenti dari aplikasi tidak disukai?

Bergerak dalam upaya saya mempelajari Android, saya baru saja membaca yang berikut ini :

Pertanyaan: Apakah pengguna memiliki pilihan untuk mematikan aplikasi kecuali kita meletakkan opsi menu untuk mematikannya? Jika tidak ada opsi seperti itu, bagaimana cara pengguna menghentikan aplikasi?

Jawaban: (Romain Guy): Pengguna tidak, sistem menangani ini secara otomatis. Itulah gunanya siklus hidup aktivitas (terutama onPause / onStop / onDestroy). Apa pun yang Anda lakukan, jangan meletakkan tombol aplikasi "keluar" atau "keluar". Tidak ada gunanya dengan model aplikasi Android. Ini juga bertentangan dengan cara kerja aplikasi inti.

Hehe, untuk setiap langkah yang saya ambil di dunia Android, saya mengalami beberapa masalah = (

Tampaknya, Anda tidak dapat keluar dari aplikasi di Android (tetapi sistem Android dapat menghancurkan aplikasi Anda dengan sangat baik kapan pun rasanya). Ada apa dengan itu? Saya mulai berpikir bahwa tidak mungkin untuk menulis aplikasi yang berfungsi sebagai "aplikasi normal" - bahwa pengguna dapat keluar dari aplikasi ketika dia memutuskan untuk melakukannya. Itu bukan sesuatu yang harus diandalkan OS untuk dilakukan.

Aplikasi yang saya coba buat bukanlah aplikasi untuk Android Market. Ini bukan aplikasi untuk "digunakan luas" oleh masyarakat umum, ini adalah aplikasi bisnis yang akan digunakan dalam bidang bisnis yang sangat sempit.

Saya sebenarnya sangat menantikan untuk mengembangkan platform Android, karena ini membahas banyak masalah yang ada di Windows Mobile dan .NET. Namun, minggu terakhir ini sedikit mengganggu bagi saya ... Saya harap saya tidak harus meninggalkan Android, tapi itu tidak terlihat sangat baik sekarang = (

Apakah ada cara bagi saya untuk benar - benar keluar dari aplikasi?

Ini pada akhirnya akan sampai ke pertanyaan Anda, tetapi saya pertama-tama ingin membahas sejumlah masalah yang Anda ajukan dalam berbagai komentar Anda untuk berbagai jawaban yang sudah diberikan pada saat penulisan ini. Saya tidak punya niat mengubah pikiran Anda - melainkan, ini ada di sini untuk orang lain yang datang untuk membaca posting ini di masa depan.

Intinya adalah saya tidak bisa mengizinkan Android menentukan kapan aplikasi saya akan dihentikan. itu harus menjadi pilihan pengguna.

Jutaan orang sangat senang dengan model di mana lingkungan menutup aplikasi sesuai kebutuhan. Para pengguna itu tidak berpikir tentang "menghentikan" aplikasi Android, lebih dari yang mereka pikirkan tentang "mengakhiri" halaman Web atau "mengakhiri" termostat.

Pengguna iPhone memiliki cara yang sama, yaitu menekan tombol iPhone tidak selalu "terasa" seperti aplikasi dihentikan, karena banyak aplikasi iPhone mengambil di mana pengguna tinggalkan, bahkan jika aplikasi benar-benar ditutup (karena iPhone hanya memungkinkan satu aplikasi pihak ketiga pada suatu waktu, saat ini).

Seperti yang saya katakan di atas, ada banyak hal yang terjadi di aplikasi saya (data sedang PUSHed ke perangkat, daftar dengan tugas yang selalu ada di sana, dll.).

Saya tidak tahu apa artinya "daftar tugas yang selalu ada di sana", tetapi "data yang di-PUSHed ke perangkat" adalah fiksi yang menyenangkan dan tidak boleh dilakukan dengan aktivitas dalam kasus apa pun. Gunakan tugas yang dijadwalkan (via AlarmManager) untuk memperbarui data Anda untuk keandalan maksimum.

Pengguna kami masuk dan tidak bisa melakukan itu setiap kali mereka mendapat panggilan telepon dan Android memutuskan untuk mematikan aplikasi.

Ada banyak aplikasi iPhone dan Android yang berurusan dengan ini. Biasanya, itu karena mereka memegang kredensial masuk, alih-alih memaksa pengguna untuk masuk setiap kali secara manual.

Misalnya, kami ingin memeriksa pembaruan saat keluar dari aplikasi

Itu adalah kesalahan pada sistem operasi apa pun. Sejauh yang Anda tahu, alasan aplikasi Anda "keluar" adalah karena OS dimatikan, dan kemudian proses pembaruan Anda akan gagal di tengah-aliran. Secara umum, itu bukan hal yang baik. Baik memeriksa pembaruan saat memulai atau memeriksa pembaruan sama sekali tidak sinkron (misalnya, melalui tugas yang dijadwalkan), tidak pernah keluar.

Beberapa komentar menyarankan bahwa menekan tombol kembali sama sekali tidak mematikan aplikasi (lihat tautan di pertanyaan saya di atas).

Menekan tombol KEMBALI tidak "membunuh aplikasi". Ini menyelesaikan aktivitas yang ada di layar ketika pengguna menekan tombol BACK.

Seharusnya hanya berhenti ketika pengguna ingin menghentikannya - tidak pernah dengan cara lain. Jika Anda tidak dapat menulis aplikasi yang berperilaku seperti itu di Android, maka saya pikir Android tidak dapat digunakan untuk menulis aplikasi nyata = (

Maka aplikasi Web juga tidak. Atau WebOS , jika saya memahami model mereka dengan benar (belum memiliki kesempatan untuk bermain dengan salah satunya). Dalam semua itu, pengguna tidak "mengakhiri" apa pun - mereka pergi begitu saja. iPhone sedikit berbeda, karena saat ini hanya memungkinkan satu hal berjalan pada satu waktu (dengan beberapa pengecualian), sehingga tindakan meninggalkan menyiratkan penghentian aplikasi yang cukup cepat.

Apakah ada cara bagi saya untuk benar-benar keluar dari aplikasi?

Seperti yang dikatakan orang lain kepada Anda, pengguna (melalui BACK) atau kode Anda (via finish()) dapat menutup aktivitas yang sedang berjalan. Pengguna umumnya tidak memerlukan hal lain, untuk aplikasi yang ditulis dengan benar, tidak lebih dari yang mereka butuhkan opsi "keluar" untuk menggunakan aplikasi Web.

Tidak ada dua lingkungan aplikasi yang sama, menurut definisi. Ini berarti bahwa Anda dapat melihat tren di lingkungan saat yang baru muncul dan yang lain terkubur.

Misalnya, ada gerakan yang tumbuh untuk mencoba menghilangkan gagasan "file". Sebagian besar aplikasi Web tidak memaksa pengguna untuk memikirkan file. Aplikasi iPhone biasanya tidak memaksa pengguna untuk memikirkan file. Aplikasi Android umumnya tidak memaksa pengguna untuk memikirkan file. Dan seterusnya.

Demikian pula, ada gerakan yang tumbuh untuk mencoba menghilangkan gagasan "mengakhiri" aplikasi. Sebagian besar aplikasi Web tidak memaksa pengguna untuk keluar, tetapi secara implisit mengeluarkan pengguna setelah beberapa saat tidak aktif. Hal yang sama dengan Android, dan pada tingkat lebih rendah, iPhone (dan mungkin WebOS).

Ini membutuhkan lebih banyak penekanan pada desain aplikasi, fokus pada tujuan bisnis dan tidak bertahan dengan model implementasi yang terkait dengan lingkungan aplikasi sebelumnya. Pengembang yang tidak memiliki waktu atau kecenderungan untuk melakukan ini akan merasa frustrasi dengan lingkungan baru yang merusak model mental yang ada. Ini bukan kesalahan dari salah satu lingkungan, lebih dari itu adalah kesalahan gunung untuk badai yang mengalir di sekitarnya daripada melalui itu.

Sebagai contoh, beberapa lingkungan pengembangan, seperti Hypercard dan Smalltalk, memiliki aplikasi dan alat pengembangan berbaur dalam satu pengaturan. Konsep ini tidak menangkap banyak, di luar ekstensi bahasa ke aplikasi (misalnya, VBA di Excel , Lisp di AutoCAD ). Pengembang yang datang dengan model mental yang menganggap keberadaan alat pengembangan dalam aplikasi itu sendiri, oleh karena itu, harus mengubah model mereka atau membatasi diri pada lingkungan di mana model mereka akan berlaku.

Jadi, ketika Anda menulis:

Seiring dengan hal-hal berantakan lainnya yang saya temukan, saya pikir mengembangkan aplikasi kami untuk Android tidak akan terjadi.

Tampaknya itu untuk yang terbaik, untuk Anda, untuk saat ini. Demikian pula, saya akan menasihati Anda untuk tidak mencoba mem-port aplikasi Anda ke Web, karena beberapa masalah yang sama dengan yang Anda laporkan dengan Android juga akan Anda temukan di aplikasi Web (mis., Tidak ada "terminasi"). Atau, sebaliknya, suatu hari jika Anda melakukan porting aplikasi Anda ke Web, Anda mungkin menemukan bahwa aliran aplikasi Web mungkin lebih cocok untuk Android, dan Anda dapat mengunjungi kembali port Android pada waktu itu.

Saya hanya ingin menambahkan koreksi di sini untuk pembaca masa depan dari utas ini. Nuansa khusus ini telah luput dari pemahaman saya sejak lama sehingga saya ingin memastikan tidak ada di antara Anda yang melakukan kesalahan yang sama:

System.exit()tidak mematikan aplikasi Anda jika Anda memiliki lebih dari satu aktivitas di tumpukan. Apa yang sebenarnya terjadi adalah bahwa proses tersebut dimatikan dan segera dimulai kembali dengan satu aktivitas lebih sedikit di stack. Ini juga yang terjadi ketika aplikasi Anda terbunuh oleh dialog Force Close, atau bahkan ketika Anda mencoba untuk mematikan proses dari DDMS. Ini adalah fakta yang sepenuhnya tidak berdokumen, setahu saya.

Jawaban singkatnya adalah, jika Anda ingin keluar dari aplikasi Anda, Anda harus melacak semua aktivitas di tumpukan Anda dan finish()SEMUA dari mereka ketika pengguna ingin keluar (dan tidak, tidak ada cara untuk beralih melalui tumpukan Aktivitas) , jadi Anda harus mengelola semua ini sendiri). Bahkan ini sebenarnya tidak mematikan proses atau referensi menggantung yang mungkin Anda miliki. Itu hanya menyelesaikan kegiatan. Juga, saya tidak yakin apakah Process.killProcess(Process.myPid())berfungsi lebih baik; Saya belum mengujinya.

Jika, di sisi lain, tidak apa-apa bagi Anda untuk memiliki kegiatan yang tersisa di tumpukan Anda, ada metode lain yang membuat semuanya menjadi sangat mudah bagi Anda: Activity.moveTaskToBack(true)hanya akan latar belakang proses Anda dan menampilkan layar beranda.

Jawaban panjang melibatkan penjelasan filosofi di balik perilaku ini. Filosofi ini lahir dari sejumlah asumsi:

1. Pertama-tama, ini hanya terjadi ketika aplikasi Anda berada di latar depan. Jika di latar belakang proses akan berakhir dengan baik. Namun, jika berada di latar depan, OS menganggap bahwa pengguna ingin terus melakukan apa pun yang dia lakukan. (Jika Anda mencoba untuk mematikan proses dari DDMS, Anda harus menekan tombol home terlebih dahulu, dan kemudian matikan)
2. Ini juga mengasumsikan bahwa setiap kegiatan independen dari semua kegiatan lainnya. Ini sering benar, misalnya dalam hal aplikasi Anda meluncurkan Aktivitas Browser, yang sepenuhnya terpisah dan tidak ditulis oleh Anda. Aktivitas Browser dapat atau tidak dapat dibuat pada Tugas yang sama, tergantung pada atribut manifesnya.
3. Ini mengasumsikan bahwa masing-masing kegiatan Anda sepenuhnya mandiri dan dapat dibunuh / dikembalikan dalam waktu singkat. (Saya agak tidak menyukai asumsi khusus ini, karena aplikasi saya memiliki banyak kegiatan yang bergantung pada sejumlah besar data yang di-cache, terlalu besar untuk diserialisasi secara efisien selama onSaveInstanceState, tetapi apa yang akan dilakukan?) Untuk sebagian besar aplikasi Android yang ditulis dengan baik, ini harus benar, karena Anda tidak pernah tahu kapan aplikasi Anda akan dimatikan di latar belakang.
4. Faktor terakhir bukanlah asumsi, melainkan keterbatasan OS: membunuh aplikasi secara eksplisit sama dengan aplikasi yang mogok, dan juga sama dengan Android yang membunuh aplikasi untuk mendapatkan kembali memori. Ini memuncak dalam kudeta kami: karena Android tidak dapat mengetahui apakah aplikasi keluar atau jatuh atau terbunuh di latar belakang, itu mengasumsikan pengguna ingin kembali ke tempat yang mereka tinggalkan, dan ActivityManager akan memulai kembali proses.

Ketika Anda memikirkannya, ini sesuai untuk platform. Pertama, ini adalah persis apa yang terjadi ketika proses terbunuh di latar belakang dan pengguna kembali ke sana, sehingga harus dimulai ulang di tempat yang ditinggalkannya. Kedua, inilah yang terjadi ketika aplikasi crash dan menyajikan dialog Force Close yang ditakuti.

Katakanlah saya ingin pengguna saya dapat mengambil gambar dan mengunggahnya. Saya meluncurkan Aktivitas Kamera dari aktivitas saya, dan memintanya untuk mengembalikan gambar. Kamera didorong ke atas Tugas saya saat ini (daripada dibuat di Tugasnya sendiri). Jika Kamera memiliki kesalahan dan crash, apakah itu akan menyebabkan seluruh aplikasi crash? Dari sudut pandang pengguna, hanya Kamera yang gagal, dan mereka harus dikembalikan ke aktivitas sebelumnya. Jadi itu hanya me-restart proses dengan semua Kegiatan yang sama di tumpukan, minus Kamera. Karena Aktivitas Anda harus dirancang sedemikian rupa sehingga kegiatan itu dapat dibunuh dan dipulihkan dengan mudah, ini seharusnya tidak menjadi masalah. Sayangnya, tidak semua aplikasi dapat dirancang seperti itu, sehingga adalahmasalah bagi banyak dari kita, tidak peduli apa yang Romain Guy atau orang lain katakan kepada Anda. Jadi, kita perlu menggunakan solusi.

Jadi, saran penutup saya:

• Jangan mencoba untuk menghentikan prosesnya. Panggil finish()semua aktivitas atau panggilan moveTaskToBack(true).
• Jika proses Anda macet atau terbunuh, dan jika, seperti saya, Anda memerlukan data yang ada di memori yang sekarang hilang, Anda harus kembali ke aktivitas root. Untuk melakukan ini, Anda harus memanggil startActivity()dengan Intent yang berisi Intent.FLAG_ACTIVITY_CLEAR_TOPbendera.
• Jika Anda ingin mematikan aplikasi Anda dari perspektif Eclipse DDMS, lebih baik tidak berada di latar depan, atau itu akan restart sendiri. Anda harus menekan tombol Rumah terlebih dahulu, lalu matikan prosesnya.

Semua aplikasi saya telah keluar dari tombol ... dan saya cukup sering mendapat komentar positif dari pengguna karenanya. Saya tidak peduli apakah platform itu dirancang dengan cara yang seharusnya tidak dibutuhkan oleh aplikasi. Mengatakan "jangan taruh di sana" agak konyol. Jika pengguna ingin berhenti ... Saya memberikan mereka akses untuk melakukan hal itu. Saya tidak berpikir itu mengurangi cara Android beroperasi sama sekali dan sepertinya praktik yang baik. Saya memahami siklus hidup ... dan pengamatan saya adalah bahwa Android tidak melakukan pekerjaan dengan baik dalam menanganinya .... dan itu adalah fakta dasar.

Berhentilah memikirkan aplikasi Anda sebagai aplikasi monolitik. Ini adalah satu set layar UI yang pengguna dapat berinteraksi dengan "aplikasi" Anda, dan "fungsi" yang disediakan melalui layanan Android.

Tidak tahu apa "aplikasi" misterius Anda tidak terlalu penting. Mari kita asumsikan terowongan itu menjadi intranet perusahaan yang sangat aman, melakukan beberapa pemantauan atau interaksi dan tetap masuk sampai pengguna "berhenti dari aplikasi". Karena departemen TI Anda memerintahkannya, pengguna harus sangat sadar ketika mereka masuk atau keluar dari intranet. Karenanya pola pikir Anda tentang hal ini penting bagi pengguna untuk "keluar".

Ini sederhana. Buat layanan yang menempatkan pemberitahuan berkelanjutan di bilah pemberitahuan yang mengatakan "Saya di intranet, atau saya sedang menjalankan". Mintalah layanan itu melakukan semua fungsi yang Anda butuhkan untuk aplikasi Anda. Miliki aktivitas yang mengikat layanan itu untuk memungkinkan pengguna Anda mengakses bit UI yang mereka butuhkan untuk berinteraksi dengan "aplikasi" Anda. Dan memiliki Android Menu -> Keluar (atau logout, atau apa pun) tombol yang memberitahu layanan untuk berhenti, kemudian tutup aktivitas itu sendiri.

Ini, untuk semua maksud dan tujuan persis apa yang Anda katakan Anda inginkan. Dilakukan dengan cara Android. Lihatlah Google Talk atau Navigasi Google Maps untuk contoh "keluar" ini mungkin mentalitas. Satu-satunya perbedaan adalah bahwa menekan tombol kembali dari aktivitas Anda dapat membuat proses UNIX Anda menunggu jika pengguna ingin menghidupkan kembali aplikasi Anda. Ini benar-benar tidak berbeda dengan sistem operasi modern yang menyimpan file-file yang baru-baru ini diakses dalam memori. Setelah Anda keluar dari program windows Anda, kemungkinan besar sumber daya yang dibutuhkan masih dalam memori, menunggu untuk digantikan oleh sumber daya lain karena mereka dimuat sekarang karena mereka tidak lagi diperlukan. Android adalah hal yang sama.

Saya benar-benar tidak melihat masalah Anda.

Ini adalah diskusi yang menarik dan mendalam dengan banyak pakar yang berkontribusi. Saya merasa posting ini harus dilingkarkan kembali dari dalam situs web utama pengembangan Android, karena itu berputar di sekitar salah satu desain inti dari OS Android.

Saya juga ingin menambahkan dua sen saya di sini.

Sejauh ini saya terkesan dengan cara Android menangani acara siklus hidup, membawa konsep pengalaman seperti web ke aplikasi asli.

Karena itu saya masih percaya bahwa harus ada Quittombol. Mengapa? ... bukan untuk saya atau Ted atau guru teknologi mana pun di sini, tetapi hanya untuk memenuhi permintaan pengguna akhir.

Meskipun saya bukan penggemar Windows, tapi sejak dulu mereka memperkenalkan konsep yang biasa digunakan pengguna akhir (tombol X) ... "Saya ingin berhenti menjalankan widget ketika 'Saya' ingin".

Itu tidak berarti seseorang (OS, pengembang?) Akan mengurus itu atas kebijakannya sendiri ... itu hanya berarti "di mana tombol X Merah saya yang biasa saya". Tindakan saya harus analog dengan 'akhiri panggilan dengan menekan tombol', 'matikan perangkat dengan menekan tombol', dan seterusnya dan seterusnya ... itu persepsi. Ini membawa kepuasan bahwa tindakan saya memang mencapai tujuannya.

Meskipun pengembang dapat menipu perilaku ini menggunakan saran yang diberikan di sini, persepsi masih tetap yaitu aplikasi harus sepenuhnya berhenti berfungsi (sekarang), oleh sumber (OS) independen, tepercaya dan netral berdasarkan permintaan dari pengguna akhir.

Anda dapat keluar, baik dengan menekan Backtombol atau dengan menelepon finish()Anda Activity. Panggil saja finish()dari MenuItemjika Anda ingin membunuhnya secara eksplisit.

Romain tidak mengatakan itu tidak dapat dilakukan, hanya saja itu tidak ada gunanya - pengguna tidak perlu peduli untuk berhenti atau menyimpan pekerjaan mereka atau apa pun, karena cara kerja siklus aplikasi bekerja mendorong Anda untuk menulis perangkat lunak pintar yang secara otomatis menyimpan dan menyimpan mengembalikan keadaannya apa pun yang terjadi.

Perdebatan ini bermuara pada pertanyaan kuno apakah pengembang tahu yang terbaik atau apakah pengguna tahu yang terbaik. Desainer profesional di semua bidang faktor manusia berjuang dengan ini setiap hari.

Ted menegaskan bahwa salah satu aplikasi yang paling banyak diunduh di Market adalah 'App Killer'. Orang-orang mendapatkan sedikit serotonin ekstra ketika mereka berhenti dari aplikasi. Mereka terbiasa dengan desktop / laptop. Itu membuat semuanya bergerak cepat. Itu membuat prosesor tetap dingin dan kipas tidak menyala. Ini menggunakan lebih sedikit daya.

Ketika Anda menganggap bahwa perangkat seluler adalah kapal yang jauh lebih kecil, maka Anda dapat menghargai insentif mereka untuk 'membuang apa yang tidak lagi Anda perlukan'. Sekarang para pengembang Android beralasan bahwa OS tahu yang terbaik dan berhenti dari suatu aplikasi adalah barang antik. Saya sepenuh hati mendukung ini.

Namun, saya juga percaya bahwa Anda tidak boleh membuat frustasi pengguna, bahkan jika frustrasi itu berasal dari ketidaktahuan mereka sendiri. Karena itu, saya menyimpulkan bahwa memiliki opsi 'Berhenti' adalah desain yang baik, bahkan jika sebagian besar merupakan tombol plasebo yang tidak lebih dari menutup Tampilan.

Ted, apa yang Anda coba capai bisa dilakukan, mungkin tidak hanya bagaimana Anda memikirkannya sekarang.

Saya sarankan Anda membaca tentang Aktivitas dan Layanan. Berhentilah menggunakan istilah "aplikasi" dan mulailah merujuk pada komponen, yaitu Aktivitas, Layanan. Saya pikir Anda hanya perlu belajar lebih banyak tentang platform Android; itu adalah perubahan pola pikir dari aplikasi PC standar. Fakta bahwa tidak ada posting Anda yang memiliki kata "Activity" (singkat dari kutipan FAQ, yaitu bukan kata-kata Anda) di dalamnya memberitahu saya bahwa Anda perlu membaca lebih banyak lagi.

Posting blog Kapan Menyertakan Tombol Keluar di Aplikasi Android (Petunjuk: Jangan pernah) menjelaskannya jauh, jauh lebih baik daripada yang saya bisa. Saya berharap setiap pengembang Android sudah membacanya.

Kutipan:

Dalam pengalaman saya apa yang [para pengguna] benar-benar inginkan adalah: Cara yang jelas untuk menjamin bahwa suatu aplikasi akan berhenti mengkonsumsi sumber daya (baterai, siklus CPU, transfer data, dll.).

Banyak pengguna merasakan bahwa tombol keluar mengimplementasikan persyaratan ini dan memintanya untuk ditambahkan. Pengembang, yang ingin menyenangkan penggunanya, wajib menambahkannya. Tak lama kemudian mereka berdua gagal.

• Dalam kebanyakan kasus tombol keluar hanya memanggil Activity.finish(). Ini persis sama dengan menekan tombol kembali. Persis. Layanan terus berjalan dan pemungutan suara terus terjadi. Pengguna mungkin berpikir mereka telah membunuh aplikasi tetapi tidak, dan segera mereka akan lebih kesal.
• Perilaku keluar sekarang ambigu. Haruskah tombol keluar Anda menutup saja Kegiatan, atau haruskah itu juga menghentikan semua Layanan, Penerima, dan Alarm yang terkait? Apa yang harus Backdilakukan Apa yang terjadi jika mereka memukul Home? Apa yang terjadi jika aplikasi Anda memiliki widget? Haruskah tombol keluar menghentikan itu dari memperbarui juga?

Solusinya adalah membuat tombol kembali berperilaku seperti yang Anda harapkan dari tombol keluar. Lebih baik lagi, cukup hentikan konsumsi sumber daya setiap kali aplikasi tidak terlihat.

Silakan baca artikel selengkapnya.

Jawaban: (Romain Guy): Pengguna tidak, sistem menangani ini secara otomatis. Itulah gunanya siklus hidup aktivitas (terutama onPause / onStop / onDestroy). Apa pun yang Anda lakukan, jangan meletakkan tombol aplikasi "keluar" atau "keluar". Tidak ada gunanya dengan model aplikasi Android. Ini juga bertentangan dengan cara kerja aplikasi inti.

1: Benar-benar keluar dari aplikasi mungkin umumnya tidak wajib, tetapi tidak sia-sia. Bagaimana jika windows tidak memiliki opsi keluar? Sistem akan berjalan lambat karena memori penuh dan OS harus menebak program mana yang Anda lakukan. Saya tidak peduli apa yang Romain Guy atau bahkan Larry Page dan Sergey Brin katakan - ini adalah fakta yang tidak perlu dipertanyakan lagi: Sistem berjalan lebih lambat ketika mereka harus membunuh tugas untuk mendapatkan ingatan mereka sebelum aplikasi baru dapat diluncurkan. Anda tidak bisa memberi tahu saya bahwa tidak perlu waktu untuk mematikan aplikasi! Bahkan cahaya dari bintang-bintang jauh mengambil waktu ... Ada adalah beberapa digunakan dalam memungkinkan pengguna untuk aplikasi sepenuhnya dekat.

2: Bertolak belakang dengan cara kerja aplikasi inti? Maksudnya apa? Ketika saya selesai menjalankan aplikasi untuk saat ini, itu tidak lagi melakukan pekerjaan apa pun ... Hanya menunggu untuk dibunuh oleh OS ketika ingatannya diperlukan.

Singkatnya, ada perbedaan yang jelas antara meminimalkan dan keluar, dan tidak ada klik yang baik untuk yang lain. Apakah kita meninggalkan obeng di setiap sekrup? Atau kunci di setiap pintu? Apakah kita membiarkan semua peralatan kita tetap tinggi sampai pemutusnya pecah dan kita perlu menyalakan alat lain? Apakah kita meninggalkan mesin cuci piring penuh dengan hidangan, dan hanya mengambil cukup setiap kali untuk memberikan ruang bagi beberapa yang kotor baru? Apakah kita membiarkan semua mobil berjalan di jalan masuk sampai - oh tidak apa-apa.

Jika pengguna ingin meminimalkan suatu aplikasi, maka hal terbaik adalah menguranginya. Jika pengguna ingin keluar dari aplikasi, berarti yang terbaik adalah keluar.

Apakah itu disukai? Itulah pandangan Android - mereka tidak menyukai itu. Dan banyak banyak pengembang Android pemula yang tidak menyukai itu.

Tetapi ketika tiba saatnya, ada pengkodean yang baik dan pengkodean yang buruk. Ada model aliran program yang baik dan ada model aliran program yang buruk.

Meninggalkan program di memori ketika pengguna tahu mereka selesai dengan mereka sama sekali bukan aliran program yang baik. Sama sekali tidak ada gunanya, dan memperlambat segalanya saat meluncurkan aplikasi baru atau ketika menjalankan aplikasi mengalokasikan lebih banyak memori.

Ini seperti mobil Anda: Ada kalanya Anda membiarkannya berjalan, seperti berhenti di lampu merah, atau mungkin makanan cepat saji melewati, atau berhenti di ATM. Tetapi ada situasi lain di mana Anda ingin mematikannya - seperti ketika Anda mulai bekerja, atau toko kelontong atau bahkan rumah.

Demikian pula, jika Anda memainkan permainan dan telepon berdering, ya. Hentikan permainan dan terus jalankan. Tetapi jika pengguna selesai dengan game untuk sementara waktu, maka tentu saja biarkan mereka keluar.

Tombol keluar pada beberapa aplikasi harus lebih di depan daripada yang lain. Game, misalnya, atau program di mana pengguna kemungkinan ingin sepenuhnya keluar, harus memiliki jalan keluar yang jelas. Program lain, seperti, mungkin, program email, di mana keluar adalah keinginan yang tidak mungkin (sehingga dapat terus memeriksa email) - program ini tidak boleh menyia-nyiakan ruang layar input kontrol utama dengan opsi keluar, tetapi untuk aliran program yang baik, itu harus memiliki opsi keluar. Bagaimana jika seseorang memutuskan mereka tidak ingin program surat mereka mencoba memeriksa email ketika mereka berada di daerah jangkauan yang buruk, atau mungkin dalam panggilan Skype atau apa pun? Biarkan mereka keluar dari program email jika mereka mau!

Menangguhkan dan keluar adalah dua tugas penting dan tidak memenuhi peran yang lain.

Saya pikir intinya adalah bahwa tidak perlu keluar dari aplikasi kecuali Anda memiliki perangkat lunak kereta. Android berhenti aplikasi saat pengguna tidak menggunakannya dan perangkat membutuhkan lebih banyak memori. Jika Anda memiliki aplikasi yang perlu menjalankan layanan di latar belakang, Anda mungkin ingin cara untuk mematikan layanan.

Misalnya, Google Listen terus memutar podcast ketika aplikasi tidak terlihat. Tetapi selalu ada tombol jeda untuk mematikan podcast ketika pengguna selesai menggunakannya. Jika saya ingat dengan benar, Dengar, bahkan menempatkan pintasan di bilah notifikasi sehingga Anda selalu dapat membuka tombol jeda dengan cepat. Contoh lain adalah aplikasi seperti aplikasi twitter misalnya yang secara konstan memilih layanan di internet. Jenis aplikasi ini harus benar-benar memungkinkan pengguna untuk memilih seberapa sering melakukan polling pada server, atau apakah akan melakukan polling di latar belakang.

Jika Anda perlu memiliki kode yang berjalan saat keluar, Anda dapat mengganti onPause (), onStop (), atau onDestroy () yang sesuai. http://developer.android.com/reference/android/app/Activity.html#ActivityLifecycle

Jika Anda tidak dapat memahami bagaimana membuat data / koneksi Anda (dan dengan demikian "aplikasi" Anda) tetap ada, maka Anda tidak akan dapat melakukan apa yang "perlu" Anda lakukan dengan Android.

Mereka yang mengunduh App Killers kecil yang imut itu biasanya menemukan bahwa mereka tidak membantu masa pakai baterai atau penggunaan memori, tetapi menghalangi OS untuk melakukan tugas mengelola memori secara efisien ...

http://android-developers.blogspot.com/2010/04/multitasking-android-way.html

Saya akan mempertimbangkan membaca "Pengembangan Aplikasi Nirkabel Android" yang diterbitkan oleh Addison-Wesley. Saya baru saja menyelesaikannya dan itu SANGAT menyeluruh.

Tampaknya Anda memiliki beberapa kesalahpahaman mendasar pada platform Android. Saya juga agak frustrasi pada awalnya dengan siklus hidup aplikasi aplikasi Android, tetapi setelah mencapai pemahaman yang lebih besar, saya menjadi sangat menikmati pendekatan ini. Buku ini akan menjawab semua pertanyaan Anda dan banyak lagi. Ini benar-benar sumber daya terbaik yang saya temukan untuk pengembang Android baru.

Juga, saya pikir Anda perlu melepaskan port line-for-line dari aplikasi yang ada. Untuk mem-port aplikasi Anda ke platform Android, beberapa desain aplikasi akan berubah. Siklus hidup aplikasi yang digunakan diperlukan karena perangkat seluler memiliki sumber daya yang sangat terbatas relatif terhadap sistem desktop dan memungkinkan perangkat Android untuk menjalankan beberapa aplikasi secara teratur dan sadar sumber daya. Lakukan beberapa studi mendalam tentang platform ini, dan saya pikir Anda akan menyadari bahwa apa yang ingin Anda lakukan sepenuhnya layak. Semoga berhasil.

Ngomong-ngomong, saya sama sekali tidak berafiliasi dengan Addison-Wesley atau orang atau organisasi apa pun yang terkait dengan buku ini. Setelah membaca kembali posting saya, saya merasa bahwa saya keluar dari fanboyish kecil. Saya hanya benar-benar menikmatinya dan merasa sangat membantu. :)

Hampir 99% dari waktu tidak perlu untuk aplikasi Android untuk mengambil alih siklus hidupnya sendiri. Sebagian besar waktu datang ke perencanaan yang lebih baik atau desain aplikasi yang lebih cerdas. Misalnya, lebih baik membangun layanan internal (tidak diekspor) untuk menangani unduhan, dll., Atau merancang tindakan dan tugas di sekitar alur kerja pengguna.

Tapi itu dikatakan, di mana ada kemauan di sana ada jalan. Android menyediakan - melalui kelas android.os.Process, API yang jauh lebih baik daripada Java untuk mengontrol proses yang mendasarinya. Dan tidak seperti Java, ia tidak memperlakukan pengembang seperti orang bodoh dengan menyembunyikan semuanya di balik panggilan java.lang.System.exit () sederhana.

Jadi bagaimana Anda meminta aplikasi Anda untuk bunuh diri di Android? Nah, triknya sederhana:

Buat kelas aplikasi Android Anda sendiri dengan mewarisi dari kelas android.app.Application standar (jangan lupa untuk mendeklarasikannya dalam file AndroidManifest.xml).

Ganti metode onCreate (), dan simpan ID proses yang memulai aplikasi Anda:

this.pid = android.os.Process.myPid(); // Save for later use.

Sekarang untuk mematikan aplikasi Anda, berikan metode kill ():

android.os.Process.sendSignal(pid, android.os.Process.SIGNAL_KILL);

Sekarang, kapan pun Anda membutuhkan aplikasi Anda untuk bunuh diri, ketikkan saja Cast konteks aplikasi, dan panggil metode kill Anda!

((MySuicidalApp) context.getApplicationContext()).kill()

Hanya ingat bahwa karena kebijakan manajemen proses di Android, khususnya yang terkait dengan layanan, Android mungkin hanya memilih untuk memulai kembali layanan Anda (lihat Anda tidak harus menggunakan pembunuh tugas di Android ).

Ketika saya menyusun aplikasi di Android, saya melihatnya seperti ini:

• Anda bekerja dengan aplikasi Anda
• Telepon berdering
• Anda menerima telepon
• Pada akhir panggilan, Anda kembali ke aplikasi Anda di tempat yang sama dengan Anda

Untuk melakukan itu, Anda hanya perlu Backtombol atau Hometombol telepon Anda (baik dengan menekan pendek atau panjang) dan bilah notifikasi.

Ketika saya keluar dari aplikasi saya, saya hanya menggunakan Backtombol sampai saya keluar dari itu atau Hometombol.

Begitulah menurut saya sebagian besar aplikasi. Tetapi jika saya memerlukan semacam sesi atau koneksi, saya menjelaskan kepada pengguna dengan tombol masuk / keluar dan pemberitahuan (bilah judul atau apa pun). Ini adalah gaya yang agak berbeda dari aplikasi gaya "keluar" murni.

Di PC, Anda memiliki desktop multi-GUI, dan di Android, Anda jelas memiliki banyak tugas, tetapi Anda hanya menampilkan satu aplikasi pada satu waktu (saya tidak mempertimbangkan widget di sini ^^). Dan di ponsel, kapan saja, Anda dapat memiliki pemberitahuan untuk sesuatu yang lebih penting daripada apa yang Anda lakukan.

Jadi seluruh konsep aplikasi bergantung pada sesuatu yang berbeda yaitu "masuk aplikasi - kerja - keluar aplikasi".

Hmmmm ...

Saya pikir Anda tidak melihat aplikasi Android dengan cara yang benar. Anda dapat melakukan sesuatu yang hampir seperti apa yang Anda inginkan dengan mudah:

• Apakah aktivitas aplikasi menyimpan / mengembalikan status seperti yang dianjurkan dalam dokumentasi siklus hidup pengembang.

• Jika beberapa login diperlukan pada tahap pemulihan (tidak ada informasi login / sesi tersedia) maka lakukanlah.

• Akhirnya tambahkan tombol / menu / batas waktu dalam hal ini Anda akan melakukan finish()tanpa menyimpan login dan info sesi lainnya, membuat secara implisit akhir sesi aplikasi: jadi jika aplikasi dimulai / dibawa ke depan lagi itu akan memulai sesi baru.

Dengan begitu Anda tidak terlalu peduli apakah aplikasi tersebut benar-benar dihapus dari memori atau tidak.

Jika Anda benar-benar ingin menghapusnya dari memori (ini tidak disarankan, dan BTW untuk tujuan apa?), Anda dapat membunuhnya secara bersyarat di akhir onDestroy()dengan java.lang.System.exit(0)(atau mungkin restartPackage(..)?). Tentu saja lakukan hanya dalam kasus di mana Anda ingin "benar-benar mengakhiri aplikasi", karena itu onDestroy()adalah bagian dari siklus hidup normal kegiatan dan bukan akhir aplikasi sama sekali.

Karena Aplikasi dalam konteks Android hanyalah Sekumpulan Kegiatan yang terkait secara samar, berhenti dari Aplikasi tidak terlalu masuk akal. Anda dapat menyelesaikan () suatu Kegiatan, dan tampilan Kegiatan sebelumnya di tumpukan Kegiatan akan digambar.

Saya setuju dengan Ted. Saya mengerti bahwa keluar dari aplikasi bukanlah "cara Android", tetapi sepertinya tidak harus dihilangkan. Berikut adalah tiga alasan mengapa Anda mungkin ingin keluar nyata ke aplikasi (bukan hanya aktivitas):

1. Pengguna mungkin ingin kontrol atas aplikasi mana yang terbunuh jika memori rendah. Jika aplikasi penting A berjalan di latar belakang, maka Anda mungkin ingin keluar dari aplikasi B saat Anda selesai menggunakannya sehingga aplikasi A tidak terbunuh oleh sistem operasi.

2. Jika aplikasi Anda memiliki data sensitif yang di-cache dalam memori, Anda mungkin ingin mematikan aplikasi tersebut sehingga aplikasi virus / worm / nakal tidak bisa mendapatkannya. Saya tahu model keamanan seharusnya mencegah itu, tetapi untuk berjaga-jaga ...

3. Jika aplikasi Anda menggunakan sumber daya (seperti jaringan, CPU, sensor, dll.) Yang dapat mempengaruhi telepon, maka salah satu cara untuk memastikan bahwa sumber daya tersebut dibebaskan adalah dengan keluar dari aplikasi. Saya memahami bahwa aplikasi yang berperilaku baik harus membebaskan sumber daya saat tidak diperlukan. Tetapi sekali lagi, keluar dari aplikasi sepertinya cara yang masuk akal untuk memastikan hal itu.

Kernel Linux memiliki fitur yang disebut Pembunuh Kehabisan Memori (seperti yang disebutkan di atas, kebijakan dapat dikonfigurasi di tingkat userspace serta kernel tidak optimal, tetapi tidak berarti tidak perlu).

Dan ini banyak digunakan oleh Android:

• Pembunuh OOM bukan untuk ruang pengguna

• Android Notes (OOM Killer Info - tempat Anda dapat mengonfigurasi fitur OOM di Android)

• Android Porting Pada Target Nyata

Beberapa aplikasi userspace tersedia untuk membantu membunuh aplikasi ini, misalnya:

• Autokiller / Mengkonfigurasi pembunuh tugas internal Android

Anda tampaknya telah menemukan jawaban yang Anda inginkan dalam perintah finish (). Ini tidak akan menghapus aplikasi Anda dari memori, tetapi Android akan melakukannya kapan pun ia membutuhkan sumber daya, sehingga tidak ada bedanya bahwa Anda tidak akan melakukannya secara eksplisit.

Saya hanya akan menambahkan bahwa untuk mencapai efek penuh yang biasanya dimiliki oleh keluar aplikasi, Anda ingin mengatur ulang status aplikasi ke kondisi apa pun yang normalnya pada saat dijalankan pertama kali setelah boot perangkat, sebelum untuk memanggil selesai () pada semua aktivitas Anda. Dengan begitu, jika pengguna memilih aplikasi Anda lagi, itu akan tampak telah dijalankan "segar," tanpa negara tersisa dari titik sebelum "keluar" yang disimulasikan.

Jika ada beberapa tindakan khusus yang seharusnya hanya terjadi pada "keluar," seperti menyimpan pekerjaan pengguna atau apa pun, Anda juga dapat melakukannya sebelum bagian inisialisasi ulang dari rutin di atas.

Pendekatan ini memungkinkan Anda untuk mencapai tujuan Anda memiliki perintah "keluar" tanpa melanggar filosofi Android meninggalkan pengelolaan sumber daya OS, termasuk penutupan aplikasi, di tangan sistem operasi.

Secara pribadi, saya tidak akan menggunakan pendekatan ini, karena pengguna Android mengharapkan aplikasi untuk mempertahankan kontinuitasnya ketika mereka mengunjunginya kembali, sehingga mereka tidak terbiasa dengan modalitas "keluar" dari aplikasi. Saya sebaliknya akan mendukung fungsi "jelas" yang dapat dipanggil pengguna untuk mengatur ulang aplikasi ke beberapa keadaan awal default, tanpa perlu "meninggalkan" dalam proses.

Satu-satunya pengecualian adalah ketika pengguna menekan tombol kembali beberapa kali untuk menutup aplikasi. Dalam situasi itu, tidak ada harapan di pihak pengguna bahwa negara akan diselamatkan (dan jika ada keadaan yang belum disimpan dalam aplikasi, maka Anda, sebagai pengembang, harus memiliki kode yang menangani tombol kembali yang mendeteksi bahwa data yang belum disimpan, dan meminta pengguna untuk menyimpannya ke SharedPreferences atau file, atau ke media non-volatil lainnya).

Mengenai system.exit (0):

Jika Anda memutuskan untuk menggunakan system.exit (0) untuk menutup aplikasi Anda dengan finalitas kasar (misalnya, sebagai hasil dari tombol kembali tombol akhir), maka saya akan memperingatkan Anda bahwa meskipun bagi saya ini meskipun "bekerja," dan dalam beberapa kasing adalah satu-satunya cara saya bisa menutup aplikasi tanpa sisa itu tersisa, ada satu kesalahan kecil yang terjadi di Jelly Bean ketika Anda menggunakan pendekatan ini.

Khususnya, jika Anda menggunakan daftar Aplikasi Terkini untuk membuka aplikasi Anda, dan kemudian menggunakan tombol kembali untuk menutup aplikasi (dengan yang dekat dilaksanakan melalui system.exit (0)), daftar Aplikasi Terkini akan menjadi terlihat lagi, karena akan tidak pernah ditutup. Jika kemudian Anda mengetuk entri aplikasi Anda dalam daftar itu untuk menjalankannya untuk kedua kalinya dari daftar Aplikasi Terakhir yang sama dan sudah terbuka, tidak akan ada respons.

Saya menduga bahwa penyebabnya adalah karena daftar Aplikasi Terkini memegang referensi ke aplikasi Anda yang telah menjadi tidak berfungsi karena Anda telah menutup aplikasi menggunakan system.exit (0). Penutupan aplikasi Anda yang lebih beradab menggunakan selesai () mungkin telah memberi tahu OS dengan cara yang akan memungkinkannya untuk me-refresh daftar Aplikasi Terkini, tetapi system.exit (0) tampaknya tidak melakukan ini.

Ini bukan masalah besar di dalam dan dari dirinya sendiri, karena sangat sedikit orang akan membuka aplikasi dari Aplikasi Terbaru, kemudian keluar, dan kemudian segera membukanya lagi dari daftar Aplikasi Terkini yang terbuka. Dan jika mereka mengetuk tombol beranda dan kemudian membuka kembali daftar Aplikasi Terbaru, entri aplikasi Anda akan ada di sana, dan itu akan berfungsi penuh. Tapi saya pikir itu menunjukkan bahwa penggunaan system.exit (0) dapat mengganggu komunikasi yang tepat antara aplikasi Anda dan OS, dan ini menunjukkan bahwa mungkin ada konsekuensi lain, lebih serius, mungkin halus, dari penggunaan pendekatan ini.

Saya harap semuanya akan berubah seiring waktu. Pengguna harus dapat mematikan aplikasi atau proses jika proses aplikasi diberi sandbox dengan benar oleh OS. Ada anggapan bahwa aplikasi harus ditulis dengan sempurna atau pengguna hanya akan menggunakan aplikasi yang mengikuti semua rekomendasi SDK. Saya pikir itu adalah tugas berat.

Ada desain (relatif) sederhana yang akan memungkinkan Anda untuk berkeliling teka-teki "keluar". Jadikan aplikasi Anda memiliki status "aktivitas" yang hanya layar kosong. Pada onCreate pertama dari aktivitas tersebut, Anda dapat meluncurkan aktivitas lain di mana fungsi utama aplikasi Anda berada. "Keluar" kemudian dapat diselesaikan dengan menyelesaikan () pada aktivitas kedua ini dan kembali ke dasar hanya layar kosong. OS dapat menyimpan layar kosong ini dalam memori selama yang diinginkan ...

Intinya, karena Anda tidak bisa keluar ke OS, Anda hanya berubah menjadi ketiadaan yang diciptakan sendiri.

Tanpa fungsi keluar untuk pengembang aplikasi untuk membunuh aplikasi mereka sendiri itu adalah desain yang sangat buruk.

Aplikasi saya perlu memungkinkan pengguna untuk secara dinamis mengubah data secara dinamis selama runtime dan pengguna perlu me-restart aplikasi saya untuk membuat efek perubahan, tetapi Android tidak mengizinkan aplikasi saya restart dengan sendirinya. OS Android memiliki siklus hidup aplikasi desain yang sangat buruk.

Untuk menutup aplikasi di titik mana saja, gunakan FLAG_ACTIVITY_CLEAR_TOPflag di Intent lalusystem.exit();

Atau ada cara yang serupa, tetapi tanpa system.exit()ketika Anda ingin keluar panggil metode ini:

public void exit() {
    startActivity(new Intent(this, HomeActivity.class).
    setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | IntentCompat.FLAG_ACTIVITY_CLEAR_TASK).putExtra(EXIT_FLAG, true));
}

Di HomeActivity.onCreate()tambahkan kode berikut Anda

protected void onCreate(Bundle savedInstanceState) {
    if (getIntent().getBooleanExtra(EXIT_FLAG, false)) {
        if ((getIntent().getFlags() & Intent.FLAG_ACTIVITY_LAUNCHED_FROM_HISTORY) == 0) {
            finish();
        }
    }
......................

Ini akan bekerja tanpa memutus siklus hidup Android.

Pertama-tama, jangan pernah menggunakan System.exit (0). Itu seperti membuat seseorang tidur meninju kepalanya!

Kedua: Saya menghadapi masalah ini. Sebelum membagikan solusi saya, saya ingin membagikan pemikiran saya.

Saya pikir "Tombol Keluar" itu bodoh. Benar-benar sangat bodoh. Dan saya pikir pengguna (konsumen) yang meminta tombol keluar untuk aplikasi Anda juga bodoh. Mereka tidak mengerti bagaimana OS bekerja dan bagaimana mengelola sumber daya (dan itu melakukan pekerjaan dengan baik).

Saya pikir jika Anda menulis kode yang baik yang melakukan hal-hal yang benar (memperbarui, menyimpan, dan mendorong) pada saat dan kondisi yang tepat dan menggunakan hal-hal yang benar (Layanan dan Penerima) itu akan berfungsi dengan cukup baik dan tidak ada yang akan mengeluh .

Tetapi untuk melakukan itu Anda harus mempelajari dan mempelajari cara kerja Android. Bagaimanapun, ini adalah solusi saya untuk memberikan kepada pengguna "Tombol Keluar".

Saya membuat Menu Opsi yang selalu terlihat di setiap aktivitas (saya punya aktivitas super yang melakukan itu).

Ketika pengguna mengklik tombol itu inilah yang terjadi:

Intent intent = new Intent(this, DashBoardActivity.class);
intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);

SharedPreferences settings = getSharedPreferences(getString(PREF_ID), Context.MODE_PRIVATE);
SharedPreferences.Editor editor = settings.edit();
editor.putBoolean(FORCE_EXIT_APPLICATION, true);

  // Commit the edits!
editor.commit();
startActivity(intent);
finish();

Jadi saya menyimpan di SharedPreferences bahwa saya ingin mematikan aplikasi saya, dan saya memulai Intent. Silakan lihat bendera-bendera itu; itu akan menghapus semua backstack saya memanggil Aktivitas DashBoard saya yang merupakan aktivitas "rumah" saya.

Jadi di Aktivitas Dashboard saya, saya menjalankan metode ini di onResume:

private void checkIfForceKill() {

    // CHECK IF I NEED TO KILL THE APP

    // Restore preferences
    SharedPreferences settings = getSharedPreferences(
            getString(MXMSettingHolder.PREF_ID), Context.MODE_PRIVATE);
    boolean forceKill = settings.getBoolean(
            MusicSinglePaneActivity.FORCE_EXIT_APPLICATION, false);

    if (forceKill) {

        //CLEAR THE FORCE_EXIT SETTINGS
        SharedPreferences.Editor editor = settings.edit();
        editor.putBoolean(FORCE_EXIT_APPLICATION, false);

        // Commit the edits!
        editor.commit();

        //HERE STOP ALL YOUR SERVICES
        finish();
    }
}

Dan itu akan bekerja dengan cukup baik.

Satu-satunya hal yang saya tidak mengerti mengapa itu terjadi adalah bahwa ketika saya melakukan finish terakhir (dan saya sudah memeriksa: itu mengikuti semua aliran onPause → onStop → onDestroy) aplikasi masih pada aktivitas terbaru (tetapi ini kosong).

Sepertinya maksud terbaru (yang telah memulai DashboardActivity) masih dalam sistem.

Saya harus menggali lebih banyak untuk juga menghapusnya.

Siklus hidup aplikasi Android dirancang untuk pengguna ponsel, bukan pengguna komputer.

Siklus hidup aplikasi adalah paradigma brutal sederhana yang diperlukan untuk mengubah server Linux menjadi alat konsumen.

Android adalah Java over Linux, OS server lintas platform nyata. Begitulah cara penyebarannya begitu cepat. Siklus hidup aplikasi merangkum realitas yang mendasari OS.

Untuk pengguna seluler, aplikasi baru saja diinstal atau tidak diinstal. Tidak ada konsep berlari atau keluar. Bahkan, proses aplikasi dimaksudkan untuk berjalan sampai OS merilisnya untuk sumber daya yang dimiliki.

Karena ini adalah Stack Overflow, siapa pun yang membaca ini adalah pengguna komputer dan harus mematikan 90% pengetahuan mereka untuk memahami siklus hidup aplikasi seluler.

Perlu waktu lebih lama bagi saya untuk membaca T&J ini daripada benar-benar menerapkan Siklus Aplikasi Android yang tidak layak.

Ini adalah aplikasi GPS yang mengumpulkan poin dan mengirimkan lokasi saat ini ke layanan web setiap beberapa detik menggunakan utas ... Ini bisa menjadi polling setiap 5 menit dalam kasus Ted untuk pembaruan, kemudian onStop dapat dengan mudah memulai aktivitas pembaruan. Ted was soo khawatir jika ada yang ditemukan (asynchronous Ted, jangan kode seperti programmer Windows atau program Anda akan berjalan seperti program Windows ... ya, tidak terlalu sulit).

Saya melakukan beberapa kode awal di onCreate untuk mengatur hal-hal untuk aktivitas seumur hidup, termasuk checkUpdate.start();:

...

@Override
public void onStart() {
    super.onStart();
    isRemote = true;
    checkUpdate.resume();

    locationManager.requestLocationUpdates(LocationManager.GPS_PROVIDER, 2000, 0, luh);
}

@Override
public void onPause() {
    isRemote = false;
    checkUpdate.suspend();
    locationManager.removeUpdates(luh);
    super.onStop();
}

Kode ini mungkin benar-benar salah, tetapi berhasil. Ini adalah salah satu aplikasi Android pertama saya.

Voa, sebuah aplikasi yang tidak mengkonsumsi CPU ketika berada di latar belakang, namun langsung siap untuk dibuka kembali karena berada dalam RAM (meskipun tidak memegang RAM seperti siklus hidup Android) ... aplikasi selalu siap, itu telepon , teman-teman. Jika suatu aplikasi menggunakan semua RAM dan tidak dapat ditutup oleh OS maka masalahnya mungkin berhenti berdering = P Itu sebabnya OS harus dapat menutup aplikasi Anda ketika itu di latar belakang (jika aplikasi Anda tidak itu sumber daya babi itu tidak akan ditutup BTW), jadi mari kita menulis aplikasi yang lebih baik.

Setiap kali saat Anda pindah ke halaman berikutnya melalui niat, gunakan:

`YourActivityname.this.finish()`;

Contoh:

Intent intent = new Intent(getApplicationContext(), SMS.class);

startActivity(intent);
MainActivity.this.finish();

Agar tidak ada aktivitas yang berjalan di latar belakang dan ketika Anda ingin Keluar dari aplikasi Anda, gunakan:

MainActivity.this.finish();
android.os.Process.killProcess(android.os.Process.myPid());
System.exit(0);
getParent().finish();

Keluar ini bekerja seperti pesona bagi saya :)

Dalam kasus apa pun, jika Anda ingin menghentikan aplikasi Anda, Anda selalu dapat menelepon System.exit(0);.

Jika Anda memiliki 10,20 .. beberapa Kegiatan berjalan dan Anda ingin menyelesaikan semua itu dan keluar dari sistem.

Buat array statis di application classatauconstants class.

Konstanta

public class Constants {

public static ArrayList<Activity> activities = new ArrayList<Activity>();

}

MainActivity Tambahkan referensi aktivitas saat ini di larik ini

activity = MainActivity.this; Constants.activities.add(activity);

public class MainActivity extends Activity {

    private ImageView imageButton;
    private Activity activity;


    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        activity = MainActivity.this;
        Constants.activities.add(activity);

        imageButton = (ImageView) findViewById(R.id.camera);
        imageButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {

                // existing app.
                if (Constants.activities != null) {
                    for (int i = 0; i < Constants.activities.size(); i++) {
                        Activity s = Constants.activities.get(i);
                        s.finish();
                    }
                }
                //super.finish();
                finish();
                android.os.Process.killProcess(android.os.Process.myPid());
                System.exit(1);
            }
        });
    }
}