Android Activity全局管理类

问题描述

做Android项目，退出程序时，有时不能退出所有的activity，这时我们就需要在退出时，关闭所有的activity。

相信大家在处理Activity跳转，或者是删除指定的Activity和所有的Activity都会遇到困惑。尤其是在做项目的退出整个应用功能模块的时候，需要关闭所有的Activity，这里对于新手来说经常性会存在MainActivity已经finish掉了，但是还有其他的Activity存在。那么这个时候我们就需要这么个管理类了。

自定义一个Activity 栈（通用方法）。利用一个单例模式的Activity栈来存放并管理所有Activity。并提供退出所有Activity的方法。

1.自定义一个Activity 栈方法（通用方法）

package com.project.test;

import android.app.Activity;

import java.util.LinkedList;
import java.util.List;

/**
* Author:AND
* Time:2018/3/16.
* Email:2911743255@qq.com
* Description:用于处理退出程序时可以退出所有的activity，而编写的通用类
* Detail:
*/

public class ActivityManager {

private List<Activity> activityList = new LinkedList<Activity>();
private static ActivityManager instance;

private ActivityManager() {
}

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

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

/**
* 移除一个activity
*
* @param activity
*/
public void deleteActivity(Activity activity) {
if (activityList != null && activityList.size() > 0) {
if (activity != null) {
activity.finish();
activityList.remove(activity);
activity = null;
}
}
}

/**
* 遍历所有Activity并finish
*/
public void exit() {
for (Activity activity : activityList) {
activity.finish();
}
System.exit(0);
}
}

大家都知道，Android系统有自己的Activity管理机制，也就ActivityStack(栈)。奉行着先进后出，后进先出的原则。那么我们就通过Stack来进行Activity的管理。

2.更加全面的堆栈管理类

/**
* Author:AND
* Time:2018/3/16.
* Email:2911743255@qq.com
* Description: activity堆栈管理
* Detail:
*/

public class ActivityStack
{
private static ActivityStack mSingleInstance;
private Stack<Activity> mActicityStack;

private ActivityStack()
{
mActicityStack = new Stack<Activity>();
}

public static ActivityStack getInstance()
{
if (null == mSingleInstance)
{
mSingleInstance = new ActivityStack();
}
return mSingleInstance;
}

public Stack<Activity> getStack()
{
return mActicityStack;
}

/**
* 入栈
*
* @author blue
*/
public void addActivity(Activity activity)
{
mActicityStack.push(activity);
}

/**
* 出栈
*
* @author blue
*/
public void removeActivity(Activity activity)
{
mActicityStack.remove(activity);
}

/**
* 彻底退出
*
* @author blue
*/
public void finishAllActivity()
{
Activity activity;
while (!mActicityStack.empty())
{
activity = mActicityStack.pop();
if (activity != null)
activity.finish();
}
}

/**
* finish指定的activity
*
* @author blue
*/
public boolean finishActivity(Class<? extends Activity> actCls)
{
Activity act = findActivityByClass(actCls);
if (null != act && !act.isFinishing())
{
act.finish();
return true;
}
return false;
}

public Activity findActivityByClass(Class<? extends Activity> actCls)
{
Activity aActivity = null;
Iterator<Activity> itr = mActicityStack.iterator();
while (itr.hasNext())
{
aActivity = itr.next();
if (null != aActivity && aActivity.getClass().getName().equals(actCls.getName()) && !aActivity.isFinishing())
{
break;
}
aActivity = null;
}
return aActivity;
}

/**
* finish指定的activity之上的所有activity
*
* @author blue
*/
public boolean finishToActivity(Class<? extends Activity> actCls, boolean isIncludeSelf)
{
List<Activity> buf = new ArrayList<Activity>();
int size = mActicityStack.size();
Activity activity = null;
for (int i = size - 1; i >= 0; i--)
{
activity = mActicityStack.get(i);
if (activity.getClass().isAssignableFrom(actCls))
{
for (Activity a : buf)
{
a.finish();
}
return true;
} else if (i == size - 1 && isIncludeSelf)
{
buf.add(activity);
} else if (i != size - 1)
{
buf.add(activity);
}
}
return false;
}
}

3.使用方法

在onCreate()方法里面加上：

ActivityManager.getInstance().addActivity(this);

在onDestroy()方法里面加上:

ActivityManager.getInstance().deleteActivity(this);

退出时调用:

ActivityManager.getInstance().exit();

另一个更加全面的全栈管理,我个人非常喜欢这个:

import android.app.Activity;
import android.app.ActivityManager;
import android.content.Context;

import java.util.Stack;

/**
* Author:AND
* Time: 2018/3/31.
* Email:2911743255@qq.com
* Description:全栈管理
* Detail
*/
public class ActivityStackManager {
private static Stack<Activity> activityStack;

private static ActivityStackManager instance;

private ActivityStackManager() {
}

/**
* 单一实例
*/
public static ActivityStackManager getAppManager() {
if (instance == null) {
instance = new ActivityStackManager();
}
return instance;
}

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

/**
* 获取当前Activity（堆栈中最后一个压入的）
*/
public Activity currentActivity() {
Activity activity = activityStack.lastElement();
return activity;
}

/**
* 结束当前Activity（堆栈中最后一个压入的）
*/
public void finishActivity() {
Activity activity = activityStack.lastElement();
finishActivity(activity);
}

/**
* 结束指定的Activity
*/
public void finishActivity(Activity activity) {
if (activity != null) {
activityStack.remove(activity);
activity.finish();
activity = null;
}
}

/**
* 结束指定类名的Activity
*/
public void finishActivity(Class<?> cls) {
for (Activity activity : activityStack) {
if (activity.getClass().equals(cls)) {
finishActivity(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();
}

/**
* 退出应用程序
*/
@SuppressWarnings("deprecation")
public void AppExit(Context context) {
try {
finishAllActivity();
ActivityManager activityManager = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
activityManager.restartPackage(context.getPackageName());
System.exit(0);
} catch (Exception e) {
e.printStackTrace();
}
}
}