Başvurudan vazgeçmek kaşlarını çattı mı?

Android'i öğrenme girişimim devam ederken , aşağıdakileri okudum :

Soru: Kullanmayı öldürmek için bir menü seçeneği koymadıkça, kullanıcının uygulamayı öldürme seçeneği var mı? Böyle bir seçenek yoksa, kullanıcı uygulamayı nasıl sonlandırır?

Cevap: (Romain Guy): Kullanıcı bunu yapmaz, sistem bunu otomatik olarak yapar. Etkinlik yaşam döngüsü (özellikle onPause / onStop / onDestroy) bunun içindir. Ne yaparsanız yapın, bir "quit" veya "exit" uygulama düğmesi koymayın. Android'in uygulama modeli ile işe yaramaz. Bu, temel uygulamaların çalışma şekline de aykırıdır.

Hehe, Android dünyasında attığım her adım için bir tür problemle karşılaşıyorum = (

Görünüşe göre, Android'deki bir uygulamadan çıkamazsınız (ancak Android sistemi, uygulamanızı hissettiğinizde tamamen yok edebilir). Bunun nesi var? "Normal bir uygulama" olarak işlev gören bir uygulama yazmanın imkansız olduğunu düşünmeye başlıyorum - kullanıcı bunu yapmaya karar verdiğinde uygulamayı bırakabilir. Bu, işletim sisteminin yapılması gereken bir şey değildir.

Oluşturmaya çalıştığım uygulama Android Market için bir uygulama değil. Genel halk tarafından "geniş kullanım" için bir uygulama değil, çok dar bir iş alanında kullanılacak bir iş uygulaması.

Windows Mobile ve .NET'te var olan birçok sorunu ele aldığı için gerçekten Android platformu için geliştirmeyi dört gözle bekliyordum. Ancak, geçen hafta benim için biraz sapma oldu ... Umarım Android'i terk etmek zorunda değilim, ama şu anda çok iyi görünmüyor = (

Uygulamayı gerçekten bırakmamın bir yolu var mı ?

Bu nihayetinde sorunuza gelecektir, ancak önce bu yorum sırasında verilen çeşitli cevaplara çeşitli yorumlarınızda ortaya koyduğunuz bir dizi sorunu ele almak istiyorum. Fikrinizi değiştirmek gibi bir niyetim yok - dahası, bunlar gelecekte bu yazıyı okumak için gelenler için burada.

Mesele şu ki, Android uygulamamın ne zaman sonlandırılacağını belirlemesine izin veremem. kullanıcının tercihi olmalıdır.

Milyonlarca insan, ortamın uygulamayı gerektiği gibi kapattığı modelden son derece memnun. Bu kullanıcılar, bir Web sayfasını "sonlandırma" veya bir termostatı "sonlandırma" konusunda düşündüklerinden daha fazla Android uygulamasını "sonlandırmayı" düşünmezler.

iPhone kullanıcıları aynı şekilde, iPhone düğmesine basıldığında uygulamanın sonlandırıldığı gibi "hissetmemesi" gerekmez, çünkü birçok iPhone uygulaması, uygulama gerçekten kapatılmış olsa bile kullanıcının kaldığı yerden devam eder (yalnızca iPhone'dan beri) şu anda bir üçüncü taraf uygulamasına izin verir).

Yukarıda söylediğim gibi, uygulamamda çok şey oluyor (veriler cihaza PUSHed, her zaman orada olması gereken görevlerle listeler, vb.).

"Her zaman orada olması gereken görevlerle listeler" ne anlama geldiğini bilmiyorum, ancak "veriler cihaza PUSHed ediliyor" hoş bir kurgudur ve her durumda bir etkinlik tarafından yapılmamalıdır. AlarmManagerVerilerinizi maksimum güvenilirlik için güncellemek üzere zamanlanmış bir görev (yoluyla ) kullanın.

Kullanıcılarımız giriş yapar ve her telefon araması aldığında bunu yapamaz ve Android uygulamayı öldürmeye karar verir.

Bununla ilgilenen birçok iPhone ve Android uygulaması var. Genellikle, kullanıcıları her seferinde manuel olarak oturum açmaya zorlamak yerine oturum açma kimlik bilgilerini tutmalarıdır.

Örneğin, uygulamadan çıkarken güncellemeleri kontrol etmek istiyoruz

Bu herhangi bir işletim sisteminde bir hatadır. Bildiğiniz gibi, uygulamanızın "çıkılmasının" nedeni işletim sisteminin kapanması ve güncelleme işleminizin orta akışta başarısız olmasıdır. Genel olarak, bu iyi bir şey değil. Başlangıçta güncellemeleri kontrol edin veya güncellemeleri tamamen eşzamansız olarak kontrol edin (örn. Zamanlanmış bir görev aracılığıyla), asla çıkışta değil.

Bazı yorumlar, geri düğmesine basmanın uygulamayı hiç öldürmediğini gösterir (yukarıdaki sorumdaki bağlantıya bakın).

GERİ düğmesine basmak "uygulamayı öldürmez". Kullanıcı GERİ düğmesine bastığında ekrandaki etkinliği sonlandırır.

Yalnızca kullanıcılar sonlandırmak istediğinde sonlandırılmalıdır - asla başka bir şekilde. Android'de böyle davranan uygulamaları yazamıyorsanız, Android'in gerçek uygulamalar yazmak için kullanılamayacağını düşünüyorum = (

O zaman Web uygulamaları da olamaz. Veya WebOS , modellerini doğru anlarsam (henüz bir tane ile oynama şansı bulamadıysanız). Tüm bunlarda, kullanıcılar hiçbir şeyi "sonlandırmaz" - sadece ayrılırlar. iPhone biraz farklıdır, çünkü şu anda sadece bir şeyin bir seferde çalışmasına izin vermektedir (birkaç istisna dışında) ve bu nedenle ayrılma eylemi uygulamanın hemen sonlandırılmasını ima eder.

Uygulamayı gerçekten bırakmamın bir yolu var mı?

Herkesin söylediği gibi, kullanıcılar (BACK aracılığıyla) veya kodunuz (aracılığıyla finish()) şu anda çalışan etkinliğinizi kapatabilir. Kullanıcılar, düzgün yazılmış uygulamalar için, Web uygulamalarını kullanmak için "çık" seçeneğinden fazlasına ihtiyaç duymazlar.

Tanım olarak iki uygulama ortamı aynı değildir. Bu, yenileri ortaya çıktıkça ve diğerleri gömüldükçe ortamlardaki eğilimleri görebileceğiniz anlamına gelir.

Örneğin, "dosya" nosyonunu ortadan kaldırmak için büyüyen bir hareket vardır. Çoğu Web uygulaması kullanıcıları dosyaları düşünmeye zorlamaz. iPhone uygulamaları genellikle kullanıcıları dosyaları düşünmeye zorlamaz. Android uygulamaları genellikle kullanıcıları dosyaları düşünmeye zorlamaz. Ve bunun gibi.

Benzer şekilde, bir uygulamanın "sonlandırılması" kavramını ortadan kaldırmaya çalışan büyüyen bir hareket vardır. Çoğu Web uygulaması kullanıcıyı oturumu kapatmaya zorlamaz, bunun yerine belirli bir süre kullanılmadığında örtük olarak kullanıcının oturumunu kapatır. Android ile aynı şey ve daha az bir ölçüde iPhone (ve muhtemelen WebOS).

Bu, uygulama tasarımına daha fazla önem verilmesini, iş hedeflerine odaklanılmasını ve önceki bir uygulama ortamına bağlı bir uygulama modeline bağlı kalmamayı gerektirir. Bunu yapmak için zamana veya eğilime sahip olmayan geliştiriciler, mevcut zihinsel modellerini kıran yeni ortamlardan hayal kırıklığına uğrayacaklar. Bu, her iki ortamın da hatası değildir, bundan ziyade etrafından akan fırtınalar için bir dağın hatasıdır.

Örneğin, Hypercard ve Smalltalk gibi bazı geliştirme ortamları, uygulama ve geliştirme araçlarını tek bir kurulumda birleştirdi. Bu kavram, uygulamalara yönelik dil uzantılarının dışında (ör . Excel'de VBA , AutoCAD'de Lisp ) fazla bir şey yakalamadı . Bu nedenle, uygulamanın kendisinde geliştirme araçlarının varlığını kabul eden zihinsel modellerle gelen geliştiriciler, modellerini değiştirmek veya kendilerini modellerinin geçerli olacağı ortamlarla sınırlamak zorunda kaldılar.

Yani, yazdığınızda:

Keşfettiğim diğer dağınık şeylerle birlikte, Android için uygulamamızı geliştirmenin olmayacağını düşünüyorum.

Bu şu an için en iyisi, sizin için, gibi görünüyor. Benzer şekilde, Android ile bildirdiğiniz aynı sorunların bazıları Web uygulamalarında da (örneğin, "sonlandırma" yok) bulunduğundan, başvurunuzu Web'e aktarmaya çalışmamanız konusunda size danışmanlık yaparım. Veya, tersine, birgün eğer yapmak liman Web'e uygulamanızı, Web uygulamanın akış Android için daha iyi bir eşleşme olabileceğini bulmak olabilir ve o zaman bir Android portu yeniden ziyaret edebilirsiniz.

Bu konunun gelecekteki okuyucuları için buraya bir düzeltme eklemek istiyorum. Bu özel nüans uzun zamandır anlayışımdan kaçtı, bu yüzden hiçbirinizin aynı hataları yapmadığından emin olmak istiyorum:

System.exit()yığın üzerinde birden fazla etkinliğiniz varsa uygulamanızı öldürmez. Gerçekte olan şey, sürecin yığın üzerinde daha az bir etkinlikle öldürülüp hemen yeniden başlatılmasıdır . Bu, uygulamanızın Kapatmaya Zorla iletişim kutusu tarafından öldürüldüğünde veya işlemi DDMS'den öldürmeye çalıştığınızda da olur. Bu, bilgim için tamamen belgelenmemiş bir gerçektir.

Kısa yanıt, uygulamanızdan çıkmak istiyorsanız, kullanıcı çıkmak istediğinde yığındaki tüm etkinlikleri ve finish()TÜMÜNÜ izlemeniz gerektiğidir (ve hayır, Etkinlik yığınını yinelemenin bir yolu yoktur) , tüm bunları kendiniz yönetmeniz gerekir). Bu bile süreci veya sahip olabileceğiniz herhangi bir sarkan referansı gerçekten öldürmez. Sadece faaliyetleri bitirir. Ayrıca, Process.killProcess(Process.myPid())daha iyi çalışıp çalışmadığından emin değilim ; Test etmedim.

Öte yandan, yığınızda kalan aktivitelere sahip olmanız uygunsa, işleri sizin için süper kolaylaştıran başka bir yöntem daha vardır: Activity.moveTaskToBack(true)işleminizi arka planlatır ve ana ekranı gösterir.

Uzun cevap, bu davranışın arkasındaki felsefenin açıklanmasını içerir. Felsefe bir dizi varsayımdan doğar:

1. Her şeyden önce, bu sadece uygulamanız ön planda olduğunda gerçekleşir. Eğer arka planda ise, işlem gayet iyi sona erecektir. Ancak, ön planda ise, işletim sistemi kullanıcının yaptığı her şeyi yapmaya devam etmek istediğini varsayar. (Süreci DDMS'den öldürmeye çalışıyorsanız, önce ana sayfa düğmesine basmanız ve ardından öldürmeniz gerekir)
2. Ayrıca her bir faaliyetin diğer tüm faaliyetlerden bağımsız olduğunu varsayar. Bu, örneğin uygulamanızın tamamen ayrı olan ve sizin tarafınızdan yazılmayan Tarayıcı Etkinliğini başlatması durumunda genellikle doğrudur. Tarayıcı Etkinliği, manifest özelliklerine bağlı olarak aynı Görev üzerinde oluşturulabilir veya oluşturulamayabilir.
3. Etkinliklerinizin her birinin tamamen kendine bağlı olduğunu ve bir an önce öldürülebileceğini / geri yüklenebileceğini varsayar. (Uygulamam, verimli bir şekilde serileştirilemeyecek kadar büyük onSaveInstanceState, ancak whaddya yapacak çok büyük miktarda önbelleğe alınmış verilere dayanan birçok etkinliğe sahip olduğundan, bu özel varsayımı sevmiyorum?) Çoğu iyi yazılmış Android uygulaması için bu doğru olmalı, çünkü uygulamanızın arka planda ne zaman öldürüleceğini asla bilemezsiniz.
4. Son faktör bir varsayım değil, işletim sisteminin bir sınırlamasıdır: uygulamayı açık bir şekilde öldürmek, uygulamanın kilitlenmesi ile aynıdır ve aynı zamanda Android'in belleği geri kazanmak için öldürmesi ile aynıdır. Bu, bizim de zarafetle sonuçlanıyor: Android, uygulamanın çıkıp çıkmadığını ya da arka planda öldürüldüğünü anlayamadığından, kullanıcının kaldığı yere geri dönmek istediğini varsayar ve böylece ActivityManager işlemi yeniden başlatır.

Bunu düşündüğünüzde, bu platform için uygundur. İlk olarak, süreç arka planda öldürüldüğünde ve kullanıcı geri döndüğünde tam olarak bu olur, bu yüzden kaldığı yerden yeniden başlatılması gerekir. İkincisi, uygulama çöktüğünde ve korkunç Zorla Kapat iletişim kutusunu gösterdiğinde olan budur.

Kullanıcılarımın resim çekmesini ve yükleyebilmesini istiyorum. Kamera Etkinliğini aktivitemden başlatıyorum ve bir görüntü döndürmesini rica ediyorum. Kamera mevcut Görevimin üstüne itilir (kendi Görevinde oluşturulmak yerine). Kamerada bir hata varsa ve kilitlenirse, tüm uygulamanın kilitlenmesi gerekir mi? Kullanıcı açısından, yalnızca Kamera başarısız oldu ve önceki etkinliklerine geri döndürülmelidir. Böylece, yığındaki tüm aynı Aktivitelerle, kamera eksi ile işlemi yeniden başlatır. Senin Faaliyetleri yana olmalıdır öldürdükleri ve bir şapka açılır restore şekilde tasarlanmalıdır, bu bir problem olmamalı. O kadar maalesef tüm uygulamaların bu şekilde dizayn edilebilir değildir olduğunuRomain Guy veya başkası size ne söylerse söylesin, çoğumuz için bir problem. Bu nedenle, geçici çözümler kullanmamız gerekiyor.

Yani, kapanış tavsiyem:

• Süreci öldürmeye çalýţma. Ya çağrı finish()bütün faaliyetleri veya çağrı üzerine moveTaskToBack(true).
• İşleminiz çökerse veya öldürülürse ve benim gibi, şimdi kaybolan bellekteki verilere ihtiyacınız varsa, kök etkinliğine geri dönmeniz gerekir. Bunu yapmak startActivity()için Intent.FLAG_ACTIVITY_CLEAR_TOPbayrağı içeren bir Niyet ile görüşmelisiniz .
• Uygulamanızı Eclipse DDMS perspektifinden öldürmek istiyorsanız, ön planda olmamak daha iyidir, yoksa kendini yeniden başlatır. Önce Ana Ekran düğmesine basmanız ve ardından işlemi sonlandırmanız gerekir.

Tüm uygulamalarımın çıkma düğmeleri var ... ve sık sık kullanıcılardan olumlu yorumlar alıyorum. Platformun, uygulamaların onlara ihtiyaç duymayacağı bir şekilde tasarlanıp tasarlanmadığı umurumda değil. "Onları oraya koyma" demek saçma. Kullanıcı çıkmak istiyorsa ... Ben tam olarak bunu yapmak için erişim sağlar. Android'in çalışma şeklini azalttığını ve iyi bir uygulama gibi göründüğünü sanmıyorum. Yaşam döngüsünü anlıyorum ... ve gözlemim, Android'in bunu ele almakta iyi bir iş yapmadığıydı ... ve bu temel bir gerçektir.

Uygulamanızı monolitik bir uygulama olarak düşünmeyi bırakın. Kullanıcının Android hizmetleri aracılığıyla sağlanan "uygulama" ve "işlevler" ile etkileşime girebileceği bir kullanıcı arabirimi ekranı kümesidir.

Gizemli uygulamanızın ne yaptığını bilmemek gerçekten önemli değil. Biraz süper güvenli kurumsal intranete tünel olduğunu varsayalım, bazı izleme veya etkileşim gerçekleştirir ve kullanıcı "uygulamadan çıkıncaya kadar giriş yapmış olarak kalır. BT departmanınız komut verdiğinden, kullanıcılar intranetin IN veya OUT olduklarında çok bilinçli olmalıdır. Bu nedenle, bunun "zihninizi" bırakması için zihniyetiniz önemlidir.

Bu basit. Bildirim çubuğuna "İntranetteyim veya çalıştırıyorum" yazan bir bildirim gönderen bir hizmet oluşturun. Bu hizmetin uygulamanız için gereken tüm işlevleri gerçekleştirmesini sağlayın. Kullanıcılarınızın "uygulamanızla" etkileşime girmeleri için ihtiyaç duydukları kullanıcı arayüzü parçalarına erişmelerine olanak sağlamak için bu hizmete bağlanan etkinliklere sahip olun. Ve bir Android Menüsü -> Çık (veya oturumdan çıkma veya herhangi bir şey) düğmesine sahip olup, hizmetten çıkmasını söyler ve ardından etkinliğin kendisini kapatır.

Bu, tüm niyetler ve amaçlar için tam olarak istediğinizi söylediğiniz şeydir. Android yolu bitti. Bu "çıkış" örneklerinin olası zihniyete ilişkin örnekleri için Google Talk veya Google Haritalar Navigasyon'a bakın. Tek fark, aktivitenizden geri düğmesine basmanın, kullanıcının uygulamanızı yeniden canlandırmak istemesi durumunda UNIX işleminizi beklemede bırakmasıdır. Bu, bellekteki son erişilen dosyaları önbelleğe alan modern bir işletim sisteminden farklı değildir. Windows programınızdan çıktıktan sonra, gereksinim duyduğu büyük olasılıkla kaynaklar hala bellekte kalır ve artık artık ihtiyaç duyulmadığı için diğer kaynaklarla değiştirilmeyi beklerler. Android aynı şey.

Sorununu gerçekten görmüyorum.

Bu, katkıda bulunan pek çok uzmanla ilginç ve anlayışlı bir tartışma. Bu yazının Android geliştirme ana web sitesinden geri çevrilmesi gerektiğini hissediyorum, çünkü Android işletim sisteminin temel tasarımlarından biri etrafında dönüyor.

İki sentimi de buraya eklemek istiyorum.

Şimdiye kadar Android'in yaşam döngüsü etkinliklerini işleme biçiminden etkilendim ve yerel uygulamalara web benzeri bir deneyim kavramı getirdim.

Hala bir Quitdüğme olması gerektiğine inandığımı söyledikten sonra . Neden? ... ben veya Ted ya da buradaki teknoloji gurusu için değil, yalnızca son kullanıcı talebini karşılamak için.

Ben büyük bir Windows hayranı olmasam da, uzun zaman önce çoğu kullanıcının (X düğmesi) alışkın olduğu bir kavramı tanıttılar ... "'İstediğim zaman bir widget çalıştırmayı bırakmak istiyorum"

Bu, birisinin (işletim sistemi, geliştirici?) Kendi takdirine bağlı olarak bununla ilgileneceği anlamına gelmez ... sadece "alışkın olduğum Red X düğmem nerede" anlamına gelir. Benim eylemim 'bir düğmeye basarak çağrıyı sonlandırmak', 'bir düğmeye basarak cihazı kapatmak' ve benzerleri gibi olmalıdır ... bu bir algıdır. Eylemimin gerçekten amacına ulaşması kendi başına bir memnuniyet getirir.

Bir geliştirici, burada verilen önerileri kullanarak bu davranışı taklit edebilse de, algı hala devam etmektedir, yani bir uygulamanın son kullanıcıdan talep üzerine bağımsız, güvenilir ve tarafsız bir kaynak (OS) tarafından işlevini tamamen bırakması gerekir.

Sen edebilirsiniz basarak ya çıkmak Backdüğmesini veya arayarak finish()Gözlerinde farklı Activity. Açıkça öldürmek istiyorsanız finish(), bir telefondan arayın MenuItem.

Romain, bunun anlamsız olduğunu söyleyemez - kullanıcıların yaşamlarını bırakma veya kaydetme konusunda herhangi bir şeyleri önemsemelerine gerek yoktur, çünkü uygulama yaşam döngüsünün çalışma şekli sizi otomatik olarak kaydeden akıllı yazılım yazmaya teşvik eder ve ne olursa olsun durumunu geri yükler.

Bu tartışma, geliştiricilerin en iyi bilip bilmediği veya kullanıcının en iyi bilip bilmediği hakkında asırlık soruya dayanıyor. İnsan faktörlerinin her alanındaki profesyonel tasarımcılar her gün bununla mücadele ediyor.

Ted, Market'te en çok indirilen uygulamalardan birinin 'Uygulama Katili' olduğuna dikkat çekti. İnsanlar uygulamalardan ayrıldıklarında biraz ekstra serotonin alırlar. Bir masaüstü / dizüstü bilgisayar ile alışkınlar. İşlerin hızlı ilerlemesini sağlar. İşlemciyi serin tutar ve fanın çalışmasını önler. Daha az güç kullanır.

Bir mobil cihazın çok daha küçük bir gemi olduğunu düşündüğünüzde, özellikle 'artık ihtiyacınız olmayanı denize atmak' için teşviklerini takdir edebilirsiniz. Şimdi Android geliştiricileri işletim sisteminin en iyisini bildiğini ve bir uygulamayı bırakmanın antika olduğunu düşünüyorlar. Bunu yürekten destekliyorum.

Bununla birlikte, bu hayal kırıklığı kendi cehaletinden kaynaklansa bile kullanıcıyı hayal kırıklığına uğratmamanız gerektiğine inanıyorum. Bu nedenle, çoğunlukla bir Görünümü kapatmaktan başka bir şey yapmayan bir plasebo düğmesi olsa bile, 'Çık' seçeneğine sahip olmanın iyi bir tasarım olduğu sonucuna varıyorum.

Ted, başarmaya çalıştığın şey yapılabilir, belki de şu an bunu nasıl düşündüğünüzü değil.

Etkinlikler ve Hizmetler hakkında bilgi vermenizi öneririm. "Uygulama" terimini kullanmayı bırakın ve bileşenlere, yani Etkinlik, Hizmet'e başvurmaya başlayın. Android platformu hakkında daha fazla bilgi edinmeniz gerektiğini düşünüyorum; Bu, standart bir PC uygulamasından bir zihniyet değişikliğidir. Gönderilerinizden hiçbirinde "Etkinlik" kelimesi (SSS teklifinin kısa olması, yani kelimeleriniz değil) bulunmaması bana biraz daha fazla bilgi vermeniz gerektiğini söylüyor.

Blog yazısı Ne zaman Android Uygulamalarına Çıkış Düğmesi Eklenmeli (İpucu: Asla) benden çok daha iyi açıklıyor . Keşke her Android geliştiricisi zaten okumuş olsa.

alıntılar:

Benim deneyimime göre [kullanıcıların] gerçekten istediği şey: Bir uygulamanın kaynakları (pil, CPU döngüleri, veri aktarımı, vb.) Tüketmeyi durduracağının kesin bir yolu.

Birçok kullanıcı bir çıkış düğmesinin bu gereksinimi uyguladığını algılar ve eklenmesini ister. Geliştiriciler, kullanıcılarını memnun etmek için, zorunlu olarak bir tane ekleyin. Kısa bir süre sonra ikisi de başarısız olur.

• Çoğu durumda çıkış düğmesi basitçe arar Activity.finish(). Bu tam olarak geri düğmesine basmaya eşdeğerdir. Kesinlikle. Hizmetler çalışmaya devam eder ve yoklama devam eder. Kullanıcılar uygulamayı öldürdüklerini düşünebilirler ancak henüz öldürmediler ve yakında daha da rahatsız olacaklar.
• Çıkış davranışı artık belirsiz. Çıkış düğmeniz yalnızca Etkinliği kapatmalı mı yoksa ilgili tüm Servisleri, Alıcıları ve Alarmları da durdurmalı mıdır? Ne Backyapmalı? Bunun Homeyerine vururlarsa ne olur ? Uygulamanızda bir widget varsa ne olur? Çıkış düğmesi bunun güncellenmesini durdurmalı mıdır?

Çözüm, geri düğmesinin çıkış düğmesinden beklediğiniz gibi davranmasını sağlamaktır. Daha da iyisi, uygulama görünür olmadığında kaynakları tüketmeyi bırakmanız yeterlidir.

Devam edin ve makalenin tamamını okuyun.

Cevap: (Romain Guy): Kullanıcı bunu yapmaz, sistem bunu otomatik olarak yapar. Etkinlik yaşam döngüsü (özellikle onPause / onStop / onDestroy) bunun içindir. Ne yaparsanız yapın, bir "quit" veya "exit" uygulama düğmesi koymayın. Android'in uygulama modeli ile işe yaramaz. Bu, temel uygulamaların çalışma şekline de aykırıdır.

1: Tamamen başvurudan çıkmak genellikle mantıklı olmayabilir, ancak işe yaramaz. Pencerelerde çıkış seçeneği yoksa ne olur? Bellek doluyken ve işletim sistemi hangi programlarla yapıldığını tahmin etmek zorunda kaldığında sistem yavaş yavaş olurdu. Romain Guy ve hatta Larry Page ve Sergey Brin'in ne söylediğini umursamıyorum - bunlar tartışılmaz gerçekler: Yeni bir uygulama başlatılmadan önce belleklerini almak için görevleri öldürmek zorunda kaldıklarında sistemler daha yavaş çalışıyor. Bana bir uygulamayı öldürmenin zaman almadığını söyleyemezsin! Uzak yıldızlardan bile ışık var ... zaman alacak olan tamamen kapatmak uygulamalara imkan vererek bazı kullanım.

2: Temel uygulamaların nasıl çalıştığının aksine? Bunun anlamı ne? Şimdilik bir uygulamayı çalıştırmayı bitirdiğimde, artık herhangi bir iş yapmıyor ... Sadece belleği gerektiğinde işletim sistemi tarafından öldürülmeyi bekliyor.

Özetle, küçültme ve çıkma arasında belirgin bir fark vardır ve ikisi de diğeri için iyi vurur. Her vidada bir tornavida bırakıyor muyuz? Yoksa her kapıda bir anahtar mı? Kesici patlayana kadar tüm cihazlarımızı yüksekte bırakıyor muyuz ve başka bir cihazı açmamız gerekiyor mu? Bulaşık makinesini bulaşıklarla dolu bırakıyor muyuz ve her seferinde sadece yeni kirli olanlara yer açmak için yeteri kadar çıkarıyoruz? Tüm arabaları araba yoluna kadar bırakıyor muyuz - oh boş verin.

Kullanıcı bir uygulamayı en aza indirmek istiyorsa, en iyi şey onu en aza indirmektir. Bir kullanıcı bir uygulamadan çıkmak istiyorsa, elbette çıkmak en iyisidir.

Kaşlarını çattı mı? Bu Android'in görüşü - kaşlarını çattılar. Ve birçok bağımsız çaylak Android geliştiricisi kaşlarını çattı.

Ancak, tam aşağı doğru geldiğinde, iyi kodlama ve kötü kodlama vardır. İyi program akış modelleri vardır ve kötü program akış modelleri vardır.

Kullanıcı onlarla yapıldığını bildiğinde programları bellekte bırakmak sadece iyi bir program akışı değildir. Kesinlikle hiçbir amaca hizmet etmez ve yeni uygulamalar başlatırken veya uygulamaları çalıştırırken daha fazla bellek ayırır.

Arabanız gibi: Durma ışığında durmak veya belki de fast-food sürüşü yapmak veya ATM'de durdurmak gibi, onu çalışır durumda bıraktığınız zamanlar vardır. Ama kapatmak istediğiniz başka durumlar da var - işe gittiğinizde, bakkalda ve hatta evde.

Benzer şekilde, eğer bir oyun oynuyorsanız ve telefon çalarsa, evet. Oyunu duraklatın ve çalışmaya devam edin. Ancak kullanıcı bir süre oyunla yapılırsa, elbette çıkmasına izin verin.

Bazı uygulamalardaki çıkış düğmesi diğerlerinden daha önde olmalıdır. Örneğin, kullanıcının tamamen çıkmak isteyebileceği oyunların veya programların bariz bir çıkışı olmalıdır. Belki de, çıkmanın beklenmedik bir arzu olduğu e-posta programları gibi diğer programlar (e-postayı kontrol etmeye devam edebilmesi için) - bu programlar bir çıkış seçeneği ile ana kontrol giriş ekranı alanını boşa harcamamalı, ancak iyi bir program akışı için bir çıkış seçeneğine sahip olmalıdır. Birisi posta programlarının zayıf kapsama alanı içindeyken veya belki bir Skype çağrısında ya da her neyse e-postayı kontrol etmesini istemediğine karar verirse ne olur? İstedikleri takdirde e-posta programından çıkmalarına izin verin!

Askıya alma ve çıkma iki hayati görevdir ve ikisi de diğerinin rolünü yerine getirmez.

Bence buggy yazılımı olmadığı sürece uygulamayı bırakmaya gerek olmadığını düşünüyorum. Android, kullanıcı tarafından kullanılmadığında uygulamadan çıkar ve cihazın daha fazla belleğe ihtiyacı vardır. Arka planda bir hizmeti çalıştırmanız gereken bir uygulamanız varsa, büyük olasılıkla hizmeti kapatmanın bir yolunu isteyeceksiniz.

Örneğin, Google Listen uygulama görünür olmadığında podcast'i çalmaya devam eder. Ancak podcast'i kullanıcı ile işiniz bittiğinde kapatmak için her zaman duraklatma düğmesi vardır. Doğru hatırlıyorsam, Dinle, bildirim çubuğuna bir kısayol bile koyar, böylece her zaman duraklatma düğmesine hızlıca ulaşabilirsiniz. Başka bir örnek, örneğin internette sürekli bir hizmeti sorgulayan bir twitter uygulaması gibi bir uygulamadır. Bu tür uygulamalar, kullanıcının sunucuyu ne sıklıkta yoklayacağını veya hatta bir arka plan iş parçacığında yok olup olmayacağını seçmesine izin vermelidir.

Çıkışta çalışan kodunuz olması gerekiyorsa, onPause (), onStop () veya onDestroy () yöntemini uygun şekilde geçersiz kılabilirsiniz. http://developer.android.com/reference/android/app/Activity.html#ActivityLifecycle

Verilerinizi / bağlantılarınızı (ve böylece "uygulamanızı") nasıl kalıcı hale getireceğinizi bilmiyorsanız, Android ile yapmak için ihtiyaç duyduğunuz her şeyi yapamazsınız.

Bu sevimli küçük App Killers'ı indirenler genellikle pil ömrüne veya bellek kullanımına yardımcı olmadıklarını buluyorlar, ancak işletim sisteminin belleği verimli bir şekilde yönetme işini yapmasını engelliyorlar ...

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

Addison-Wesley tarafından yayınlanan "Android Kablosuz Uygulama Geliştirme" yi okumayı düşünürüm. Ben sadece bitirmek ve ÇOK ayrıntılı.

Android platformunda bazı temel yanlış anlamalarınız olduğu anlaşılıyor. Ben de ilk başta Android uygulamalarının uygulama yaşam döngüsünde biraz hayal kırıklığına uğradım, ancak daha büyük bir anlayışa geldikten sonra bu yaklaşımdan gerçekten keyif almaya başladım. Bu kitap tüm sorularınızı ve daha fazlasını cevaplayacaktır. Gerçekten yeni Android geliştiricileri için bulduğum en iyi kaynak.

Ayrıca, mevcut uygulamanın bir hat için bağlantı noktasını bırakmanız gerektiğini düşünüyorum. Uygulamanızı Android platformuna taşımak için bazı uygulama tasarımı değişecektir. Mobil cihazların masaüstü sistemlere göre çok sınırlı kaynaklara sahip olması ve Android cihazların birden fazla uygulamayı düzenli ve kaynağa duyarlı bir şekilde çalıştırmasına izin vermesi nedeniyle kullanılan uygulama yaşam döngüsü gereklidir. Platform hakkında biraz daha derinlemesine çalışma yapın ve bence yapmak istediğiniz şeyin tamamen mümkün olduğunu fark edeceksiniz. İyi şanslar.

Bu arada, Addison-Wesley veya bu kitapla ilişkili herhangi bir kişi veya kuruluşla hiçbir şekilde bağlantılı değilim. Yazımı tekrar okuduktan sonra biraz hayal kırıklığına uğradığımı hissediyorum. Sadece gerçekten, gerçekten zevk ve son derece yararlı buldum. :)

Zamanın neredeyse% 99'u bir Android uygulamasının kendi yaşam döngüsünü devralmasına gerek yoktur. Çoğu zaman uygulamanın daha iyi planlanması veya daha akıllı tasarımı söz konusudur. Örneğin, indirmeleri vb. İşlemek için dahili bir hizmet (dışa aktarılmadı) oluşturun veya kullanıcı iş akışı etrafında eylemler ve görevler tasarlayın.

Ancak bir irade olduğu yerde bir yol var deniliyor. Android, android.os.Process sınıfı aracılığıyla, temel işlemi kontrol etmek için Java'dan çok daha iyi bir API sağlar. Ve Java'nın aksine, basit bir java.lang.System.exit () çağrısının arkasına gizleyerek geliştiriciye moron gibi davranmaz.

Peki başvurunuzdan Android'de intihar etmesini nasıl istersiniz? Püf noktası basit:

Standart android.app.Application sınıfından devralınarak kendi Android uygulama sınıfınızı oluşturun (AndroidManifest.xml dosyasında bildirmeyi unutmayın).

OnCreate () yöntemini geçersiz kılın ve uygulamanızı başlatan işlem kimliğini depolayın:

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

Şimdi uygulamanızı öldürmek için bir kill () yöntemi sağlayın:

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

Şimdi intihar etmek için uygulamanıza ihtiyacınız olduğunda, sadece uygulama bağlamını yazın ve kill yönteminizi çağırın!

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

Android'deki, özellikle hizmetlerle ilgili süreç yönetimi politikaları nedeniyle, Android'in hizmetinizi yeniden başlatmayı seçebileceğini unutmayın (bkz . Android'de görev katiller kullanmamalısınız ).

Android'de bir uygulama tasarladığımda, bunu şu şekilde görüyorum:

• Başvurunuzla çalışıyorsunuz
• Telefon çaldı
• Aramayı cevapla
• Görüşmenin sonunda başvurunuza bulunduğunuz yerde geri dönersiniz

Bunu yapmak için, yalnızca telefonunuzun Backdüğmesine veya Homedüğmesine (kısa veya uzun basışla) ve bildirim çubuğuna ihtiyacınız vardır.

Uygulamamdan çıktığımda, Backdüğmeyi yalnızca uygulamadan çıkana kadar veya düğmesini kullanana kadar kullanıyorum Home.

Sanırım uygulamaların çoğu böyle düşünülüyor. Ancak bir tür oturum veya bağlantıya ihtiyacım varsa, bir oturum açma / oturum kapatma düğmesi ve bildirimi (başlık çubuğu veya başka bir şey) ile kullanıcıya açıkça belirttim. Bu saf "çıkış" tarzı uygulamadan oldukça farklı bir stil.

PC'lerde, çoklu GUI masaüstünüz var ve Android'de, açıkça çok göreviniz var, ancak her seferinde yalnızca bir uygulama görüntülüyorsunuz (burada widget'ları düşünmüyorum ^^). Ve bir cep telefonunda, istediğiniz zaman, yaptığınızdan daha önemli bir şey için bildirim alabilirsiniz.

Bu nedenle, bir uygulamanın tüm konsepti "uygulamaya giriş - iş çıkış uygulamasına" farklı bir şeye dayanır.

Hmmmm ...

Android uygulamasını doğru şekilde görmediğinizi düşünüyorum. Neredeyse kolayca istediğiniz gibi bir şey yapabilirsiniz:

• Uygulama faaliyetleri, geliştirici yaşam döngüsü belgelerinde teşvik edildiği gibi kaydetme / geri yükleme durumunu yapın.

• Geri yükleme aşamasında bazı oturum açma işlemleri gerekiyorsa (oturum açma / oturum bilgisi yok), bunu yapın.

• Sonunda bir düğme / menü / zaman aşımı ekleyin; bu durumda finish(), oturum açma ve diğer oturum bilgilerini kaydetmeden bir yapacaksınız ve uygulama oturumunun sonunu örtülü hale getireceksiniz: böylece uygulama yeniden başlatılırsa / öne çıkarılırsa yeni bir oturum başlatılır.

Bu şekilde, uygulamanın gerçekten bellekten kaldırılıp kaldırılmadığını umursamazsınız.

Eğer gerçekten bellekten kaldırmak istiyorsanız (bu hangi amaçla BTW cesareti ve?) İfadesinin sonundaki şartlı onu öldürebilir onDestroy()ile java.lang.System.exit(0)(ya da belki restartPackage(..)?). Tabii ki sadece "gerçekten uygulamayı sonlandırmak" istediğiniz durumda yapın, çünkü onDestroy()bir uygulama hiç değil normal faaliyet yaşam döngüsü bir parçasıdır.

Bir Android bağlamındaki bir Uygulama, belirsiz bir şekilde ilişkili Faaliyetlerden sadece bir grup olduğundan, bir Uygulamadan çıkmak gerçekten çok mantıklı değildir. Bir Etkinliği bitirebilir () ve Etkinlik yığınındaki önceki Etkinliğin görünümü çizilir.

Ted ile aynı fikirdeyim. Uygulamadan çıkmanın "Android yolu" olmadığını anlıyorum, ancak engellenmesi gerekmiyor gibi görünüyor. Uygulamaya gerçek bir çıkış yapmak istemenizin üç nedeni (yalnızca etkinlik değil):

1. Kullanıcı, düşük bellek durumunda hangi uygulamanın öldürüleceğini kontrol etmek isteyebilir. Önemli uygulama A arka planda çalışıyorsa, işiniz bittiğinde B uygulamasından çıkmak isteyebilirsiniz, böylece A uygulaması işletim sistemi tarafından öldürülmez.

2. Uygulamanızın bellekte önbelleğe alınmış hassas verileri varsa, bir virüs / solucan / haydut uygulamasının erişememesi için uygulamayı öldürmek isteyebilirsiniz. Güvenlik modelinin bunu önlemesi gerektiğini biliyorum, ama ne olur ne olmaz ...

3. Uygulamanız telefonu olumsuz yönde etkileyebilecek kaynaklar (ağ, CPU, sensörler vb.) Kullanıyorsa, bu kaynakların serbest kalmasını sağlamanın bir yolu uygulamadan çıkmaktır. İyi davranan uygulamaların gerekli olmadığında kaynakları boşaltması gerektiğini anlıyorum. Ama yine de, uygulamadan çıkmak bunu sağlamanın makul bir yolu gibi görünüyor.

Linux çekirdeği, bellek yetersiz katil adı verilen bir özelliğe sahiptir (yukarıda belirtildiği gibi, politikalar kullanıcı düzeyinde yapılandırılabilir ve çekirdek en uygun olanı değildir, ancak hiçbir şekilde gereksiz değildir).

Ve Android tarafından yoğun bir şekilde kullanılıyor:

• OOM katili kullanıcı alanı için değil

• Android Notes (OOM Killer Info - Android'de OOM özelliğini yapılandırabileceğiniz)

• Gerçek Hedefte Android Taşıma

Bu kill uygulamalarına yardımcı olmak için bazı kullanıcı alanı uygulamaları mevcuttur, örneğin:

• Autokiller / Android'in dahili görev katilini yapılandırma

Görünüşe göre finish () komutunda istediğiniz yanıtı buldunuz. Bu, uygulamanızı bellekten kaldırmaz, ancak Android kaynaklara her ihtiyaç duyduğunda bunu yapar, bu yüzden bunu açıkça yapmayacağınız herhangi bir fark yaratmaz.

Yalnızca bir uygulama çıkışının tipik olarak sahip olacağı tam etkiyi elde etmek için uygulamanın durumunu, cihazın önyüklemesinden hemen sonra çalıştırıldığı sırada normalde durumuna ne olursa olsun sıfırlamak istersiniz. tüm etkinliklerinizde finish () işlevini çağırmak için. Bu şekilde, kullanıcı uygulamanızı tekrar seçerse, simüle edilmiş "çıkıştan" önceki noktadan geriye hiçbir durum kalmadan "yeni" çalıştırılmış gibi görünür.

Kullanıcının çalışmasını veya herhangi bir şeyi kaydetmek gibi yalnızca "çıkışta" gerçekleşmesi gereken bazı özel işlemler varsa, bunları yukarıdaki rutinin yeniden başlatma kısmından önce de gerçekleştirebilirsiniz.

Bu yaklaşım, Android'in uygulamaların kapatılması da dahil olmak üzere işletim sisteminin kaynaklarının yönetimini işletim sisteminin elinde bırakma felsefesini ihlal etmeden bir "çıkış" komutuna sahip olma hedefinize ulaşmanızı sağlar.

Kişisel olarak, bu yaklaşımı kullanmam, çünkü Android kullanıcıları bir uygulamanın tekrar ziyaret ettiklerinde sürekliliğini korumasını bekler ve bu nedenle bir uygulamadan "çıkma" yöntemine alışık olmazlar. Bunun yerine, kullanıcının işlemde "bırakmaya" gerek kalmadan uygulamayı varsayılan bir başlangıç ​​durumuna sıfırlamak için çağırabileceği bir "temizle" işlevini destekliyorum.

Bunun tek istisnası, kullanıcının uygulamanın kapanmasına neden olmak için geri düğmesine yeterli sayıda vurmasıdır. Bu durumda, kullanıcının tarafına durumun kaydedileceği beklentisi yoktur (ve uygulamada kaydedilmemiş bir durum varsa, geliştirici olarak, kaydedilmemiş verileri algılayan geri düğmesini işleyen kodunuz olmalıdır ve kullanıcıdan SharedPreferences'e veya bir dosyaya veya başka bir geçici olmayan ortama kaydetmesini ister).

System.exit (0) ile ilgili olarak:

Uygulamanızı kaba bir sonlıkla kapatmak için system.exit (0) kullanmaya karar verirseniz (örneğin, son geri düğmesine basmanın bir sonucu olarak), o zaman benim için bu "işe yarar" ve bazılarında Vakalar, herhangi bir iz bırakmadan bir uygulamayı kapatabilmemin tek yolu oldu, bu yaklaşımı kullandığınızda Jelly Bean'de meydana gelen küçük bir aksaklık var.

Özellikle, uygulamanızı açmak için Son Uygulamalar listesini kullanırsanız ve ardından uygulamayı kapatmak için geri düğmesini kullanırsanız (bu kapanma system.exit (0) aracılığıyla uygulandığında), Son Uygulamalar listesi yeniden görünür hale gelir asla kapatılmadı. Daha sonra ikinci kez çalıştırmak için uygulamanızın o listedeki girişine dokunursanız , aynı açık olan Son Uygulamalar listesinden yanıt gelmez.

Bunun nedeninin, Son Uygulamalar listesinin, system.exit (0) kullanarak uygulamayı kapatmış olmanız nedeniyle işlevsel olmayan hale gelen uygulamanıza yapılan bir referansı tuttuğundan şüpheleniyorum. Finish () kullanarak uygulamanızın daha medeni bir şekilde kapatılması, işletim sistemini Son Uygulamalar listesini yenilemesine izin verecek şekilde bilgilendirmiş olabilir, ancak system.exit (0) görünüşte bunu yapmaz.

Bu, kendi başına büyük bir sorun değildir, çünkü çok az kişi Son Uygulamalar'dan bir uygulama açar, ardından çıkar ve hemen aynı açık Son Uygulamalar listesinden tekrar açar. Ana sayfa düğmesine dokunup Son Uygulamalar listesini tekrar açarlarsa, uygulamanızın girişi orada olacak ve tamamen işlevsel olacaktır. Ancak , system.exit (0) kullanımının, uygulamanız ve işletim sistemi arasındaki uygun iletişime müdahale edebileceğini gösterdiğini düşünüyorum ve bu, bu yaklaşımı kullanmanın başka, daha ciddi, muhtemelen ince sonuçları olabileceğini düşündürmektedir.

Umarım işler zamanla değişir. Uygulama işlemi işletim sistemi tarafından doğru bir şekilde yerleştirilmişse, kullanıcı bir uygulamayı veya işlemi öldürebilmelidir. Uygulamaların mükemmel bir şekilde yazılması gerektiği veya kullanıcının yalnızca tüm SDK önerilerini takip eden uygulamaları kullanacağı fikri vardır. Bence bu uzun bir emirdir.

"Çıkış" bilmecesini aşmanıza izin verecek (nispeten) basit bir tasarım var. Uygulamanızın yalnızca boş bir ekran olan bir "temel" duruma (etkinlik) sahip olmasını sağlayın. Etkinliğin ilk on'unda, uygulamanızın ana işlevinin bulunduğu başka bir etkinlik başlatabilirsiniz. "Çıkış", bu ikinci etkinliği bitirip () tamamlayarak ve yalnızca boş bir ekranın tabanına giderek gerçekleştirilebilir. İşletim sistemi bu boş ekranı istediği sürece bellekte tutabilir ...

Özünde, işletim sisteminden çıkamadığınız için, sadece kendi yarattığınız bir hiçliğe dönüşürsünüz.

Uygulama geliştiricinin kendi uygulamasını öldürmesi için bir çıkış fonksiyonu olmadan çok kötü bir tasarımdır.

Uygulamamın, çalışma zamanı sırasında kullanıcının dinamik olarak verileri dinamik olarak değiştirmesine izin vermesi gerekiyor ve kullanıcının değişiklik efekti yapmak için uygulamamı yeniden başlatması gerekiyor, ancak Android, uygulamamın kendi başına yeniden başlamasına izin vermedi. Android işletim sistemi çok kötü bir tasarım uygulama yaşam döngüsüne sahiptir.

Bir uygulamayı herhangi bir noktada kapatmak için FLAG_ACTIVITY_CLEAR_TOPNiyet'teki bayrağı kullanın ve ardındansystem.exit();

Veya benzer bir yol var, ancak system.exit()çıkmak istediğinizde bu yöntemi çağırın:

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

Senin içinde HomeActivity.onCreate()eklenti şu kodu

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

Bu, Android yaşam döngüsünü bozmadan çalışacaktır.

Her şeyden önce asla asla System.exit (0) kullanmayın. Bir insanın kafasına yumruk atmasını uyku gibi yapmak!

İkincisi: Bu sorunla karşı karşıyayım. Çözümümü paylaşmadan önce düşüncelerimi paylaşmak istiyorum.

Bir "Çıkış Düğmesi" aptal olduğunu düşünüyorum. Gerçekten çok aptalca. Ve bence başvurunuz için bir çıkış düğmesi isteyen kullanıcılar da (aptal) aptal. İşletim sisteminin nasıl çalıştığını ve kaynakları nasıl yönettiğini anlamıyorlar (ve harika bir iş çıkarıyor).

Doğru şeyleri (güncellemeler, kaydeder ve iter) doğru zamanda ve koşullarda yapan iyi bir kod yazarsanız ve doğru şeyleri (Servis ve Alıcı) kullanarak oldukça iyi çalışacağını ve hiç kimsenin şikayet etmeyeceğini düşünüyorum .

Ancak bunu yapmak için Android'de işlerin nasıl çalıştığını öğrenmeli ve öğrenmelisiniz. Her neyse, bu benim kullanıcılara bir "Çıkış Düğmesi" sağlamak için benim çözümdür.

Her etkinlikte her zaman görülebilen bir Seçenekler Menüsü oluşturdum (bunu yapan bir süper etkinliğim var).

Kullanıcı bu düğmeyi tıkladığında bu olur:

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

Uygulamamı öldürmek istediğim SharedPreferences'a kaydediyorum ve bir Niyet başlatıyorum. Lütfen şu bayraklara bakın; bunlar benim "ev" etkinliğim olan DashBoard Etkinliğimi çağıran tüm backstack'ımı temizleyecek.

Bu yüzden Gösterge Tablosu Etkinliğimde bu yöntemi onResume'de çalıştırıyorum:

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

Ve oldukça iyi çalışacak.

Neden olduğunu anlamadığım tek şey, son bitirme işlemini yaptığımda (ve kontrol ettim: onPause → onStop → onDestroy) tüm doğru akışını izliyor olması, uygulamanın hala son etkinlikte (ancak boş).

Görünüşe göre (DashboardActivity'yi başlatan) son amaç hala sistemdedir.

Çıkarmak için daha fazla kazmalıyım.

Android uygulama yaşam döngüsü, bilgisayar kullanıcıları için değil cep telefonu kullanıcıları için tasarlanmıştır.

Uygulama yaşam döngüsü, bir Linux sunucusunu bir tüketici cihazına dönüştürmek için gereken vahşice basit bir paradigmadır.

Android, gerçek bir platformlar arası sunucu işletim sistemi olan Linux üzerinden Java'dır. İşte bu kadar çabuk yayıldı. Uygulama yaşam döngüsü, işletim sisteminin altında yatan gerçekliği kapsar.

Mobil kullanıcılar için uygulamalar yeni yüklenir veya yüklenmez. Koşma veya çıkma kavramı yoktur. Aslında, uygulama süreçleri, işletim sistemi bunları tutulan kaynakları için serbest bırakana kadar çalıştırılmalıdır.

Bu Yığın Taşması olduğundan, bunu okuyan herkes bir bilgisayar kullanıcısıdır ve mobil uygulama yaşam döngüsünü anlamak için bilgilerinin% 90'ını kapatmalıdır.

Bu soru ve cevapları okumak, yarı uygun bir Android Uygulama Yaşam Döngüsü uygulamaktan daha uzun sürdü.

Puanlar için anket yapan ve mevcut konumu bir iş parçacığı kullanarak birkaç saniyede bir web hizmetine gönderen bir GPS uygulaması ... Ted'in güncellemesinde her 5 dakikada bir yoklama olabilir, o zaman onStop Ted'in güncellemesini başlatabilir birinin bulunup bulunmadığı konusunda endişeli (zaman uyumsuz Ted, bir Windows programcısı gibi kod yazmayın yoksa programlarınız Windows programları gibi çalışacaktır ... eww, o kadar da zor değil).

OnCreate bazı başlangıç ​​kodları dahil olmak üzere etkinlik yaşam için şeyler ayarlamak için yaptım 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();
}

Bu kod tamamen yanlış olabilir, ancak çalışır. Bu benim ilk Android uygulamalardan biri.

Voilà, arka planda olduğunda CPU tüketmeyen, ancak RAM'de olduğu için (Android yaşam döngüsü gibi RAM tutmasa da) anında yeniden açılmaya hazır bir uygulama ... bir uygulama her zaman hazır, bir telefon , çocuklar / kızlar. Bir uygulama tüm RAM'i kullanacaksa ve işletim sistemi tarafından kapatılamıyorsa, o zaman çalmayı durdurabilir = P Bu yüzden işletim sisteminin arka planda olduğunda uygulamanızı kapatabilmesi gerekir (uygulamanız çalışmıyorsa) BTW kapatılmayacak bir kaynak domuzudur), bu yüzden daha iyi uygulamalar yazalım.

Niyet yoluyla bir sonraki sayfaya geçtiğinizde şunu kullanın:

`YourActivityname.this.finish()`;

Misal:

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

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

Arka planda hiçbir etkinlik çalışmaz ve uygulamanızdan çıkmak istediğinizde şunu kullanın:

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

Bu çıkış benim için bir cazibe gibi çalıştı :)

Her durumda, başvurunuzu sonlandırmak isterseniz her zaman arayabilirsiniz System.exit(0);.

10,20 .. birden fazla etkinliğiniz varsa ve hepsini bitirmek ve sistemden çıkmak istiyorsanız.

application classVeya içinde statik bir dizi oluşturmaconstants class.

Sabitler

public class Constants {

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

}

MainActivity Bu diziye geçerli etkinlik referansını ekle

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