You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
860 lines
34 KiB
860 lines
34 KiB
/*
|
|
* @Author: BATU1579
|
|
* @CreateDate: 2022-07-26 11:23:12
|
|
* @LastEditor: BATU1579
|
|
* @LastTime: 2022-09-11 10:23:04
|
|
* @FilePath: \\src\\types\\events.d.ts
|
|
* @Description: 事件模块
|
|
*/
|
|
declare module 'events' {
|
|
import { Point } from 'images'
|
|
global {
|
|
/**
|
|
* @description: `events` 本身是一个 `EventEmiiter` ，但内置了一些事件、包括按键事件、通知事件、Toast 事件等。
|
|
*
|
|
* **注意！：**
|
|
*
|
|
* - 事件的处理是单线程的，并且仍然在原线程执行，如果脚本主体或者其他事件处理中有耗时操作、轮询等，则事件将无法得到及时处理（会进入事件队列等待脚本主体或其他事件处理完成才执行）。
|
|
*
|
|
*/
|
|
const events: Events;
|
|
|
|
const keys: Keys;
|
|
|
|
class KeyEvent {
|
|
/**
|
|
* @description: 获取事件的动作。
|
|
* @return {number} 触发按键事件的动作，可能的值为：
|
|
*
|
|
* - `KeyEvent.ACTION_DOWN` - 按下事件。
|
|
* - `KeyEvent.ACTION_UP` - 弹起事件。
|
|
*
|
|
*/
|
|
getAction(): number;
|
|
|
|
/**
|
|
* @description: 获取按键的按键编号。
|
|
* @return {number} 触发按键事件的按键编号，可能的值为：
|
|
*
|
|
* - `KeyEvent.KEYCODE_HOME` - 主页键。
|
|
* - `KeyEvent.KEYCODE_BACK` - 返回键。
|
|
* - `KeyEvent.KEYCODE_MENU` - 菜单键。
|
|
* - `KeyEvent.KEYCODE_VOLUME_UP` - 音量上键。
|
|
* - `KeyEvent.KEYCODE_VOLUME_DOWN` - 音量下键。
|
|
*
|
|
*/
|
|
getKeyCode(): number;
|
|
|
|
/**
|
|
* @description: 获取事件发生的时间戳。
|
|
* @return {number} 事件发生的时间戳，可以用于构造 `Date` 对象。
|
|
*/
|
|
getEventTime(): number;
|
|
|
|
/**
|
|
* @description: 获取最近一次按下事件的时间戳。如果本身是按下事件，则与 `getEventTime()` 相同。
|
|
* @return {number} 最近一次按下事件的时间戳，可以用于构造 `Date` 对象。
|
|
*/
|
|
getDownTime(): number;
|
|
|
|
/**
|
|
* @description: 把按键编号转换为字符串。
|
|
* @return {string} 按键名称。
|
|
*/
|
|
keyCodeToString(keyCode: number): string;
|
|
|
|
/**
|
|
* @description: 按下事件。
|
|
*/
|
|
static readonly ACTION_DOWN: number;
|
|
|
|
/**
|
|
* @description: 弹起事件。
|
|
*/
|
|
static readonly ACTION_UP: number;
|
|
|
|
/**
|
|
* @description: 主页键。
|
|
*/
|
|
static readonly KEYCODE_HOME: number;
|
|
|
|
/**
|
|
* @description: 返回键。
|
|
*/
|
|
static readonly KEYCODE_BACK: number;
|
|
|
|
/**
|
|
* @description: 菜单键。
|
|
*/
|
|
static readonly KEYCODE_MENU: number;
|
|
|
|
/**
|
|
* @description: 音量上键。
|
|
*/
|
|
static readonly KEYCODE_VOLUME_UP: number;
|
|
|
|
/**
|
|
* @description: 音量下键。
|
|
*/
|
|
static readonly KEYCODE_VOLUME_DOWN: number;
|
|
}
|
|
|
|
/**
|
|
* @description: 脚本间通信除了使用 engines 模块提供的 `ScriptEngine.emit()` 方法以外，也可以使用 events 模块提供的 `broadcast` 广播。
|
|
*
|
|
* `events.broadcast` 本身是一个 `EventEmitter` ，但它的事件是在脚本间共享的，所有脚本都能发送和监听这些事件；事件处理会在脚本主线程执行（后续可能加入函数 `onThisThread(eventName, ...args)` 来提供在其他线程执行的能力）。
|
|
* @example
|
|
* ```typescript
|
|
* // 脚本 A
|
|
* events.broadcast.emit("hello", "小明");
|
|
*
|
|
* // 脚本 B
|
|
* events.broadcast.on("hello", function(name) {
|
|
* toast("你好, " + name);
|
|
* });
|
|
* // 保持脚本运行
|
|
* setInterval(()=>{}, 1000);
|
|
* ```
|
|
*/
|
|
const broadcast: EventEmitter;
|
|
}
|
|
|
|
class Events extends EventEmitter {
|
|
/**
|
|
* @description: 创建一个新的 `EventEmitter` 。这个 `EventEmitter` 没有内置任何事件。
|
|
* @return {EventEmitter} 新创建的 `EventEmitter` 对象。
|
|
*/
|
|
emitter(): EventEmitter;
|
|
|
|
/**
|
|
* @description: 启用按键监听，例如音量键、Home 键。按键监听使用无障碍服务实现，如果无障碍服务未启用会抛出异常并提示开启。只有这个函数成功执行后, onKeyDown, onKeyUp等按键事件的监听才有效。
|
|
*
|
|
* **注意！：**
|
|
*
|
|
* - 此函数在安卓 4.3 以上才能使用。
|
|
*
|
|
*/
|
|
observeKey(): void;
|
|
|
|
/**
|
|
* @description: 注册一个按键监听函数，当有 `keyName` 对应的按键按下会调用该函数。一次完整的按键动作包括了按键按下和弹起。按下事件会在手指按下一个按键的瞬间触发, 弹起事件则在手指放开这个按键时触发。
|
|
* @param {string} keyName 要监听的按键名称，可选的值为：
|
|
*
|
|
* - `volume_up` - 音量上键。
|
|
* - `volume_down` - 音量下键。
|
|
* - `home` - 主屏幕键。
|
|
* - `back` - 返回键。
|
|
* - `menu` - 菜单键。
|
|
*
|
|
* @param {Function} listener 按键监听器。参数为 KeyEvent （按键事件），返回值为 any 。
|
|
* @return {this} 返回自身以便链式调用。
|
|
* @example
|
|
* ```typescript
|
|
* // 启用按键监听
|
|
* events.observeKey();
|
|
* // 监听音量下键按下
|
|
* events.onKeyDown('volume_down', function(event) {
|
|
* toast('音量上键按下');
|
|
* });
|
|
* // 监听Home键按下
|
|
* events.onKeyDown('home', function(event) {
|
|
* toast('Home键按下');
|
|
* exit();
|
|
* });
|
|
* ```
|
|
*/
|
|
onKeyDown(keyName: KeyName, listener: (event: KeyEvent) => any): this;
|
|
|
|
/**
|
|
* @description: 注册一个按键监听函数，当有 `keyName` 对应的按键弹起会调用该函数。一次完整的按键动作包括了按键按下和弹起。按下事件会在手指按下一个按键的瞬间触发, 弹起事件则在手指放开这个按键时触发。
|
|
* @param {string} keyName 要监听的按键名称，可选的值为：
|
|
*
|
|
* - `volume_up` - 音量上键。
|
|
* - `volume_down` - 音量下键。
|
|
* - `home` - 主屏幕键。
|
|
* - `back` - 返回键。
|
|
* - `menu` - 菜单键。
|
|
*
|
|
* @param {Function} listener 按键监听器。参数为 KeyEvent （按键事件），返回值为 any 。
|
|
* @return {this} 返回自身以便链式调用。
|
|
* @example
|
|
* ```typescript
|
|
* // 启用按键监听
|
|
* events.observeKey();
|
|
* // 监听音量下键弹起
|
|
* events.onKeyDown('volume_down', function(event) {
|
|
* toast('音量上键弹起');
|
|
* });
|
|
* // 监听Home键弹起
|
|
* events.onKeyDown('home', function(event) {
|
|
* toast('Home键弹起');
|
|
* exit();
|
|
* });
|
|
* ```
|
|
*/
|
|
onKeyUp(keyName: KeyName, listener: (event: KeyEvent) => any): this;
|
|
|
|
/**
|
|
* @description: 注册一个按键监听函数，当有 `keyName` 对应的按键被按下时会调用该函数，之后会注销该按键监听器。也就是 `listener` 只有在 `onceKeyDown()` 调用后的第一次按键事件被调用一次。
|
|
* @param {string} keyName 要监听的按键名称，可选的值为：
|
|
*
|
|
* - `volume_up` - 音量上键。
|
|
* - `volume_down` - 音量下键。
|
|
* - `home` - 主屏幕键。
|
|
* - `back` - 返回键。
|
|
* - `menu` - 菜单键。
|
|
*
|
|
* @param {Function} listener 按键监听器。参数为 KeyEvent （按键事件），返回值为 any 。
|
|
* @return {this} 返回自身以便链式调用。
|
|
*/
|
|
onceKeyDown(keyName: KeyName, listener: (event: KeyEvent) => any): this;
|
|
|
|
/**
|
|
* @description: 注册一个按键监听函数，当有 `keyName` 对应的按键弹起时会调用该函数，之后会注销该按键监听器。也就是 `listener` 只有在 `onceKeyUp()` 调用后的第一次按键事件被调用一次。
|
|
* @param {string} keyName 要监听的按键名称，可选的值为：
|
|
*
|
|
* - `volume_up` - 音量上键。
|
|
* - `volume_down` - 音量下键。
|
|
* - `home` - 主屏幕键。
|
|
* - `back` - 返回键。
|
|
* - `menu` - 菜单键。
|
|
*
|
|
* @param {Function} listener 按键监听器。参数为 KeyEvent （按键事件），返回值为 any 。
|
|
* @return {this} 返回自身以便链式调用。
|
|
*/
|
|
onceKeyUp(keyName: KeyName, listener: (event: KeyEvent) => any): this;
|
|
|
|
/**
|
|
* @description: 删除该按键的 `KeyDown` 按下事件的所有监听。
|
|
* @param {string} keyName 要取消监听的按键名称，可选的值为：
|
|
*
|
|
* - `volume_up` - 音量上键。
|
|
* - `volume_down` - 音量下键。
|
|
* - `home` - 主屏幕键。
|
|
* - `back` - 返回键。
|
|
* - `menu` - 菜单键。
|
|
*
|
|
* @return {this} 返回自身以便链式调用。
|
|
*/
|
|
removeAllKeyDownListeners(keyName: KeyName): this;
|
|
|
|
/**
|
|
* @description: 删除该按键的 `KeyDown` 弹起事件的所有监听。
|
|
* @param {string} keyName 要取消监听的按键名称，可选的值为：
|
|
*
|
|
* - `volume_up` - 音量上键。
|
|
* - `volume_down` - 音量下键。
|
|
* - `home` - 主屏幕键。
|
|
* - `back` - 返回键。
|
|
* - `menu` - 菜单键。
|
|
*
|
|
* @return {this} 返回自身以便链式调用。
|
|
*/
|
|
removeAllKeyUpListeners(keyName: KeyName): this;
|
|
|
|
/**
|
|
* @description: 设置 **全部** 按键屏蔽状态。所谓按键屏蔽指的是，屏蔽原有按键的功能，例如使得音量键不再能调节音量，但此时仍然能通过按键事件监听按键。
|
|
*
|
|
* **注意！：**
|
|
*
|
|
* - 只要有一个脚本屏蔽了某个按键，该按键便会被屏蔽；当脚本退出时，会自动解除所有按键屏蔽。
|
|
*
|
|
* @param {boolean} enabled 是否屏蔽所有按键。
|
|
* @return {this} 返回自身以便链式调用。
|
|
* @example
|
|
* ```typescript
|
|
* events.setKeyInterceptionEnabled("volume_up", true);
|
|
* events.observeKey();
|
|
* events.onKeyDown("volume_up", ()=>{
|
|
* log("音量上键被按下");
|
|
* });
|
|
* ```
|
|
*/
|
|
setKeyInterceptionEnabled(enabled: boolean): this;
|
|
|
|
/**
|
|
* @description: 设置 **单个** 按键屏蔽状态。所谓按键屏蔽指的是，屏蔽原有按键的功能，例如使得音量键不再能调节音量，但此时仍然能通过按键事件监听按键。
|
|
*
|
|
* **注意！：**
|
|
*
|
|
* - 只要有一个脚本屏蔽了某个按键，该按键便会被屏蔽；当脚本退出时，会自动解除所有按键屏蔽。
|
|
*
|
|
* @param {KeyName} key 要屏蔽的按键，可选的值为：
|
|
*
|
|
* - `volume_up` - 音量上键。
|
|
* - `volume_down` - 音量下键。
|
|
* - `home` - 主屏幕键。
|
|
* - `back` - 返回键。
|
|
* - `menu` - 菜单键。
|
|
*
|
|
* @param {boolean} enabled 是否屏蔽按键 `key` 。
|
|
* @return {this} 返回自身以便链式调用。
|
|
* @example
|
|
* ```typescript
|
|
* events.setKeyInterceptionEnabled("volume_up", true);
|
|
* events.observeKey();
|
|
* events.onKeyDown("volume_up", ()=>{
|
|
* log("音量上键被按下");
|
|
* });
|
|
* ```
|
|
*/
|
|
setKeyInterceptionEnabled(key: KeyName, enabled: boolean): this;
|
|
|
|
/**
|
|
* @description: 启用屏幕触摸监听。只有这个函数被成功执行后, 触摸事件的监听才有效。
|
|
*
|
|
* **注意！：**
|
|
*
|
|
* - 此函数需要 root 权限。没有 root 权限调用该函数则什么也不会发生。
|
|
*
|
|
*/
|
|
observeKey(): void;
|
|
|
|
/**
|
|
* @description: 设置两个触摸事件分发的最小时间间隔。例如间隔为 10 毫秒的话，前一个触摸事件发生并被注册的监听器处理后，至少要过 10 毫秒才能分发和处理下一个触摸事件，这 10 毫秒之间的触摸将会被忽略。
|
|
*
|
|
* *建议（：*
|
|
*
|
|
* - 在满足需要的情况下尽量提高这个间隔。
|
|
*
|
|
*
|
|
* **注意！：**
|
|
*
|
|
* - 如果 timeout 设置过低可能造成事件拥堵。强烈建议不要设置 `timeout` 为 0 。
|
|
*
|
|
* @param {number} timeout 两个触摸事件的最小间隔。单位毫秒。默认为 10 毫秒。如果小于 0 ，视为 0 处理。
|
|
*/
|
|
setTouchEventTimeout(timeout: number): void;
|
|
|
|
/**
|
|
* @description: 查询触摸事件的最小时间间隔。
|
|
* @return {number} 触摸事件的最小时间间隔。
|
|
*/
|
|
getTouchEventTimeout(): number;
|
|
|
|
/**
|
|
* @description: 注册一个触摸监听函数。相当于 `on('touch', listener)` 。
|
|
* @param {function} listener 触摸事件监听器。参数为 Point （屏幕坐标），返回值为 any 。
|
|
* @return {this} 返回自身以便链式调用。
|
|
* @example
|
|
* ```typescript
|
|
* // 启用触摸监听
|
|
* events.observeTouch();
|
|
* // 注册触摸监听器
|
|
* events.onTouch(function(p) {
|
|
* // 触摸事件发生时, 打印出触摸的点的坐标
|
|
* log(p.x + ", " + p.y);
|
|
* });
|
|
* ```
|
|
*/
|
|
onTouch(listener: (p: Point) => any): this;
|
|
|
|
/**
|
|
* @description: 删除所有触摸事件监听函数。
|
|
*/
|
|
removeAllTouchListeners(): this;
|
|
|
|
/**
|
|
* @description: 当有按键被按下或弹起时触发的事件。
|
|
* @param {string} eventName 事件名称（ `key` ）。
|
|
* @param {KeyListener} listener 当事件发生时要执行的回调函数。
|
|
* @return {this} 返回自身以便链式调用。
|
|
* @example
|
|
* ```typescript
|
|
* auto();
|
|
* events.observeKey();
|
|
* events.on("key", function(keyCode, event){
|
|
* if(keyCode == keys.menu && event.getAction() == event.ACTION_UP){
|
|
* toast("菜单键按下");
|
|
* }
|
|
* });
|
|
* ```
|
|
*/
|
|
on(eventName: 'key', listener: KeyListener): this;
|
|
|
|
/**
|
|
* @description: 当有按键被按下时触发的事件。
|
|
* @param {string} eventName 事件名称（ `key_down` ）。
|
|
* @param {KeyListener} listener 当事件发生时要执行的回调函数。
|
|
* @return {this} 返回自身以便链式调用。
|
|
* @example
|
|
* ```typescript
|
|
* auto();
|
|
* events.observeKey();
|
|
* events.on("key_down", function(keyCode, event){
|
|
* // 处理按键按下事件
|
|
* });
|
|
* ```
|
|
*/
|
|
on(eventName: 'key_down', listener: KeyListener): this;
|
|
|
|
/**
|
|
* @description: 当有按键弹起时触发的事件。
|
|
* @param {string} eventName 事件名称（ `key_up` ）。
|
|
* @param {KeyListener} listener 当事件发生时要执行的回调函数。
|
|
* @return {this} 返回自身以便链式调用。
|
|
* @example
|
|
* ```typescript
|
|
* auto();
|
|
* events.observeKey();
|
|
* events.on("key_up", function(keyCode, event){
|
|
* // 处理按键按下事件
|
|
* });
|
|
* ```
|
|
*/
|
|
on(eventName: 'key_up', listener: KeyListener): this;
|
|
|
|
/**
|
|
* @description: 当脚本正常或者异常退出时会触发该事件。事件处理中如果有异常抛出，则立即中止 exit 事件的处理（即使 exit 事件有多个处理函数）并在控制台和日志中打印该异常。
|
|
*
|
|
* 一个脚本停止运行时，会关闭该脚本的所有悬浮窗，触发 exit 事件，之后再回收资源。如果 exit 事件的处理中有死循环，则后续资源无法得到及时回收。 此时脚本会停留在任务列表，如果在任务列表中关闭，则会强制结束exit事件的处理并回收后续资源。
|
|
* @param {string} eventName 事件名称（ `exit` ）。
|
|
* @param {Function} listener 当事件发生时要执行的回调函数。
|
|
* @return {this} 返回自身以便链式调用。
|
|
* @example
|
|
* ```typescript
|
|
* log("开始运行")
|
|
* events.on("exit", function(){
|
|
* log("结束运行");
|
|
* });
|
|
* log("即将结束运行");
|
|
* ```
|
|
*/
|
|
on(eventName: 'exit', listener: Function): this;
|
|
|
|
/**
|
|
* @description: 开启通知监听。例如QQ消息、微信消息、推送等通知。通知监听依赖于通知服务，如果通知服务没有运行，会抛出异常并跳转到通知权限开启界面。
|
|
*
|
|
* **注意！：**
|
|
*
|
|
* - 有时即使通知权限已经开启通知服务也没有运行，这时需要关闭权限再重新开启一次。
|
|
*
|
|
* @example
|
|
* ```typescript
|
|
* events.obverseNotification();
|
|
* events.onNotification(function(notification){
|
|
* log(notification.getText());
|
|
* });
|
|
* ```
|
|
*/
|
|
observeNotification(): void;
|
|
|
|
/**
|
|
* @description: 开启 Toast 监听。 Toast 监听依赖于无障碍服务，因此此函数会确保无障碍服务运行。
|
|
*/
|
|
observeToast(): void;
|
|
|
|
/**
|
|
* @description: 当有应用发出 toast （气泡消息）时会触发该事件。但 助手 软件本身的 toast 除外。
|
|
* @param {string} eventName 事件名称（ `toast` ）。
|
|
* @param {ToastListener} listener 当事件发生时要执行的回调函数。
|
|
* @return {this} 返回自身以便链式调用。
|
|
* @example
|
|
* ```typescript
|
|
* events.observeToast();
|
|
* events.onToast(function(toast) {
|
|
* log("Toast内容: " + toast.getText() + " 包名: " + toast.getPackageName());
|
|
* });
|
|
* ```
|
|
*/
|
|
on(eventName: 'toast', listener: ToastListener): this;
|
|
|
|
/**
|
|
* @description: 当有应用发出通知时会触发该事件。
|
|
* @param {string} eventName 事件名称（ `notification` ）。
|
|
* @param {ToastListener} listener 当事件发生时要执行的回调函数。
|
|
* @return {this} 返回自身以便链式调用。
|
|
* @example
|
|
* ```typescript
|
|
* events.observeNotification();
|
|
* events.on("notification", function(n) {
|
|
* log(
|
|
* "收到新通知:\n 标题: %s, 内容: %s, \n包名: %s",
|
|
* n.getTitle(),
|
|
* n.getText(),
|
|
* n.getPackageName()
|
|
* );
|
|
* });
|
|
* ```
|
|
*/
|
|
on(eventName: 'notification', listener: NotificationListener): this;
|
|
}
|
|
|
|
class Notification {
|
|
/**
|
|
* @description: 通知数量。例如 QQ 连续收到两条消息时 number 为 2。
|
|
*/
|
|
readonly number: number;
|
|
|
|
/**
|
|
* @description: 通知发出时间的时间戳，可以用于构造 `Date` 对象。
|
|
* @example
|
|
* ```typescript
|
|
* events.observeNotification();
|
|
* events.on("notification", function(n) {
|
|
* log("通知时间为}" + new Date(n.when));
|
|
* });
|
|
* ```
|
|
*/
|
|
readonly when: number;
|
|
|
|
/**
|
|
* @description: 获取发出通知的应用包名。
|
|
* @return {string} 发出通知的应用包名。
|
|
*/
|
|
getPackageName(): string;
|
|
|
|
/**
|
|
* @description: 获取通知的标题。
|
|
* @return {string} 通知的标题。
|
|
*/
|
|
getTitle(): string;
|
|
|
|
/**
|
|
* @description: 获取通知的内容。
|
|
* @return {string} 通知的内容。
|
|
*/
|
|
getText(): string;
|
|
|
|
/**
|
|
* @description: 点击该通知。例如对于一条 QQ 消息，点击会进入具体的聊天界面。
|
|
*/
|
|
click(): void;
|
|
|
|
/**
|
|
* @description: 删除该通知。该通知将从通知栏中消失。
|
|
*/
|
|
delete(): void;
|
|
}
|
|
|
|
interface Keys {
|
|
/**
|
|
* @description: 主页键。
|
|
*/
|
|
readonly home: number;
|
|
|
|
/**
|
|
* @description: 返回键。
|
|
*/
|
|
readonly back: number;
|
|
|
|
/**
|
|
* @description: 菜单键。
|
|
*/
|
|
readonly menu: number;
|
|
|
|
/**
|
|
* @description: 音量上键。
|
|
*/
|
|
readonly volume_up: number;
|
|
|
|
/**
|
|
* @description: 音量下键。
|
|
*/
|
|
readonly volume_down: number;
|
|
}
|
|
|
|
class EventEmitter {
|
|
/**
|
|
* @description: 每个事件默认可以注册最多 10 个监听器。 单个 `EventEmitter` 实例的限制可以使用 `emitter.setMaxListeners(n)` 方法改变。 所有 `EventEmitter` 实例的默认值可以使用 `EventEmitter.defaultMaxListeners` 属性改变。
|
|
*
|
|
* 设置 `EventEmitter.defaultMaxListeners` 要谨慎，因为会影响所有 `EventEmitter` 实例，包括之前创建的。 因而，调用 `emitter.setMaxListeners(n)` 优先于 `EventEmitter.defaultMaxListeners` 。
|
|
*
|
|
* **注意！：**
|
|
*
|
|
* - 与 Node.js 不同，这是一个硬性限制。 `EventEmitter` 实例不允许添加更多的监听器，监听器超过最大数量时会抛出 `TooManyListenersException` 。
|
|
*
|
|
* @example
|
|
* ```typescript
|
|
* emitter.setMaxListeners(emitter.getMaxListeners() + 1);
|
|
* emitter.once('event', () => {
|
|
* // 做些操作
|
|
* emitter.setMaxListeners(Math.max(emitter.getMaxListeners() - 1, 0));
|
|
* });
|
|
* ```
|
|
*/
|
|
static defaultMaxListeners: number;
|
|
|
|
/**
|
|
* @description: 添加 `listener` 函数到名为 `eventName` 的事件的监听器数组的末尾。
|
|
*
|
|
* 此函数是 `emitter.on(eventName, listener)` 的别名。
|
|
*
|
|
* **注意！：**
|
|
*
|
|
* - 多次调用并传入相同的 `eventName` 和 `listener` 会导致 `listener` 被添加与调用多次。
|
|
*
|
|
* @param {string} eventName 事件名称。
|
|
* @param {Function} listener 当事件发生时要执行的回调函数。
|
|
* @return {this} 返回自身以便链式调用。
|
|
*/
|
|
addListener(eventName: string, listener: Function): this;
|
|
|
|
/**
|
|
* @description: 按监听器的注册顺序，同步地调用每个注册到名为 eventName 事件的监听器，并传入提供的参数。
|
|
* @param {string} eventName 事件名称。
|
|
* @param {array} [args] 要传入的参数。
|
|
* @return {boolean} 如果事件有监听器，则返回 true ，否则返回 false。
|
|
*/
|
|
emit(eventName: string, ...args: any[]): boolean;
|
|
|
|
/**
|
|
* @description: 查询全部已注册监听器的事件。
|
|
* @return {(string | Symbol)[]} 返回一个列出触发器已注册监听器的事件的数组。数组中的值为字符串或符号。
|
|
* @example
|
|
* ```typescript
|
|
* const myEE = events.emitter();
|
|
* myEE.on('foo', () => {});
|
|
* myEE.on('bar', () => {});
|
|
*
|
|
* const sym = Symbol('symbol');
|
|
* myEE.on(sym, () => {});
|
|
*
|
|
* console.log(myEE.eventNames());
|
|
* // 打印: [ 'foo', 'bar', Symbol(symbol) ]
|
|
* ```
|
|
*/
|
|
eventNames(): (string | Symbol)[];
|
|
|
|
/**
|
|
* @description: 获取 `EventEmitter` 当前的最大监听器限制值，该值可以通过 `emitter.setMaxListeners(n)` 设置或默认为 `EventEmitter.defaultMaxListeners` 。
|
|
* @return {number} 当前的最大监听器限制值。
|
|
*/
|
|
getMaxListeners(): number;
|
|
|
|
/**
|
|
* @description: 获取注册在 `eventName` 事件的监听器的数量。
|
|
* @param {string} eventName 要查询的事件名。
|
|
* @return {number} 当前正在监听 `eventName` 事件的监听器的数量。
|
|
*/
|
|
listenerCount(eventName: string): number;
|
|
|
|
/**
|
|
* @description: 获取注册在名为 `eventName` 的事件的全部监听器数组的副本。
|
|
* @param {string} eventName 要查询的事件名。
|
|
* @return {Function[]} 名为 `eventName` 的事件的全部监听器数组的副本。
|
|
* @example
|
|
* ```typescript
|
|
* server.on('connection', (stream) => {
|
|
* console.log('someone connected!');
|
|
* });
|
|
* console.log(util.inspect(server.listeners('connection')));
|
|
* // 打印: [ [Function] ]
|
|
* ```
|
|
*/
|
|
listeners(eventName: string): Function[];
|
|
|
|
/**
|
|
* @description: 添加 `listener` 函数到名为 `eventName` 的事件的监听器数组的末尾。
|
|
*
|
|
* 默认情况下，事件监听器会按照添加的顺序依次调用。 `emitter.prependListener()` 方法可用于将事件监听器添加到监听器数组的开头。
|
|
*
|
|
* **注意！：**
|
|
*
|
|
* - 多次调用并传入相同的 `eventName` 和 `listener` 会导致 `listener` 被添加与调用多次。
|
|
*
|
|
* @param {string} eventName 事件名称。
|
|
* @param {Function} listener 当事件发生时要执行的回调函数。
|
|
* @return {this} 返回自身以便链式调用。
|
|
* @example
|
|
* ```typescript
|
|
* server.on('connection', (stream) => {
|
|
* console.log('有连接！');
|
|
* });
|
|
* ```
|
|
* @example
|
|
* ```typescript
|
|
* const myEE = events.emitter();
|
|
* myEE.on('foo', () => console.log('a'));
|
|
* myEE.prependListener('foo', () => console.log('b'));
|
|
* myEE.emit('foo');
|
|
* // 打印:
|
|
* // b
|
|
* // a
|
|
* ```
|
|
*/
|
|
on(eventName: string, listener: Function): this;
|
|
|
|
/**
|
|
* @description: 添加一个单次 `listener` 函数到名为 `eventName` 的事件的监听器数组的末尾。下次触发 eventName 事件时，监听器会被移除，然后调用。
|
|
*
|
|
* 默认情况下，事件监听器会按照添加的顺序依次调用。 `emitter.prependOnceListener() ` 方法可用于将事件监听器添加到监听器数组的开头。
|
|
*
|
|
* **注意！：**
|
|
*
|
|
* - 多次调用并传入相同的 `eventName` 和 `listener` 会导致 `listener` 被添加与调用多次。
|
|
*
|
|
* @param {string} eventName 事件名称。
|
|
* @param {Function} listener 当事件发生时要执行的回调函数。
|
|
* @return {this} 返回自身以便链式调用。
|
|
* @example
|
|
* ```typescript
|
|
* server.once('connection', (stream) => {
|
|
* console.log('首次调用！');
|
|
* });
|
|
* ```
|
|
* @example
|
|
* ```typescript
|
|
* const myEE = events.emitter();
|
|
* myEE.once('foo', () => console.log('a'));
|
|
* myEE.prependOnceListener('foo', () => console.log('b'));
|
|
* myEE.emit('foo');
|
|
* // 打印:
|
|
* // b
|
|
* // a
|
|
* ```
|
|
*/
|
|
once(eventName: string, listener: Function): this;
|
|
|
|
/**
|
|
* @description: 添加 `listener` 函数到名为 `eventName` 的事件的监听器数组的开头。
|
|
*
|
|
* **注意！：**
|
|
*
|
|
* - 多次调用并传入相同的 `eventName` 和 `listener` 会导致 `listener` 被添加与调用多次。
|
|
*
|
|
* @param {string} eventName 事件名称。
|
|
* @param {Function} listener 当事件发生时要执行的回调函数。
|
|
* @return {this} 返回自身以便链式调用。
|
|
* @example
|
|
* ```typescript
|
|
* server.prependListener('connection', (stream) => {
|
|
* console.log('有连接！');
|
|
* });
|
|
* ```
|
|
*/
|
|
prependListener(eventName: string, listener: Function): this;
|
|
|
|
/**
|
|
* @description: 添加一个单次 `listener` 函数到名为 `eventName` 的事件的监听器数组的开头。下次触发 `eventName` 事件时，监听器会被移除，然后调用。
|
|
*
|
|
* **注意！：**
|
|
*
|
|
* - 多次调用并传入相同的 `eventName` 和 `listener` 会导致 `listener` 被添加与调用多次。
|
|
*
|
|
* @param {string} eventName 事件名称。
|
|
* @param {Function} listener 当事件发生时要执行的回调函数。
|
|
* @return {this} 返回自身以便链式调用。
|
|
* @example
|
|
* ```typescript
|
|
* server.prependListener('connection', (stream) => {
|
|
* console.log('有连接！');
|
|
* });
|
|
* ```
|
|
*/
|
|
prependOnceListener(eventName: string, listener: Function): this;
|
|
|
|
/**
|
|
* @description: 移除全部或指定 `eventName` 的监听器。
|
|
*
|
|
* **注意！：**
|
|
*
|
|
* - 注意，在代码中移除其他地方添加的监听器是一个不好的做法，尤其是当 EventEmitter 实例是其他组件或模块创建的。
|
|
*
|
|
* @param {string} [eventName] 事件名称。
|
|
* @return {this} 返回自身以便链式调用。
|
|
*/
|
|
removeAllListeners(eventName?: string): this;
|
|
|
|
/**
|
|
* @description: 从名为 `eventName` 的事件的监听器数组中移除指定的 `listener` 。
|
|
*
|
|
* `removeListener()` 最多只会从监听器数组里移除一个监听器实例。 如果任何单一的监听器被多次添加到指定 `eventName` 的监听器数组中，则必须多次调用 `removeListener()` 才能移除每个实例。
|
|
*
|
|
* 因为监听器是使用内部数组进行管理的，所以调用它会改变在监听器被移除后注册的任何监听器的位置索引。 虽然这不会影响监听器的调用顺序，但意味着由 `emitter.listeners()` 方法返回的监听器数组副本需要被重新创建。
|
|
*
|
|
* **注意！：**
|
|
*
|
|
* - 一旦一个事件被触发，所有绑定到它的监听器都会按顺序依次触发。 这意味着，在事件触发后、最后一个监听器完成执行前，任何 `removeListener()` 或 `removeAllListeners()` 调用都不会从 `emit()` 中移除它们。 随后的事件会像预期的那样发生。
|
|
*
|
|
* @param {string} eventName 事件名称。
|
|
* @param {Function} listener 要移除的监听器。
|
|
* @return {this} 返回自身以便链式调用。
|
|
* @example
|
|
* ```typescript
|
|
* const callback = (stream) => {
|
|
* console.log('有连接！');
|
|
* };
|
|
* server.on('connection', callback);
|
|
* // ...
|
|
* server.removeListener('connection', callback);
|
|
* ```
|
|
*/
|
|
removeListener(eventName: string, listener: Function): this;
|
|
|
|
/**
|
|
* @description: 默认情况下，如果为特定事件添加了超过 10 个监听器，则 `EventEmitter` 会打印一个警告。 此限制有助于寻找内存泄露。 但是，并不是所有的事件都要被限为 10 个。 `emitter.setMaxListeners()` 方法允许修改指定的 `EventEmitter` 实例的限制。 值设为 Infinity（或 0）表明不限制监听器的数量。
|
|
* @param {number} n 要设置的监听器数量上限。
|
|
* @return {this} 返回自身以便链式调用。
|
|
*/
|
|
setMaxListeners(n: number): this;
|
|
|
|
}
|
|
|
|
type KeyName = keyof typeof keys;
|
|
|
|
/**
|
|
* @callback KeyListener
|
|
* @description: 当有按键被按下或弹起时要执行的回调函数。
|
|
* @param {number} keyCode 触发事件的按键编号。
|
|
*
|
|
* *建议（：*
|
|
*
|
|
* - 使用 `keys` 比较 `keyCode` 的值。
|
|
*
|
|
* @param {KeyEvent} event 按键事件。
|
|
*/
|
|
type KeyListener = (
|
|
/**
|
|
* 触发事件的按键编号。
|
|
*
|
|
* *建议（：*
|
|
*
|
|
* - 使用 `keys` 比较 `keyCode` 的值。
|
|
*
|
|
*/
|
|
keyCode: number,
|
|
/**
|
|
* 按键事件。
|
|
*/
|
|
event: KeyEvent
|
|
) => any;
|
|
|
|
/**
|
|
* @callback ToastListener
|
|
* @description: 当有应用发出 toast （气泡消息）时要执行的回调函数。
|
|
* @param {ToastObject} toast 触发事件的 toast 对象。
|
|
*/
|
|
type ToastListener = (
|
|
/**
|
|
* 触发事件的 toast 对象。
|
|
*/
|
|
toast: ToastObject
|
|
) => any;
|
|
|
|
class ToastObject {
|
|
/**
|
|
* @description: 获取 toast 的文本内容。
|
|
* @return {string} toast 对象的文本。
|
|
*/
|
|
getText(): string;
|
|
|
|
/**
|
|
* @description: 获取发出 toast 的应用包名。
|
|
* @return {string} 发出 toast 的应用包名。
|
|
*/
|
|
getPackageName(): string;
|
|
}
|
|
|
|
/**
|
|
* @callback NotificationListener
|
|
* @description: 当有应用发出通知时要执行的回调函数。
|
|
* @param {Notification} notification 触发事件的通知对象。
|
|
*/
|
|
type NotificationListener = (
|
|
/**
|
|
* 触发事件的通知对象。
|
|
*/
|
|
notification: Notification
|
|
) => any;
|
|
}
|