退出app_app异常退出 - CSDN
精华内容
参与话题
  • android 退出app 退出应用程序

    热门讨论 2020-07-30 23:30:38
    退出app的两种方式 1 创建activity的基类,让所有的activity都继承该基类,在基类中创建一个静态的activity列表,并在oncreate方法添加该activity, 在退出时,遍历该list的activity,逐个关闭每一个activity,从而...
  • 退出App的几种方法

    2016-03-17 15:49:42
    查阅了些资料,要完全退出App,最常用的方法是:1.将activity放入一个list集合,然后遍历关闭。 具体步骤如下: 1)创建一个activity管理类:ActivityCollector 定义三个共有静态的方法;定义存储activity的list...

    查阅了些资料,要完全退出App,最常用的方法是:

    1.将activity放入一个list集合,然后遍历关闭。
    具体步骤如下:
    1)创建一个activity管理类:ActivityCollector
    定义三个共有静态的方法;定义存储activity的list集合。方法如下:
    ①addActivity:往集合里添加activity对象
    ②removeActivity:移除activity对象
    ③finishAll:增强for循环,遍历所有activity并销毁

    2)在baseActivity中
    ①onCreate方法中添加:ActivityCollector.addActivity(this).
    ②onDestory方法中添加:ActivityCollector.removeActivity(this).
    ③可以在任何一个集成baseActivity的activity中调用
    ActivityCollector.finishAll().
    从而关闭所有App.

    具体代码如下:

    public class ActivityCollector {  
        public static LinkedList<Activity> activities = new LinkedList<Activity>();  
        public static void addActivity(Activity activity)  
        {  
            activities.add(activity);  
        }  
        public static void removeActivity(Activity activity)  
        {  
            activities.remove(activity);  
        }  
        public static void finishAll()  
        {  
            for(Activity activity:activities)  
            {  
                if(!activity.isFinishing())  
                {  
                    activity.finish();  
                }  
            }  
        }  
    }  

    2.用singTask模式

    将主Activity的启动模式设置位singleTask:简单的说就是这个Activity重新回到栈顶部时,会把他上面所有Activity干掉,然后再把自己finish掉就退出程序了。不过这种方法会存在特殊情况,退不出程序!

    3.杀死后台进程

    上面说的是关闭所有Activity的,但是有些时候我们可能想杀死整个App,连后台任务都杀死 杀得一干二净的话,可以使用搭配着下述代码使用:

    /** 
     * 退出应用程序 
     */  
    public void AppExit(Context context) {  
        try {  
            ActivityCollector.finishAll();  
            ActivityManager activityMgr = (ActivityManager) context  
                    .getSystemService(Context.ACTIVITY_SERVICE);  
            activityMgr.killBackgroundProcesses(context.getPackageName());  
            System.exit(0);  
        } catch (Exception ignored) {}  
    }  

    4.双击退出程序

    方法一:定义一个变量,来标识是否退出

    // 定义一个变量,来标识是否退出
    private static boolean isExit = false;
    Handler mHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            isExit = false;
        }
    };
    
    public boolean onKeyDown(int keyCode, KeyEvent event) {
        if (keyCode == KeyEvent.KEYCODE_BACK) {
            if (!isExit) {
                isExit = true;
                Toast.makeText(getApplicationContext(), "再按一次退出程序",
                        Toast.LENGTH_SHORT).show();
                // 利用handler延迟发送更改状态信息
                mHandler.sendEmptyMessageDelayed(0, 2000);
            } else {
                exit(this);
            }
            return false;
        }
    return super.onKeyDown(keyCode, event);}

    方法二:保存点击时间

    //保存点击的时间
    private long exitTime = 0;
    public boolean onKeyDown(int keyCode, KeyEvent event) {
        if (keyCode == KeyEvent.KEYCODE_BACK) {
            if ((System.currentTimeMillis() - exitTime) > 2000) {
                Toast.makeText(getApplicationContext(), "再按一次退出程序",
                        Toast.LENGTH_SHORT).show();
                exitTime = System.currentTimeMillis();
            } else {
                            exit();
                          }
            return false;
        }
            return super.onKeyDown(keyCode, event);
    }
    展开全文
  • Android -- 退出整个App

    2018-06-19 16:42:58
    转载自: https://blog.csdn.net/u011967006/article/details/53669458一. 工具类public class ActivityManager { /** * 定义HashSet集合来装Activity,是可以防止Activity不被重复 */ private static HashSet...

    转载自: https://blog.csdn.net/u011967006/article/details/53669458

    一. 工具类

    public class ActivityManager {
    
        /**
         *  定义HashSet集合来装Activity,是可以防止Activity不被重复
         */
        private static HashSet<Activity> hashSet = new HashSet<Activity>();
    
        private static ActivityManager instance = new ActivityManager();;
    
        private ActivityManager() {}
    
        public static ActivityManager getInstance() {
            return instance;
        }
    
        /**
         * 每一个Activity 在 onCreate 方法的时候,可以装入当前this
         * @param activity
         */
        public void addActivity(Activity activity) {
            try {
                hashSet.add(activity);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    
        /**
         * 调用此方法用于退出整个Project
         */
        public void exit() {
            try {
                for (Activity activity : hashSet) {
                    if (activity != null)
                        activity.finish();
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                System.exit(0);
            }
        }
    
        // 此方法用于扩展使用
        /*
        public void onLowMemory() {
          super.onLowMemory();
          System.gc();
        }
        */
    
    }

    二. 调用

    (1)添加activity

    ActivityManager.getInstance().addActivity(this);

    (2)执行退出

    ActivityManager.getInstance().exit();
    The end!
    展开全文
  • Android 安全退出App完美实现

    千次阅读 2018-06-08 11:09:53
    本文主要介绍两种方式退出APP,一种是基于Activity的启动模式singleTask模式实现的,一种是基于全局Activity管理类实现的。强烈推荐第一种方法实现,简单又方便。 基于Activity的启动模式singleTask模式实现 ...

    本文主要介绍两种方式退出APP,一种是基于Activity的启动模式singleTask模式实现的,一种是基于全局Activity管理类实现的。强烈推荐第一种方法实现,简单又方便。

    • 基于Activity的启动模式singleTask模式实现
      singleTask是Activity启动模式中的一种,当startActivity时,它先会在当前栈中查询是否存在Activity的实例,如果存在,则将其置于栈顶,并将其之上的所有Activity移出栈。同时调用Activity的onNewIntent方法。可以看出实现安全退出APP很简单,只需要将MainActivity的launchMode改为singleTask,在MainActivity中的onNewintent方法中finish掉当前Activity即可。

    说下环境:MainActivity跳转到FirstActivity,FirstActivity跳转到secondActivity,在secondActivity中退出程序。
    首先,将MainActivity的launchMode改为singleTask,如下

     <activity
                android:name=".MainActivity"
                android:launchMode="singleTask">
                <intent-filter>
                    <action android:name="android.intent.action.MAIN" />
    
                    <category android:name="android.intent.category.LAUNCHER" />
                </intent-filter>
            </activity>

    其次 实现MainActivity中的onNewIntent方法,实现退出APP的逻辑。

       @Override
        protected void onNewIntent(Intent intent) {
            super.onNewIntent(intent);
            String tag = intent.getStringExtra("EXIT_TAG");
            if (tag != null&& !TextUtils.isEmpty(tag)) {
                if ("SINGLETASK".equals(tag)) {//退出程序
                    finish();
                }
            }
        }

    这里面的tag用来标识关闭app的,在secondActivity中退出APP调用startActivity的时候需要传入。
    现在就看下secondActivity中相关代码

     Intent intent = new Intent(this, MainActivity.class);
                    intent.putExtra("EXIT_TAG", "SINGLETASK");
                    startActivity(intent);

    通过这三步就解决了安全退出APP的问题,现在很多人都在用,你还在等啥。

    • 基于全局Activity管理类实现

    说下环境:MainActivity跳转到FirstActivity,FirstActivity跳转到secondActivity,在secondActivity中退出程序。
    首先创建一个全局的Activity管理类 ActivityManager,里面有添加Activity,移除Activity,关闭activitys。ActivityManager的单例是用静态内部类实现的。贴下ActivityManager的全部代码

      package com.appexit.util;
    
    import android.app.Activity;
    
    import java.util.ArrayList;
    import java.util.List;
    
    /**
     * Author:wang_sir
     * Time:2018/6/7 20:15
     * Description:This is ActivityManager
     */
    public class ActivityManager {
    
        private List<Activity> activityList = new ArrayList<>();
    
        private ActivityManager() {
        }
    
        public static ActivityManager getInstance() {
    
            return ActivityManagerHolder.Instantce;
        }
    
        /**
         * 静态内部类获取单例
         */
        static class ActivityManagerHolder {
            public static ActivityManager Instantce = new ActivityManager();
    
        }
    
        /**
         * 添加activity
         * @param activity
         */
        public void addActivity(Activity activity){
            if (!activityList.contains(activity)) {
                activityList.add(activity);
            }
    
        }
    
        /**
         * 移除activity
         * @param activity
         */
        public void removeActivity(Activity activity){
            if (activityList.contains(activity)) {
                activityList.remove(activity);
            }
        }
    
        /**
         * 关闭所有的activity,退出应用
         */
        public void finishActivitys(){
            if (activityList != null&&!activityList.isEmpty()) {
                for (Activity activity1 : activityList) {
                    activity1.finish();
                }
                activityList.clear();
            }
        }
    
    }
    

    其次是创建一个BaseActivity,所有的Activity都继承这个BaseActivity,在BaseActivity中实现添加Activity和移除Activity的操作,看代码

    package com.appexit;
    
    import android.app.Activity;
    import android.os.Bundle;
    import android.support.annotation.Nullable;
    import android.support.v7.app.AppCompatActivity;
    
    import com.appexit.util.ActivityManager;
    
    import java.lang.ref.WeakReference;
    
    /**
     * Author:wang_sir
     * Time:2018/6/7 20:11
     * Description:This is BaseActivity
     */
    public class BaseActivity extends AppCompatActivity {
    
        private WeakReference<Activity> weakReference = null;
    
        @Override
        protected void onCreate(@Nullable Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            //将activity添加到列表中
    
            if (weakReference==null) {
                weakReference =  new WeakReference<Activity>(this);
            }
          ActivityManager.getInstance().addActivity(weakReference.get());
    
        }
    
    
    
        @Override
        protected void onDestroy() {
            super.onDestroy();
            //将activity从列表中移除
            ActivityManager.getInstance().removeActivity(weakReference.get());
        }
    
    
    
    
    }
    

    这里用到了弱引用,目的防止内存泄漏,因为ActivityManager有Activity的引用。

    当需要退出应用的时候直接调用ActivityManager中的关闭Activity的方法即可,看下secondActivity中的相关代码

      ActivityManager.getInstance().finishActivitys();

    至此两种安全退出APP的方法总结完了,都挺实用的,个人感觉还是第一种方法好。

    Demo地址:https://github.com/DevelopWb/AppExit.git

    展开全文
  • Android 中几种优雅的退出APP方式介绍

    千次阅读 2018-06-05 10:58:41
    最近由于项目的修改,项目由MainActivity按返回键一次退出修改为MainActivity中连续按两次返回键退出,顺便优化一下推出这里的代码。因此还是在网上搜索了一番,总结比较之后得出了有以下集中方式,优缺点都会提出来...

    我们的态度是:每天进步一点点,理想终会被实现。

    前言


    最近由于项目的修改,项目由MainActivity按返回键一次退出修改为MainActivity中连续按两次返回键退出,顺便优化一下推出这里的代码。因此还是在网上搜索了一番,总结比较之后得出了有以下集中方式,优缺点都会提出来,有需要的老铁按需选择。

    目录


    常见的有5中方式:

    • 容器式
    • 便捷式
    • 广播式
    • SingleTask式
    • 进程式

    实现方法


    1.容器式
    容器式可能是我们最常见的方式之一了,主要通过创建一个全局的容器,把所有的Activity都保存下来,退出的时候循环遍历所有activity,然后finish()掉。

    BaseActivity添加代码:

    public abstract class BaseActivity extends AppCompatActivity{
     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         // 添加Activity到堆栈
         ActivityUtils.getInstance().addActivity(this);
     }
    
     @Override
     protected void onDestroy() {
         super.onDestroy();
         // 结束Activity&从栈中移除该Activity
         ActivityUtils.getInstance().removeActivity(this);
     }
    
    }

    创建一个全局工具类:

    public class ActivityUtils{
    
       private ActivityUtils() {
       }
    
       private static AtyContainer instance = new AtyContainer();
       private static List<Activity> activitys = new ArrayList<Activity>();
    
       public static ActivityUtils getInstance() {
           return instance;
       }
    
       public void addActivity(Activity activity) {
           activityStack.add(activity);
       }
    
       public void removeActivity(Activity activity) {
           activityStack.remove(activity);
       }
    
       /**
        * 结束所有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();
       }
    
    }

    这种方式是有一定的缺点的,我们的工具类ActivityUtils持有Activity的引用,当我们的应用发生异常,ActivityUtils持有的引用没有被销毁会导致部分内存问题,而且代码量多,不够优雅,诸多不便。

    但是容器式这种方式还是有解决办法的,我们可以采用弱引用的方式,就不存在前面所说的问题了,习惯于容器式的可以采用弱引用这种方式的。

    2.便捷式

    在之前,先讲一下Activity的启动模式:SingleTask

    我们知道Activity有四种加载模式,而singleTask就是其中的一种,使用这个模式之后,当startActivity时,它先会在当前栈中查询是否存在Activity的实例,如果存在,则将其至于栈顶,并将其之上的所有Activity移除栈。我们打开一个app,首先是一个splash页面,然后会finish掉splash页面。跳转到主页。然后会在主页进行N次的跳转,期间会产生数量不定的Activity,有的被销毁,有的驻留在栈中,但是栈底永远是我们的HomeActivity。这样就让问题变得简单很多了。我们只需两步操作即可优雅的实现app的退出。

    有了这么一个启动模式,就好办了,我们将退出的出口放在MainActivity中所有事都解决了。

    那么这种方法为什么叫便捷式呢?这种方式代码量很少而且很好理解、优雅,而且市面上很多APP都是基于此实现的。我们在MainActivity中实现如下代码:

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

    不要着急,不要以为就完了,还有很重要的一步:将MainActivity设置为singleTask。

    <activity android:name=".MainActivity"
               android:launchMode="singleTask">
               <intent-filter>
                   <action android:name="android.intent.action.MAIN"/>
    
                   <category android:name="android.intent.category.LAUNCHER"/>
               </intent-filter>
           </activity>

    上面这种方法就是我个人认为最简便的方式了,这也符合有些要求按2次退出。

    3.广播式

    我相信很多的老铁是使用的广播式,毕竟很方便,先上代码,再说利弊。

    public abstract class BaseActivity extends Activity {
    
       private static final String ACTION = "action.exit";
    
       private ExitReceiver exitReceiver = new ExitReceiver();
    
       @Override
       protected void onCreate(Bundle savedInstanceState) {
           super.onCreate(savedInstanceState);
           IntentFilter filter = new IntentFilter();
           filter.addAction(ACTION);
           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();
           }
    
       }
    
    }

    最后再需要退出的地方,发送一个广播就可以了,注意Action和注册的相同就可以了。

    但是个人觉得这种方式还是太耗性能,毕竟广播是进程间通信,我们一个退出APP功能不是特别的有必要。

    4.SingleTask式

    简单解释一下SingleTask这种启动模式的两个特点:
    清除堆栈中处于当前Activity上方的Activity
    堆栈中含有你要启动的Activity时,不会重新创建。

    假设我们的MainActivity是使用的SingleTask的启动模式,假设我跳转到了其他的页面,然后使用startActivity(this,MainActivity.class)的方式再次启动MainActivity,这时MainActivity走到onNewIntent()方法,然后按照生命周期onRestart()——>onStart()——>onResume(),MainActivity不会重新创建。

    既然有这么一个特点我们就可以分三步来退出APP:

    第一步:MainActivity设置为SingleTask。

    android:launchMode="singleTask"

    第二步:重写MainActivity中的onNewIntent方法

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

    第三步:需要退出时在Intent中添加退出的tag

    Intent intent = new Intent(this,MainActivity.class);
           intent.putExtra(MainActivity.TAG_EXIT, true);
           startActivity(intent);

    虽然这种方式简单、便捷,但还有弊端:当我们需要退出的时候,假如是在其他的Activity中退出,这时MainActivity要走一段生命周期的方法,有点浪费。

    5.进程式

    1.android.os.Process.killProcess(android.os.Process.myPid());
    
    2.System.exit(0);
    
    3.ActivityManager manager = (ActivityManager) getSystemService(ACTIVITY_SERVICE);
       manager.killBackgroundProcesses(getPackageName());

    这三种方式都能够达到杀死进程的效果,直接退出APP,但是这种太暴力了不推荐使用,而且使用体验不好。不知道是不是华为手机问题,我用华为P10 Plus使用这种方式退出的时候要白屏、闪屏一下,反正就是不建议使用这种方式。

    总结


    其实严格来说,还有一种方式就是抛异常让APP强制退出,因为感觉用的人不多就没有细说。
    上面的几种方式中,最不推荐的就是最后第五种方式,暴力而且用户体验不好。大家在项目中看着需求、以及自己习惯的方式来选择就好,今天就到这里了。


    温馨提示:
    我创建了一个技术交流群,群里有各个行业的大佬都有,大家可以在群里畅聊技术方面内容,以及文章推荐;如果有想加入的伙伴加我微信号【luotaosc】备注一下“加群”
    另外关注公众号,还有一些个人收藏的视频:
    回复“Android” ,获取Android视频链接。
    回复“Java” ,获取Java视频链接。
    回复“C++” ,获取C++视频链接。
    回复“C” ,获取C视频链接。
    回复“Python” ,获取Python视频链接等等。

    原创文章不易,如果觉得写得好,扫码关注一下点个赞,是我最大的动力。

    关注我,一定会有意想不到的东西等你:
    每天专注分享Android、JAVA干货

    这里写图片描述

    备注:程序圈LT

    展开全文
  • iOS退出APP

    千次阅读 2019-09-16 09:33:07
    主要用到了exit(0)函数,代码如下:加了个动画,类似电视荧幕关闭的效果 - (void)exitApplication { UIWindow *window = [UIApplication sharedApplication].keyWindow; [UIView animateWithDuration:0.5f ...
  • 一键退出App所有方式

    2019-04-11 11:50:12
    在安卓面试过程中经常会被问到如何从一个Activity中退出整个App的问题,下面我就总结一下大概市面上所有的一键退出App所有方式和优劣程度。 1.写一个基类BaseActivity,让你所创建的Activity都继承与它,在该基类中...
  • 关于app退出的问题,完美退出方式

    万次阅读 2017-06-20 10:07:35
    实际开发中会有很多关于app退出问题,我个人比较常见的有两种: 一、双击退出 比如说我们在首页的时候需要一个双击退出的方法,点击第一次手机的返回键时提示:“再点一次退出应用”。之类的话语,我们可以这样...
  • android中彻底退出App的办法

    千次阅读 2019-06-04 17:36:23
    所谓的“彻底退出App”的含义是包括释放所有App new出来的东西,比如说某些正在运行的线程、定时器之类的。 需要注意的是:finish()方法是作用于Activity,因此,即使finish了app的最后一个Activity,app在运行...
  • Android app退出程序的两种方式

    千次阅读 2018-02-09 11:37:14
    1. Process.killProcess(android.os.process.pId()); 杀掉当前的进程,从而退出程序2. system.exit(0); 括号里面的参数:0代表正常的退出 0以外的数值代表异常退出 相当于是退出JVM...
  • IOS 退出程序APP代码

    万次阅读 2014-07-04 16:08:21
    怎样用代码方式退出IOS程序
  • Android App退出检测

    万次阅读 2017-04-08 13:15:59
    app退出检测是很难的,但是获取app“要退出”的状态就容易多了,退出的瞬间并不是真的退出了,ActivityManager要销毁activity,也需要一些时间和资源的。 先见下面的运行效果: gif做的比价粗啊, 两个activity...
  • android 实现退出app仍然在后台运行

    万次阅读 2018-08-22 17:39:13
    @Override public boolean onKeyDown(int keyCode, KeyEvent event) { if (keyCode == KeyEvent.KEYCODE_BACK) { moveTaskToBack(false); return true; } retu...
  • Android 退出(应用程序)App的方法

    千次阅读 2018-06-25 10:00:28
    System.exit(0);//正常退出App
  • HBuilder手机退出APP的方式

    万次阅读 2015-12-26 21:55:42
    1.手机返回键监听 点击两次退出系统 mui.oldback = mui.back; var clickNum = 0; mui.back = function(event){  clickNum++;  if(clickNum > 1){  plus.runtime.quit();... mui.toast("再按一次退出应用");
  • 起初设置的方法为这个- (void)...}可是通过测试发现,APP退出的时候并不走这个方法 只要添加观察者才会执行这个方法[[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(a
  • qt退出应用程序(exe)的方法

    万次阅读 2017-11-16 11:35:24
    首先退出应用程序(exe)的方法 方法1: QApplication* app; app->exit(0); 方法2: QApplication* app; app->quit(); 可以将以上方法加入到关闭程序的槽函数中 为了增加应用程序的人性化,在退出
  • uni-app怎么实现双击返回退出app

    千次阅读 2019-12-03 15:10:17
    uni-app提供了一个监听返回按钮的api:onBackPress(event) //监听返回键 onBackPress() { uni.showModal({ title: '提示', content: '是否退出来聊?', success: function(res) { if (res....
  • vue 开发webapp 手机返回键 退出问题

    万次阅读 2018-06-13 16:23:23
    mui进行手机物理键的监听首先安装 vue-awesome-muinpm i vue-awesome-mui在main.js注册import Mui from 'vue-awesome-mui';Vue.use(Mui);...lt;script&gt; mui.init({ keyEventBind: { backbutton: t...
  • 昨天通过hbuilder将做了一部分的vue项目进行打包成app测试,发现打包成的app点击手机的返回键的时候直接退出app,并不会返回上一页 于是去网上查了一下终于解决了这个问题 参考博客链接:...
1 2 3 4 5 ... 20
收藏数 193,368
精华内容 77,347
关键字:

退出app