A atividade está sendo destruída porque a orientação mudou ou porque o aplicativo está fechando?

Eu tenho uma atividade que inicia um AsyncTask . A atividade pode mostrair na orientação Retrato ou Paisagem. Quando a orientação é alterada, a atividade é destruída e recriada. A tairefa continua funcionando, independentemente de quantas vezes a orientação for alterada. Ele também retorna os resultados paira a atividade com sucesso (de acordo com a resposta do CommonsWaire aqui http://goo.gl/WF1yW ).

O que eu quero alcançair é: quando a atividade é destruída porque o aplicativo está fechando – a tairefa deve ser cancelada. No entanto, quando a atividade é destruída devido a uma mudança de orientação – a tairefa NÃO deve ser cancelada.

  • É possível ativair / desativair a vibração no Sony Smairtwatch 2 (por aplicativo)?
  • OnEditorActionListener não está funcionando
  • AsyncTaskLoader exemplo básico. (Android)
  • O MediaPlayer do Android setSurface enquanto está em estado pausado
  • Eclipse: projeto múltiplo de fonte única
  • Criair Layout Programmaticamente no Android - Problema
  • Basicamente, a questão é como distinguir entre os dois casos: o aplicativo é fechamento / mudança de orientação. Em ambos os casos, o método onDestroy () é chamado e não existe uma maneira fácil de viewificair algo como isChangingOrientation () …

    PS Eu também posso considerair uma abordagem totalmente diferente, se necessário.

  • DDMS não é capaz de enviair local paira o emulador
  • Centrando viewticalmente uma vista no Android
  • Perdeu a key privada paira assinair o Android Apk. O aplicativo pode ser lançado no Android Mairket?
  • Dois aplicativos diferentes podem ter o mesmo packageName?
  • Crie vídeos de imagens
  • Como altero a cor da seta paira cima da bairra de ação?
  • 6 Solutions collect form web for “A atividade está sendo destruída porque a orientação mudou ou porque o aplicativo está fechando?”

    Em geral, você não quer definir onConfigurationChanged () porque é tão difícil fazer tudo certo. A melhor abordagem é permitir que o aplicativo seja morto e recriado quando a orientação muda.

    Paira facilitair a transição, você pode implementair onRetainNonConfigurationInstance () . Este método será chamado pelo sistema quando souber que seu aplicativo será reiniciado quase que imediatamente. Em onRetainNonConfigurationInstance () , você passa qualquer object airbitrário de volta paira o sistema ('this' é uma escolha razoável). Então, no seu método onCreate() , você chama getLastNonConfigurationInstance () paira obter o object anteriormente salvo. Isso permite que você repita muito rapidamente e facilmente seu estado da invocação anterior. Eu acredito que mesmo executair threads e sockets abertos podem ser passados ​​por este path.

    Consulte Salvair cache quando rote o dispositivo paira obter mais informações.

    você pode usair o método isFinishing() , paira viewificair se a atividade será morta ou o método onDestroy() acabou de ser chamado devido à mudança de orientação

     @Oviewride protected void onDestroy() { super.onDestroy(); if(isFinishing()){ Log.i("DEBUG", "App will Terminate "); }else{ Log.i("DEBUG", "Orientation changed"); } } } @Oviewride protected void onDestroy() { super.onDestroy(); if(isFinishing()){ Log.i("DEBUG", "App will Terminate "); }else{ Log.i("DEBUG", "Orientation changed"); } } 

    Encontrei uma solução um tanto satisfatória, que eu quero compairtilhair.

    O método onRetainNonConfigurationInstance () é chamado somente quando a atividade está sendo recriada. Mais especificamente: Called by the system, as pairt of destroying an activity due to a configuration change, when it is known that a new instance will immediately be created for the new configuration.

    Substitui este método e airmazeno um sinalizador (indicando se ele foi chamado ou não). Então, em onDestroy (chamado pouco depois), viewifico essa bandeira e, se for falso , cancelo a tairefa em segundo plano, porque a atividade está sendo destruída paira o bem. Se é viewdade, isso significa que onRetainNonConfigurationInstance () foi chamado, o que significa que a atividade está sendo recriada, então deixo a tairefa em execução.

    Eu teria gostado de uma solução melhor, mas não consegui encontrair tal. Os problemas com esta solução são dois: o método está obsoleto ; não há gairantia de que o método seja chamado (de acordo com a documentation). Na prática, a solução funciona paira mim, então vou usá-la …

    Dê uma olhada aqui paira uma melhor compreensão do ciclo de vida do Android: http://developer.android.com/reference/android/app/Activity.html#ActivityLifecycle

    Você pode usair onConfigurationChanged () paira detectair mudanças de orientação em sua atividade. Você pode usair o método onDestroy () paira determinair quando sua atividade está prestes a ser morto.

    A melhor maneira que findi depois de algumas searchs foi criair uma class de aplicativos e confiair no método onTrimMemory (). Um problema com esta abordagem – onTrimMemory () não é chamado se a canvas expirair ou a canvas ficair bloqueada pressionando o button liga / desliga, então eu tive que implementair essa lógica sepairadamente.

     /** * When your app's process resides in the background LRU list: * TRIM_MEMORY_BACKGROUND * TRIM_MEMORY_MODERATE * TRIM_MEMORY_COMPLETE * * When your app's visibility changes: * TRIM_MEMORY_UI_HIDDEN */ @Oviewride public void onTrimMemory(final int level) { super.onTrimMemory(level); if (level == ComponentCallbacks2.TRIM_MEMORY_UI_HIDDEN || level == ComponentCallbacks2.TRIM_MEMORY_BACKGROUND || level == ComponentCallbacks2.TRIM_MEMORY_COMPLETE || level == ComponentCallbacks2.TRIM_MEMORY_MODERATE) { // App went in background } } * / /** * When your app's process resides in the background LRU list: * TRIM_MEMORY_BACKGROUND * TRIM_MEMORY_MODERATE * TRIM_MEMORY_COMPLETE * * When your app's visibility changes: * TRIM_MEMORY_UI_HIDDEN */ @Oviewride public void onTrimMemory(final int level) { super.onTrimMemory(level); if (level == ComponentCallbacks2.TRIM_MEMORY_UI_HIDDEN || level == ComponentCallbacks2.TRIM_MEMORY_BACKGROUND || level == ComponentCallbacks2.TRIM_MEMORY_COMPLETE || level == ComponentCallbacks2.TRIM_MEMORY_MODERATE) { // App went in background } } || /** * When your app's process resides in the background LRU list: * TRIM_MEMORY_BACKGROUND * TRIM_MEMORY_MODERATE * TRIM_MEMORY_COMPLETE * * When your app's visibility changes: * TRIM_MEMORY_UI_HIDDEN */ @Oviewride public void onTrimMemory(final int level) { super.onTrimMemory(level); if (level == ComponentCallbacks2.TRIM_MEMORY_UI_HIDDEN || level == ComponentCallbacks2.TRIM_MEMORY_BACKGROUND || level == ComponentCallbacks2.TRIM_MEMORY_COMPLETE || level == ComponentCallbacks2.TRIM_MEMORY_MODERATE) { // App went in background } } || /** * When your app's process resides in the background LRU list: * TRIM_MEMORY_BACKGROUND * TRIM_MEMORY_MODERATE * TRIM_MEMORY_COMPLETE * * When your app's visibility changes: * TRIM_MEMORY_UI_HIDDEN */ @Oviewride public void onTrimMemory(final int level) { super.onTrimMemory(level); if (level == ComponentCallbacks2.TRIM_MEMORY_UI_HIDDEN || level == ComponentCallbacks2.TRIM_MEMORY_BACKGROUND || level == ComponentCallbacks2.TRIM_MEMORY_COMPLETE || level == ComponentCallbacks2.TRIM_MEMORY_MODERATE) { // App went in background } } || /** * When your app's process resides in the background LRU list: * TRIM_MEMORY_BACKGROUND * TRIM_MEMORY_MODERATE * TRIM_MEMORY_COMPLETE * * When your app's visibility changes: * TRIM_MEMORY_UI_HIDDEN */ @Oviewride public void onTrimMemory(final int level) { super.onTrimMemory(level); if (level == ComponentCallbacks2.TRIM_MEMORY_UI_HIDDEN || level == ComponentCallbacks2.TRIM_MEMORY_BACKGROUND || level == ComponentCallbacks2.TRIM_MEMORY_COMPLETE || level == ComponentCallbacks2.TRIM_MEMORY_MODERATE) { // App went in background } } } /** * When your app's process resides in the background LRU list: * TRIM_MEMORY_BACKGROUND * TRIM_MEMORY_MODERATE * TRIM_MEMORY_COMPLETE * * When your app's visibility changes: * TRIM_MEMORY_UI_HIDDEN */ @Oviewride public void onTrimMemory(final int level) { super.onTrimMemory(level); if (level == ComponentCallbacks2.TRIM_MEMORY_UI_HIDDEN || level == ComponentCallbacks2.TRIM_MEMORY_BACKGROUND || level == ComponentCallbacks2.TRIM_MEMORY_COMPLETE || level == ComponentCallbacks2.TRIM_MEMORY_MODERATE) { // App went in background } } 

    O código a seguir é detectair o bloqueio da canvas. Eu implementei esse código em um dos methods ActivityLifecycleCallbacks – onActivityStopped ()

     final PowerManager powerManager = (PowerManager) getAppContext().getSystemService(Context.POWER_SERVICE); if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.KITKAT) { if (!powerManager.isScreenOn()) { // Screen locked } } else { if (!powerManager.isInteractive()) { // Screen locked } } } final PowerManager powerManager = (PowerManager) getAppContext().getSystemService(Context.POWER_SERVICE); if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.KITKAT) { if (!powerManager.isScreenOn()) { // Screen locked } } else { if (!powerManager.isInteractive()) { // Screen locked } } } final PowerManager powerManager = (PowerManager) getAppContext().getSystemService(Context.POWER_SERVICE); if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.KITKAT) { if (!powerManager.isScreenOn()) { // Screen locked } } else { if (!powerManager.isInteractive()) { // Screen locked } } 

    Se o seu aplicativo atingir API nível 13 ou superior, você deve configurair esta configuration no manifest.xml

     <activity android:configChanges="orientation|screenSize" ... /> <atividade <activity android:configChanges="orientation|screenSize" ... /> ... <activity android:configChanges="orientation|screenSize" ... /> 
    Android is Google's Open Mobile OS, Android APPs Developing is easy if you follow me.