Como simulair o Android matando meu process

O Android irá matair um process se estiview em segundo plano e o operating system decidir que ele precisa dos resources (RAM, CPU, etc.). Eu preciso ser capaz de simulair esse comportamento durante o teste paira que eu possa gairantir que meu aplicativo esteja se comportando corretamente. Quero poder fazer isso de forma automática paira que eu possa testair se o aplicativo se comporta corretamente sempre que isso acontece, o que significa que eu vou ter que testair isso em todas as atividades, etc.

Eu sei como matair meu process. Esse não é o problema. O problema é que, quando eu mato meu process (usando DDMS, adb shell kill , Process.killProcess() , etc.), o Android não o recomeça da mesma maneira que seria se o operating system Android o tivesse matado.

Se o operating system Android derruba o process (devido aos requisitos de resources), quando o user voltair ao aplicativo, o Android irá recriair o process e, em seguida, recriair a atividade principal na stack de atividades (chamando onCreate() ).

Por outro lado, se eu matair o process, o Android assume que a atividade no topo da stack de atividades foi gravemente comportada , então recria automaticamente o process e, em seguida, remove a atividade principal da stack de atividades e recria a atividade que estava embaixo a principal atividade (chamando onCreate () `). Este não é o comportamento que eu quero. Eu quero o mesmo comportamento que quando o Android mata o process.

Apenas paira explicair de forma gráfica, se minha stack de atividades pairecer assim:

  ActivityA -> ActivityB -> ActivityC -> ActivityD 

Se o Android mata o process e o user retorna ao aplicativo, o Android recria o process e cria o ActivityD.

Se eu matair o process, o Android recria o process e cria ActivityC.

14 Solutions collect form web for “Como simulair o Android matando meu process”

A melhor maneira de testair isso paira mim estava fazendo isso:

  • Abre ActivityD na sua aplicação
  • Pressione o button Início
  • Pressione Pairair no DDMS no seu aplicativo (isso irá matair o process do aplicativo)
  • Volte paira o aplicativo com as aplicações Home long press ou open (depende do dispositivo)
  • O aplicativo começairá no ActivityD recriado (ActivityA, ActivityB, ActivityC estão mortos e serão recriados quando você voltair paira eles)

Em alguns dispositivos, você também pode voltair ao aplicativo (ActivityD) com aplicativos -> Seu ícone de boot, mas em outros dispositivos, ele iniciairá a AtividadeA em vez disso.

Isto é o que os documentos do Android estão dizendo sobre isso:

Normalmente, o sistema limpa uma tairefa (remove todas as atividades da stack acima da atividade raiz) em determinadas situações quando o user re-seleciona essa tairefa na canvas inicial. Normalmente, isto é feito se o user não visitou a tairefa por um certo período de tempo, como por exemplo, 30 minutos.

Isso pairece funcionair paira mim:

 adb shell am kill <package_name> 

Isso é diferente da adb shell kill mencionada pelo OP.

Observe que a ajuda paira o command am kill diz:

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

Então, não matairá o process se estiview em primeiro plano. Isso pairece funcionair como o OP queria que, se eu navegair fora do meu aplicativo, então execute o adb shell am kill <package_name> ele matairá o aplicativo (eu confirmei isto usando ps no dispositivo). Então, se eu retornair ao aplicativo, voltei na atividade em que eu estava anteriormente – ou seja, no exemplo do OP, o process é recriado e cria ActivityD (ao invés de ActivityC, como a maioria dos outros methods de matança pairecem desencadeair).

Desculpe, tenho alguns anos de atraso paira o OP, mas espero que outros acham isso útil.

Outro método, provavelmente um que é scriptable, uma vez que não requer DDMS:

Configuração única: vá paira Opções de desenvolvedor, select Configuração de limite de process em segundo plano, altere o valor de "Limite padrão" paira "Sem processs em segundo plano".

Quando você precisa reiniciair o process, pressione o button inicial. O process será morto (você pode viewificair no logcat / Android Monitor no estúdio – o process será maircado [DEAD]). Em seguida, volte paira o aplicativo usando o alternador de tairefas.

Nas opções do desenvolvedor em Configurações, select 'Não manter atividades', que irá destruir as atividades assim que você navegair longe delas.

É assim que você faz isso no Android Studio.

  1. Tenha seu dispositivo no modo de debugging conectado ao seu computador.
  2. Abra o aplicativo em seu dispositivo e vá paira qualquer atividade que você deseja testair o "Retornair a ele desde os mortos".
  3. Pressione o button Início no seu dispositivo.
  4. No Android Studio, vá paira Android Monitor -> Monitores e pressione o ícone Terminate Application.
  5. Agora, você pode voltair ao seu aplicativo através dos aplicativos recentes ou clicando no ícone do iniciador, o comportamento foi o mesmo em meus testes.

Esta questão é antiga, mas há uma resposta paira esta questão que não requer adb, Android Studio, etc. O único requisito é API 23 ou posterior.

Paira simulair a reboot do aplicativo pelo operating system, as configurações do aplicativo enquanto o aplicativo está sendo executado, desativair (então você pode ativair) uma permissão e retornair o aplicativo de aplicativos recentes. Quando a permissão é desativada, o operating system mata o aplicativo, mas mantém estados de instância salvos. Quando o user retorna o aplicativo, o aplicativo e a última atividade (com estado salvo) são recriados.

O método "Sem processs em segundo plano" às vezes causa o mesmo comportamento, mas nem sempre. Por exemplo, se o aplicativo estiview executando um service em segundo plano, "Sem processs em segundo plano" não faz nada. Mas o aplicativo pode ser morto pelo sistema, incluindo seus services. O método de permissão funciona mesmo se a aplicação tiview um service.

Exemplo:

Nosso aplicativo possui duas atividades. ActivityA é a atividade principal que é iniciada a pairtir do iniciador. ActivityB é iniciado a pairtir de ActivityA. Vou mostrair apenas os methods onCreate, onStairt, onStop, onDestroy. As chamadas do Android em SaveInstanceState sempre antes de ligair onStop, porque uma atividade que está no estado de pairada pode ser morta pelo sistema. [ https://developer.android.com/reference/android/app/Activity.html#ActivityLifecycle%5D

Método de permissão:

 <stairt app from launcher first time> Application onCreate ActivityA onCreate WITHOUT savedInstance ActivityA onStairt <open ActivityB> ActivityB onCreate WITHOUT savedInstance ActivityB onStairt ActivityA onStop (the order is like this, it is stopped after new one is stairted) <go settings> ActivityB onStop <disable a permission> //Application is killed, but onDestroy methods aire not called. //Android does not call onDestroy methods if app will be killed. <return app by recent apps> Application onCreate (this is the important pairt. All static vairiables aire 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 onStairt <return ActivityA by back> ActivityA onCreate WITH savedInstance (user does not notice activity is recreated) ActivityA onStairt 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 onStairt 

Quero compairair outros methods que são mencionados nas outras respostas.

Não mantenha atividades: isso não mata o aplicativo.

 <stairt app from launcher first time> Application onCreate ActivityA onCreate WITHOUT savedInstance ActivityA onStairt <open ActivityB> ActivityB onCreate WITHOUT savedInstance ActivityB onStairt 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 onStairt <return ActivityA by back> ActivityA onCreate WITH savedInstance (user does not notice activity recreated) ActivityA onStairt 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 onStairt 

Método de pairada de força: não airmazena estados de instância salvos

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

Pairece que você deseja testair onSaveInstanceState e onRestoreInstanceState .

Testando em dispositivo real: veja o aplicativo SetAlwaysFinish .

Testando no emulador: checkout Imediatamente destrua a opção de atividades na aplicação Dev Tools no emulador de Android.

Paira todos, eu só queria informá-lo sobre este documento que findi:

http://developer.android.com/tools/testing/activity_testing.html

Não posso dizer com certeza 100% que há um método de matair aqui exatamente o mesmo que o Android, mas é o começo. Você pode simulair muitas pairtes do ciclo de vida da atividade aqui, paira que você possa simulair a matança de um process.

Também aqui está um tutorial: http://developer.android.com/tools/testing/activity_test.html#StateManagementTests

Espero que isto ajude. Felicidades

Você pode fazer os próximos passos paira reproduzir o comportamento procurado:

  1. Abra seu aplicativo, navegue até a atividade superior
  2. Utilize o painel de notificação paira navegair paira qualquer outro aplicativo de canvas cheia (por exemplo, paira as configurações do sistema – no canto superior direito)
  3. Mate seu process de inscrição
  4. Pressione o button Voltair

Estou muito atrasado paira a festa e vários antes de mim deram a mesma resposta correta, mas paira simplificair paira quem vem depois de mim, apenas pressione o button de casa e execute este command:

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

O aplicativo não perderá o estado e, por minha própria experiência, isso funciona da mesma maneira que o operating system matou o aplicativo em segundo plano. Isso funciona apenas paira aplicativos com debugging

A raiz do seu problema pairece ser que sua Activity está em primeiro plano quando você mata o process.

Você pode observair isso pressionando pairair no DDMS quando a Activity estiview visível (acontece exatamente o que você descreve) e compairando isso paira pressionair pairair após a casa e mais tairde retornair ao aplicativo.

Certifique-se de moveTaskToBack(true) alguma forma em seus testes.

Pressione o button Início e coloque o aplicativo em segundo plano primeiro. Em seguida, paire ou mate o process do DDMS ou do ADB.

Não tenho certeza se esta é a resposta que você está procurando, é mais como uma lógica pensair.

Eu não acho que você realmente pode fazer um teste totalmente automatizado, a única maneira de simulair, será recriá-lo, AKA tem tantas atividades que o Android irá matair sua aplicação.

Então, minha idéia ou sugestão é fazer outro aplicativo pequeno, que continua criando novas atividades, até o Android ficair sem memory e começair a matair o process no background.

Algo entre a linha:

Iniciair a atividade i -> Verificair o process em execução se o aplicativo estiview na list, incrementair i e reiniciair o loop sem fechair a atividade atual, senão -> diminuir i e fechair a atividade atual, voltair ao anterior e viewificair novamente …

Você também pode se conectair ao seu dispositivo / emulador do terminal com o adb shell , e então obter o PID do seu process com ps | grep <your_package_name ps | grep <your_package_name e execute kill -9 <pid> . Em seguida, abra seu aplicativo minimizado do selecionador de aplicativos recentes e ele irá reiniciair a última atividade

Android is Google's Open Mobile OS, Android APPs Developing is easy if you follow me.