前言
优雅的意思就是让别人看不懂，显的很酷炫，项目退出时都会用到，所以一定要收藏起来
使用
（1） RxBus优雅式
首先在基类BaseActivity里，注册RxBus监听
public class BaseActivity3 extends AppCompatActivity {
Subscription mSubscription;
@Override
public void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
initRxBus();
}
//接收退出的指令，关闭所有activity
private void initRxBus() {
mSubscription = RxBus.getInstance().toObserverable(NormalEvent.class)
.subscribe(new Action1<NormalEvent>() {
@Override
public void call(NormalEvent userEvent) {
if (userEvent.getType() == -1) {
finish();
}
}
},
new Action1<Throwable>() {
@Override
public void call(Throwable throwable) {
}
});
}
@Override
protected void onDestroy() {
super.onDestroy();
if (!mSubscription.isUnsubscribed()) {
mSubscription.unsubscribe();
}
}
}
- 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
这是事件实体NormalEvent
public class NormalEvent {
private int type;
public NormalEvent(int type) {
this.type = type;
}
public int getType() {
return type;
}
public void setType(int type) {
this.type = type;
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
新建RxBus类
public class RxBus {
private static volatile RxBus mInstance;
private final Subject bus;
public RxBus()
{
bus = new SerializedSubject<>(PublishSubject.create());
}
/**
* 单例模式RxBus
*
* @return
*/
public static RxBus getInstance()
{
RxBus rxBus2 = mInstance;
if (mInstance == )
{
synchronized (RxBus.class)
{
rxBus2 = mInstance;
if (mInstance == )
{
rxBus2 = new RxBus();
mInstance = rxBus2;
}
}
}
return rxBus2;
}
/**
* 发送消息
*
* @param object
*/
public void post(Object object)
{
bus.onNext(object);
}
/**
* 接收消息
*
* @param eventType
* @param <T>
* @return
*/
public <T> Observable<T> toObserverable(Class<T> eventType)
{
return bus.ofType(eventType);
}
}
- 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
最后，在需要退出的地方调用：
RxBus.getInstance().post(new NormalEvent(-1));//发送退出指令
- 1
（2）容器式
建立一个全局容器，把所有的Activity存储起来，退出时循环遍历finish所有Activity
public class BaseActivity extends AppCompatActivity {
@Override
public void onCreate(@Nullable Bundle savedInstanceState ) {
super.onCreate(savedInstanceState);
ActivityManager.getActivityManager().addActivity(this);
}
@Override protected void onDestroy() {
super.onDestroy();
// 结束Activity&从栈中移除该Activity
ActivityManager.getActivityManager().finishActivity();
}
}
public class ActivityManager {
// Activity栈
private static Stack<Activity> activityStack;
// 单例模式
private static ActivityManager instance;
private ActivityManager() {
}
/**
* 单一实例
*/
public static ActivityManager getActivityManager() {
if (instance == ) {
instance = new ActivityManager();
}
return instance;
}
/**
* 添加Activity到堆栈
*/
public void addActivity(Activity activity) {
if (activityStack == ) {
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 != ) {
activityStack.remove(activity);
activity.finish();
activity = ;
}
}
/**
* 结束指定类名的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; i < activityStack.size(); i++) {
if ( != activityStack.get(i)) {
activityStack.get(i).finish();
}
}
activityStack.clear();
}
/**
* 退出应用程序
*/
public void AppExit(Context context) {
try {
finishAllActivity();
//根据进程ID，杀死该进程
android.os.Process.killProcess(android.os.Process.myPid());
//退出真个应用程序
System.exit(0);
} catch (Exception e) {
}
}
}
- 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
（3）广播式
通过在BaseActivity中注册一个广播，当退出时发送一个广播，finish退出
public class BaseActivity2 extends AppCompatActivity {
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) {
BaseActivity2.this.finish();
}
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
（4）SingleTask
设置MainActivity的加载模式为singleTask
android:launchMode="singleTask"
- 1
将退出出口放置在MainActivity
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);
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
（5）SingleTask改版式
第一步设置MainActivity的加载模式为singleTask
android:launchMode="singleTask"
- 1
第二步重写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
第三步 退出
Intent intent = new Intent(this,MainActivity.class); intent.putExtra(MainActivity.TAG_EXIT, true);
startActivity(intent);
- 1
- 2
（6）懒人式
这种方式更加简单，只需要如下两步操作
- 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);
}
- 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
（7）进程式
通过直接杀死当前应用的进程来结束应用，简单粗暴，而且有（wu）效！
android.os.Process.killProcess(android.os.Process.myPid());
System.exit(0);
ActivityManager manager = (ActivityManager) getSystemService(ACTIVITY_SERVICE);
manager.killBackgroundProcesses(getPackageName());
- 1
- 2
- 3
- 4
- 5
- 6
这三种都能达到同样的效果，但是在模拟器上都会弹出 Unfortunately , XXX has stopped 消息提示框，但确实能退出应用。部分真机直接失效，只能finish当前Activity（比如我手上这台小米note，国产的几款ROM fw层改动太多，使用这种方式需慎重）
总结
<link rel="stylesheet" href="https://csdnimg.cn/release/phoenix/template/css/markdown_views-ea0013b516.css">
</div>