Opuszczanie aplikacji na Androida z przyciskiem Wstecz

Question

Chcę, aby użytkownicy mojej aplikacji na Androida opuścili moją aplikację, gdy wracają do określonej aktywności. Czy można to zrobić?

Answer 1

Można spróbować coś takiego (pokazuje okno dialogowe, aby potwierdzić wyjście):

 @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(); 
       } 

Należy zauważyć, jak to wspomniano w komentarzach poniżej tego opuszczającego aplikacji z System.exit jest Niepolecane. Bardziej "poprawnym" sposobem byłoby prawdopodobnie nadawanie intencji na odwrocie i jeśli działania twojej aplikacji otrzymały ten zamiar same w sobie.

Answer 2

Możesz osiągnąć wszystko, przesuwając przycisk Wstecz.

@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

Dobrym sposobem jest poczekać na chwilę z powrotem

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

można przesłonić onBackPressed() w działalności i rób co chcesz w nim. Oto kod, który zamyka aplikację, gdy oparcie jest wciśnięty:

@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

można spróbować ten jeden

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

Answer 6

Wydaje się to pytasz złamie cel przycisk Wstecz i oczekiwany przepływ aplikacji. Użytkownik oczekiwałby naciśnięcia przycisku Wstecz, aby powrócić do poprzedniego ekranu aktywności.

Jeśli chcesz zamknąć całą aplikację za pomocą przycisku Wstecz, za każdym razem, gdy używasz funkcji startActivity(), wykonaj ją z wywołaniem kończącym(). Spowoduje to zamknięcie bieżącej aktywności, więc jeśli użytkownik naciśnie przycisk Wstecz, opuści aplikację.

Answer 7

Umieścić go w każdej działalności swojej manifeście:

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

On Powrót prasie ze swojego Activity:

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

Answer 8

Zamiast nadrzędnymi zachowanie przycisku wstecz rozważyć przy użyciu FLAG_ACTIVITY_CLEAR_TOP zamiaru flagę kontrolować stos działań aplikacji.

Jeśli ustawione, a aktywność uruchamiana jest już uruchomiony w bieżącym zadaniu, a następnie zamiast uruchomienia nowej instancji tej działalności, wszystkie inne działania na wierzchu zostanie zamknięte, a ten zamiar będzie dostarczone do (obecnie na górze) starej działalności jako nowy zamiar.

Weźmy na przykład zadanie składające się z czynności: A, B, C, D. Jeśli D wywoła funkcję startActivity() z intencją, która rozstrzyga komponent działania B, wówczas C i D zostaną zakończone, a B Otrzymasz podany cel, w wyniku czego stos będzie teraz: A, B.

Korzystając z powyższego przykładu.Byłoby to być realizowane coś takiego: z działalności D:

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

Answer 9

używam tej metody, aby opuścić aplikację na grzbiecie Prasa:

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

Answer 10

Przede wszystkim jest to zupełnie dziwne, że chcesz aby zamknąć aplikację, ponieważ normalnie, jeśli użytkownik opuści twoją aplikację, android załatwi resztę i zdecyduje albo zamknąć, albo wstrzymać ją na podstawie stanu pamięci urządzenia i wykonuje na niej doskonałą pracę, co oznacza, że ​​nie powinieneś się martwić o tym.

Ale jeśli chcesz, aby zamknąć aplikację, w przypadku, gdy istnieje tylko jedna czynność działa (w momencie naciśnięcia przycisku wstecz w danym przypadku) zamknięcie tej działalności zamyka całą aplikację. mam na myśli to, że jeśli przekazałeś do bieżącej aktywności używając intencji i nie zamknąłeś poprzedniej aktywności, to użycie this.finish() zamyka tylko bieżącą aktywność i przywraca poprzednią wstrzymaną aktywność, w przeciwnym razie zamyka całą aplikację. należy wziąć pod uwagę fakt, że dana aktywność może używać fragmentu, a fragmenty mogą być bez układów. to wygląda na to, że aplikacja jest zamknięta, gdy nadal działa.

Ale jak używać sprzętu z powrotem klucz, aby wykonywać swoją pracę? trzeba będzie zrobić to

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

Powodzenia

Answer 11

Wiem, że to stary post. Ale może to być pomocne dla kogoś takiego, jak dla mnie, który chce zaimplementować tę samą funkcję w swojej aplikacji.

Roztwór identyfikacji zawrócić może być wykonywane przez obliczenie czasu pomiędzy tyłu prasy. Jeśli różnica jest mniejsza niż 2 sekundy (tj. 2000 milisekund), możesz zaakceptować to jako podwójne naciśnięcie i wyjście z aplikacji. W przeciwnym razie wyświetl wiadomość Toast.

Proste wdrożenie byłoby:

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(); 
} 

Kod można znaleźć w tym 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

Oto gotowy sposób zarządzać backPressed(), gdy naciśnięty dwukrotnie w czasie i wywołaj okno dialogowe potwierdzenia:

/** 
* 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); 
}