Lasciando l'app per Android con pulsante indietro

Question

Desidero che gli utenti della mia app per Android lascino la mia app quando si premono su una determinata attività. Può essere fatto?

Answer 1

Si può provare qualcosa di simile (mostra una finestra di dialogo per confermare l'uscita):

 @Override 
     public void onBackPressed() { 
        new AlertDialog.Builder(this).setIcon(android.R.drawable.ic_dialog_alert).setTitle("Exit") 
          .setMessage("Are you sure you want to exit?") 
          .setPositiveButton("Yes", new DialogInterface.OnClickListener() { 
           @Override 
           public void onClick(DialogInterface dialog, int which) { 
            finish(); 
            System.exit(0); 
           } 
          }).setNegativeButton("No", null).show(); 
       } 

Si deve notare come è menzionato nei commenti qui sotto che esce un app con System.exit è non consigliato. Un modo più "corretto" sarebbe probabilmente quello di trasmettere un intento su back press e se le attività della tua applicazione hanno ricevuto quell'intento finire da sole.

Answer 2

È possibile ottenere qualsiasi risultato con Override del pulsante Indietro.

@Override 
public boolean onKeyDown(int keyCode, KeyEvent event) { 
    if (keyCode == KeyEvent.KEYCODE_BACK) { 
     // Do whatever you want with your activity 
     // And for closing the whole app, you can use System.exit() which is absolutely not recomended 
     return true; 
    } 
    return super.onKeyDown(keyCode, event); 
} 

Answer 3

Un buon modo è quello di attendere un secondo indietro

private boolean    _doubleBackToExitPressedOnce = false; 

@Override 
public void onBackPressed() { 

    Log.i(TAG, "onBackPressed--"); 
    if (_doubleBackToExitPressedOnce) { 
     super.onBackPressed(); 
     return; 
    } 
    this._doubleBackToExitPressedOnce = true; 
    Toast.makeText(this, "Press again to quit", Toast.LENGTH_SHORT).show(); 
    new Handler().postDelayed(new Runnable() { 
     @Override 
     public void run() { 

      _doubleBackToExitPressedOnce = false; 
     } 
    }, 2000); 
} 

Answer 4

È possibile ignorare onBackPressed() nell'attività e fare quello che vuoi in esso. Ecco il codice che esce l'applicazione quando si preme di nuovo:

@Override 
public void onBackPressed(){ 
    Intent intent = new Intent(Intent.ACTION_MAIN); 
    intent.addCategory(Intent.CATEGORY_HOME); 
    intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK); 
    startActivity(intent); 
} 

Answer 5

Si può provare questo uno

public void onBackPressed() { 
    moveTaskToBack(true); 
} 

Answer 6

Sembra quello che stai chiedendo spezzerebbe lo scopo del pulsante indietro e l'atteso flusso di un'applicazione. Un utente si aspetterebbe una pressione del pulsante Indietro per tornare alla schermata precedente dell'attività.

Se si desidera terminare l'intera applicazione con il pulsante Indietro, ogni volta che si utilizza startActivity() seguirlo con una chiamata alla fine(). Questo chiuderà l'attività corrente mentre esci, quindi se l'utente preme il pulsante Indietro lascerà la tua app.

Answer 7

Mettilo in ogni attività del vostro manifesto:

<activity android:name=".MyActivity" 
      android:noHistory="true"> 
</activity> 

Su Torna stampa dal Activity:

@Override 
protected void onBackPressed() { 
    if (this.isFinishing()){ 
     finish(); 
     super.onBackPressed(); 
    } 
} 

Answer 8

Invece di override del comportamento pulsante Indietro considerare l'uso della bandiera intento FLAG_ACTIVITY_CLEAR_TOP per controllare il pila di attività della vostra applicazione.

Se impostato, e l'attività avviata è già in esecuzione nell'attività corrente, quindi anziché avviare una nuova istanza di tale attività, tutte le altre attività su di essa verranno chiuse e questo Intento sarà consegnato alla vecchia attività (ora in cima) come nuovo intento.

Ad esempio, considerare un'attività che consiste delle attività: A, B, C, D. Se D chiama startActivity() con un Intent che si risolve nel componente dell'attività B, C e D saranno terminati e B ricevere l'Intento specificato, risultante nello stack ora: A, B.

Utilizzando l'esempio sopra.E sarebbe stato attuato qualcosa di simile: Dal attività di D:

Intent intent = new Intent(context, B.class); 
intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP); 
startActivity(intent); 

Answer 9

Io uso questo metodo per lasciare un app su Indietro stampa:

@Override 
public void onBackPressed() { 
enter code here 
    finish(); 
} 

Answer 10

Prima di tutto è completamente strano che si desidera per chiudere la tua applicazione perché normalmente se l'utente lascia la tua app, Android ne gestisce il resto e decide di chiuderla o tenerla in pausa in base allo stato della memoria del dispositivo e fa un lavoro perfetto su di essa, il che significa che non dovresti preoccuparti a proposito.

Ma se si desidera chiudere la propria app, nel caso in cui sia in corso una sola attività (al momento della pressione del pulsante Indietro nel proprio caso) chiudendo tale attività si chiude l'intera app. ciò che intendo è che se hai trasmesso all'attività corrente utilizzando un intento e non hai chiuso l'attività precedente, utilizzando this.finish() si chiude solo l'attività corrente e si torna indietro alla precedente attività in pausa, altrimenti si chiude l'intera app. considera il fatto che un'attività può utilizzare un frammento e i frammenti possono essere senza layout. quindi sembra che l'app sia chiusa mentre è ancora in esecuzione.

Ma come utilizzare il back key hardware per svolgere il proprio lavoro? è necessario fare questo

@Override 
public void onBackPressed() 
{ 
    if(/* check a condition to make sure you are in that certain activity */) 
    { 
     Process.killProcess(Process.myPid()); 
    } 
    else 
    { 
     super.onBackPressed(); 
    } 
} 

Buona fortuna

Answer 11

So che questo è un vecchio post. Ma questo potrebbe essere utile per qualcuno così come lo è stato per me, che vuole implementare la stessa funzionalità nella propria applicazione.

La soluzione per l'identificazione del dorso può essere calcolata calcolando il tempo tra due pressioni indietro. Se la differenza è inferiore a 2 secondi (vale a dire 2000 millisecondi), è possibile accettarla come doppia pressione indietro e uscire dall'applicazione. Altrimenti visualizza il messaggio Toast.

semplice implementazione di questo sarebbe:

private static long back_pressed; 

@Override 
public void onBackPressed() 
{ 
     if (back_pressed + 2000 > System.currentTimeMillis()) 
      super.onBackPressed(); 
     else 
      Toast.makeText(getBaseContext(), "Press once again to exit!",Toast.LENGTH_SHORT).show(); 

     back_pressed = System.currentTimeMillis(); 
} 

Il codice può essere trovato in questo link

Answer 12

@Override 
    public void onBackPressed(){ 
     new AlertDialog.Builder(this).setIcon(android.R.drawable.ic_dialog_alert).setTitle("Exit") 
     .setMessage("Are you sure you want to exit?") 
     .setPositiveButton("Yes", new DialogInterface.OnClickListener() { 
      @Override 
      public void onClick(DialogInterface dialog, int which) { 
       Intent intent = new Intent(Intent.ACTION_MAIN); 
        intent.addCategory(Intent.CATEGORY_HOME); 
        intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK); 
        startActivity(intent); 
      } 
     }).setNegativeButton("No", null).show(); 

    } 

Answer 13

Ecco un metodo pronto a gestire backPressed() quando viene premuto due volte in un tempo e chiama una finestra di dialogo di conferma:

/** 
* Overrides Back Pressed Button handler. 
* Single continuous press custom clear in your activity. 
* Double continuous press - confirmation dialog to close all activities and exit to Android. 
*/ 
@Override 
public void onBackPressed() { 

if (isBackPressedTwice) { 

    new AlertDialog.Builder(this) 
    .setCancelable(false) 
    .setIcon(
     R.drawable.exit) 
    .setTitle(
     getString(
     R.string.exit)) 
    .setMessage(
     getString(
     R.string.close_application)) 
    .setNegativeButton(
     getString(
     R.string.no), 
     null) 
    .setPositiveButton(
     getString(
     R.string.yes), 
     new DialogInterface.OnClickListener() { 
     @Override 
     public void onClick(
      DialogInterface dialog, 
      int which) { 

      finishAffinity(); 

      return; 
     } 
     }) 
    .show(); 
} else { 
    // Custom activity clearing operations. 
} 

this.isBackPressedTwice = true; 

new Handler().postDelayed(
    new Runnable() { 
    @Override 
    public void run() { 

     isBackPressedTwice = false; 
    } 
    }, 
    1000); 
}