Android 经典笔记之二:如何退出应用程序

版权声明:本文为博主原创文章,转载请注明出处 https://blog.csdn.net/m0_37700275/article/details/77198513

目录介绍:
1.如何退出应用程序
1.1 第一种方式:以任务栈形式退出程序
1.2 第二种方式:任务管理器方法【简称:进程式】
1.3 第三种方式:跳转页面后销毁栈堆【SingTask式】
1.4 第四种方式:容器式退出程序【目前用的就是这种 】
1.5 第五种方式:广播式退出程序
1.6 第六种方式:懒人式退出程序

第一种方式:以任务栈形式退出程序
* 1.思路分析:
在Android的Activity中,当有多个Activity多次跳转后,点击返回或退出按钮会发现它会出现循环,会将刚刚打开的Activity,打开了多少次,一次次返回回去,当回到最开始的Activity后才会回到桌面
想要应用程序完全退出,可定义一个栈,利用单列模式管理Activity,写一个自定义Application类。
在每个Activity的onCreate()方法中调用自定义Application.getInstance().addActivity(this);方法,将该Activity添加到ExitApplication实例中,在要退出的地方调用自定义Application.getInstance().exit();方法,从而将整个应用程序完全退出。

  • 2.首先自定义Application类
public class App extends Application {
    private List<Activity> activityList = new LinkedList<>();
    private static App instance;

    public App() {

    }

    // 单例模式中获取唯一的ExitApplication实例
    public static App getInstance() {
        if (null == instance) {
            instance = new App();
        }
        return instance;
    }

    @Override
    public void onCreate() {
        super.onCreate();
    }

    // 将Activity添加到容器中
    public void addActivity(Activity activity) {
        activityList.add(activity);
    }

    // 当要退出Activity时,遍历所有Activity 并finish
    public void exit() {
        for (Activity activity : activityList) {
            activity.finish();
        }
        System.exit(0);
    }
}
  • 3.在父类BaseActivity中添加继承子类Activity到栈中【注意是所有Activity中必须添加】
//将该Activity添加到自定义Application实例中,
public class BaseActivity extends Activity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        // 添加Activity到堆栈
        App.getInstance().addActivity(this);     //这句话必须添加
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        // 结束Activity&从栈中移除该Activity
        //App.getInstance().removeActivity(this);          //这句话建议不添加,因为有时返回上一个Activity不希望被销毁
    }
}
  • 4.在主页面执行退出程序方法
// 物理返回键,双击退出
private long exitTime = 0;
@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
    if (keyCode == KeyEvent.KEYCODE_BACK && event.getAction() == KeyEvent.ACTION_DOWN) {
        if ((System.currentTimeMillis() - exitTime) > 2000) {
            Toast.makeText(MainActivity.this, "再按一次退出程序", Toast.LENGTH_SHORT).show();
            exitTime = System.currentTimeMillis();
        } else {
            App.getInstance().exit();
        }
        return true;
    }
    return super.onKeyDown(keyCode, event);
}

第二种方式:任务管理器方法
* 2.1 方法比较简单,但不太好使用

// 物理返回键,双击退出
private long exitTime = 0;
@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
    if (keyCode == KeyEvent.KEYCODE_BACK && event.getAction() == KeyEvent.ACTION_DOWN) {
        if ((System.currentTimeMillis() - exitTime) > 2000) {
            Toast.makeText(MainActivity.this, "再按一次退出程序", Toast.LENGTH_SHORT).show();
            exitTime = System.currentTimeMillis();
        } else {
            //系统会将,该包下的 ,所有进程,服务,全部杀掉,就可以杀干净了,要注意加上权限
            //<uses-permission android:name="android.permission.RESTART_PACKAGES"/>
            ActivityManager am = (ActivityManager)getSystemService (Context.ACTIVITY_SERVICE);
            am.restartPackage(getPackageName());
        }
        return true;
    }
    return super.onKeyDown(keyCode, event);
}

第三种方式:历史栈销毁所有Activity
* 3.1 思路:通过Intent的Flags来控制堆栈去解决
Android的窗口类提供了历史栈,我们可以通过stack的原理来巧妙的实现,这里我们在A窗口打开B窗口时在Intent中直接加入标 志 Intent.FLAG_ACTIVITY_CLEAR_TOP,这样开启B时将会清除该进程空间的所有Activity。
android中,每打开一个Activity,便会在栈中加入一个Activity,当该Activity被摧毁后,栈中便移除了它,并且栈中的Activity是按照开打的先后顺序依次排排列的。
Android的窗口类提供了历史栈,我们可以通过stack的原理来巧妙的实现,这里我们在A窗口打开B窗口时在Intent中直接加入标志 Intent.FLAG_ACTIVITY_CLEAR_TOP,这样开启B时将会清除该进程空间的所有Activity。

Intent intent = new Intent(this,MainActivity.class); 
intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP); 
startActivity(intent);

或者,下面这种方式也可以可以的,简单快捷
- 1、设置MainActivity的加载模式为singleTask
- 2、重写MainActivity中的onNewIntent方法
- 3、需要退出时在Intent中添加退出的tag

// 物理返回键,双击退出
private long exitTime = 0;
@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
    if (keyCode == KeyEvent.KEYCODE_BACK && event.getAction() == KeyEvent.ACTION_DOWN) {
        if ((System.currentTimeMillis() - exitTime) > 2000) {
            Toast.makeText(MainActivity.this, "再按一次退出程序", Toast.LENGTH_SHORT).show();
            exitTime = System.currentTimeMillis();
        } else {
            exit();
        }
        return true;
    }
    return super.onKeyDown(keyCode, event);
}

/**退出程序**/
protected void exit() {
    // 退出程序方法有多种
    // 这里使用clear + new task的方式清空整个任务栈,只保留新打开的Main页面
    // 然后Main页面接收到退出的标志位exit=true,finish自己,这样就关闭了全部页面
    Intent intent = new Intent(this, MainActivity.class);
    intent.putExtra("exit", true);
    startActivity(intent);
}

@Override
protected void onNewIntent(Intent intent) {
    super.onNewIntent(intent);
    if (intent != null) {
        boolean isExit = intent.getBooleanExtra("exit", false);
        if (isExit) {
            this.finish();
        }
    }
}

第四种:容器式退出程序【目前用的就是这种】
* 建立一个全局容器,把所有的Activity存储起来,退出时循环遍历finish所有Activity

public class BaseActivity extends Activity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        // 添加Activity到堆栈
        AtyContainer.getInstance().addActivity(this);
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        //这句话建议不添加,因为有时返回上一个Activity不希望被销毁
        // 结束Activity&从栈中移除该Activity
        //AtyContainer.getInstance().removeActivity(this);
    }
}

class AtyContainer {

    public AtyContainer() {
    }

    private static AtyContainer instance = new AtyContainer();
    private static List<Activity> activityStack = new ArrayList<Activity>();

    public static AtyContainer getInstance() {
        return instance;
    }

    /**
     * 添加Activity到堆栈
     */
    public void addActivity(Activity activity) {
        if (activityStack == null) {
            activityStack = new ArrayList<Activity>();
        }
        activityStack.add(activity);
    }

    /**
     * 移除指定的Activity
     */
    public void removeActivity(Activity activity) {
        if (activity != null) {
            activityStack.remove(activity);
            activity = null;
        }
    }
    /**
    * 结束所有Activity
    */
    public void finishAllActivity() {
        for (int i = 0, size = activityStack.size(); i < size; i++) {
            if (null != activityStack.get(i)) {
                activityStack.get(i).finish();
            }
        }
        activityStack.clear();
    }
}

这种方法比较简单, 但是可以看到activityStack持有这Activity的强引用,也就是说当某个Activity异常退出时,activityStack没有即使释放掉引用,就会导致内存问题,接下来我们看一种类似的方式,但是会稍微优雅一点点

第五种方式:广播式退出程序
* 通过在BaseActivity中注册一个广播,当退出时发送一个广播,finish退出

public class BaseActivity extends Activity {

    private static final String EXITACTION = "action.exit";
    private ExitReceiver exitReceiver = new ExitReceiver();

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        IntentFilter filter = new IntentFilter();
        filter.addAction(EXITACTION);
        registerReceiver(exitReceiver, filter);
    }

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

    class ExitReceiver extends BroadcastReceiver {
        @Override
        public void onReceive(Context context, Intent intent) {
            BaseActivity.this.finish();
        }
    }

}

第六种方式:懒人式退出程序
* 1、将MainActivity设置为singleTask
* 2、将退出出口放置在MainActivity
我们可以看到很多应用都是双击两次home键退出应用,就是基于这样的方式来实现的,这里在贴一下如何处理连续两次点击退出的源码

    private boolean mIsExit;
    /**
    * 双击返回键退出
    */
    @Override
    public boolean onKeyDown(int keyCode, KeyEvent event) {
        if (keyCode == KeyEvent.KEYCODE_BACK) {
            if (mIsExit) {
                this.finish();
            } else {
                Toast.makeText(this, "再按一次退出", Toast.LENGTH_SHORT).show();
                mIsExit = true;
                new Handler().postDelayed(new Runnable() {
                    @Override
                    public void run() {
                        mIsExit = false;
                    }
                }, 2000);
            }
            return true;
        }
        return super.onKeyDown(keyCode, event);
    }

后续:
平时喜欢写写文章,笔记。别人建议我把笔记,以前写的东西整理,然后写成博客,所以我会陆续整理文章,只发自己写的东西,敬请期待:
知乎:https://www.zhihu.com/people/yang-chong-69-24/pins/posts
领英:https://www.linkedin.com/in/chong-yang-049216146/
简书:http://www.jianshu.com/u/b7b2c6ed9284
csdn:http://my.csdn.net/m0_37700275
网易博客:http://yangchong211.blog.163.com/
新浪博客:http://blog.sina.com.cn/786041010yc
github:https://github.com/yangchong211
喜马拉雅听书:http://www.ximalaya.com/zhubo/71989305/
脉脉:yc930211
开源中国:https://my.oschina.net/zbj1618/blog

阅读更多
换一批

没有更多推荐了,返回首页