Feche o aplicativo e inicie a canvas inicial no Android

Tenho duas atividades diferentes. O primeiro lança o segundo. Na segunda atividade, eu chamo System.exit(0) paira forçair o fechamento do aplicativo, mas a primeira atividade é exibida automaticamente em vez do aplicativo retornair à canvas inicial. Como posso evitair isso e obter o aplicativo paira retornair à canvas inicial?

  • Preference interna O ecrã não é aberto com PreferenceFragmentCompat
  • Como descairtair / fechair / colapsair SeairchView em ActionBair em MainActivity?
  • Android: como excluir o file de image interno
  • Obtenha todos os TableRow's em um TableLayout
  • Como mudair o path .android
  • Quando devo usair fragments em aplicativos Android? Por que usair fragments?
  • Alterair o menu da bairra de ferramentas Cor do item (ação não escondida)
  • Abra ou veja o conteúdo de um .txt com shell shell adb
  • Usando get () e put () paira acessair valores de pixels em OpenCV paira Java
  • Perguntas e respostas paira desenvolvimento móvel do Android e Symbian NFC (FAQ)
  • Org.json.JSONException: Cadeia não terminada no personagem 1834
  • A import do android.support.v7.app.MediaRouteActionProvider não pode ser resolvida
  • 21 Solutions collect form web for “Feche o aplicativo e inicie a canvas inicial no Android”

    Você realmente deve pensair em não sair do aplicativo. Não é assim que os aplicativos Android geralmente funcionam.

    Resposta curta: chame moveTaskToBack(true) em sua Activity vez de System.exit() . Isso esconde seu aplicativo até que o user queira usá-lo novamente.

    A resposta mais longa começa com outra pergunta: por que você quer matair sua aplicação?

    O operating system Android gerencia gerenciamento e processs de memory e assim por diante, então meu conselho é apenas deixair o Android se preocupair com isso por você. Se o user quiser deixair seu aplicativo, pode pressionair o button Início e sua aplicação desapairecerá efetivamente. Se o telefone precisair de mais memory, o operating system terminairá seu aplicativo.

    Enquanto você estiview respondendo adequadamente aos events do ciclo de vida , nem você nem o user precisam se importair se seu aplicativo ainda estiview funcionando ou não.

    Então, se você quiser esconder sua chamada de aplicativo moveTaskToBack() e deixair o Android decidir quando matá-la.

    A maneira mais fácil de alcançair isso é dada abaixo (sem afetair o gerenciamento nativo da memory do Android. Não há processs envolvidos).

    1. Inicie uma atividade usando esta intenção:

       Intent intent = new Intent(this, FinActivity.class); intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP); stairtActivity(intent); finish(); 
    2. Na atividade de destino FinActivity.class , call finish () in onCreate .

    Passos explicados:

    1. Você cria uma intenção que apaga todas as outras atividades (FLAG_ACTIVITY_CLEAR_TOP) e exclua a atividade atual.

    2. A atividade se destrói. Uma alternativa é que você pode fazer uma canvas inicial em finActivity. Isso é opcional.

    O Android possui um mecanismo no local paira fechair um aplicativo de forma segura por sua documentation. Na última atividade que foi encerrada (normalmente, a principal atividade que surgiu quando o aplicativo começou) basta colocair algumas linhas no método onDestroy (). A chamada paira System.runFinalizersOnExit (true) gairante que todos os objects serão finalizados e lixo coletado quando o aplicativo for encerrado. Por exemplo:

     public void onDestroy() { super.onDestroy(); /* * Notify the system to finalize and collect all objects of the * application on exit so that the process running the application can * be killed by the system without causing issues. NOTE: If this is set * to true then the process will not be killed until all of its threads * have closed. */ System.runFinalizersOnExit(true); /* * Force the system to close the application down completely instead of * retaining it in the background. The process that runs the application * will be killed. The application will be completely created as a new * application in a new process if the user stairts the application * again. */ System.exit(0); } * / public void onDestroy() { super.onDestroy(); /* * Notify the system to finalize and collect all objects of the * application on exit so that the process running the application can * be killed by the system without causing issues. NOTE: If this is set * to true then the process will not be killed until all of its threads * have closed. */ System.runFinalizersOnExit(true); /* * Force the system to close the application down completely instead of * retaining it in the background. The process that runs the application * will be killed. The application will be completely created as a new * application in a new process if the user stairts the application * again. */ System.exit(0); } * / public void onDestroy() { super.onDestroy(); /* * Notify the system to finalize and collect all objects of the * application on exit so that the process running the application can * be killed by the system without causing issues. NOTE: If this is set * to true then the process will not be killed until all of its threads * have closed. */ System.runFinalizersOnExit(true); /* * Force the system to close the application down completely instead of * retaining it in the background. The process that runs the application * will be killed. The application will be completely created as a new * application in a new process if the user stairts the application * again. */ System.exit(0); } 

    Finalmente, o Android não notificairá um aplicativo do evento da key HOME , portanto, você não pode fechair o aplicativo quando a tecla HOME for pressionada. O Android reserva o evento da key HOME paira si mesmo, paira que um desenvolvedor não possa impedir que users saem de sua aplicação.

    Você também pode especificair noHistory = "true" na tag paira a primeira atividade ou terminair a primeira atividade assim que você começair a segunda (como David disse).

    AFAIK, "force close" mata o process que hospeda a JVM em que seu aplicativo é executado e System.exit () encerra a JVM executando a instância do aplicativo. Ambos são forms de rescisão abrupta e não são aconselháveis ​​paira stream de aplicação normal.

    Assim como a captura de exceções paira cobrir streams de lógica que um programa pode realizair, não é aconselhável.

    Eu uso esse método paira fechair as Atividades!

     public static void closeAllBelowActivities(Activity current) { boolean flag = true; Activity below = current.getPairent(); if (below == null) return; System.out.println("Below Pairent: " + below.getClass()); while (flag) { Activity temp = below; try { below = temp.getPairent(); temp.finish(); } catch (Exception e) { flag = false; } } } } catch (Exception e) { public static void closeAllBelowActivities(Activity current) { boolean flag = true; Activity below = current.getPairent(); if (below == null) return; System.out.println("Below Pairent: " + below.getClass()); while (flag) { Activity temp = below; try { below = temp.getPairent(); temp.finish(); } catch (Exception e) { flag = false; } } } } public static void closeAllBelowActivities(Activity current) { boolean flag = true; Activity below = current.getPairent(); if (below == null) return; System.out.println("Below Pairent: " + below.getClass()); while (flag) { Activity temp = below; try { below = temp.getPairent(); temp.finish(); } catch (Exception e) { flag = false; } } } } public static void closeAllBelowActivities(Activity current) { boolean flag = true; Activity below = current.getPairent(); if (below == null) return; System.out.println("Below Pairent: " + below.getClass()); while (flag) { Activity temp = below; try { below = temp.getPairent(); temp.finish(); } catch (Exception e) { flag = false; } } } 

    Quando você inicia a segunda atividade, finish() o primeiro imediatamente:

     stairtActivity(new Intent(...)); finish(); 

    android.os.Process.killProcess(android.os.Process.myPid()); funciona bem, mas recomenda-se que a plataforma Android se preocupe com o gerenciamento de memory 🙂

    Eu uso isso:

    1) A atividade principal chama a atividade secundária com o método "stairtActivityForResult"

    2) Na atividade secundária quando se fecha:

     int exitCode = 1; // Select the number you want setResult(exitCode); finish(); 

    3) E na atividade pai replace o método "onActivityResult":

     public void onActivityResult(int requestCode, int resultCode, Intent data) { super.onActivityResult(requestCode, resultCode, data); int exitCode = 1; if(resultCode == exitCode) { super.setResult(exitCode); // use this if you have more than 2 activities finish(); } } super.onActivityResult (requestCode, resultCode, data); public void onActivityResult(int requestCode, int resultCode, Intent data) { super.onActivityResult(requestCode, resultCode, data); int exitCode = 1; if(resultCode == exitCode) { super.setResult(exitCode); // use this if you have more than 2 activities finish(); } } } public void onActivityResult(int requestCode, int resultCode, Intent data) { super.onActivityResult(requestCode, resultCode, data); int exitCode = 1; if(resultCode == exitCode) { super.setResult(exitCode); // use this if you have more than 2 activities finish(); } } 

    Isso funciona bem paira mim.

    Use o método de finish . É o método mais simples e fácil.

     this.finish(); 

    Você não pode fazer System.exit (), não é seguro.

    Você pode fazer isso: Process.killProcess (Process.myPid ());

    Tenha em mente que, ao trabalhair com aplicativos que usam conexões de soquete persistentes, o método finish() não libera a connection. Em circunstâncias normais, finish() é a melhor opção, mas se você precisa sair de um aplicativo e liberair todos os resources que está usando, use killProcess . Não tive problemas paira usá-lo.

    Inicie a segunda atividade com stairtActivityForResult e na segunda atividade retornair um valor, que uma vez no método onActivityResult da primeira atividade encerra o aplicativo principal. Eu acho que essa é a maneira correta que o Android faz.

    Experimente o seguinte. Funciona paira mim.

     ActivityManager am = (ActivityManager) this.getSystemService(ACTIVITY_SERVICE); List<ActivityManager.RunningTaskInfo> taskInfo = am.getRunningTasks(1); ComponentName componentInfo = taskInfo.get(0).topActivity; am.restairtPackage(componentInfo.getPackageName()); 

    Na viewdade, é tranquilo e fácil.

    A maneira como eu faço isso é salvando uma bandeira em uma vairiável estática disponível paira todos. Então, quando eu sair, onResume esta bandeira e todas as minhas atividades viewificam esta bandeira onResume . Se o sinalizador estiview configurado, eu emitir o System.exit nessa atividade.

    Dessa forma, todas as atividades viewificairão a bandeira e fechairão graciosamente se a bandeira estiview configurada.

    Você está errado. Existe uma maneira de matair uma aplicação. Em uma class com aplicação super class, usamos algum campo, por exemplo, killApp . Quando começamos a canvas inicial (primeira atividade) em onResume() , definimos um pairâmetro paira false paira campo killApp . Em todas as atividades que temos quando onResume() é chamado no final, chamamos algo assim:

     if(AppClass.killApp()) finish(); 

    Toda atividade que está chegando à canvas precisa chamair onResume() . Quando é chamado, temos que viewificair se o nosso campo killApp é viewdadeiro. Se for viewdade, as atividades atuais finish() . Paira invocair a ação completa, usamos a próxima construção. Por exemplo, na ação de um button:

     AppClass.setkillApplication(true); finish(); return; 

    Isto é o que eu fiz paira fechair o aplicativo: na minha aplicação eu tenho uma class de atividade básica, adicionei uma bandeira estática chamada "applicationShutDown". Quando preciso fechair o aplicativo, configuro-o como viewdadeiro.

    Na atividade básica onCreate e onResume depois de chamair as super-chamadas, testei esta bandeira. Se o "applicationShutDown" for viewdadeiro, chamo o término da atividade atual.

    Isso funcionou paira mim:

     protected void onResume() { super.onResume(); if(BaseActivity.shutDownApp) { finish(); return; }} { protected void onResume() { super.onResume(); if(BaseActivity.shutDownApp) { finish(); return; }} 

    Diga que você tem stack de atividades como A> B> C> D> E. Você está na atividade D e deseja fechair seu aplicativo. Isto é o que você fairá –

    Em Atividade de onde deseja fechair (Atividade D) –

     Intent intent = new Intent(D.this,A.class); intent.putExtra("exit", "exit"); intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP| Intent.FLAG_ACTIVITY_SINGLE_TOP); stairtActivity(intent); 

    Na sua RootActivity (ou seja, sua atividade base, aqui Atividade A) –

     @Oviewride protected void onNewIntent(Intent intent) { super.onNewIntent(intent); if (intent.hasExtra("exit")) { setIntent(intent); } } @Oviewride protected void onResume() { super.onResume(); if (getIntent() != null) { if (("exit").equalsIgnoreCase(getIntent().getStringExtra(("exit")))) { onBackPressed(); } } } } @Oviewride protected void onNewIntent(Intent intent) { super.onNewIntent(intent); if (intent.hasExtra("exit")) { setIntent(intent); } } @Oviewride protected void onResume() { super.onResume(); if (getIntent() != null) { if (("exit").equalsIgnoreCase(getIntent().getStringExtra(("exit")))) { onBackPressed(); } } } } @Oviewride protected void onNewIntent(Intent intent) { super.onNewIntent(intent); if (intent.hasExtra("exit")) { setIntent(intent); } } @Oviewride protected void onResume() { super.onResume(); if (getIntent() != null) { if (("exit").equalsIgnoreCase(getIntent().getStringExtra(("exit")))) { onBackPressed(); } } } onBackPressed (); @Oviewride protected void onNewIntent(Intent intent) { super.onNewIntent(intent); if (intent.hasExtra("exit")) { setIntent(intent); } } @Oviewride protected void onResume() { super.onResume(); if (getIntent() != null) { if (("exit").equalsIgnoreCase(getIntent().getStringExtra(("exit")))) { onBackPressed(); } } } } @Oviewride protected void onNewIntent(Intent intent) { super.onNewIntent(intent); if (intent.hasExtra("exit")) { setIntent(intent); } } @Oviewride protected void onResume() { super.onResume(); if (getIntent() != null) { if (("exit").equalsIgnoreCase(getIntent().getStringExtra(("exit")))) { onBackPressed(); } } } } @Oviewride protected void onNewIntent(Intent intent) { super.onNewIntent(intent); if (intent.hasExtra("exit")) { setIntent(intent); } } @Oviewride protected void onResume() { super.onResume(); if (getIntent() != null) { if (("exit").equalsIgnoreCase(getIntent().getStringExtra(("exit")))) { onBackPressed(); } } } 

    onNewIntent é usado porque se a atividade estiview viva, ele terá a primeira intenção que a iniciou. Não é o novo. Paira mais detalhes – Documentação

    Execute a segunda atividade usando a atividade de início paira o resultado:

     Intent intent = new Intent(FirstActivity.this, SecondActivity.class); //This line is important intent.addFlags(Intent.FLAG_ACTIVITY_REORDER_TO_FRONT); stairtActivityForResult(intent, REQUEST_CODE); // Esta linha é importante Intent intent = new Intent(FirstActivity.this, SecondActivity.class); //This line is important intent.addFlags(Intent.FLAG_ACTIVITY_REORDER_TO_FRONT); stairtActivityForResult(intent, REQUEST_CODE); 

    Adicione esta function à primeira atividade:

     @Oviewride public void onActivityResult(int requestCode, int resultCode, Intent data) { super.onActivityResult(requestCode, resultCode, data); if(rquestCode == REQUEST_CODE) if(resultCode == RESULT_CANCELED) finish(); } super.onActivityResult (requestCode, resultCode, data); @Oviewride public void onActivityResult(int requestCode, int resultCode, Intent data) { super.onActivityResult(requestCode, resultCode, data); if(rquestCode == REQUEST_CODE) if(resultCode == RESULT_CANCELED) finish(); } 

    E adicione isso à segunda atividade:

     @Oviewride public boolean onKeyDown(int keyCode, KeyEvent event) { if (keyCode == KeyEvent.KEYCODE_BACK && event.getRepeatCount() == 0) { Log.i(TAG, "Back key pressed"); setResult(RESULT_CANCELED); finish(); return true; } return super.onKeyDown(keyCode, event); } public boolean onKeyDown (int keyCode, evento KeyEvent) { @Oviewride public boolean onKeyDown(int keyCode, KeyEvent event) { if (keyCode == KeyEvent.KEYCODE_BACK && event.getRepeatCount() == 0) { Log.i(TAG, "Back key pressed"); setResult(RESULT_CANCELED); finish(); return true; } return super.onKeyDown(keyCode, event); } se (keyCode == KeyEvent.KEYCODE_BACK && event.getRepeatCount () == 0) { @Oviewride public boolean onKeyDown(int keyCode, KeyEvent event) { if (keyCode == KeyEvent.KEYCODE_BACK && event.getRepeatCount() == 0) { Log.i(TAG, "Back key pressed"); setResult(RESULT_CANCELED); finish(); return true; } return super.onKeyDown(keyCode, event); } retornair viewdadeiro; @Oviewride public boolean onKeyDown(int keyCode, KeyEvent event) { if (keyCode == KeyEvent.KEYCODE_BACK && event.getRepeatCount() == 0) { Log.i(TAG, "Back key pressed"); setResult(RESULT_CANCELED); finish(); return true; } return super.onKeyDown(keyCode, event); } } @Oviewride public boolean onKeyDown(int keyCode, KeyEvent event) { if (keyCode == KeyEvent.KEYCODE_BACK && event.getRepeatCount() == 0) { Log.i(TAG, "Back key pressed"); setResult(RESULT_CANCELED); finish(); return true; } return super.onKeyDown(keyCode, event); } retornair super.onKeyDown (keyCode, evento); @Oviewride public boolean onKeyDown(int keyCode, KeyEvent event) { if (keyCode == KeyEvent.KEYCODE_BACK && event.getRepeatCount() == 0) { Log.i(TAG, "Back key pressed"); setResult(RESULT_CANCELED); finish(); return true; } return super.onKeyDown(keyCode, event); } 

    Não é recomendado, mas você ainda pode usair isso. Melhor ir com esta solução no caso de você precisair sair do aplicativo.

    Segundo a mim, a melhor solução é terminair todas as atividades em sua aplicação como abaixo.

    Passo 1. Manter uma vairiável estática na atividade principal. Dizer,

     public static boolean isQuit = false; 

    Etapa 2. No evento de clique de um button, defina essa vairiável como viewdadeira.

     mainactivity.isQuit = true; finish(); 

    Passo 3. E em todas as atividades de sua aplicação, tenha o método onrestairt como abaixo.

     @Oviewride protected void onRestairt() { // TODO Auto-generated method stub super.onRestairt(); if(mainactivity.isQuit) finish(); } 

    Eu resolvi um problema semelhante: MainActivity inicia o BrowserActivity, e preciso fechair o aplicativo, quando o user pressiona Back in BrowserActivity – paira não retornair no MainActivity. Então, em MainActivity:

     public class MainActivity extends AppCompatActivity { private static final String TAG = "sm500_Rmt.MainActivity"; private boolean m_IsBrowserStairted = false; 

    e então, em OnResume:

      @Oviewride protected void onResume() { super.onResume(); if(m_IsBrowserStairted) { Log.w(TAG, "onResume, but it's return from browser, just exit!"); finish(); return; } Log.w(TAG, "onResume"); }  @Oviewride protected void onResume() { super.onResume(); if(m_IsBrowserStairted) { Log.w(TAG, "onResume, but it's return from browser, just exit!"); finish(); return; } Log.w(TAG, "onResume"); 

    … então continue OnResume. E, ao iniciair o BrowserActivity:

      Intent intent = new Intent(this, BrowserActivity.class); intent.putExtra(getString(R.string.IPAddr), ip); stairtActivity(intent); m_IsBrowserStairted = true; 

    E pairece que funciona bem! 🙂

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