활동을 종료하려면 뒤로 단추를 두 번 클릭하십시오.

최근 많은 Android 앱 및 게임에서이 패턴을 발견했습니다. 뒤로 버튼을 클릭하여 애플리케이션을 "종료"하면 "다시 다시 클릭하여 종료" Toast와 유사한 메시지가 나타납니다.

점점 더 자주 볼 수 있듯이 액티비티에서 어떻게 든 액세스 할 수있는 내장 기능입니까? 많은 클래스의 소스 코드를 살펴 보았지만 그것에 대해 아무것도 찾을 수없는 것 같습니다.

물론 동일한 기능을 매우 쉽게 달성 할 수있는 몇 가지 방법에 대해 생각할 수 있습니다 (가장 쉬운 것은 사용자가 이미 한 번 클릭했는지 여부를 나타내는 활동에 부울을 유지하는 것입니다 ...).하지만 이미 여기에 무언가가 있는지 궁금합니다. .

편집 : @LAS_VEGAS가 언급했듯이 나는 전통적인 의미에서 "종료"를 의미하지 않았습니다. (즉, 종료 됨) "응용 프로그램 시작 활동이 시작되기 전에 열려있는 모든 항목으로 돌아가는 것"을 의미했습니다.

Java 활동에서 :

boolean doubleBackToExitPressedOnce = false;

@Override
public void onBackPressed() {
    if (doubleBackToExitPressedOnce) {
        super.onBackPressed();
        return;
    }

    this.doubleBackToExitPressedOnce = true;
    Toast.makeText(this, "Please click BACK again to exit", Toast.LENGTH_SHORT).show();

    new Handler().postDelayed(new Runnable() {

        @Override
        public void run() {
            doubleBackToExitPressedOnce=false;                       
        }
    }, 2000);
} 

코 틀린 활동에서 :

private var doubleBackToExitPressedOnce = false
override fun onBackPressed() {
        if (doubleBackToExitPressedOnce) {
            super.onBackPressed()
            return
        }

        this.doubleBackToExitPressedOnce = true
        Toast.makeText(this, "Please click BACK again to exit", Toast.LENGTH_SHORT).show()

        Handler().postDelayed(Runnable { doubleBackToExitPressedOnce = false }, 2000)
    }

이 핸들러는 2 초 후에 변수를 재설정하는 데 도움이된다고 생각합니다.

Sudheesh B Nair 는이 질문에 대한 좋은 대답을 가지고 있으며, 다음과 같은 더 나은 대안이 있어야한다고 생각합니다.

시간이 경과하고 TIME_INTERVAL마지막 백 프레스 이후에 밀리 초 (예 : 2000)가 경과 했는지 확인하는 데 문제가 있습니다. 다음 샘플 코드는 System.currentTimeMillis();시간을 저장하는 데 사용 됩니다 onBackPressed().

private static final int TIME_INTERVAL = 2000; // # milliseconds, desired time passed between two back presses.
private long mBackPressed;

@Override
public void onBackPressed()
{
    if (mBackPressed + TIME_INTERVAL > System.currentTimeMillis()) 
    { 
        super.onBackPressed(); 
        return;
    }
    else { Toast.makeText(getBaseContext(), "Tap back button in order to exit", Toast.LENGTH_SHORT).show(); }

    mBackPressed = System.currentTimeMillis();
}

수락 된 답변 비평으로 돌아 가기 ; 사용 flag이 마지막으로 누를 경우 표시하기 위해 TIME_INTERVAL(2000 년 말) 밀리 초 세트 - 리셋 경유 Handler의 postDelayed()방법은 내 마음에 와서 제일 먼저했다. 그러나 postDelayed()활동이 닫히면 작업을 취소하여을 (를) 제거해야합니다 Runnable.

을 제거하려면 익명Runnable 으로 선언해서는 안되며 또한 멤버와 함께 선언 해야합니다 . 그러면의 방법을 적절히 호출 할 수 있습니다.HandlerremoveCallbacks()Handler

다음 샘플은 데모입니다.

private boolean doubleBackToExitPressedOnce;
private Handler mHandler = new Handler();

private final Runnable mRunnable = new Runnable() {
    @Override
    public void run() {
        doubleBackToExitPressedOnce = false;                       
    }
};

@Override 
protected void onDestroy() 
{ 
    super.onDestroy();

    if (mHandler != null) { mHandler.removeCallbacks(mRunnable); }
}

@Override
public void onBackPressed() {
    if (doubleBackToExitPressedOnce) {
        super.onBackPressed();
        return;
    }

    this.doubleBackToExitPressedOnce = true;
    Toast.makeText(this, "Please click BACK again to exit", Toast.LENGTH_SHORT).show();

    mHandler.postDelayed(mRunnable, 2000);
}

기여해 주신 @NSouth에게 감사드립니다. 응용 프로그램을 닫은 후에도 토스트 메시지가 표시 되는 것을 방지하기 위해 Toast멤버로 선언 mExitToast할 수 있으며 호출 mExitToast.cancel();직전에 취소 할 수 있습니다 super.onBackPressed();.

방금 마지막에 내가 한 일을 공유하겠다고 생각하고 방금 활동에 추가했습니다.

private boolean doubleBackToExitPressedOnce = false;

@Override
protected void onResume() {
    super.onResume();
    // .... other stuff in my onResume ....
    this.doubleBackToExitPressedOnce = false;
}

@Override
public void onBackPressed() {
    if (doubleBackToExitPressedOnce) {
        super.onBackPressed();
        return;
    }
    this.doubleBackToExitPressedOnce = true;
    Toast.makeText(this, R.string.exit_press_back_twice_message, Toast.LENGTH_SHORT).show();
}

그리고 그것은 내가 원하는대로 정확하게 작동합니다. 활동이 재개 될 때마다 상태 재설정을 포함합니다.

공정 흐름도:

자바 코드 :

private long lastPressedTime;
private static final int PERIOD = 2000;

@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
    if (event.getKeyCode() == KeyEvent.KEYCODE_BACK) {
        switch (event.getAction()) {
        case KeyEvent.ACTION_DOWN:
            if (event.getDownTime() - lastPressedTime < PERIOD) {
                finish();
            } else {
                Toast.makeText(getApplicationContext(), "Press again to exit.",
                        Toast.LENGTH_SHORT).show();
                lastPressedTime = event.getEventTime();
            }
            return true;
        }
    }
    return false;
}

이 모든 답변 중에서 가장 간단한 방법이 있습니다.

onBackPressed()메소드 안에 다음 코드를 작성하십시오 .

long back_pressed;

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

활동에서 back_pressed와 같이 오브젝트 를 정의해야합니다 long.

스낵 바를 사용하는 솔루션 :

Snackbar mSnackbar;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    final LinearLayout layout = findViewById(R.id.layout_main);
    mSnackbar = Snackbar.make(layout, R.string.press_back_again, Snackbar.LENGTH_SHORT);
}

@Override
public void onBackPressed() {
    if (mSnackbar.isShown()) {
        super.onBackPressed();
    } else {
        mSnackbar.show();
    }
}

간단하고 세련된.

정답과 의견의 제안을 바탕으로, 절대적으로 잘 작동하고 사용 후 핸들러 콜백을 제거하는 데모를 만들었습니다.

MainActivity.java

package com.mehuljoisar.d_pressbacktwicetoexit;

import android.os.Bundle;
import android.os.Handler;
import android.app.Activity;
import android.widget.Toast;

public class MainActivity extends Activity {

    private static final long delay = 2000L;
    private boolean mRecentlyBackPressed = false;
    private Handler mExitHandler = new Handler();
    private Runnable mExitRunnable = new Runnable() {

        @Override
        public void run() {
            mRecentlyBackPressed=false;   
        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }

    @Override
    public void onBackPressed() {

        //You may also add condition if (doubleBackToExitPressedOnce || fragmentManager.getBackStackEntryCount() != 0) // in case of Fragment-based add
        if (mRecentlyBackPressed) {
            mExitHandler.removeCallbacks(mExitRunnable);
            mExitHandler = null;
            super.onBackPressed();
        }
        else
        {
            mRecentlyBackPressed = true;
            Toast.makeText(this, "press again to exit", Toast.LENGTH_SHORT).show();
            mExitHandler.postDelayed(mExitRunnable, delay);
        }
    }

}

도움이 되길 바랍니다!

 public void onBackPressed() {
    if (doubleBackToExitPressedOnce) {
        super.onBackPressed();
        return;
    }

    this.doubleBackToExitPressedOnce = true;
    Toast.makeText(this, "Please click BACK again to exit", Toast.LENGTH_SHORT).show();

    new Handler().postDelayed(new Runnable() {

        @Override
        public void run() {
            doubleBackToExitPressedOnce=false;
        }
    }, 2000);

변수 선언private boolean doubleBackToExitPressedOnce = false;

이것을 주요 활동에 붙여 넣으면 문제가 해결됩니다.

응용 프로그램을 종료 할 때 Runnable을 사용하는 것은 좋지 않습니다. 최근에는 최근에 두 개의 BACK 버튼 클릭 사이의 기간을 기록하고 비교하는 훨씬 간단한 방법을 알아 냈습니다. 다음과 같은 샘플 코드 :

private static long back_pressed_time;
private static long PERIOD = 2000;

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

이것은 샘플에서 2000 밀리 초인 특정 지연 시간 내에 더블 BACK 버튼 클릭으로 응용 프로그램을 종료하는 트릭을 수행합니다.

수락 된 답변은 최고 답변이지만 Android Design Support Library사용중인 SnackBar경우 더 나은보기에 사용할 수 있습니다 .

   boolean doubleBackToExitPressedOnce = false;

    @Override
    public void onBackPressed() {
        if (doubleBackToExitPressedOnce) {
            super.onBackPressed();
            return;
        }

        this.doubleBackToExitPressedOnce = true;

        Snackbar.make(findViewById(R.id.photo_album_parent_view), "Please click BACK again to exit", Snackbar.LENGTH_SHORT).show();

        new Handler().postDelayed(new Runnable() {

            @Override
            public void run() {
                doubleBackToExitPressedOnce=false;
            }
        }, 2000);
    }

내장 기능이 아닙니다. 나는 그것이 권장되는 행동조차 아니라고 생각합니다. Android 앱은 종료하지 않습니다.

Android 애플리케이션이 "종료"옵션을 제공하지 않는 이유는 무엇입니까?

1. MainActivity Class에 대한 전역 토스트 변수를 선언하십시오. 예 : 토스트 exitToast;
2. onCreate보기 메소드에서 초기화하십시오. 예 : exitToast = Toast.makeText (getApplicationContext (), "다시 누르면 다시 종료", Toast.LENGTH_SHORT);

3. 마지막으로 다음과 같이 onBackPressedMethod를 만듭니다.

   @Override
   public void onBackPressed() {
   
       if (exitToast.getView().isShown()) {
           exitToast.cancel();
           finish();
       } else {
           exitToast.show();
       }
   }

이것은 올바르게 작동합니다. 테스트했습니다. 저는 이것이 훨씬 간단하다고 생각합니다.

System.currentTimeMillis ()를 사용하는 Zefnus 의 답변이 가장 좋습니다 (+1). 내가 한 방식은 아닙니다 더 나은보다,하지만 여전히 위의 아이디어에 추가 게시.

Back (뒤로) 버튼을 누를 때 토스트가 보이지 않으면 토스트가 표시되는 반면, 마지막 (이전 Toast.LENGTH_SHORT시간 내에 다시 한 번 이미 누르면) 토스트가 표시 됩니다.

exitToast = Toast.makeText(this, "Press again to exit", Toast.LENGTH_SHORT);
.
.
@Override
public void onBackPressed() {
   if (exitToast.getView().getWindowToken() == null) //if toast is currently not visible
      exitToast.show();  //then show toast saying 'press againt to exit'
   else {                                            //if toast is visible then
      finish();                                      //or super.onBackPressed();
      exitToast.cancel();
   }
}

최근에 나는이 뒤로 버튼 기능을 내 앱에서 구현해야했습니다. 원래 질문에 대한 답변은 유용했지만 두 가지 점을 더 고려해야했습니다.

1. 어떤 시점에서는 뒤로 버튼이 비활성화됩니다
2. 주요 활동은 백 스택과 함께 조각을 사용하는 것입니다.

답변과 의견을 바탕으로 다음 코드를 작성했습니다.

private static final long BACK_PRESS_DELAY = 1000;

private boolean mBackPressCancelled = false;
private long mBackPressTimestamp;
private Toast mBackPressToast;

@Override
public void onBackPressed() {
    // Do nothing if the back button is disabled.
    if (!mBackPressCancelled) {
        // Pop fragment if the back stack is not empty.
        if (getSupportFragmentManager().getBackStackEntryCount() > 0) {
            super.onBackPressed();
        } else {
            if (mBackPressToast != null) {
                mBackPressToast.cancel();
            }

            long currentTimestamp = System.currentTimeMillis();

            if (currentTimestamp < mBackPressTimestamp + BACK_PRESS_DELAY) {
                super.onBackPressed();
            } else {
                mBackPressTimestamp = currentTimestamp;

                mBackPressToast = Toast.makeText(this, getString(R.string.warning_exit), Toast.LENGTH_SHORT);
                mBackPressToast.show();
            }
        }
    }
}

위의 코드는 지원 라이브러리가 사용되는 것으로 가정합니다. 당신이 조각이 아니라 지원 라이브러리를 사용하는 경우 대체 할 getSupportFragmentManager()에 의해 getFragmentManager().

if뒤로 버튼이 취소되지 않으면 첫 번째를 제거하십시오 . 두 번째를 제거if프래그먼트 또는 프래그먼트 백 스택을 사용하지 않는 경우

또한이 메소드 onBackPressed는 Android 2.0부터 지원 된다는 점에 유의해야합니다 . 자세한 설명은 이 페이지 를 확인하십시오 . 이전 버전에서도 역전 기능을 사용하려면 다음 방법을 활동에 추가하십시오.

@Override
public boolean onKeyDown(int keyCode, KeyEvent event)  {
    if (android.os.Build.VERSION.SDK_INT < android.os.Build.VERSION_CODES.ECLAIR
            && keyCode == KeyEvent.KEYCODE_BACK
            && event.getRepeatCount() == 0) {
        // Take care of calling this method on earlier versions of
        // the platform where it doesn't exist.
        onBackPressed();
    }

    return super.onKeyDown(keyCode, event);
}

자바에서

private Boolean exit = false; 

if (exit) {
onBackPressed(); 
}

 @Override
public void onBackPressed() {
    if (exit) {
        finish(); // finish activity
    } else {
        Toast.makeText(this, "Press Back again to Exit.",
                Toast.LENGTH_SHORT).show();
        exit = true;
        new Handler().postDelayed(new Runnable() {
            @Override
            public void run() {
                exit = false;
            }
        }, 3 * 1000);

    }
}

코 틀린에서

 private var exit = false

 if (exit) {
        onBackPressed()
         }

 override fun onBackPressed(){
           if (exit){
               finish() // finish activity
           }else{
            Toast.makeText(this, "Press Back again to Exit.",
                    Toast.LENGTH_SHORT).show()
            exit = true
            Handler().postDelayed({ exit = false }, 3 * 1000)

        }
    }

나는 이것이 매우 오래된 질문이라는 것을 알고 있지만 이것은 당신이 원하는 것을하는 가장 쉬운 방법입니다.

@Override
public void onBackPressed() {
   ++k; //initialise k when you first start your activity.
   if(k==1){
      //do whatever you want to do on first click for example:
      Toast.makeText(this, "Press back one more time to exit", Toast.LENGTH_LONG).show();
   }else{
      //do whatever you want to do on the click after the first for example:
      finish(); 
   }
}

이것이 최선의 방법은 아니지만 잘 작동한다는 것을 알고 있습니다!

이를 위해 다음 기능을 구현했습니다.

private long onRecentBackPressedTime;
@Override
public void onBackPressed() {
    if (System.currentTimeMillis() - onRecentBackPressedTime > 2000) {
       onRecentBackPressedTime = System.currentTimeMillis();
       Toast.makeText(this, "Please press BACK again to exit", Toast.LENGTH_SHORT).show();
       return;
     }
   super.onBackPressed();
}

또한 스택에 이전 스택 활동이 저장된 경우에도 도움이됩니다.

Sudheesh의 답변을 수정했습니다

boolean doubleBackToExitPressedOnce = false;

@Override
public void onBackPressed() {
    if (doubleBackToExitPressedOnce) {
        //super.onBackPressed();

  Intent intent = new Intent(Intent.ACTION_MAIN);
                    intent.addCategory(Intent.CATEGORY_HOME);
                    intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);//***Change Here***
                    startActivity(intent);
                    finish();
                    System.exit(0);
        return;
    }

    this.doubleBackToExitPressedOnce = true;
    Toast.makeText(this, "Please click BACK again to exit", Toast.LENGTH_SHORT).show();

    new Handler().postDelayed(new Runnable() {

        @Override
        public void run() {
            doubleBackToExitPressedOnce=false;                       
        }
    }, 2000);
} 

@Override public void onBackPressed() {
   Log.d("CDA", "onBackPressed Called");
   Intent intent = new Intent();
   intent.setAction(Intent.ACTION_MAIN);
   intent.addCategory(Intent.CATEGORY_HOME);

   startActivity(intent);
}

제프 누스 보다 약간 더 나은 방법 이라고 생각합니다. System.currentTimeMillis ()를 한 번만 호출하고 생략하십시오 return;.

long previousTime;

@Override
public void onBackPressed()
{
    if (2000 + previousTime > (previousTime = System.currentTimeMillis())) 
    { 
        super.onBackPressed();
    } else {
        Toast.makeText(getBaseContext(), "Tap back button in order to exit", Toast.LENGTH_SHORT).show();
    }
}

전체 작업 코드는 다음과 같습니다. 또한 앱에서 메모리 누수가 발생하지 않도록 콜백을 제거하는 것을 잊지 마십시오. :)

private boolean backPressedOnce = false;
private Handler statusUpdateHandler;
private Runnable statusUpdateRunnable;

public void onBackPressed() {
        if (backPressedOnce) {
            finish();
        }

        backPressedOnce = true;
        final Toast toast = Toast.makeText(this, "Press again to exit", Toast.LENGTH_SHORT);
        toast.show();

        statusUpdateRunnable = new Runnable() {
            @Override
            public void run() {
                backPressedOnce = false;
                toast.cancel();  //Removes the toast after the exit.
            }
        };

        statusUpdateHandler.postDelayed(statusUpdateRunnable, 2000);
}

@Override
protected void onDestroy() {
    super.onDestroy();
    if (statusUpdateHandler != null) {
        statusUpdateHandler.removeCallbacks(statusUpdateRunnable);
    }
}

여기에서는 N 탭 수에 대한 코드 작성을 일반화했습니다. 코드는 안드로이드 장치 전화의 개발자 활성화 옵션과 유사하게 작성되었습니다. 개발자가 앱을 테스트하는 동안이 기능을 사용하여 기능을 활성화 할 수도 있습니다.

 private Handler tapHandler;
 private Runnable tapRunnable;
 private int mTapCount = 0;
 private int milSecDealy = 2000;

onCreate(){
 ...
tapHandler = new Handler(Looper.getMainLooper());

 }

뒤로 누르기 또는 로그 아웃 옵션에서 askToExit () 를 호출 하십시오 .

private void askToExit() {
   if (mTapCount >= 2) {
    releaseTapValues();
    /* ========= Exit = TRUE  =========  */
   }

   mTapCount++;
   validateTapCount();
  }


  /* Check with null to avoid create multiple instances of the runnable */
  private void validateTapCount() {
   if (tapRunnable == null) {
    tapRunnable = new Runnable() {
     @Override
     public void run() {
      releaseTapValues();
      /* ========= Exit = FALSE  =========  */
     }
    };
    tapHandler.postDelayed(tapRunnable, milSecDealy);
   }
  }

  private void releaseTapValues() {
   /* Relase the value  */
   if (tapHandler != null) {
    tapHandler.removeCallbacks(tapRunnable);
    tapRunnable = null; /* release the object */
    mTapCount = 0; /* release the value */
   }
  }


  @Override
  protected void onDestroy() {
   super.onDestroy();
   releaseTapValues();
  }

나는 이것을 사용한다

import android.app.Activity;
import android.support.annotation.StringRes;
import android.widget.Toast;

public class ExitApp {

    private static long lastClickTime;

    public static void now(Activity ctx, @StringRes int message) {
        now(ctx, ctx.getString(message), 2500);
    }

    public static void now(Activity ctx, @StringRes int message, long time) {
        now(ctx, ctx.getString(message), time);
    }

    public static void now(Activity ctx, String message, long time) {
        if (ctx != null && !message.isEmpty() && time != 0) {
            if (lastClickTime + time > System.currentTimeMillis()) {
                ctx.finish();
            } else {
                Toast.makeText(ctx, message, Toast.LENGTH_SHORT).show();
                lastClickTime = System.currentTimeMillis();
            }
        }
    }

}

에 사용하는 경우에onBackPressed

@Override
public void onBackPressed() {
   ExitApp.now(this,"Press again for close");
}

또는 ExitApp.now(this,R.string.double_back_pressed)

변경 초 동안 닫기, 지정된 밀리 초가 필요합니다.

ExitApp.now(this,R.string.double_back_pressed,5000)

HomeActivity에 탐색 창과 두 개의 backPressed () 함수가 포함되어 있으면 앱을 종료합니다. (글로벌 변수 boolean doubleBackToExitPressedOnce = false;를 초기화하는 것을 잊지 마십시오) 2 초 후 새 핸들러는 doubleBackPressedOnce 변수를 false로 설정합니다.

@Override
public void onBackPressed() {
    DrawerLayout drawer = findViewById(R.id.drawer_layout);
    if (drawer.isDrawerOpen(GravityCompat.END)) {
        drawer.closeDrawer(GravityCompat.END);
    } else {
        if (doubleBackToExitPressedOnce) {
            super.onBackPressed();
            moveTaskToBack(true);
            return;
        } else {
            this.doubleBackToExitPressedOnce = true;
            Toast.makeText(this, "Please click BACK again to exit", Toast.LENGTH_SHORT).show();
            new Handler().postDelayed(new Runnable() {
                @Override
                public void run() {
                    doubleBackToExitPressedOnce = false;
                }
            }, 2000);
        }
    }
}

boolean doubleBackToExitPressedOnce = false;

@Override
public void onBackPressed() {
    if (doubleBackToExitPressedOnce) {
        super.onBackPressed();
        return;
    }

    this.doubleBackToExitPressedOnce = true;

    Snackbar.make(findViewById(R.id.photo_album_parent_view), "Please click BACK again to exit", Snackbar.LENGTH_SHORT).show();

    new Handler().postDelayed(new Runnable() {

        @Override
        public void run() {
            doubleBackToExitPressedOnce=false;
        }
    }, 2000);
}

Sudheesh B Nair의 답변에서 일부 개선 사항은 즉시 두 번 다시 눌러도 처리기를 기다리는 것으로 나타 났으므로 아래 그림과 같이 처리기를 취소하십시오. 앱 종료 후 표시되지 않도록 토스트를 취소 할 수도 있습니다.

 boolean doubleBackToExitPressedOnce = false;
        Handler myHandler;
        Runnable myRunnable;
        Toast myToast;

    @Override
        public void onBackPressed() {
            if (doubleBackToExitPressedOnce) {
                myHandler.removeCallbacks(myRunnable);
                myToast.cancel();
                super.onBackPressed();
                return;
            }

            this.doubleBackToExitPressedOnce = true;
            myToast = Toast.makeText(this, "Please click BACK again to exit", Toast.LENGTH_SHORT);
            myToast.show();

            myHandler = new Handler();

            myRunnable = new Runnable() {

                @Override
                public void run() {
                    doubleBackToExitPressedOnce = false;
                }
            };
            myHandler.postDelayed(myRunnable, 2000);
        }

이것은 가장 많이 받아 들여지고 투표 된 응답과 동일하지만 토스트 대신 스낵바를 사용했습니다.

boolean doubleBackToExitPressedOnce = false;

    @Override
    public void onBackPressed() {
        if (doubleBackToExitPressedOnce) {
            super.onBackPressed();
            return;
        }

        this.doubleBackToExitPressedOnce = true;
        Snackbar.make(content, "Please click BACK again to exit", Snackbar.LENGTH_SHORT)
                .setAction("Action", null).show();


        new Handler().postDelayed(new Runnable() {

            @Override
            public void run() {
                doubleBackToExitPressedOnce=false;
            }
        }, 2000);
    }

제 경우에는 Snackbar#isShown()더 잘 의지했습니다 UX.

private Snackbar exitSnackBar;

@Override
public void onBackPressed() {
    if (isNavDrawerOpen()) {
        closeNavDrawer();
    } else if (getSupportFragmentManager().getBackStackEntryCount() == 0) {
        if (exitSnackBar != null && exitSnackBar.isShown()) {
            super.onBackPressed();
        } else {
            exitSnackBar = Snackbar.make(
                    binding.getRoot(),
                    R.string.navigation_exit,
                    2000
            );
            exitSnackBar.show();
        }
    } else {
        super.onBackPressed();
    }
}

Navigation Drawer 가있는 활동의 경우 OnBackPressed ()에 다음 코드를 사용하십시오.

boolean doubleBackToExitPressedOnce = false;

@Override
    public void onBackPressed() {
        DrawerLayout drawer = (DrawerLayout) findViewById(R.id.drawer_layout);
        if (drawer.isDrawerOpen(GravityCompat.START)) {
            drawer.closeDrawer(GravityCompat.START);
        } else {
            if (doubleBackToExitPressedOnce) {
                if (getFragmentManager().getBackStackEntryCount() ==0) {
                    finishAffinity();
                    System.exit(0);
                } else {
                    getFragmentManager().popBackStackImmediate();
                }
                return;
            }

            if (getFragmentManager().getBackStackEntryCount() ==0) {
                this.doubleBackToExitPressedOnce = true;
                Toast.makeText(this, "Please click BACK again to exit", Toast.LENGTH_SHORT).show();

                new Handler().postDelayed(new Runnable() {

                    @Override
                    public void run() {
                        doubleBackToExitPressedOnce = false;
                    }
                }, 2000);
            } else {
                getFragmentManager().popBackStackImmediate();
            }
        }
    }

CountDownTimer 메서드를 사용하는 또 다른 방법은 다음과 같습니다.

private boolean exit = false;
@Override
public void onBackPressed() {
        if (exit) {
            finish();
        } else {
            Toast.makeText(this, "Press back again to exit",
                    Toast.LENGTH_SHORT).show();
            exit = true;
            new CountDownTimer(3000,1000) {

                @Override
                public void onTick(long l) {

                }

                @Override
                public void onFinish() {
                    exit = false;
                }
            }.start();
        }

    }