Android 기본 종료 모든 Activity 공통 방법

출처:http://blog.csdn.net/chenliguan/article/details/47295163
문제 설명
Android 프로젝트 를 하고 프로그램 을 종료 할 때 모든 activity 를 종료 할 수 없 을 때 가 있 습 니 다. 이 때 는 종료 할 때 모든 activity 를 닫 아야 합 니 다.
해결 방법
1. Dalvik VM 의 로 컬 방법
　　android.os.Process.killProcess(android.os.Process.myPid());  PID 를 가 져 옵 니 다. 현재 자신 을 가 져 오 는 것 도 이 API 뿐 입 니 다. 그렇지 않 으 면 / proc 에서 다른 프로 세 스 를 매 거 합 니 다. 하지만 다른 프로 세 스 를 끝 내 는 데 권한 이 있 는 것 이 아니 라 혼 란 스 럽 습 니 다.  　　System.exit(0);  일반적인 자바, c \ # 의 표준 종료 법, 반환 값 이 0 이면 정상 적 인 종료 입 니 다.
2. 작업 관리자 방법
Android 1.5 이상 이 어야 합 니 다. 권한 이 필요 합 니 다.  　　android:name=\”android.permission.RESTART_PACKAGES\”>

    ActivityManager am = (ActivityManager)getSystemService (Context.ACTIVITY_SERVICE); 
    am.restartPackage(getPackageName()); 

1
2
시스템 은 이 가방 의 모든 프로 세 스, 서 비 스 를 모두 죽 이면 깨끗하게 죽 일 수 있 습 니 다.
3. Activity 의 성명 주기 에 따라
우 리 는 안 드 로 이 드 의 창 클래스 가 역사 스 택 을 제공 한 다 는 것 을 알 고 있 습 니 다. 우 리 는 stack 의 원 리 를 통 해 교묘 하 게 실현 할 수 있 습 니 다. 여기 서 우 리 는 A 창 에서 B 창 을 열 때 Intent 에 로고 Intent. FLAG 를 직접 추가 할 수 있 습 니 다.ACTIVITY_CLEAR_TOP, 이렇게 B 를 열 면 이 프로 세 스 공간의 모든 Activity 가 삭 제 됩 니 다.
A 창 에서 아래 코드 를 사용 하여 B 창 을 호출 합 니 다.

   Intent intent = new Intent(); 
　 intent.setClass(Android123.this, CWJ.class);
　 intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);  //     FLAG  
　 startActivity(intent);

1
2
3
4
다음 B 창 에서 종료 할 때 finish 방법 을 사용 하면 모두 종료 할 수 있 습 니 다.
4. Activity 스 택 (일반적인 방법) 을 사용자 정의 합 니 다.하나의 단일 모드 의 Activity 스 택 을 이용 하여 모든 Activity 를 저장 하고 관리 합 니 다.모든 Activity 를 종료 하 는 방법 을 제공 합 니 다.
3. Activity 스 택 방법 (일반적인 방법) 을 사용자 정의 합 니 다. 코드 는 다음 과 같 습 니 다.

package com.example.guan.activitywork;

import android.app.Activity;

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

/**
 *                 activity，       
 * @author guan
 * @date 2015-8-5
 */
public class ActivityManager {

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

    private ActivityManager() {
    }

    //           MyApplication  
    public static ActivityManager getInstance() {
        if (null == instance) {
            instance = new ActivityManager();
        }
        return instance;
    }

    //   Activity    
    public void addActivity(Activity activity) {
        activityList.add(activity);
    }

    //     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);
    }
}

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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
보다 전면적 인 스 택 관리 류

/**
 * activity    
 * 
 * @author blue
 */
public class ActivityStack
{
    private static ActivityStack mSingleInstance;
    private Stack mActicityStack;

    private ActivityStack()
    {
        mActicityStack = new Stack();
    }

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

    public Stack 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 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 buf = new ArrayList();
        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;
    }
}

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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
4. 사용 방법
1. onCreate () 방법 에 추가:

ActivityManager.getInstance().addActivity(this);

1
2. onDestroy () 방법 에:

ActivityManager.getInstance().deleteActivity(this);

1
2
3. 종료 시 호출:

ActivityManager.getInstance().exit();