Android'in işlemimi öldürme simülasyonu

Android, arka planda ise ve işletim sistemi kaynaklara (RAM, CPU, vb.) İhtiyaç duyduğuna karar verirse bir işlemi öldürecektir. Uygulamamın doğru bir şekilde çalıştığından emin olmak için test sırasında bu davranışı simüle edebilmem gerekiyor. Uygulamanın bu gerçekleştiğinde doğru davranıp davranmadığını test edebilmem için otomatik bir şekilde yapabilmek istiyorum, yani her etkinlikte test etmek zorunda kalacağım.

Süreci nasıl öldüreceğimi biliyorum. Sorun bu değil. Sorun benim sürecini öldürdüğünde (DDMS kullanarak olmasıdır adb shell kill, Process.killProcess()Android Bir o Android işletim bunu kendisini öldürdüğünü olsaydı aynı şekilde yeniden başlamazsa, vs.).

Android işletim sistemi işlemi (kaynak gereksinimleri nedeniyle) öldürürse, kullanıcı uygulamaya geri döndüğünde Android işlemi yeniden oluşturur ve daha sonra etkinlik yığınındaki (arama onCreate()) en üstteki etkinliği yeniden oluşturur .

Öte yandan, ben süreci öldürmek, Android etkinlik yığının tepesine etkinliği kötü davrandım olduğunu varsayar otomatik sürecini yeniden yüzden, ardından etkinlik yığınından üst aktivitesini kaldırır ve altından oldu aktiviteyi yeniden oluşturur üst etkinlik (onCreate () `çağrılıyor). İstediğim davranış bu değil. Android'in süreci öldürmesi ile aynı davranışı istiyorum.

Sadece resimsel olarak açıklamak için, eğer aktivite yığınım şöyle görünüyorsa:

    ActivityA -> ActivityB -> ActivityC -> ActivityD

Android işlemi öldürür ve kullanıcı uygulamaya geri dönerse, Android işlemi yeniden oluşturur ve ActivityD oluşturur.

İşlemi öldürürsem, Android işlemi yeniden oluşturur ve ActivityC oluşturur.

Bunu benim için test etmenin en iyi yolu bunu yapmaktı:

• Uygulamanızda ActivityD'yi açın
• Ana Ekran düğmesine basın
• Terminate ApplicationAndroid Studio'daki Logcat penceresine basın (bu, uygulama işlemini öldürür, cihazınızı seçtiğinizden ve üstteki Logcat açılır listelerinde işlem yaptığınızdan emin olun)
• Ana Ekrana uzun basma veya açılmış uygulamalarla (cihaza bağlı olarak) uygulamaya geri dönün
• Uygulama yeniden oluşturulan ActivityD'de başlayacak (ActivityA, ActivityB, ActivityC öldü ve geri döndüğünüzde yeniden oluşturulacak)

Bazı cihazlarda Uygulamalar -> Başlatıcı simgenizle uygulamaya (ActivityD) geri dönebilirsiniz, ancak diğer cihazlarda bunun yerine ActivityA başlatılır.

Android dokümanlarının bu konuda söylediği şey:

Normalde, kullanıcı bir görevi ana ekrandan yeniden seçtiğinde, sistem belirli durumlarda bir görevi temizler (kök etkinliğinin üstündeki yığından tüm etkinlikleri kaldırır). Genellikle, kullanıcı görevi 30 dakika gibi belirli bir süre ziyaret etmediğinde yapılır.

Bu benim için işe yarıyor gibi görünüyor:

adb shell am kill <package_name>

Bu adb shell killOP tarafından belirtilenden farklıdır .

am killKomutun yardımının şunları söylediğine dikkat edin:

am kill: Kill all processes associated with <PACKAGE>.  Only kills.
  processes that are safe to kill -- that is, will not impact the user
  experience.

Yani, eğer ön planda ise süreci öldürmez. Bu, OP'nin istediğim gibi çalıştığı anlaşılıyor, eğer uygulamamdan uzaklaşırsam, uygulamayı çalıştırır adb shell am kill <package_name>(bunu pscihazda kullanarak onayladım ). Sonra uygulamaya dönersem, daha önce bulunduğum aktiviteye geri döndüm - yani OP'nin örneğinde süreç yeniden oluşturulur ve ActivityD oluşturur (diğer öldürme yöntemlerinin çoğu gibi tetikleyici gibi görünüyor).

Üzgünüm OP için birkaç yıl geç kaldım, ama umarım diğerleri bunu faydalı bulacaktır.

Başka bir yöntem, muhtemelen DDMS gerektirmediği için yazılabilir bir yöntemdir:

Tek seferlik kurulum: Geliştirici Seçenekleri'ne gidin, Arka plan işlemi sınır ayarı'nı seçin, 'Standart Sınır' dan 'Arka plan işlemi yok' olarak değeri değiştirin.

İşlemi yeniden başlatmanız gerektiğinde, ana sayfa düğmesine basın. İşlem öldürülecek (stüdyoda logcat / Android Monitor'de doğrulayabilirsiniz - işlem [DEAD] olarak işaretlenecektir). Ardından görev değiştiriciyi kullanarak uygulamaya geri dönün.

Bu soru eskidir, ancak bu soru için adb, Android Studio vb. Gerektirmeyen bir cevap vardır. Tek gereksinim API 23 veya daha yenisidir.

İşletim sistemi tarafından uygulamanın yeniden başlatılmasını simüle etmek için, uygulamanız çalışırken uygulama ayarlarına gidin, bir izni devre dışı bırakın (ardından etkinleştirebilirsiniz) ve uygulamayı son uygulamalardan döndürün. İzin devre dışı bırakıldığında, işletim sistemi uygulamayı öldürür ancak kaydedilen örnek durumlarını korur. Kullanıcı uygulamayı döndürdüğünde, uygulama ve son etkinlik (kaydedilmiş durumla birlikte) yeniden oluşturulur.

'Arka plan işlemi yok' yöntemi bazen aynı davranışa neden olur, ancak her zaman değil. Örneğin, uygulama bir arka plan hizmeti çalıştırıyorsa, "Arka plan işlemi yok" hiçbir şey yapmaz. Ancak uygulama hizmetleri de dahil olmak üzere sistem tarafından öldürülebilir. Uygulamada bir hizmet olsa bile izin yöntemi çalışır.

Misal:

Bizim app iki faaliyet vardır. ActivityA, başlatıcıdan başlatılan ana etkinliktir. ActivityB, ActivityA'dan başlatılır. Yalnızca onCreate, onStart, onStop, onDestroy yöntemlerini göstereceğim. Android, onStop'u çağırmadan önce her zaman onSaveInstanceState'i çağırır, çünkü durma durumunda olan bir etkinlik sistem tarafından öldürülebilir. [ https://developer.android.com/reference/android/app/Activity.html#ActivityLifecycle]

İzin yöntemi:

<start app from launcher first time>
Application onCreate
ActivityA onCreate WITHOUT savedInstance
ActivityA onStart
<open ActivityB>
ActivityB onCreate WITHOUT savedInstance
ActivityB onStart
ActivityA onStop (the order is like this, it is stopped after new one is started)
<go settings>
ActivityB onStop
<disable a permission>
//Application is killed, but onDestroy methods are not called.
//Android does not call onDestroy methods if app will be killed.
<return app by recent apps>
Application onCreate (this is the important part. All static variables are reset.)
ActivityB onCreate WITH savedInstance (user does not notice activity is recreated)
//Note that ActivityA is not created yet, do not try to access it.
ActivityB onStart
<return ActivityA by back>
ActivityA onCreate WITH savedInstance (user does not notice activity is recreated)
ActivityA onStart
ActivityB onStop
ActivityB onDestroy
<press back again, return launcher>
ActivityA onStop
ActivityA onDestroy
<open app again>
//does not call Application onCreate, app was not killed
ActivityA onCreate WITHOUT savedInstance
ActivityA onStart

Diğer cevaplarda bahsedilen diğer yöntemleri karşılaştırmak istiyorum.

Faaliyetleri tutmayın: Bu, uygulamayı öldürmez.

<start app from launcher first time>
Application onCreate
ActivityA onCreate WITHOUT savedInstance
ActivityA onStart
<open ActivityB>
ActivityB onCreate WITHOUT savedInstance
ActivityB onStart
ActivityA onStop
ActivityA onDestroy (do not keep)
<return launcher by home button>
ActivityB onStop
ActivityB onDestroy (do not keep) 
<retun app from recent apps>
// NO Application onCreate
ActivityB onCreate WITH savedInstance (user does not notice activity recreated)
ActivityB onStart
<return ActivityA by back>
ActivityA onCreate WITH savedInstance (user does not notice activity recreated)
ActivityA onStart
ActivityB onStop
ActivityB onDestroy
<press back again, return launcher>
ActivityA onStop
ActivityA onDestroy
<open app again>
//does not call Application onCreate, app was not killed
ActivityA onCreate WITHOUT savedInstance
ActivityA onStart

Zorla durdurma yöntemi: Kayıtlı örnek durumlarını saklamaz

<start app from launcher first time>
Application onCreate
ActivityA onCreate WITHOUT savedInstance
ActivityA onStart
<open ActivityB>
ActivityB onCreate WITHOUT savedInstance
ActivityB onStart
ActivityA onStop
<go settings>
ActivityB onStop
<force stop, return app from recent apps>
Application onCreate
ActivityA onCreate WITHOUT savedInstance 
//This is important part, app is destroyed by user.
//Root activity of the task is started, not the top activity.
//Also there is no savedInstance.

Partiye çok geç kaldım ve benden önce birkaç aynı cevabı verdi ama benden sonra gelenleri basitleştirmek için ev düğmesine basın ve bu komutu çalıştırın:

adb shell ps | grep <package name> | awk '{print $2}' | xargs adb shell run-as <package name again> kill

Uygulama durumu kaybetmeyecek ve kendi deneyimimden bu, işletim sisteminin uygulamayı arka planda öldürdüğü gibi çalışıyor. Bu yalnızca hata ayıklama yerleşik uygulamalar için çalışır

Android Studio'da böyle yaparsınız.

1. Cihazınızın Hata Ayıklama Modunda bilgisayarınıza bağlı olmasını sağlayın.
2. Cihazınızda uygulamayı açın ve "Ölüden dön" test etmek istediğiniz herhangi bir etkinliğe gidin.
3. Cihazınızdaki Ana Ekran düğmesine basın.
4. Android Studio'da Android Monitör -> Monitörler'e gidin ve Uygulamayı Sonlandır simgesine basın.
5. Artık son uygulamalar aracılığıyla uygulamanıza geri dönebilir veya başlatıcı simgesine tıklayarak davranışlarım testlerimde aynı olmuştur.

HOME düğmesiyle uygulamayı arka plana yerleştirin

Android Studio'da "Logcat" modunda işleminizi seçin, ardından alt sol köşedeki Uygulamayı Sonlandır'ı tıklayın

Şimdi uygulamanızı Android cihazdaki başlatıcıdan başlatın

EDIT: İnternete göre, aşağıdakiler de çalışır:

 adb shell am kill [my-package-name]

Gelecekten DÜZENLEME: nota bir şey kullanırsanız, Android Studio 4.0 bir değişiklik olmamıştır RunAS den sonra Terminatebir yayınlayacaktır Force Stop.

Ancak, daha sonra başlatıcıdan başlatırsanız ve daha sonra bu şekilde simüle etmeye çalışırsanız, istediğiniz sonuçları alırsınız (düşük bellek davranışı).

İstenen davranışı yeniden oluşturmak için sonraki adımları gerçekleştirebilirsiniz:

1. Uygulamanızı açın, en üst etkinliğe gidin
2. Başka bir tam ekran uygulamasına gitmek için bildirim panelini kullanın (örneğin, sistem ayarlarına - sağ üst köşede)
3. Başvuru sürecinizi öldürün
4. Geri düğmesine basın

Ayarlar altındaki Geliştirici seçeneklerinde, etkinliklerden ayrılır ayrılmaz etkinlikleri yok edecek olan 'Etkinlikleri tutma' seçeneğini belirtin.

Not: Aşağıdaki yararlı bir yoruma göre, bunu yalnızca statik değerlerin silinmesini önemsemiyorsanız kullanın.

Ana Ekran düğmesine basın ve uygulamayı önce arka plana koyun. Ardından işlemi DDMS veya ADB'den durdurun veya öldürün.

Ayrıca cihazınıza / emülatörünüze terminalden bağlanabilir adb shell, ardından işleminizin PID'sini alabilir ps | grep <your_package_nameve yürütebilirsiniz kill -9 <pid>. Ardından, son uygulama seçiciden simge durumuna küçültülmüş uygulamanızı açın, son etkinliği yeniden başlatacak

Sorunun kökü Activity, süreci öldürdüğünüzde ön plana çıkmış gibi görünüyor .

Bunu Activitygörünür durumdayken (tam olarak açıkladığınız şekilde gerçekleşir) DDMS'de durdur'a basarak ve bunu evden sonra durmaya ve daha sonra uygulamaya geri dönerek karşılaştırarak gözlemleyebilirsiniz .

Sadece moveTaskToBack(true)testlerinizde bir şekilde emin olun .

Aradığınız yanıtın bu olduğundan emin değilim, daha çok mantık düşüncesine benziyor.

Gerçekten tam otomatik bir test yapabileceğinizi düşünmüyorum, simüle etmenin tek yolu, onu yeniden yaratmak olacak, AKA'nın Android'in uygulamanızı öldüreceği birçok aktivitesi var.

Benim fikrim veya önerim, Android hafızası tükenene ve arka planı işlemeye başlayana kadar yeni aktiviteler açmaya devam eden başka bir küçük uygulama yapmak.

Hattın arasında bir şey var:

Etkinliği başlat i -> Uygulama listede bulunuyorsa çalışan işlemi kontrol edin, i'yi artırın ve geçerli etkinliği kapatmadan döngüyü yeniden başlatın, aksi takdirde -> i'yi azaltın ve mevcut etkinliği kapatın, önceki haline dönün ve tekrar kontrol edin ...

Uygulama süreci sona erdiğinde, Android etkinlik kayıtlarından geçer (girişler geçmiş yığınındaki etkinlikleri temsil eder) ve geçmişte hangilerinin saklanacağına ve hangilerinin kaldırılacağına karar verir .

Buradaki anahtar noktalardan biri olduğunu ActivityRecordadlandırılan alan haveStateAndroid Çerçeve mühendisleri, tarif olarak "Biz aldık geçen etkinlik durumunu?".

Varsayılan olarak, Android etkinliğin bir durumu olduğunu düşünür . Uygulama , etkinliğin devam ettiği etkinlik görev yöneticisi hizmetine rapor verdiğinde etkinlik durumsuz hale gelir ve bu, uygulama etkinliğin Durduruldu durumuna girdiğini bildirene kadar geçerlidir . Basit bir ifadeyle, değer, uygulama hedef sürümüne bağlı olarak aktivite olarak çağrılır ve veya çağrılır .haveStatefalseonResume()onStop()onSaveInstanceState()

İşlemi öldürürsem, Android işlemi yeniden oluşturur ve ActivityC oluşturur.

Bu durumda, ActivityD android:stateNotNeeded="true"uygulama bildiriminde bir özniteliğe sahip değildir ve şu anda ön planda çalışmaktadır, bu nedenle sistem son durumuna gelmediğinden Android bunu geçmişten kaldırır.

Android'in işlemimi öldürme simülasyonu

Birkaç kez bahsedildiği gibi, uygulamayı arka plana taşıyabilirsiniz, böylece etkinlik geri yığınındaki en üst düzey etkinlik durumunu kaydeder ve bundan sonra Android Debug Bridge, Android Studio veya Arka Plan İşlemleri Geliştirici Seçeneklerindeki Limit özelliği. Bundan sonra son etkinliğiniz başarıyla yeniden oluşturulacaktır.

Buna rağmen, başvuru süreci ölüm senaryosunu test etmenin başka bir basit yolu daha var. Yukarıda açıklananların tümünü ve şu anda çalışan ActivityD'den yeni ActivityE başlatırsanız, ActivityD onStop()geri aramasının yalnızca ActivityE onResume()yönteminden sonra çağrılması gerçeğini bilerek , aşağıdaki numarayı yapabilirsiniz.

class TerminatorActivity : Activity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        val isPrePie = applicationInfo.targetSdkVersion < Build.VERSION_CODES.P
        val callbacks = TerminatorLifecycleCallbacks(isPrePie)
        (applicationContext as Application).registerActivityLifecycleCallbacks(callbacks)
    }

    private class TerminatorLifecycleCallbacks(
        // Before P onSaveInstanceState() was called before onStop(), starting with P it's
        // called after
        // Used to schedule the death as app reports server that activity has stopped
        // after the latest of these was invoked
        private val isPrePie: Boolean
    ) : ActivityLifecycleCallbacksDefault {

        private val handler = Handler(Looper.getMainLooper())

        override fun onActivityPostStopped(activity: Activity) {
            if (isPrePie) {
                terminate()
            }
        }

        override fun onActivityPostSaveInstanceState(activity: Activity, outState: Bundle) {
            if (!isPrePie) {
                terminate()
            }
        }

        fun terminate() {
            handler.postDelayed(
                {
                    Process.killProcess(Process.myPid()) // This is the end... 
                },
                LAST_MILLIS
            )
        }

        companion object {
            // Let's wait for a while, so app can report and server can handle the update
            const val LAST_MILLIS = 100L
        }

    }

    private interface ActivityLifecycleCallbacksDefault : Application.ActivityLifecycleCallbacks {
        override fun onActivityCreated(activity: Activity, savedInstanceState: Bundle?) {}
        override fun onActivityStarted(activity: Activity) {}
        override fun onActivityResumed(activity: Activity) {}
        override fun onActivityPaused(activity: Activity) {}
        override fun onActivityStopped(activity: Activity) {}
        override fun onActivitySaveInstanceState(activity: Activity, outState: Bundle) {}
        override fun onActivityDestroyed(activity: Activity) {}
    }
}

Sonra sadece TerminatorActivityuygulamayı öldürmek istediğinizde başlayın .

Sonunda, Venom adı verilen başvuru sürecinizin ölümünün test edilmesini kolaylaştıran hafif bir araç var .