基于事件触发的开源框架EventTrigger

一、介绍
离散发生的事件，我们都可以把它抽象成触发器模型，事件因为某种原因发生了，可以抽象成触发器因为某种原因触发了，android世界中的事件也是如此，因为网络发生改变导致触发了网络触发器，因为时间到了，触发了计时触发器。这就是有了基于事件触发的开源框架EventTrigger。目前该开源框架还处于初始阶段，还存在很多不足，欢迎大家都来fork和pull
request，把这个框架变得更加完善。
地址：https://github.com/GreatEye/EventTrigger
EventTrigger基本架构如下：



二、使用

开始使用EventTrigger

EventTrigger使用分为4步

Step 1. 添加依赖

在build.gradle添加依赖

compile 'cn.appleye.eventtrigger:library:1.0.2'

在maven中添加依赖

<dependency>
<groupId>cn.appleye.eventtrigger</groupId>
<artifactId>library</artifactId>
<version>1.0.2</version>
<type>pom</type>
</dependency>

Step 2. 定义触发器

框架中已经自带了触发器，你也可以自定义触发器，实现Trigger接口或者继承AbstractTrigger(实现了Trigger接口)，以TimerTrigger说明

public class TimerTrigger extends AbstractTrigger{
private static final String TAG = "TimerTrigger";

/**时间间隔*/
private int mInterval;
/**是否结束*/
private boolean mIsFinished;

private static final int MSG_DELAY = 1000;

/**发送延迟消息Handler*/
private Handler mHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case MSG_DELAY:{
if(!mIsFinished){
                       dispatch(null);//派发结果
                       mHandler.sendEmptyMessageDelayed(MSG_DELAY, mInterval);
}
break;
}
}
}
};

/**
* 构造方法
    * @param observer 用于获取当前触发器结果的观察者
    * @param interval 时间间隔
* */
public TimerTrigger(Observer observer, int interval) {
super(observer);

mInterval = interval<0?100:interval;//小于0时，定义为100ms

mIsFinished = false;
}

@Override
public String getName() {
return "TimerTrigger";
}

@Override
   public void setup() {//初始化工作
       if(mIsFinished) {
throw new IllegalStateException("the timer has been stopped");
}

mHandler.sendEmptyMessage(MSG_DELAY);
}

@Override
   public void forceTrigger() {//强制调用
       //移除延迟消息
mHandler.removeMessages(MSG_DELAY);
//立刻执行
mHandler.sendEmptyMessage(MSG_DELAY);
}

@Override
   public void stopTrigger() {//结束计时触发器
       mIsFinished = true;
}
}

Step 3. 定义类的方法

@TriggerSubscribe(className = CustomTrigger.class, loopMode = LoopMode.ALWAYS,
strictMode = StrictMode.STRICT)
public void onTriggerChanged(Object result) {
//TODO:处理派发的结果
}

注解TriggerSubscribe参数说明
className - 表示目标触发器类，缺省Void.class
loopMode - 表示调用模式， LoopMode.ALWAYS：只要触发器触发就调用，LoopMode.ONCE：调用完一次之后就不再调用，缺省LoopMode.ALWAYS
strictMode - 表示严格模式， StrictMode.STRICT表示className对应的触发器必须要实现Trigger接口，StrictMode.ALLOW_ALL表示可以是任意触发器，不过所有调用都得自己来实现。缺省StrictMode.STRICT

Step 4. 初始化触发器和注册当前对象

EventTriggerBus实现了Observer接口，将其传入到触发器构造方法当中，触发器将结果派发之后传给EventTriggerBus处理

EventTriggerBus eventTriggerBus = EventTriggerBus.getInstance();//获取实例
eventTriggerBus.register(object);//注册当前对象

CustomTrigger customTrigger = new CustomTrigger(eventTriggerBus);
customTrigger.setOwner(owner);//为了避免不同对象所包含的触发器的影响，这里需要设置触发器所属的对象，全局触发器不需要设置
customTrigger.setup(); //初始化操作

不再使用的时候，需要注销当前对象和停止触发器

customTrigger.stopTrigger();
eventTriggerBus.unregister(object)

另外，经常会用到全局触发器，可以在Application初始化的时候，将实例化触发器即可，下面demo有使用详解，代码实现，请参考EventTrigger
三、使用Demo

1.单个类中定义触发器

以TimerTrigger为例

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.widget.TextView;

import java.util.concurrent.atomic.AtomicInteger;

import cn.appleye.eventtrigger.EventTriggerBus;
import cn.appleye.eventtrigger.annotations.TriggerSubscribe;
import cn.appleye.eventtrigger.triggers.Trigger;
import cn.appleye.eventtrigger.triggers.timer.TimerTrigger;

public class TimerTriggerActivity extends AppCompatActivity {

/**显示计时信息控件*/
private TextView mTimerInfoView;
/**计数器*/
private AtomicInteger mValue = new AtomicInteger(0);

private EventTriggerBus mEventTriggerBus;
/**计时器触发器*/
private Trigger mTimerTrigger;

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_timer_trigger);

mTimerInfoView = (TextView) findViewById(R.id.timer_info_view);

//获取EventTriggerBus并且注册当前类
mEventTriggerBus = EventTriggerBus.getInstance();
mEventTriggerBus.register(this);
//初始化触发器
mTimerTrigger = new TimerTrigger(mEventTriggerBus, 1000);//1s间隔
mTimerTrigger.setOwner(this);//设置触发器所有者为当前owner
mTimerTrigger.setup();
}

/**
* 添加注解，用于过滤和得到要订阅的方法
* */
@TriggerSubscribe(className = TimerTrigger.class)
public void onTimerInfoChanged(Object result) {
/*设置值*/
mTimerInfoView.setText(mValue.getAndIncrement() +"");
}

@Override
public void onDestroy() {
super.onDestroy();
//停止触发器，并且注销当前类
mTimerTrigger.stopTrigger();
mEventTriggerBus.unregister(this);
}
}

2.全局触发器用法

以NetworkTrigger为例

Step 1 : 首先在Application中定义全局触发器

public class DemoApplication extends Application{
private static final String TAG = "DemoApplication";

@Override
public void onCreate() {
super.onCreate();

setupGlobalTrigger();
}

/**
* 初始化全局触发器
* */
private void setupGlobalTrigger() {
EventTriggerBus eventTriggerBus = EventTriggerBus.getInstance();

/**添加网络状态变化的触发器*/
Trigger networkTrigger = new NetworkTrigger(eventTriggerBus, this);
networkTrigger.setup();
eventTriggerBus.addGlobalTrigger(networkTrigger);
}

@Override
public void onTerminate(){
super.onTerminate();
//移除所有触发器
EventTriggerBus.getInstance().removeAllGlobalTriggers();
}
}

Step 2 : 注册当前对象

public class NetworkTriggerActivity extends AppCompatActivity {
private TextView mNetworkView;
private EventTriggerBus mEventTriggerBus;

private static final int NETWORK_PERMISSION_REQUEST = 1000;

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_network_trigger_demo);

mNetworkView = (TextView) findViewById(R.id.network_info_view);

//注册当前类
mEventTriggerBus = EventTriggerBus.getInstance();
mEventTriggerBus.register(this);

forceNetworkTrigger();//立刻生效
}

@TriggerSubscribe(className = NetworkTrigger.class, loopMode = LoopMode.ALWAYS,
strictMode = StrictMode.STRICT)
public void onNetworkChanged(NetworkState networkState) {
mNetworkView.setText(networkState.toString());
}

/**
* 强制调用网络状态变化触发器
* */
private void forceNetworkTrigger(){
//强制执行当前触发器
mEventTriggerBus.forceCallGlobalTrigger(NetworkTrigger.class);
}

@Override
public void onDestroy() {
super.onDestroy();
mEventTriggerBus.unregister(this);
}
}

四、结束语
EventTrigger还有很多不足，比如自带的Trigger还很少，有待补充，一些使用情景可能考虑不全，后续需要持续优化，不断完善该框架。