EventHub

EventHub模块提供了事件中心，提供订阅、取消订阅、触发事件的能力，用于线程内通信。

在使用eventHub的功能前，需要通过Ability实例的成员变量context获取

import Ability from '@ohos.app.ability.UIAbility';
export default class MainAbility extends Ability {
    func1(){
        console.log('func1 is called');
    }
    onForeground() {
        this.context.eventHub.on('123', this.func1);
    }
}

EventHub.on

订阅指定事件

on(event: string, callback: Function): void;

import Ability from '@ohos.app.ability.UIAbility';

export default class MainAbility extends Ability {
    onForeground() {
        this.context.eventHub.on('123', this.func1);
        this.context.eventHub.on('123', () => {
            console.log('call anonymous func 1');
        });
        // 结果：
        // func1 is called
        // call anonymous func 1
        this.context.eventHub.emit('123'); 
    }
    func1() {
        console.log('func1 is called');
    }
}

EventHub.off

取消订阅指定事件，当callback传值时，取消订阅指定的callback；未传值时，取消订阅该事件下所有callback

off(event: string, callback?: Function): void;

import Ability from '@ohos.app.ability.UIAbility';

export default class MainAbility extends Ability {
    onForeground() {
        this.context.eventHub.on('123', this.func1);
        this.context.eventHub.off('123', this.func1); //取消订阅func1
        this.context.eventHub.on('123', this.func1);
        this.context.eventHub.on('123', this.func2);
        this.context.eventHub.off('123');  //取消订阅func1和func2
    }
    func1() {
        console.log('func1 is called');
    }
    func2() {
        console.log('func2 is called');
    }
}

EventHub.emit

触发指定事件

emit(event: string, ...args: Object[]): void;

import Ability from '@ohos.app.ability.UIAbility';

export default class MainAbility extends Ability {
    onForeground() {
        this.context.eventHub.on('123', this.func1);
        // 结果：
        // func1 is called,undefined,undefined
        this.context.eventHub.emit('123');
        // 结果：
        // func1 is called,1,undefined
        this.context.eventHub.emit('123', 1);
        // 结果：
        // func1 is called,1,2
        this.context.eventHub.emit('123', 1, 2);
    }
    func1(a, b) {
        console.log('func1 is called,' + a + ',' + b);
    }
}

Emitter

提供发送和处理进程内事件的能力，包括对持续订阅事件或单次订阅事件的处理，取消订阅事件，发送事件到事件队列，用于同一进程线程间通信。

emitter.on

持续订阅某个事件以及接收事件的回调处理。

let innerEvent = {
    eventId: 1
};
function EmitterCallback(eventData) {
    console.info('callback');
}
emitter.on(innerEvent, EmitterCallback);

emitter.once

单次订阅某个事件以及接收事件的回调处理，接收到回调处理后自动取消订阅。

let innerEvent = {
    eventId: 1
};
function EmitterCallback(eventData) {
    console.info('once callback');
};
emitter.once(innerEvent, EmitterCallback);

emitter.off

取消订阅某个事件
```
emitter.off(1);
```

emitter.emit

发送一个事件到事件队列

// data参数的值如果是嵌套类型，需要序列化成字符串传递，不支持嵌套类型
let eventData = {
    data: {
        "content": "c",
        "id": 1,
    }};
let innerEvent = {
    eventId: 1,
    // 无需指定，不生效
    priority: emitter.EventPriority.HIGH
};
emitter.emit(innerEvent, eventData);

commonEventManager

提供了公共事件的能力，包括公共事件的权限列表，发布公共事件，订阅或取消订阅公共事件，获取或修改公共事件结果代码、结果数据等，用于进程间通信。

CommonEventManager.publish

发布公共事件

`publish(event: string, callback: AsyncCallback<void>): void`

//发布公共事件回调
function publishCallBack(err) {
    if (err) {
        console.error("publish failed " + JSON.stringify(err));
    } else {
        console.info("publish");
    }
}

//发布公共事件
try {
    CommonEventManager.publish("event", publishCallBack);
} catch(err) {
    console.error('publish failed, catch error' + JSON.stringify(err));
}

发布公共事件指定发布信息

publish(event: string, options: CommonEventPublishData, callback: AsyncCallback<void>): void

```
//公共事件相关信息
var options = {
    code: 0,             //公共事件的初始代码
    data: "initial data",//公共事件的初始数据
    isOrdered: true     //有序公共事件
}

//发布公共事件回调
function publishCallBack(err) {
    if (err) {
        console.error("publish failed " + JSON.stringify(err));
    } else {
        console.info("publish");
    }
}

//发布公共事件
try {
    CommonEventManager.publish("event", options, publishCallBack);
} catch (err) {
    console.error('publish failed, catch error' + JSON.stringify(err));
}
```

CommonEventManager.createSubscriber

创建订阅者

createSubscriber(subscribeInfo: CommonEventSubscribeInfo, callback: AsyncCallback<CommonEventSubscriber>): void

var subscriber; //用于保存创建成功的订阅者对象，后续使用其完成订阅及退订的动作

//订阅者信息
var subscribeInfo = {
    events: ["event"]
};

//创建订阅者回调
function createSubscriberCallBack(err, commonEventSubscriber) {
    if(!err) {
        console.info("createSubscriber");
        subscriber = commonEventSubscriber;
    } else {
        console.error("createSubscriber failed " + JSON.stringify(err));
    }
}

//创建订阅者
try {
    CommonEventManager.createSubscriber(subscribeInfo, createSubscriberCallBack);
} catch (err) {
    console.error('createSubscriber failed, catch error' + JSON.stringify(err));
}

CommonEventManager.subscribe

订阅公共事件

subscribe(subscriber: CommonEventSubscriber, callback: AsyncCallback<CommonEventData>): void

//订阅者信息
var subscriber; //用于保存创建成功的订阅者对象，后续使用其完成订阅及退订的动作

//订阅者信息
var subscribeInfo = {
    events: ["event"]
};

//订阅公共事件回调
function SubscribeCallBack(err, data) {
    if (err) {
        console.error("subscribe failed " + JSON.stringify(err));
    } else {
        console.info("subscribe ");
    }
}

//创建订阅者回调
function createSubscriberCallBack(err, commonEventSubscriber) {
    if(!err) {
        console.info("createSubscriber");
        subscriber = commonEventSubscriber;
        //订阅公共事件
        try {
            CommonEventManager.subscribe(subscriber, SubscribeCallBack);
        } catch (err) {
            console.error("createSubscriber failed " + JSON.stringify(err));
        }
    } else {
        console.error("createSubscriber failed " + JSON.stringify(err));
    }
}

//创建订阅者
try {
    CommonEventManager.createSubscriber(subscribeInfo, createSubscriberCallBack);
} catch (err) {
    console.error('createSubscriber failed, catch error' + JSON.stringify(err));
}

CommonEventManager.unsubscribe

取消订阅公共事件

unsubscribe(subscriber: CommonEventSubscriber, callback?: AsyncCallback<void>): void

var subscriber; //用于保存创建成功的订阅者对象，后续使用其完成订阅及退订的动作
//订阅者信息
var subscribeInfo = {
    events: ["event"]
};
//订阅公共事件回调
function subscribeCallBack(err, data) {
    if (err) {
        console.info("subscribe failed " + JSON.stringify(err));
    } else {
        console.info("subscribe");
    }
}
//创建订阅者回调
function createSubscriberCallBack(err, commonEventSubscriber) {
    if (err) {
        console.info("createSubscriber failed " + JSON.stringify(err));
    } else {
        console.info("createSubscriber");
        subscriber = commonEventSubscriber;
        //订阅公共事件
        try {
            CommonEventManager.subscribe(subscriber, subscribeCallBack);
        } catch(err) {
            console.info("subscribe failed " + JSON.stringify(err));
        }
    }
}
//取消订阅公共事件回调
function unsubscribeCallBack(err) {
    if (err) {
        console.info("unsubscribe failed " + JSON.stringify(err));
    } else {
        console.info("unsubscribe");
    }
}
//创建订阅者
try {
    CommonEventManager.createSubscriber(subscribeInfo, createSubscriberCallBack);
} catch (err) {
    console.info("createSubscriber failed " + JSON.stringify(err));
}

//取消订阅公共事件
try {
    CommonEventManager.unsubscribe(subscriber, unsubscribeCallBack);
} catch (err) {
    console.info("unsubscribe failed " + JSON.stringify(err));
}

CommonEventSubscriber

获取公共事件的结果代码

getCode(callback: AsyncCallback<number>): void

var subscriber;    //创建成功的订阅者对象

 //获取有序公共事件的结果代码回调
 function getCodeCallback(err, Code) {
     if (err) {
         console.error("getCode failed " + JSON.stringify(err));
     } else {
         console.info("getCode " + JSON.stringify(Code));
     }
 }
 subscriber.getCode(getCodeCallback);

其他不常用函数请参数官网文档

鸿蒙公共事件