如何退出应用程序并显示主屏幕?

我有一个应用程序，在主页上我有按钮导航通过应用程序。

在那个页面上，我有一个“EXIT”按钮，当点击它时，用户应该回到应用程序图标所在的手机主屏幕。

我该怎么做呢?

335094 次浏览
小开

不建议退出Android应用程序。更多细节请参见问题。

用户总是可以通过home键退出应用程序，或者在第一个活动中通过返回按钮退出应用程序。

小开
最佳答案

Android的设计并不支持用户自行退出应用程序，而是由操作系统来管理应用程序。你可以通过相应的Intent打开Home应用:

Intent intent = new Intent(Intent.ACTION_MAIN);
intent.addCategory(Intent.CATEGORY_HOME);
intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
startActivity(intent);
小开
如果你想结束一个活动，你可以简单地调用finish()。 然而，在屏幕上设置退出按钮是一种糟糕的做法
小开

当你调用完成onDestroy()的活动将被调用，它将回到活动堆栈中的前一个活动…所以. .对于退出不调用finish();

小开

也许你可以试试这样的东西

假设在我们的应用程序中，我们有许多活动(比如10个)，我们需要直接退出这个活动。我们能做的是，创建一个intent，然后去到根活动，并在intent中设置flag为

intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);

此外，在意图中添加一些额外的布尔值

intent.putExtra("EXIT", true);

然后在根活动中，检查boolean的值，并根据调用finish()，在根活动的onCreate()中

if (getIntent().getBooleanExtra("EXIT", false)) {
finish();
}
小开 
System.exit(0);

可能就是你要找的。它将关闭整个应用程序，并带您到主屏幕。

小开

首先使用方法finish();完成应用程序

然后在onDestroy中添加以下行，用于移除关闭力

android.os.Process.killProcess(android.os.Process.myPid());
super.onDestroy();
小开

在onDestroy()中的finish();之后添加以下行:

android.os.Process.killProcess(android.os.Process.myPid());
super.onDestroy();
小开

我尝试退出应用程序使用以下代码片段，这为我工作。希望这对你有所帮助。 我做了2个活动的小演示

第一个活动

public class MainActivity extends Activity implements OnClickListener{
private Button secondActivityBtn;
private SharedPreferences pref;
private SharedPreferences.Editor editer;


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


secondActivityBtn=(Button) findViewById(R.id.SecondActivityBtn);
secondActivityBtn.setOnClickListener(this);


pref = this.getSharedPreferences("MyPrefsFile", MODE_PRIVATE);
editer = pref.edit();


if(pref.getInt("exitApp", 0) == 1){
editer.putInt("exitApp", 0);
editer.commit();
finish();
}
}
@Override
public void onClick(View v) {
switch (v.getId()) {
case R.id.SecondActivityBtn:
Intent intent= new Intent(MainActivity.this, YourAnyActivity.class);
startActivity(intent);
break;
default:
break;
}
}
}

你还有其他活动吗

public class YourAnyActivity extends Activity implements OnClickListener {
private Button exitAppBtn;
private SharedPreferences pref;
private SharedPreferences.Editor editer;


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


exitAppBtn = (Button) findViewById(R.id.exitAppBtn);
exitAppBtn.setOnClickListener(this);


pref = this.getSharedPreferences("MyPrefsFile", MODE_PRIVATE);
editer = pref.edit();
}


@Override
public void onClick(View v) {
switch (v.getId()) {
case R.id.exitAppBtn:
Intent main_intent = new Intent(YourAnyActivity.this,
MainActivity.class);
main_intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
startActivity(main_intent);
editer.putInt("exitApp",1);
editer.commit();
break;
default:
break;
}
}
}
小开

这对我来说很好

.关闭上述所有活动 
    Intent intent = new Intent(this, MainActivity.class);
intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
intent.putExtra("Exit me", true);
startActivity(intent);
finish();

然后在MainActivity的onCreate()方法中添加这个来完成MainActivity

    setContentView(R.layout.main_layout);


if( getIntent().getBooleanExtra("Exit me", false)){
finish();
return; // add this to prevent from doing unnecessary stuffs
}
小开

我用的是观察者模式。

观察者接口

public interface Observer {
public void update(Subject subject);
}

基础学科

public class Subject {
private List<Observer> observers = new ArrayList<Observer>();


public void attach(Observer observer){
observers.add(observer);
}


public void detach(Observer observer){
observers.remove(observer);
}


protected void notifyObservers(){
for(Observer observer : observers){
observer.update(this);
}
}
}

子主题实现了退出方法

public class ApplicationSubject extends Subject {
public void exit(){
notifyObservers();
}
}

MyApplication，你的应用程序应该扩展它

public class MyApplication extends Application {


private static ApplicationSubject applicationSubject;


public ApplicationSubject getApplicationSubject() {
if(applicationSubject == null) applicationSubject = new ApplicationSubject();
return applicationSubject;
}

｝

基本活动

public abstract class BaseActivity extends Activity implements Observer {


public MyApplication app;


@Override
protected void onCreate(Bundle savedInstanceState) {
// TODO Auto-generated method stub
super.onCreate(savedInstanceState);
app = (MyApplication) this.getApplication();
app.getApplicationSubject().attach(this);
}


@Override
public void finish() {
// TODO Auto-generated method stub
app.getApplicationSubject().detach(this);
super.finish();
}


/**
* exit the app
*/
public void close() {
app.getApplicationSubject().exit();
};


@Override
public void update(Subject subject) {
// TODO Auto-generated method stub
this.finish();
}


}

我们来测试一下

public class ATestActivity extends BaseActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
// TODO Auto-generated method stub
super.onCreate(savedInstanceState);
close(); //invoke 'close'
}
}
小开

(我试过以前的答案，但它们有一些不足之处。例如，如果你在完成活动后不执行return;，剩余的活动代码将运行。你还需要用return编辑onCreate。如果你不运行super.onCreate()，你会得到一个运行时错误)

假设你有MainActivity和ChildActivity。

在ChildActivity中添加这个:

Intent intent = new Intent(ChildActivity.this, MainActivity.class);
intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
intent.putExtra("EXIT", true);
startActivity(intent);
return true;

在MainActivity的onCreate中添加这个:

@Override
public void onCreate(Bundle savedInstanceState) {


mContext = getApplicationContext();


super.onCreate(savedInstanceState);


if (getIntent().getBooleanExtra("EXIT", false)) {
finish();
return;
}
// your current codes
// your current codes
}
小开

有些活动实际上你不希望在返回按钮按下时再次打开，如启动画面活动，欢迎屏幕活动，确认窗口。实际上，你在activity stack中不需要这个。您可以使用=> open manifest.xml文件并添加一个属性来做到这一点

android: noHistory = " true "

这些活动。

<activity
android:name="com.example.shoppingapp.AddNewItems"
android:label=""
android:noHistory="true">
</activity>

或

有时你想关闭整个应用程序在某些后退按钮按下。这里的最佳实践是打开home窗口而不是退出应用程序。为此，您需要重写onBackPressed()方法。通常这种方法打开堆栈中的顶部活动。

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


}

或

在返回按钮按下时，你想退出该活动，也不想将其添加到活动堆栈中。在onBackPressed()方法中调用finish()方法。它不会关闭整个应用程序。它将用于堆栈中的前一个活动。

@Override
public void onBackPressed() {
finish();
}
小开

如果您想退出应用程序。然后在按钮按下事件中使用此代码。 如:< / >强

public void onBackPressed()
{
moveTaskToBack(true);
android.os.Process.killProcess(android.os.Process.myPid());
System.exit(1);
}
小开

还有另一种选择，使用FinishAffinity方法关闭堆栈中与应用程序相关的所有任务。

< p >看: https://stackoverflow.com/a/27765687/1984636 < / p >
小开

以下是我所做的:

SomeActivity.java

 @Override
public void onBackPressed() {
Intent newIntent = new Intent(this,QuitAppActivity.class);
newIntent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP|Intent.FLAG_ACTIVITY_CLEAR_TASK | Intent.FLAG_ACTIVITY_NEW_TASK);
startActivity(newIntent);
finish();
}

QuitAppActivity.java

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
finish();
}

基本上你所做的就是从堆栈中清除所有活动并启动QuitAppActivity，这将完成任务。

小开
如果您想退出应用程序，

把这段代码放在函数

下 
public void yourFunction()
{
finishAffinity();
moveTaskToBack(true);


}






//For an instance, if you want to exit an application on double click of a
//button,then the following code can be used.
@Override
public boolean onKeyDown(int keyCode, KeyEvent event)  {
if (keyCode == KeyEvent.KEYCODE_BACK && event.getRepeatCount() == 2) {
// do something on back.
From Android 16+ you can use the following:


finishAffinity();
moveTaskToBack(true);
}


return super.onKeyDown(keyCode, event);
}
小开

100%可以。这是退出应用程序onClick(方法)的代码

    Button exit = (Button)findViewById(R.id.exitbutton);


exit.setOnClickListener(new View.OnClickListener() {


@Override


public void onClick(View view) {


finish();
android.os.Process.killProcess(android.os.Process.myPid());
System.exit(1);
Toast.makeText(getApplicationContext(), "Closed Completely and Safely", Toast.LENGTH_LONG).show();


}
});
小开

你可以在退出按钮的onClickedListener中添加moveTaskToBack(true)来最小化应用程序。

希望能有所帮助。

小开

也许我的代码可以帮助(Main_Activity.java):

    @Override
protected void onDestroy() {
super.onDestroy();
this.finish();
exit(0);
}


@Override
public boolean onKeyDown(int keyCode, KeyEvent event)  {
switch(keyCode)    {
case KeyEvent.KEYCODE_BACK:
AlertDialog.Builder builder = new AlertDialog.Builder(this);
builder.setTitle("My application").setMessage("Keep playing?").setIcon(R.drawable.icon);
// Go to backgroung
builder.setPositiveButton("OK", new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int which) { moveTaskToBack(true); }
});
// Exit from app calling protected void onDestroy()
builder.setNegativeButton("CLOSE APPLICATION", new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int which) { onDestroy(); }
});
// Close this dialog
builder.setNeutralButton("CANCEL", new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int which) { dialog.cancel(); }
});
AlertDialog dialog = builder.create();
dialog.show();
return true;
}
return false;
}
小开

这是最简单的

finish();
android.os.Process.killProcess(android.os.Process.myPid());
System.exit(0);

这将关闭应用程序，而不破坏方法服务，这个任务将完成。

小开

你可以使用finish(); moveTaskToBack(true);和System.exit(1);退出应用程序。

public void onBackPressed() {
AlertDialog.Builder alertDialogBuilder = new AlertDialog.Builder(this);
alertDialogBuilder.setTitle("Exit Application?");
alertDialogBuilder
.setMessage("Click yes to exit!")
.setCancelable(false)
.setPositiveButton("Yes",
new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int id) {
finish();
moveTaskToBack(true);
android.os.Process.killProcess(android.os.Process.myPid());
System.exit(1);
}
})


.setNegativeButton("No", new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int id) {


dialog.cancel();
}
});


AlertDialog alertDialog = alertDialogBuilder.create();
alertDialog.show();
}

提交答案