Android implements the long press back key to exit the application

This article illustrated the Android implementation of long pressing the back key to exit an application. Share to everybody for everybody reference. The specific analysis is as follows:

Recently, when I was working on an application on Android, I encountered a problem that how to achieve long press back key to exit the application. I looked up a lot of information on the Internet and found that there were few such implementations, most of which were double-clicking the back key to exit the application. Referring to the code of double-clicking back key to exit the application, one of the mainstream methods on the Internet is the following one, which is relatively simple to implement:

@Override
public boolean onKeyDown(int keyCode, KeyEvent event) 
{
  if (keyCode == KeyEvent.KEYCODE_BACK) 
  {
   if ((System.currentTimeMillis() - mExitTime) > 2000) 
   {
    mHelperUtils.showToast(mContext, R.string.exit_content);
    mExitTime = System.currentTimeMillis();
   }
   else 
   {
    finish();
   }
   return true;
  }
  return super.onKeyDown(keyCode, event);
}

As can be seen from the above code, the idea is to click the back key twice in a row within the time interval of 2s, which is considered a double click to exit the program.

Therefore, based on the above train of thought, my initial idea is that I can rewrite onKeyDown method and onKeyUp method to calculate the time interval between the execution of these two methods. If it is greater than 2s, it will be considered as a long press to exit the program. Otherwise, the original response of the back key is executed. Follow this line of thought:

public boolean onKeyDown(int keyCode, KeyEvent event) 
{ 
 if (keyCode == KeyEvent.KEYCODE_BACK&&event.getRepeatCount()==0) 
 { 
  start=System.currentTimeMillis(); 
  Log.e("start",String.valueOf(start));
  return false; 
 } 
 return super.onKeyDown(keyCode, event);
} 
public boolean onKeyUp(int keyCode,KeyEvent event)
{
 if (keyCode == KeyEvent.KEYCODE_BACK &&event.getRepeatCount()==0) 
 { 
  end=System.currentTimeMillis(); 
  Log.e("end",String.valueOf(end));
  if(start!=-1&&(end-start)>2000)
  {
  AlertDialog.Builder builder = new Builder(MainActivity.this);
  builder.setMessage(" Do you want to confirm your exit? ");
  builder.setTitle(" prompt ");
  builder.setPositiveButton(" confirm ",new DialogInterface.OnClickListener()
  {
   public void onClick(DialogInterface dialog,int which)
   {
   dialog.dismiss();
   MainActivity.this.finish();
   System.exit(0);
   }
  });
  builder.setNegativeButton(" cancel ",new DialogInterface.OnClickListener()
  {
   public void onClick(DialogInterface dialog,int which) 
   {
   dialog.dismiss();
   }
  });
  builder.create().show();
  return true;
  }
  else
  {
  return super.onKeyUp(keyCode, event);
  }
 }
 return super.onKeyUp(keyCode, event);
}

However, long press back to exit the program, but not long press back, click back will not work, looking at a lot of Android key event distribution and processing mechanism, but still do not know why (more time later). So I consider another way to deal with it, and consider rewriting the dispatchKeyEvent method in Activity.

public boolean dispatchKeyEvent(KeyEvent event)
{
 int keyCode=event.getKeyCode();
 //Log.e("start",String.valueOf(start));
 switch(keyCode)
 {
  case KeyEvent.KEYCODE_BACK:
  if(event.isLongPress())
  // This is an important sentence to determine if an event is a long-press event 
  {
  AlertDialog.Builder builder = new Builder(MainActivity.this);
  builder.setMessage(" Do you want to confirm your exit? ");
  builder.setTitle(" prompt ");
  builder.setPositiveButton(" confirm ",new DialogInterface.OnClickListener()
  {
   public void onClick(DialogInterface dialog,int which)
   {
   dialog.dismiss();
   MainActivity.this.finish();
   System.exit(0);
   }
  });
  builder.setNegativeButton(" cancel ",new DialogInterface.OnClickListener() 
  {
   public void onClick(DialogInterface dialog,int which) 
   {
   dialog.dismiss();
   }
  });
  builder.create().show();
  return true;
  }
  return super.dispatchKeyEvent(event);
  // If it is not a long press, the original method is called and executed by pressing back The key should be handled 
  default:
  break;
 }
 return super.dispatchKeyEvent(event);
}

Finally, long press back key to exit the program was achieved by rewriting dispatchKeyEvent method, and the original function of non-long press back key was not screened.

Hopefully, this article has helped you with your Android programming.