退出app_vue 退出app - CSDN
  • 退出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!
    展开全文
  • 本文主要介绍两种方式退出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

    展开全文
  • //常规Java、c#的标准退出法,返回值为0代表正常退出 2. 任务管理器方法 首先要说明该方法运行在Android 1.5 API Level为3以上才可以,同时需要权限 ActivityManager am = (ActivityManager)getSystemService ...

    通常很多APP中都有退出的需求,这里讲目前涉及到的所有方法都总结一遍。

    一、容器式

    建立一个全局容器,把所有的Activity存储起来,退出时循环遍历finish所有Activity

    import java.util.ArrayList;
    import java.util.List;
    
    import android.app.Activity;
    import android.os.Bundle;
    
    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
        AtyContainer.getInstance().removeActivity(this);
      }
    
    }
    
    class AtyContainer {
    
      private AtyContainer() {
      }
    
      private static AtyContainer instance = new AtyContainer();
      private static List<Activity> activityStack = new ArrayList<Activity>();
    
      public static AtyContainer getInstance() {
        return instance;
      }
    
      public void addActivity(Activity aty) {
        activityStack.add(aty);
      }
    
      public void removeActivity(Activity aty) {
        activityStack.remove(aty);
      }
    
      /**
       * 结束所有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异常退出时,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();
        }
    
      }
    
    }

    三、直接杀进程

    通过直接杀死当前应用的进程来结束应用,非常简单粗暴,但是有很多问题。

    杀进程

    
    android.os.Process.killProcess(android.os.Process.myPid());

    退出虚拟机

    System.exit(0);

    ActivityManager杀死后台进程

    ActivityManager manager = (ActivityManager) getSystemService(ACTIVITY_SERVICE);
    manager.killBackgroundProcesses(getPackageName());
    

    需要添加权限

    <uses-permission android:name="android.permission.KILL_BACKGROUND_PROCESSES" />
    

    ActivityManager 的killBackgroundProcesses 是AMS提供的杀死后台进程的方法,不能杀死自己。

    Process.killProcess 和 System.exit(0) 两个都会 kill 掉当前进程。

    如果是在第一个 Activity 调用 Process.killProcess 或 System.exit(0) 都会 kill 掉当前进程。但是如果不是在第一个 Activity 中调用,如 ActivityA 启动 ActivityB ,你在 ActivityB 中调用
    Process.killProcess 或 System.exit(0) 当前进程确实也被 kill 掉了,但 app 会重新启动,又创建了一个新的进程,APP生命周期重新执行。其实Process.killProcess 或 System.exit(0) 都不建议直接调用, 进程是由 os 底层进行管理的,android 系统会自己进行处理回收进程。

    四、 Receiver+singleTask

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

    1、在HomeActivity注册一个退出广播,和第二个广播式一样,但是这里只需要在HomeActivity一个页面注册即可。

    2、设置HomeActivity的启动模式为singleTask。
    当我们需要退出的时候只需要

    startActivity(this,HomeActivity,class)`, 

    再发送一个退出广播。上面代码首先会把栈中HomeActivity之上的所有Activity移除出栈,然后接到广播finish自己。

    五、SingleTask改版式

    这种方式是第四种方式的改进版,
    思路也很简单,

      1、设置MainActivity的加载模式为singleTask
      2、重写MainActivity中的onNewIntent方法
      3、需要退出时在Intent中添加退出的tag
    

    第一步 设置MainActivity的加载模式为singleTask

    android:launchMode="singleTask"
    

    第二步 重写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 intent = new Intent(this,MainActivity.class);
        intent.putExtra(MainActivity.TAG_EXIT, true);
        startActivity(intent);

    六、MainActivity界面 双击返回键退出

    这种方式更加简单,只需要如下两步操作

    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);
      }
    展开全文
  • 最近由于项目的修改,项目由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);
     }
    
    }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    创建一个全局工具类:

    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 ( != activityStack.get(i)) {
                   activityStack.get(i).finish();
               }
           }
           activityStack.clear();
       }
    
    }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33

    这种方式是有一定的缺点的,我们的工具类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);
      }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27

    不要着急,不要以为就完了,还有很重要的一步:将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>
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    上面这种方法就是我个人认为最简便的方式了,这也符合有些要求按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();
           }
    
       }
    
    }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30

    最后再需要退出的地方,发送一个广播就可以了,注意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"
    • 1

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

    private static final String TAG_EXIT = "exit";
    
       @Override
       protected void onNewIntent(Intent intent) {
           super.onNewIntent(intent);
           if (intent != ) {
               boolean isExit = intent.getBooleanExtra(TAG_EXIT, false);
               if (isExit) {
                   this.finish();
               }
           }
       }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

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

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

    虽然这种方式简单、便捷,但还有弊端:当我们需要退出的时候,假如是在其他的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());
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

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

    总结


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


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

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

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

    这里写图片描述

    备注:程序圈LT

            <link rel="stylesheet" href="https://csdnimg.cn/release/phoenix/template/css/markdown_views-ea0013b516.css">
                </div>
    
    展开全文
  • 在 Android开发中,会经常存在 “一键退出App” 的需求 但市面上流传着 太多不可用的“一键退出App”功能实现 本文将全面总结“一键退出App”的实现方式,并为你一一实践,希望你们会喜欢。 目录1. 需求本质一键退出...
  • 所谓的“彻底退出App”的含义是包括释放所有App new出来的东西,比如说某些正在运行的线程、定时器之类的。 需要注意的是:finish()方法是作用于Activity,因此,即使finish了app的最后一个Activity,app在运行...
  • android 退出App也是一门艺术,很多App都是直接使用system.exit(0)的方法直接退出的,这样的话会给用户带来不好的体验,而且不能正确释放内存,用户还以为是App闪退了呢。那如何做到退出不给用户一种闪退的感觉呢?...
  • 代码如下: ActivityManager am = (ActivityManager) getSystemService(ACTIVITY_SERVICE); if( android.os.Build.VERSION.SDK_INT ){ am.restartPackage(getPackageName());...这样写能安全退出app吗?
  • 在首页点击一次返回键直接就退出了,这种体验很不好,而且一般的APP都是需要按两次返回键退出,或者按一次返回键只返回桌面不结束进程,所以我研究了一下点击两次返回键退出APP的姿势~ 首先需要明确的是需要在APP的...
  • 用户不同意就会退出APP。同意了就跳转到首页。 那怎么才能判断用户下载APP,是否有同意使用呢。并且用户卸载重装后仍然会提示用户同意。 我们可以在用户点击同意时,保存一个关键词在本地。根据这个关键词是否存在...
  • 公司app开发,react-native(android)要实现点击手机物理键back返回和退出app功能,本人也是小白,不是很懂,但是作为一个app,这是基本功能,所以必须实现。下面两个方案的coding中有什么写的不好的地方请多多包涵...
  • 在A->B后,若想在B中直接退出APP,调用System.exit(0)或者android.os.Process.killProcess(android.os.Process.myPid()) 均不能完全退出App。 研究后,这个和Android UI的栈设计有关。 若想要退出整
  • Android 开发App中很常见的一种需求,连续按两次退出App.
  • 想必大家经常会遇到这种情况:当你想要退出APP时,按一次返回键,它会弹出”再按一次返回”。这个对于做APP的人来说,加上这样一个小功能,你的APP会显得高大上一点啦,下面小编教你如何简单实现这一功能 ps:此方法...
  • Android退出App时,个人觉得比较好用的方法 1.以广播的方式 2.在自定义Appication中管理所有的Activity 注意:在写Android退出App时,要注意是在App的主页面退出,还是任意页面退出,不要盲目的进行编码。 如...
  • uni-app 退出app操作

    2020-06-02 22:42:15
    uni-app 退出app //安卓退出 // #ifdef APP-PLUS if (plus.os.name.toLowerCase() === 'android') { plus.runtime.quit(); } else{ const threadClass = plus.ios.importClass("NSThread"); const ...
  • Android 退出 app 功能

    2019-09-04 09:05:09
    安卓如何实现点击一个按钮退出整个程序? Android 中几种优雅的退出APP方式介绍 ANDROID 完美退出APP的实例代码
  • 今天无意中在群里讨论起完全退出App的问题,纠结了很久这个System.exit(0)是否能退出程序的问题, 下面是群友:Jafir提供的参考资料: http://www.cnblogs.com/lesliefang/p/3933640.html ... 另外 ...
1 2 3 4 5 ... 20
收藏数 184,329
精华内容 73,731
热门标签
关键字:

退出app