## 基础

```json
[
  {
    "接口名称": "[wx.env](/minigame/dev/api/base/wx.env)",
    "描述": "环境变量"
  }
]
```

### 系统

```json
[
  {
    "接口名称": "[wx.openSystemBluetoothSetting](/minigame/dev/api/base/system/wx.openSystemBluetoothSetting)",
    "描述": "跳转系统蓝牙设置页"
  },
  {
    "接口名称": "[wx.openAppAuthorizeSetting](/minigame/dev/api/base/system/wx.openAppAuthorizeSetting)",
    "描述": "跳转系统微信授权管理页"
  },
  {
    "接口名称": "[wx.getWindowInfo](/minigame/dev/api/base/system/wx.getWindowInfo)",
    "描述": "获取窗口信息"
  },
  {
    "接口名称": "[wx.getSystemSetting](/minigame/dev/api/base/system/wx.getSystemSetting)",
    "描述": "获取设备设置"
  },
  {
    "接口名称": "[wx.getSystemInfoSync](/minigame/dev/api/base/system/wx.getSystemInfoSync)",
    "描述": "wx.getSystemInfo) 的同步版本"
  },
  {
    "接口名称": "[wx.getSystemInfoAsync](/minigame/dev/api/base/system/wx.getSystemInfoAsync)",
    "描述": "异步获取系统信息"
  },
  {
    "接口名称": "[wx.getSystemInfo](/minigame/dev/api/base/system/wx.getSystemInfo)",
    "描述": "获取系统信息"
  },
  {
    "接口名称": "[wx.getDeviceInfo](/minigame/dev/api/base/system/wx.getDeviceInfo)",
    "描述": "获取设备基础信息"
  },
  {
    "接口名称": "[wx.getDeviceBenchmarkInfo](/minigame/dev/api/base/system/wx.getDeviceBenchmarkInfo)",
    "描述": "获取设备性能得分和机型档位数据"
  },
  {
    "接口名称": "[wx.getAppBaseInfo](/minigame/dev/api/base/system/wx.getAppBaseInfo)",
    "描述": "获取微信APP基础信息"
  },
  {
    "接口名称": "[wx.getAppAuthorizeSetting](/minigame/dev/api/base/system/wx.getAppAuthorizeSetting)",
    "描述": "获取微信APP授权设置"
  }
]
```

### 更新

```json
[
  {
    "接口名称": "[wx.updateWeChatApp](/minigame/dev/api/base/update/wx.updateWeChatApp)",
    "描述": "更新客户端版本"
  },
  {
    "接口名称": "[wx.getUpdateManager](/minigame/dev/api/base/update/wx.getUpdateManager)",
    "描述": "获取全局唯一的版本更新管理器，用于管理小程序更新"
  }
]
```

#### UpdateManager

```json
[
  {
    "接口名称": "[UpdateManager.applyUpdate](/minigame/dev/api/base/update/UpdateManager.applyUpdate)",
    "描述": "强制小程序重启并使用新版本"
  },
  {
    "接口名称": "[UpdateManager.onCheckForUpdate](/minigame/dev/api/base/update/UpdateManager.onCheckForUpdate)",
    "描述": "监听向微信后台请求检查更新结果事件"
  },
  {
    "接口名称": "[UpdateManager.onUpdateFailed](/minigame/dev/api/base/update/UpdateManager.onUpdateFailed)",
    "描述": "监听小程序更新失败事件"
  },
  {
    "接口名称": "[UpdateManager.onUpdateReady](/minigame/dev/api/base/update/UpdateManager.onUpdateReady)",
    "描述": "监听小程序有版本更新事件"
  }
]
```

### 小程序

#### 生命周期

```json
[
  {
    "接口名称": "[wx.onShow](/minigame/dev/api/base/app/life-cycle/wx.onShow)",
    "描述": "监听小游戏回到前台的事件"
  },
  {
    "接口名称": "[wx.onHide](/minigame/dev/api/base/app/life-cycle/wx.onHide)",
    "描述": "监听小游戏隐藏到后台事件"
  },
  {
    "接口名称": "[wx.offShow](/minigame/dev/api/base/app/life-cycle/wx.offShow)",
    "描述": "移除小游戏回到前台的事件的监听函数"
  },
  {
    "接口名称": "[wx.offHide](/minigame/dev/api/base/app/life-cycle/wx.offHide)",
    "描述": "移除小游戏隐藏到后台事件的监听函数"
  },
  {
    "接口名称": "[wx.getLaunchOptionsSync](/minigame/dev/api/base/app/life-cycle/wx.getLaunchOptionsSync)",
    "描述": "获取小游戏冷启动时的参数"
  },
  {
    "接口名称": "[wx.getEnterOptionsSync](/minigame/dev/api/base/app/life-cycle/wx.getEnterOptionsSync)",
    "描述": "获取小游戏打开的参数（包括冷启动和热启动）"
  }
]
```

#### 应用级事件

```json
[
  {
    "接口名称": "[wx.onUnhandledRejection](/minigame/dev/api/base/app/app-event/wx.onUnhandledRejection)",
    "描述": "监听未处理的 Promise 拒绝事件"
  },
  {
    "接口名称": "[wx.onError](/minigame/dev/api/base/app/app-event/wx.onError)",
    "描述": "监听全局错误事件"
  },
  {
    "接口名称": "[wx.onAudioInterruptionEnd](/minigame/dev/api/base/app/app-event/wx.onAudioInterruptionEnd)",
    "描述": "监听音频中断结束事件"
  },
  {
    "接口名称": "[wx.onAudioInterruptionBegin](/minigame/dev/api/base/app/app-event/wx.onAudioInterruptionBegin)",
    "描述": "监听音频因为受到系统占用而被中断开始事件"
  },
  {
    "接口名称": "[wx.offUnhandledRejection](/minigame/dev/api/base/app/app-event/wx.offUnhandledRejection)",
    "描述": "移除未处理的 Promise 拒绝事件的监听函数"
  },
  {
    "接口名称": "[wx.offError](/minigame/dev/api/base/app/app-event/wx.offError)",
    "描述": "移除全局错误事件的监听函数"
  },
  {
    "接口名称": "[wx.offAudioInterruptionEnd](/minigame/dev/api/base/app/app-event/wx.offAudioInterruptionEnd)",
    "描述": "移除音频中断结束事件的监听函数"
  },
  {
    "接口名称": "[wx.offAudioInterruptionBegin](/minigame/dev/api/base/app/app-event/wx.offAudioInterruptionBegin)",
    "描述": "移除音频因为受到系统占用而被中断开始事件的监听函数"
  }
]
```

### 性能

```json
[
  {
    "接口名称": "[wx.triggerGC](/minigame/dev/api/base/performance/wx.triggerGC)",
    "描述": "加快触发 JavaScriptCore 垃圾回收（Garbage Collection）"
  },
  {
    "接口名称": "[wx.reportPerformance](/minigame/dev/api/base/performance/wx.reportPerformance)",
    "描述": "小程序测速上报"
  },
  {
    "接口名称": "[wx.getPerformance](/minigame/dev/api/base/performance/wx.getPerformance)",
    "描述": "获取性能管理器"
  }
]
```

#### Performance

```json
[
  {
    "接口名称": "[Performance.now](/minigame/dev/api/base/performance/Performance.now)",
    "描述": "可以获取当前时间以微秒为单位的时间戳"
  }
]
```

### 分包加载

```json
[
  {
    "接口名称": "[wx.preDownloadSubpackage](/minigame/dev/api/base/subpackage/wx.preDownloadSubpackage)",
    "描述": "触发分包预下载"
  },
  {
    "接口名称": "[wx.loadSubpackage](/minigame/dev/api/base/subpackage/wx.loadSubpackage)",
    "描述": "触发分包加载，详见 分包加载)"
  }
]
```

#### LoadSubpackageTask

```json
[
  {
    "接口名称": "[LoadSubpackageTask.onProgressUpdate](/minigame/dev/api/base/subpackage/LoadSubpackageTask.onProgressUpdate)",
    "描述": "监听分包加载进度变化事件"
  }
]
```

#### PreDownloadSubpackageTask

```json
[
  {
    "接口名称": "[PreDownloadSubpackageTask.onProgressUpdate](/minigame/dev/api/base/subpackage/PreDownloadSubpackageTask.onProgressUpdate)",
    "描述": "监听分包加载进度变化事件"
  }
]
```

### 调试

```json
[
  {
    "接口名称": "[wx.setEnableDebug](/minigame/dev/api/base/debug/wx.setEnableDebug)",
    "描述": "设置是否打开调试开关"
  },
  {
    "接口名称": "[wx.getRealtimeLogManager](/minigame/dev/api/base/debug/wx.getRealtimeLogManager)",
    "描述": "获取实时日志管理器对象"
  },
  {
    "接口名称": "[wx.getLogManager](/minigame/dev/api/base/debug/wx.getLogManager)",
    "描述": "获取日志管理器对象"
  }
]
```

#### console

```json
[
  {
    "接口名称": "[console.debug](/minigame/dev/api/base/debug/console.debug)",
    "描述": "向调试面板中打印 debug 日志"
  },
  {
    "接口名称": "[console.error](/minigame/dev/api/base/debug/console.error)",
    "描述": "向调试面板中打印 error 日志"
  },
  {
    "接口名称": "[console.group](/minigame/dev/api/base/debug/console.group)",
    "描述": "在调试面板中创建一个新的分组"
  },
  {
    "接口名称": "[console.groupEnd](/minigame/dev/api/base/debug/console.groupEnd)",
    "描述": "结束由 console.group) 创建的分组"
  },
  {
    "接口名称": "[console.info](/minigame/dev/api/base/debug/console.info)",
    "描述": "向调试面板中打印 info 日志"
  },
  {
    "接口名称": "[console.log](/minigame/dev/api/base/debug/console.log)",
    "描述": "向调试面板中打印 log 日志"
  },
  {
    "接口名称": "[console.warn](/minigame/dev/api/base/debug/console.warn)",
    "描述": "向调试面板中打印 warn 日志"
  }
]
```

#### LogManager

```json
[
  {
    "接口名称": "[LogManager.debug](/minigame/dev/api/base/debug/LogManager.debug)",
    "描述": "写 debug 日志"
  },
  {
    "接口名称": "[LogManager.info](/minigame/dev/api/base/debug/LogManager.info)",
    "描述": "写 info 日志"
  },
  {
    "接口名称": "[LogManager.log](/minigame/dev/api/base/debug/LogManager.log)",
    "描述": "写 log 日志"
  },
  {
    "接口名称": "[LogManager.warn](/minigame/dev/api/base/debug/LogManager.warn)",
    "描述": "写 warn 日志"
  }
]
```

#### RealtimeLogManager

```json
[
  {
    "接口名称": "[RealtimeLogManager.addFilterMsg](/minigame/dev/api/base/debug/RealtimeLogManager.addFilterMsg)",
    "描述": "添加过滤关键字，暂不支持在插件使用"
  },
  {
    "接口名称": "[RealtimeLogManager.error](/minigame/dev/api/base/debug/RealtimeLogManager.error)",
    "描述": "写 error 日志，暂不支持在插件使用"
  },
  {
    "接口名称": "[RealtimeLogManager.info](/minigame/dev/api/base/debug/RealtimeLogManager.info)",
    "描述": "写 info 日志，暂不支持在插件使用"
  },
  {
    "接口名称": "[RealtimeLogManager.setFilterMsg](/minigame/dev/api/base/debug/RealtimeLogManager.setFilterMsg)",
    "描述": "设置过滤关键字，暂不支持在插件使用"
  },
  {
    "接口名称": "[RealtimeLogManager.warn](/minigame/dev/api/base/debug/RealtimeLogManager.warn)",
    "描述": "写 warn 日志，暂不支持在插件使用"
  }
]
```

### 加密

```json
[
  {
    "接口名称": "[wx.getUserCryptoManager](/minigame/dev/api/base/crypto/wx.getUserCryptoManager)",
    "描述": "获取用户加密模块"
  }
]
```

#### UserCryptoManager

```json
[
  {
    "接口名称": "[UserCryptoManager.getLatestUserKey](/minigame/dev/api/base/crypto/UserCryptoManager.getLatestUserKey)",
    "描述": "获取最新的用户加密密钥"
  },
  {
    "接口名称": "[UserCryptoManager.getRandomValues](/minigame/dev/api/base/crypto/UserCryptoManager.getRandomValues)",
    "描述": "获取密码学安全随机数"
  }
]
```

## 跳转

```json
[
  {
    "接口名称": "[wx.restartMiniProgram](/minigame/dev/api/navigate/wx.restartMiniProgram)",
    "描述": "重启当前小程序"
  },
  {
    "接口名称": "[wx.openPhotoTopicView](/minigame/dev/api/navigate/wx.openPhotoTopicView)",
    "描述": "打开微信官方贴图话题发布页"
  },
  {
    "接口名称": "[wx.navigateToMiniProgram](/minigame/dev/api/navigate/wx.navigateToMiniProgram)",
    "描述": "打开另一个小程序"
  },
  {
    "接口名称": "[wx.navigateBackMiniProgram](/minigame/dev/api/navigate/wx.navigateBackMiniProgram)",
    "描述": "返回到上一个小程序"
  },
  {
    "接口名称": "[wx.exitMiniProgram](/minigame/dev/api/navigate/wx.exitMiniProgram)",
    "描述": "退出当前小程序"
  }
]
```

## 转发

```json
[
  {
    "接口名称": "[wx.updateShareMenu](/minigame/dev/api/share/wx.updateShareMenu)",
    "描述": "更新转发属性"
  },
  {
    "接口名称": "[wx.startHandoff](/minigame/dev/api/share/wx.startHandoff)",
    "描述": "开始进行接力，该接口需要在开放数据域调用"
  },
  {
    "接口名称": "[wx.showShareMenu](/minigame/dev/api/share/wx.showShareMenu)",
    "描述": "设置右上角点开的详情界面中的分享按钮是否可用"
  },
  {
    "接口名称": "[wx.showShareImageMenu](/minigame/dev/api/share/wx.showShareImageMenu)",
    "描述": "打开分享图片弹窗，可以将图片发送给朋友、收藏或下载"
  },
  {
    "接口名称": "[wx.shareAppMessage](/minigame/dev/api/share/wx.shareAppMessage)",
    "描述": "主动拉起转发，进入选择通讯录界面"
  },
  {
    "接口名称": "[wx.setMessageToFriendQuery](/minigame/dev/api/share/wx.setMessageToFriendQuery)",
    "描述": "设置 wx.shareMessageToFriend 接口 query 字段的值"
  },
  {
    "接口名称": "[wx.setHandoffQuery](/minigame/dev/api/share/wx.setHandoffQuery)",
    "描述": "设置接力参数，该接口需要在游戏域调用"
  },
  {
    "接口名称": "[wx.onShareTimeline](/minigame/dev/api/share/wx.onShareTimeline)",
    "描述": "监听用户点击右上角菜单的「分享到朋友圈」按钮时触发的事件"
  },
  {
    "接口名称": "[wx.onShareMessageToFriend](/minigame/dev/api/share/wx.onShareMessageToFriend)",
    "描述": "监听主域接收接口的成功失败通知事件"
  },
  {
    "接口名称": "[wx.onShareAppMessage](/minigame/dev/api/share/wx.onShareAppMessage)",
    "描述": "监听用户点击右上角菜单的「转发」按钮时触发的事件"
  },
  {
    "接口名称": "[wx.onHandoff](/minigame/dev/api/share/wx.onHandoff)",
    "描述": "监听用户点击菜单「在电脑上打开」按钮时触发的事件"
  },
  {
    "接口名称": "[wx.onCopyUrl](/minigame/dev/api/share/wx.onCopyUrl)",
    "描述": "监听用户点击右上角菜单的「复制链接」按钮时触发的事件"
  },
  {
    "接口名称": "[wx.onAddToFavorites](/minigame/dev/api/share/wx.onAddToFavorites)",
    "描述": "监听用户点击菜单「收藏」按钮时触发的事件"
  },
  {
    "接口名称": "[wx.offShareTimeline](/minigame/dev/api/share/wx.offShareTimeline)",
    "描述": "移除用户点击右上角菜单的「分享到朋友圈」按钮时触发的事件的监听函数"
  },
  {
    "接口名称": "[wx.offShareMessageToFriend](/minigame/dev/api/share/wx.offShareMessageToFriend)",
    "描述": "移除主域接收接口的成功失败通知事件的监听函数"
  },
  {
    "接口名称": "[wx.offShareAppMessage](/minigame/dev/api/share/wx.offShareAppMessage)",
    "描述": "移除用户点击右上角菜单的「转发」按钮时触发的事件的监听函数"
  },
  {
    "接口名称": "[wx.offHandoff](/minigame/dev/api/share/wx.offHandoff)",
    "描述": "移除用户点击菜单「在电脑上打开」按钮时触发的事件的全部监听函数"
  },
  {
    "接口名称": "[wx.offCopyUrl](/minigame/dev/api/share/wx.offCopyUrl)",
    "描述": "移除用户点击右上角菜单的「复制链接」按钮时触发的事件的全部监听函数"
  },
  {
    "接口名称": "[wx.offAddToFavorites](/minigame/dev/api/share/wx.offAddToFavorites)",
    "描述": "移除用户点击菜单「收藏」按钮时触发的事件的全部监听函数"
  },
  {
    "接口名称": "[wx.hideShareMenu](/minigame/dev/api/share/wx.hideShareMenu)",
    "描述": "隐藏当前页面的转发按钮"
  },
  {
    "接口名称": "[wx.getShareInfo](/minigame/dev/api/share/wx.getShareInfo)",
    "描述": "获取转发详细信息（主要是获取群ID）"
  },
  {
    "接口名称": "[wx.checkHandoffEnabled](/minigame/dev/api/share/wx.checkHandoffEnabled)",
    "描述": "检查是否可以进行接力，该接口需要在开放数据域调用"
  },
  {
    "接口名称": "[wx.authPrivateMessage](/minigame/dev/api/share/wx.authPrivateMessage)",
    "描述": "验证私密消息"
  }
]
```

## 聊天工具

```json
[
  {
    "接口名称": "[wx.shareVideoToGroup](/minigame/dev/api/chattool/wx.shareVideoToGroup)",
    "描述": "转发视频到聊天"
  },
  {
    "接口名称": "[wx.shareTextToGroup](/minigame/dev/api/chattool/wx.shareTextToGroup)",
    "描述": "转发文本到聊天"
  },
  {
    "接口名称": "[wx.shareImageToGroup](/minigame/dev/api/chattool/wx.shareImageToGroup)",
    "描述": "转发图片到聊天"
  },
  {
    "接口名称": "[wx.shareEmojiToGroup](/minigame/dev/api/chattool/wx.shareEmojiToGroup)",
    "描述": "转发表情到聊天"
  },
  {
    "接口名称": "[wx.shareAppMessageToGroup](/minigame/dev/api/chattool/wx.shareAppMessageToGroup)",
    "描述": "转发小程序卡片到聊天"
  },
  {
    "接口名称": "[wx.selectGroupMembers](/minigame/dev/api/chattool/wx.selectGroupMembers)",
    "描述": "选择聊天室的成员，并返回选择成员的 group_openid"
  },
  {
    "接口名称": "[wx.openChatTool](/minigame/dev/api/chattool/wx.openChatTool)",
    "描述": "进入聊天工具模式"
  },
  {
    "接口名称": "[wx.notifyGroupMembers](/minigame/dev/api/chattool/wx.notifyGroupMembers)",
    "描述": "提醒用户完成任务，标题长度不超过 30 个字符，支持中英文和数字，中文算2个字符"
  },
  {
    "接口名称": "[wx.isChatTool](/minigame/dev/api/chattool/wx.isChatTool)",
    "描述": "是否处于聊天工具模式"
  },
  {
    "接口名称": "[wx.getChatToolInfo](/minigame/dev/api/chattool/wx.getChatToolInfo)",
    "描述": "获取聊天工具模式下的群聊信息"
  },
  {
    "接口名称": "[wx.exitChatTool](/minigame/dev/api/chattool/wx.exitChatTool)",
    "描述": "退出聊天工具开放能力模式"
  },
  {
    "接口名称": "[wx.enterChatToolMode](/minigame/dev/api/chattool/wx.enterChatToolMode)",
    "描述": "进入聊天工具开放能力模式"
  }
]
```

## 界面

### 交互

```json
[
  {
    "接口名称": "[wx.showToast](/minigame/dev/api/ui/interaction/wx.showToast)",
    "描述": "显示消息提示框"
  },
  {
    "接口名称": "[wx.showModal](/minigame/dev/api/ui/interaction/wx.showModal)",
    "描述": "显示模态对话框"
  },
  {
    "接口名称": "[wx.showLoading](/minigame/dev/api/ui/interaction/wx.showLoading)",
    "描述": "显示 loading 提示框"
  },
  {
    "接口名称": "[wx.showActionSheet](/minigame/dev/api/ui/interaction/wx.showActionSheet)",
    "描述": "显示操作菜单"
  },
  {
    "接口名称": "[wx.hideToast](/minigame/dev/api/ui/interaction/wx.hideToast)",
    "描述": "隐藏消息提示框"
  },
  {
    "接口名称": "[wx.hideLoading](/minigame/dev/api/ui/interaction/wx.hideLoading)",
    "描述": "隐藏 loading 提示框"
  }
]
```

### 菜单

```json
[
  {
    "接口名称": "[wx.setMenuStyle](/minigame/dev/api/ui/menu/wx.setMenuStyle)",
    "描述": "动态设置通过右上角按钮拉起的菜单的样式"
  },
  {
    "接口名称": "[wx.onOfficialComponentsInfoChange](/minigame/dev/api/ui/menu/wx.onOfficialComponentsInfoChange)",
    "描述": "监听官方组件信息变化事件"
  },
  {
    "接口名称": "[wx.offOfficialComponentsInfoChange](/minigame/dev/api/ui/menu/wx.offOfficialComponentsInfoChange)",
    "描述": "移除官方组件信息变化事件的监听函数"
  },
  {
    "接口名称": "[wx.getOfficialComponentsInfo](/minigame/dev/api/ui/menu/wx.getOfficialComponentsInfo)",
    "描述": "获取所有官方组件的相关信息"
  },
  {
    "接口名称": "[wx.getMenuButtonBoundingClientRect](/minigame/dev/api/ui/menu/wx.getMenuButtonBoundingClientRect)",
    "描述": "获取菜单按钮（右上角胶囊按钮）的布局位置信息"
  }
]
```

### 状态栏

```json
[
  {
    "接口名称": "[wx.setStatusBarStyle](/minigame/dev/api/ui/statusbar/wx.setStatusBarStyle)",
    "描述": "当在配置中设置 showStatusBar 时，屏幕顶部会显示状态栏"
  }
]
```

### 窗口

```json
[
  {
    "接口名称": "[wx.setWindowSize](/minigame/dev/api/ui/window/wx.setWindowSize)",
    "描述": "设置窗口大小，该接口仅适用于 PC 平台，使用细则请参见指南"
  },
  {
    "接口名称": "[wx.onWindowStateChange](/minigame/dev/api/ui/window/wx.onWindowStateChange)",
    "描述": "监听小程序窗口状态变化事件"
  },
  {
    "接口名称": "[wx.onWindowResize](/minigame/dev/api/ui/window/wx.onWindowResize)",
    "描述": "监听窗口尺寸变化事件"
  },
  {
    "接口名称": "[wx.offWindowStateChange](/minigame/dev/api/ui/window/wx.offWindowStateChange)",
    "描述": "移除小程序窗口状态变化事件的监听函数"
  },
  {
    "接口名称": "[wx.offWindowResize](/minigame/dev/api/ui/window/wx.offWindowResize)",
    "描述": "移除窗口尺寸变化事件的监听函数"
  }
]
```

## 网络

### 发起请求

```json
[
  {
    "接口名称": "[wx.request](/minigame/dev/api/network/request/wx.request)",
    "描述": "发起 HTTPS 网络请求"
  }
]
```

#### RequestTask

```json
[
  {
    "接口名称": "[RequestTask.abort](/minigame/dev/api/network/request/RequestTask.abort)",
    "描述": "中断请求任务"
  },
  {
    "接口名称": "[RequestTask.offChunkReceived](/minigame/dev/api/network/request/RequestTask.offChunkReceived)",
    "描述": "移除 Transfer-Encoding Chunk Received 事件的监听函数"
  },
  {
    "接口名称": "[RequestTask.offHeadersReceived](/minigame/dev/api/network/request/RequestTask.offHeadersReceived)",
    "描述": "移除 HTTP Response Header 事件的监听函数"
  },
  {
    "接口名称": "[RequestTask.onChunkReceived](/minigame/dev/api/network/request/RequestTask.onChunkReceived)",
    "描述": "监听 Transfer-Encoding Chunk Received 事件"
  },
  {
    "接口名称": "[RequestTask.onHeadersReceived](/minigame/dev/api/network/request/RequestTask.onHeadersReceived)",
    "描述": "监听 HTTP Response Header 事件"
  }
]
```

### 下载

```json
[
  {
    "接口名称": "[wx.downloadFile](/minigame/dev/api/network/download/wx.downloadFile)",
    "描述": "下载文件资源到本地"
  }
]
```

#### DownloadTask

```json
[
  {
    "接口名称": "[DownloadTask.abort](/minigame/dev/api/network/download/DownloadTask.abort)",
    "描述": "中断下载任务"
  },
  {
    "接口名称": "[DownloadTask.offHeadersReceived](/minigame/dev/api/network/download/DownloadTask.offHeadersReceived)",
    "描述": "移除 HTTP Response Header 事件的监听函数"
  },
  {
    "接口名称": "[DownloadTask.offProgressUpdate](/minigame/dev/api/network/download/DownloadTask.offProgressUpdate)",
    "描述": "移除下载进度变化事件的监听函数"
  },
  {
    "接口名称": "[DownloadTask.onHeadersReceived](/minigame/dev/api/network/download/DownloadTask.onHeadersReceived)",
    "描述": "监听 HTTP Response Header 事件"
  },
  {
    "接口名称": "[DownloadTask.onProgressUpdate](/minigame/dev/api/network/download/DownloadTask.onProgressUpdate)",
    "描述": "监听下载进度变化事件"
  }
]
```

### 上传

```json
[
  {
    "接口名称": "[wx.uploadFile](/minigame/dev/api/network/upload/wx.uploadFile)",
    "描述": "将本地资源上传到服务器"
  }
]
```

#### UploadTask

```json
[
  {
    "接口名称": "[UploadTask.abort](/minigame/dev/api/network/upload/UploadTask.abort)",
    "描述": "中断上传任务"
  },
  {
    "接口名称": "[UploadTask.offHeadersReceived](/minigame/dev/api/network/upload/UploadTask.offHeadersReceived)",
    "描述": "移除 HTTP Response Header 事件的监听函数"
  },
  {
    "接口名称": "[UploadTask.offProgressUpdate](/minigame/dev/api/network/upload/UploadTask.offProgressUpdate)",
    "描述": "移除上传进度变化事件的监听函数"
  },
  {
    "接口名称": "[UploadTask.onHeadersReceived](/minigame/dev/api/network/upload/UploadTask.onHeadersReceived)",
    "描述": "监听 HTTP Response Header 事件"
  },
  {
    "接口名称": "[UploadTask.onProgressUpdate](/minigame/dev/api/network/upload/UploadTask.onProgressUpdate)",
    "描述": "监听上传进度变化事件"
  }
]
```

### WebSocket

```json
[
  {
    "接口名称": "[wx.sendSocketMessage](/minigame/dev/api/network/websocket/wx.sendSocketMessage)",
    "描述": "通过 WebSocket 连接发送数据"
  },
  {
    "接口名称": "[wx.onSocketOpen](/minigame/dev/api/network/websocket/wx.onSocketOpen)",
    "描述": "监听 WebSocket 连接打开事件"
  },
  {
    "接口名称": "[wx.onSocketMessage](/minigame/dev/api/network/websocket/wx.onSocketMessage)",
    "描述": "监听 WebSocket 接收到服务器的消息事件"
  },
  {
    "接口名称": "[wx.onSocketError](/minigame/dev/api/network/websocket/wx.onSocketError)",
    "描述": "监听 WebSocket 错误事件"
  },
  {
    "接口名称": "[wx.onSocketClose](/minigame/dev/api/network/websocket/wx.onSocketClose)",
    "描述": "监听 WebSocket 连接关闭事件"
  },
  {
    "接口名称": "[wx.connectSocket](/minigame/dev/api/network/websocket/wx.connectSocket)",
    "描述": "创建一个 WebSocket 连接"
  },
  {
    "接口名称": "[wx.closeSocket](/minigame/dev/api/network/websocket/wx.closeSocket)",
    "描述": "关闭 WebSocket 连接"
  }
]
```

#### SocketTask

```json
[
  {
    "接口名称": "[SocketTask.close](/minigame/dev/api/network/websocket/SocketTask.close)",
    "描述": "关闭 WebSocket 连接"
  },
  {
    "接口名称": "[SocketTask.onClose](/minigame/dev/api/network/websocket/SocketTask.onClose)",
    "描述": "监听 WebSocket 连接关闭事件"
  },
  {
    "接口名称": "[SocketTask.onError](/minigame/dev/api/network/websocket/SocketTask.onError)",
    "描述": "监听 WebSocket 错误事件"
  },
  {
    "接口名称": "[SocketTask.onMessage](/minigame/dev/api/network/websocket/SocketTask.onMessage)",
    "描述": "监听 WebSocket 接收到服务器的消息事件"
  },
  {
    "接口名称": "[SocketTask.onOpen](/minigame/dev/api/network/websocket/SocketTask.onOpen)",
    "描述": "监听 WebSocket 连接打开事件"
  },
  {
    "接口名称": "[SocketTask.send](/minigame/dev/api/network/websocket/SocketTask.send)",
    "描述": "通过 WebSocket 连接发送数据"
  }
]
```

### TCP 通信

```json
[
  {
    "接口名称": "[wx.createTCPSocket](/minigame/dev/api/network/tcp/wx.createTCPSocket)",
    "描述": "创建一个 TCP Socket 实例"
  }
]
```

#### TCPSocket

```json
[
  {
    "接口名称": "[TCPSocket.bindWifi](/minigame/dev/api/network/tcp/TCPSocket.bindWifi)",
    "描述": "将 TCP Socket 绑定到当前 wifi 网络，成功后会触发 onBindWifi 事件（仅安卓支持）"
  },
  {
    "接口名称": "[TCPSocket.close](/minigame/dev/api/network/tcp/TCPSocket.close)",
    "描述": "关闭连接"
  },
  {
    "接口名称": "[TCPSocket.connect](/minigame/dev/api/network/tcp/TCPSocket.connect)",
    "描述": "在给定的套接字上启动连接"
  },
  {
    "接口名称": "[TCPSocket.offBindWifi](/minigame/dev/api/network/tcp/TCPSocket.offBindWifi)",
    "描述": "移除当一个 socket 绑定当前 wifi 网络成功时触发该事件的监听函数"
  },
  {
    "接口名称": "[TCPSocket.offClose](/minigame/dev/api/network/tcp/TCPSocket.offClose)",
    "描述": "移除一旦 socket 完全关闭就发出该事件的监听函数"
  },
  {
    "接口名称": "[TCPSocket.offConnect](/minigame/dev/api/network/tcp/TCPSocket.offConnect)",
    "描述": "移除当一个 socket 连接成功建立的时候触发该事件的监听函数"
  },
  {
    "接口名称": "[TCPSocket.offError](/minigame/dev/api/network/tcp/TCPSocket.offError)",
    "描述": "移除当错误发生时触发的监听函数"
  },
  {
    "接口名称": "[TCPSocket.offMessage](/minigame/dev/api/network/tcp/TCPSocket.offMessage)",
    "描述": "移除当接收到数据的时触发该事件的监听函数"
  },
  {
    "接口名称": "[TCPSocket.onBindWifi](/minigame/dev/api/network/tcp/TCPSocket.onBindWifi)",
    "描述": "监听当一个 socket 绑定当前 wifi 网络成功时触发该事件"
  },
  {
    "接口名称": "[TCPSocket.onClose](/minigame/dev/api/network/tcp/TCPSocket.onClose)",
    "描述": "监听一旦 socket 完全关闭就发出该事件"
  },
  {
    "接口名称": "[TCPSocket.onConnect](/minigame/dev/api/network/tcp/TCPSocket.onConnect)",
    "描述": "监听当一个 socket 连接成功建立的时候触发该事件"
  },
  {
    "接口名称": "[TCPSocket.onError](/minigame/dev/api/network/tcp/TCPSocket.onError)",
    "描述": "监听当错误发生时触发"
  },
  {
    "接口名称": "[TCPSocket.onMessage](/minigame/dev/api/network/tcp/TCPSocket.onMessage)",
    "描述": "监听当接收到数据的时触发该事件"
  },
  {
    "接口名称": "[TCPSocket.write](/minigame/dev/api/network/tcp/TCPSocket.write)",
    "描述": "在 socket 上发送数据"
  }
]
```

### UDP 通信

```json
[
  {
    "接口名称": "[wx.createUDPSocket](/minigame/dev/api/network/udp/wx.createUDPSocket)",
    "描述": "创建一个 UDP Socket 实例"
  }
]
```

#### UDPSocket

```json
[
  {
    "接口名称": "[UDPSocket.bind](/minigame/dev/api/network/udp/UDPSocket.bind)",
    "描述": "绑定一个系统随机分配的可用端口，或绑定一个指定的端口号"
  },
  {
    "接口名称": "[UDPSocket.close](/minigame/dev/api/network/udp/UDPSocket.close)",
    "描述": "关闭 UDP Socket 实例，相当于销毁"
  },
  {
    "接口名称": "[UDPSocket.connect](/minigame/dev/api/network/udp/UDPSocket.connect)",
    "描述": "预先连接到指定的 IP 和 port，需要配合 write 方法一起使用"
  },
  {
    "接口名称": "[UDPSocket.offClose](/minigame/dev/api/network/udp/UDPSocket.offClose)",
    "描述": "移除关闭事件的监听函数"
  },
  {
    "接口名称": "[UDPSocket.offError](/minigame/dev/api/network/udp/UDPSocket.offError)",
    "描述": "移除错误事件的监听函数"
  },
  {
    "接口名称": "[UDPSocket.offListening](/minigame/dev/api/network/udp/UDPSocket.offListening)",
    "描述": "移除开始监听数据包消息的事件的监听函数"
  },
  {
    "接口名称": "[UDPSocket.offMessage](/minigame/dev/api/network/udp/UDPSocket.offMessage)",
    "描述": "移除收到消息的事件的监听函数"
  },
  {
    "接口名称": "[UDPSocket.onClose](/minigame/dev/api/network/udp/UDPSocket.onClose)",
    "描述": "监听关闭事件"
  },
  {
    "接口名称": "[UDPSocket.onError](/minigame/dev/api/network/udp/UDPSocket.onError)",
    "描述": "监听错误事件"
  },
  {
    "接口名称": "[UDPSocket.onListening](/minigame/dev/api/network/udp/UDPSocket.onListening)",
    "描述": "监听开始监听数据包消息的事件"
  },
  {
    "接口名称": "[UDPSocket.onMessage](/minigame/dev/api/network/udp/UDPSocket.onMessage)",
    "描述": "监听收到消息的事件"
  },
  {
    "接口名称": "[UDPSocket.send](/minigame/dev/api/network/udp/UDPSocket.send)",
    "描述": "向指定的 IP 和 port 发送消息"
  },
  {
    "接口名称": "[UDPSocket.setTTL](/minigame/dev/api/network/udp/UDPSocket.setTTL)",
    "描述": "设置 IP_TTL 套接字选项，用于设置一个 IP 数据包传输时允许的最大跳步数"
  },
  {
    "接口名称": "[UDPSocket.write](/minigame/dev/api/network/udp/UDPSocket.write)",
    "描述": "用法与 send 方法相同，如果没有预先调用 connect 则与 send 无差异（注意即使调用了 connect 也需要在本接口填入地址和端口参数）"
  }
]
```

## 虚拟支付

```json
[
  {
    "接口名称": "[wx.requestMidasPaymentGameItem](/minigame/dev/api/midas-payment/wx.requestMidasPaymentGameItem)",
    "描述": "发起道具直购支付请求，可参考虚拟支付2.0道具直购，虚拟支付全流程可参考技术手册-虚拟支付篇"
  },
  {
    "接口名称": "[wx.requestMidasPayment](/minigame/dev/api/midas-payment/wx.requestMidasPayment)",
    "描述": "发起购买游戏币支付请求，可参考虚拟支付2.0游戏币，虚拟支付全流程可参考技术手册-虚拟支付篇"
  },
  {
    "接口名称": "[wx.requestMidasFriendPayment](/minigame/dev/api/midas-payment/wx.requestMidasFriendPayment)",
    "描述": "发起米大师朋友礼物索要"
  },
  {
    "接口名称": "[wx.checkIsSupportMidasPayment](/minigame/dev/api/midas-payment/wx.checkIsSupportMidasPayment)",
    "描述": "检查当前环境是否支持虚拟支付"
  }
]
```

## 数据缓存

```json
[
  {
    "接口名称": "[wx.setStorageSync](/minigame/dev/api/storage/wx.setStorageSync)",
    "描述": "将数据存储在本地缓存中指定的 key 中"
  },
  {
    "接口名称": "[wx.setStorage](/minigame/dev/api/storage/wx.setStorage)",
    "描述": "将数据存储在本地缓存中指定的 key 中"
  },
  {
    "接口名称": "[wx.revokeBufferURL](/minigame/dev/api/storage/wx.revokeBufferURL)",
    "描述": "根据 URL 销毁存在内存中的数据"
  },
  {
    "接口名称": "[wx.removeStorageSync](/minigame/dev/api/storage/wx.removeStorageSync)",
    "描述": "wx.removeStorage) 的同步版本"
  },
  {
    "接口名称": "[wx.removeStorage](/minigame/dev/api/storage/wx.removeStorage)",
    "描述": "从本地缓存中移除指定 key"
  },
  {
    "接口名称": "[wx.getStorageSync](/minigame/dev/api/storage/wx.getStorageSync)",
    "描述": "从本地缓存中同步获取指定 key 的内容"
  },
  {
    "接口名称": "[wx.getStorageInfoSync](/minigame/dev/api/storage/wx.getStorageInfoSync)",
    "描述": "wx.getStorageInfo) 的同步版本"
  },
  {
    "接口名称": "[wx.getStorageInfo](/minigame/dev/api/storage/wx.getStorageInfo)",
    "描述": "异步获取当前storage的相关信息"
  },
  {
    "接口名称": "[wx.getStorage](/minigame/dev/api/storage/wx.getStorage)",
    "描述": "从本地缓存中异步获取指定 key 的内容"
  },
  {
    "接口名称": "[wx.createBufferURL](/minigame/dev/api/storage/wx.createBufferURL)",
    "描述": "根据传入的 buffer 创建一个唯一的 URL 存在内存中"
  },
  {
    "接口名称": "[wx.clearStorageSync](/minigame/dev/api/storage/wx.clearStorageSync)",
    "描述": "wx.clearStorage) 的同步版本"
  },
  {
    "接口名称": "[wx.clearStorage](/minigame/dev/api/storage/wx.clearStorage)",
    "描述": "清理本地数据缓存"
  }
]
```

### 数据预拉取和周期性更新

```json
[
  {
    "接口名称": "[wx.setBackgroundFetchToken](/minigame/dev/api/storage/background-fetch/wx.setBackgroundFetchToken)",
    "描述": "设置自定义登录态，在周期性拉取数据时带上，便于第三方服务器验证请求合法性"
  },
  {
    "接口名称": "[wx.onBackgroundFetchData](/minigame/dev/api/storage/background-fetch/wx.onBackgroundFetchData)",
    "描述": "监听收到 backgroundFetch 数据事件"
  },
  {
    "接口名称": "[wx.getBackgroundFetchToken](/minigame/dev/api/storage/background-fetch/wx.getBackgroundFetchToken)",
    "描述": "获取设置过的自定义登录态"
  },
  {
    "接口名称": "[wx.getBackgroundFetchData](/minigame/dev/api/storage/background-fetch/wx.getBackgroundFetchData)",
    "描述": "拉取 backgroundFetch 客户端缓存数据"
  }
]
```

## 数据分析

```json
[
  {
    "接口名称": "[wx.reportUserBehaviorBranchAnalytics](/minigame/dev/api/data-analysis/wx.reportUserBehaviorBranchAnalytics)",
    "描述": "上报场景分析，用于UI组件（一般是按钮）相关事件的上报，事件目前有曝光、点击两种，查看相关文档"
  },
  {
    "接口名称": "[wx.reportScene](/minigame/dev/api/data-analysis/wx.reportScene)",
    "描述": "用于游戏启动阶段的自定义场景上报"
  },
  {
    "接口名称": "[wx.reportMonitor](/minigame/dev/api/data-analysis/wx.reportMonitor)",
    "描述": "自定义业务数据监控上报接口"
  },
  {
    "接口名称": "[wx.reportEvent](/minigame/dev/api/data-analysis/wx.reportEvent)",
    "描述": "事件上报"
  },
  {
    "接口名称": "[wx.getScenePerformanceManager](/minigame/dev/api/data-analysis/wx.getScenePerformanceManager)",
    "描述": "该接口专门用于协助开发者分析场景化的运行性能数据"
  },
  {
    "接口名称": "[wx.getMiniReportManager](/minigame/dev/api/data-analysis/wx.getMiniReportManager)",
    "描述": "初始化并返回一个MiniReportManager实例，用于记录和管理小游戏上报"
  },
  {
    "接口名称": "[wx.getGameLogManager](/minigame/dev/api/data-analysis/wx.getGameLogManager)",
    "描述": "初始化并返回一个游戏日志管理器实例，用于记录和管理游戏日志"
  },
  {
    "接口名称": "[wx.getGameExptInfo](/minigame/dev/api/data-analysis/wx.getGameExptInfo)",
    "描述": "给定实验参数数组，获取对应的实验参数值"
  },
  {
    "接口名称": "[wx.getExptInfoSync](/minigame/dev/api/data-analysis/wx.getExptInfoSync)",
    "描述": "给定实验参数数组，获取对应的实验参数值"
  }
]
```

### GameLogManager

```json
[
  {
    "接口名称": "[GameLogManager.getCommonInfo](/minigame/dev/api/data-analysis/GameLogManager.getCommonInfo)",
    "描述": "读取当前 logger 的全局 commonInfo 对象"
  },
  {
    "接口名称": "[GameLogManager.log](/minigame/dev/api/data-analysis/GameLogManager.log)",
    "描述": "上报日志"
  },
  {
    "接口名称": "[GameLogManager.tag](/minigame/dev/api/data-analysis/GameLogManager.tag)",
    "描述": "tag 方法接受一个字符串参数，作为上报日志的 key"
  },
  {
    "接口名称": "[GameLogManager.updateCommonInfo](/minigame/dev/api/data-analysis/GameLogManager.updateCommonInfo)",
    "描述": "该方法接受一个对象，并将其与当前logger的全局 commonInfo 对象进行合并"
  }
]
```

### MiniReportManager

```json
[
  {
    "接口名称": "[MiniReportManager.report](/minigame/dev/api/data-analysis/MiniReportManager.report)",
    "描述": "上报关卡日志"
  }
]
```

### ScenePerformanceManager

```json
[
  {
    "接口名称": "[ScenePerformanceManager.getCommonInfo](/minigame/dev/api/data-analysis/ScenePerformanceManager.getCommonInfo)",
    "描述": "获取通用信息（由setCommonInfo数据得到）"
  },
  {
    "接口名称": "[ScenePerformanceManager.setCommonInfo](/minigame/dev/api/data-analysis/ScenePerformanceManager.setCommonInfo)",
    "描述": "设置通用信息（全局维度），用于描述贯穿所有上报的固定属性（如机型档位、用户角色等）"
  },
  {
    "接口名称": "[ScenePerformanceManager.setData](/minigame/dev/api/data-analysis/ScenePerformanceManager.setData)",
    "描述": "上报当前所处的场景及其附加信息，用于对运行性能数据做多维度的筛选分析"
  }
]
```

## 渲染

### 画布

```json
[
  {
    "接口名称": "[wx.createPath2D](/minigame/dev/api/render/canvas/wx.createPath2D)",
    "描述": "创建一个 Path2D 路径对象"
  },
  {
    "接口名称": "[wx.createCanvas](/minigame/dev/api/render/canvas/wx.createCanvas)",
    "描述": "创建一个画布对象"
  },
  {
    "接口名称": "[Path2D](/minigame/dev/api/render/canvas/Path2D)",
    "描述": "Canvas 2D API 的接口 Path2D 用来声明路径，此路径稍后会被 CanvasRenderingContext2D 对象使用"
  },
  {
    "接口名称": "[RenderingContext](/minigame/dev/api/render/canvas/RenderingContext)",
    "描述": "画布对象的绘图上下文"
  },
  {
    "接口名称": "[WebGLRenderingContext.wxBindCanvasTexture](/minigame/dev/api/render/canvas/WebGLRenderingContext.wxBindCanvasTexture)",
    "描述": "将一个 Canvas 对应的 Texture 绑定到 WebGL 上下文"
  }
]
```

#### Canvas

```json
[
  {
    "接口名称": "[Canvas.getContext](/minigame/dev/api/render/canvas/Canvas.getContext)",
    "描述": "获取画布对象的绘图上下文"
  },
  {
    "接口名称": "[Canvas.toDataURL](/minigame/dev/api/render/canvas/Canvas.toDataURL)",
    "描述": "把画布上的绘制内容以一个 data URI 的格式返回"
  },
  {
    "接口名称": "[Canvas.toTempFilePath](/minigame/dev/api/render/canvas/Canvas.toTempFilePath)",
    "描述": "将当前 Canvas 保存为一个临时文件"
  },
  {
    "接口名称": "[Canvas.toTempFilePathSync](/minigame/dev/api/render/canvas/Canvas.toTempFilePathSync)",
    "描述": "Canvas.toTempFilePath) 的同步版本"
  }
]
```

### 帧率

```json
[
  {
    "接口名称": "[wx.setPreferredFramesPerSecond](/minigame/dev/api/render/frame/wx.setPreferredFramesPerSecond)",
    "描述": "可以修改渲染帧率"
  },
  {
    "接口名称": "[cancelAnimationFrame](/minigame/dev/api/render/frame/cancelAnimationFrame)",
    "描述": "取消由 requestAnimationFrame 添加到计划中的动画帧请求"
  },
  {
    "接口名称": "[requestAnimationFrame](/minigame/dev/api/render/frame/requestAnimationFrame)",
    "描述": "在下次进行重绘时执行"
  }
]
```

### 字体

```json
[
  {
    "接口名称": "[wx.loadFont](/minigame/dev/api/render/font/wx.loadFont)",
    "描述": "加载自定义字体文件"
  },
  {
    "接口名称": "[wx.getTextLineHeight](/minigame/dev/api/render/font/wx.getTextLineHeight)",
    "描述": "获取一行文本的行高"
  }
]
```

### 图片

```json
[
  {
    "接口名称": "[wx.createImageData](/minigame/dev/api/render/image/wx.createImageData)",
    "描述": "这里有两种使用方法, 一种是指定ImageData的宽和高, 另外一种使用已有的ImageData的图像二进制数据，来构建新的对象"
  },
  {
    "接口名称": "[wx.createImage](/minigame/dev/api/render/image/wx.createImage)",
    "描述": "创建一个图片对象"
  },
  {
    "接口名称": "[Image](/minigame/dev/api/render/image/Image)",
    "描述": "图片对象"
  },
  {
    "接口名称": "[ImageData](/minigame/dev/api/render/image/ImageData)",
    "描述": "ImageData 对象"
  }
]
```

### 鼠标样式

```json
[
  {
    "接口名称": "[wx.setCursor](/minigame/dev/api/render/cursor/wx.setCursor)",
    "描述": "加载自定义光标，仅支持 PC 平台"
  },
  {
    "接口名称": "[wx.requestPointerLock](/minigame/dev/api/render/cursor/wx.requestPointerLock)",
    "描述": "锁定鼠标指针"
  },
  {
    "接口名称": "[wx.isPointerLocked](/minigame/dev/api/render/cursor/wx.isPointerLocked)",
    "描述": "检查鼠标指针是否被锁定"
  },
  {
    "接口名称": "[wx.exitPointerLock](/minigame/dev/api/render/cursor/wx.exitPointerLock)",
    "描述": "解除锁定鼠标指针"
  }
]
```

### gpu

```json
[
  {
    "接口名称": "[wx.getGPU](/minigame/dev/api/render/gpu/wx.getGPU)",
    "描述": "获取 WebGPU 的 GPU 对象，等价于 Web 端的 navigator.gpu"
  }
]
```

## 媒体

### 音频

```json
[
  {
    "接口名称": "[wx.setInnerAudioOption](/minigame/dev/api/media/audio/wx.setInnerAudioOption)",
    "描述": "设置 InnerAudioContext) 的播放选项"
  },
  {
    "接口名称": "[wx.getAvailableAudioSources](/minigame/dev/api/media/audio/wx.getAvailableAudioSources)",
    "描述": "获取当前支持的音频输入源"
  },
  {
    "接口名称": "[wx.createWebAudioContext](/minigame/dev/api/media/audio/wx.createWebAudioContext)",
    "描述": "创建 WebAudio 上下文"
  },
  {
    "接口名称": "[wx.createMediaAudioPlayer](/minigame/dev/api/media/audio/wx.createMediaAudioPlayer)",
    "描述": "创建媒体音频播放器对象 MediaAudioPlayer) 对象，可用于播放视频解码器 VideoDecoder) 输出的音频"
  },
  {
    "接口名称": "[wx.createInnerAudioContext](/minigame/dev/api/media/audio/wx.createInnerAudioContext)",
    "描述": "创建内部 audio) 上下文 InnerAudioContext) 对象"
  },
  {
    "接口名称": "[AudioListener](/minigame/dev/api/media/audio/AudioListener)",
    "描述": "空间音频监听器，代表在一个音频场景内唯一的位置和方向信息"
  },
  {
    "接口名称": "[AudioParam](/minigame/dev/api/media/audio/AudioParam)",
    "描述": "AudioParam 接口代表音频相关的参数，通常是 AudioNode（例如 GainNode.gain）的参数"
  },
  {
    "接口名称": "[WebAudioContextNode](/minigame/dev/api/media/audio/WebAudioContextNode)",
    "描述": "一类音频处理模块，不同的Node具备不同的功能，如GainNode(音量调整)等"
  }
]
```

#### AudioBuffer

```json
[
  {
    "接口名称": "[AudioBuffer.copyFromChannel](/minigame/dev/api/media/audio/AudioBuffer.copyFromChannel)",
    "描述": "从AudioBuffer的指定频道复制到数组终端"
  },
  {
    "接口名称": "[AudioBuffer.copyToChannel](/minigame/dev/api/media/audio/AudioBuffer.copyToChannel)",
    "描述": "从指定数组复制样本到audioBuffer的特定通道"
  },
  {
    "接口名称": "[AudioBuffer.getChannelData](/minigame/dev/api/media/audio/AudioBuffer.getChannelData)",
    "描述": "返回一个 Float32Array，包含了带有频道的PCM数据，由频道参数定义（有0代表第一个频道）"
  }
]
```

#### BufferSourceNode

```json
[
  {
    "接口名称": "[BufferSourceNode.connect](/minigame/dev/api/media/audio/BufferSourceNode.connect)",
    "描述": "连接到一个指定目标"
  },
  {
    "接口名称": "[BufferSourceNode.disconnect](/minigame/dev/api/media/audio/BufferSourceNode.disconnect)",
    "描述": "与已连接的目标节点断开连接"
  },
  {
    "接口名称": "[BufferSourceNode.start](/minigame/dev/api/media/audio/BufferSourceNode.start)",
    "描述": "音频源开始播放"
  },
  {
    "接口名称": "[BufferSourceNode.stop](/minigame/dev/api/media/audio/BufferSourceNode.stop)",
    "描述": "停止播放"
  }
]
```

#### InnerAudioContext

```json
[
  {
    "接口名称": "[InnerAudioContext.destroy](/minigame/dev/api/media/audio/InnerAudioContext.destroy)",
    "描述": "销毁当前实例"
  },
  {
    "接口名称": "[InnerAudioContext.offCanplay](/minigame/dev/api/media/audio/InnerAudioContext.offCanplay)",
    "描述": "移除音频进入可以播放状态的事件的监听函数"
  },
  {
    "接口名称": "[InnerAudioContext.offEnded](/minigame/dev/api/media/audio/InnerAudioContext.offEnded)",
    "描述": "移除音频自然播放至结束的事件的监听函数"
  },
  {
    "接口名称": "[InnerAudioContext.offError](/minigame/dev/api/media/audio/InnerAudioContext.offError)",
    "描述": "移除音频播放错误事件的监听函数"
  },
  {
    "接口名称": "[InnerAudioContext.offPause](/minigame/dev/api/media/audio/InnerAudioContext.offPause)",
    "描述": "移除音频暂停事件的监听函数"
  },
  {
    "接口名称": "[InnerAudioContext.offPlay](/minigame/dev/api/media/audio/InnerAudioContext.offPlay)",
    "描述": "移除音频播放事件的监听函数"
  },
  {
    "接口名称": "[InnerAudioContext.offSeeked](/minigame/dev/api/media/audio/InnerAudioContext.offSeeked)",
    "描述": "移除音频完成跳转操作的事件的监听函数"
  },
  {
    "接口名称": "[InnerAudioContext.offSeeking](/minigame/dev/api/media/audio/InnerAudioContext.offSeeking)",
    "描述": "移除音频进行跳转操作的事件的监听函数"
  },
  {
    "接口名称": "[InnerAudioContext.offStop](/minigame/dev/api/media/audio/InnerAudioContext.offStop)",
    "描述": "移除音频停止事件的监听函数"
  },
  {
    "接口名称": "[InnerAudioContext.offTimeUpdate](/minigame/dev/api/media/audio/InnerAudioContext.offTimeUpdate)",
    "描述": "移除音频播放进度更新事件的监听函数"
  },
  {
    "接口名称": "[InnerAudioContext.offWaiting](/minigame/dev/api/media/audio/InnerAudioContext.offWaiting)",
    "描述": "移除音频加载中事件的监听函数"
  },
  {
    "接口名称": "[InnerAudioContext.onCanplay](/minigame/dev/api/media/audio/InnerAudioContext.onCanplay)",
    "描述": "监听音频进入可以播放状态的事件"
  },
  {
    "接口名称": "[InnerAudioContext.onEnded](/minigame/dev/api/media/audio/InnerAudioContext.onEnded)",
    "描述": "监听音频自然播放至结束的事件"
  },
  {
    "接口名称": "[InnerAudioContext.onError](/minigame/dev/api/media/audio/InnerAudioContext.onError)",
    "描述": "监听音频播放错误事件"
  },
  {
    "接口名称": "[InnerAudioContext.onPause](/minigame/dev/api/media/audio/InnerAudioContext.onPause)",
    "描述": "监听音频暂停事件"
  },
  {
    "接口名称": "[InnerAudioContext.onPlay](/minigame/dev/api/media/audio/InnerAudioContext.onPlay)",
    "描述": "监听音频播放事件"
  },
  {
    "接口名称": "[InnerAudioContext.onSeeked](/minigame/dev/api/media/audio/InnerAudioContext.onSeeked)",
    "描述": "监听音频完成跳转操作的事件"
  },
  {
    "接口名称": "[InnerAudioContext.onSeeking](/minigame/dev/api/media/audio/InnerAudioContext.onSeeking)",
    "描述": "监听音频进行跳转操作的事件"
  },
  {
    "接口名称": "[InnerAudioContext.onStop](/minigame/dev/api/media/audio/InnerAudioContext.onStop)",
    "描述": "监听音频停止事件"
  },
  {
    "接口名称": "[InnerAudioContext.onTimeUpdate](/minigame/dev/api/media/audio/InnerAudioContext.onTimeUpdate)",
    "描述": "监听音频播放进度更新事件"
  },
  {
    "接口名称": "[InnerAudioContext.onWaiting](/minigame/dev/api/media/audio/InnerAudioContext.onWaiting)",
    "描述": "监听音频加载中事件"
  },
  {
    "接口名称": "[InnerAudioContext.pause](/minigame/dev/api/media/audio/InnerAudioContext.pause)",
    "描述": "暂停"
  },
  {
    "接口名称": "[InnerAudioContext.play](/minigame/dev/api/media/audio/InnerAudioContext.play)",
    "描述": "播放"
  },
  {
    "接口名称": "[InnerAudioContext.seek](/minigame/dev/api/media/audio/InnerAudioContext.seek)",
    "描述": "跳转到指定位置"
  },
  {
    "接口名称": "[InnerAudioContext.stop](/minigame/dev/api/media/audio/InnerAudioContext.stop)",
    "描述": "停止"
  }
]
```

#### MediaAudioPlayer

```json
[
  {
    "接口名称": "[MediaAudioPlayer.addAudioSource](/minigame/dev/api/media/audio/MediaAudioPlayer.addAudioSource)",
    "描述": "添加音频源"
  },
  {
    "接口名称": "[MediaAudioPlayer.destroy](/minigame/dev/api/media/audio/MediaAudioPlayer.destroy)",
    "描述": "销毁播放器"
  },
  {
    "接口名称": "[MediaAudioPlayer.removeAudioSource](/minigame/dev/api/media/audio/MediaAudioPlayer.removeAudioSource)",
    "描述": "移除音频源"
  },
  {
    "接口名称": "[MediaAudioPlayer.start](/minigame/dev/api/media/audio/MediaAudioPlayer.start)",
    "描述": "启动播放器"
  },
  {
    "接口名称": "[MediaAudioPlayer.stop](/minigame/dev/api/media/audio/MediaAudioPlayer.stop)",
    "描述": "停止播放器"
  }
]
```

#### WebAudioContext

```json
[
  {
    "接口名称": "[WebAudioContext.close](/minigame/dev/api/media/audio/WebAudioContext.close)",
    "描述": "关闭WebAudioContext"
  },
  {
    "接口名称": "[WebAudioContext.createAnalyser](/minigame/dev/api/media/audio/WebAudioContext.createAnalyser)",
    "描述": "创建一个 AnalyserNode"
  },
  {
    "接口名称": "[WebAudioContext.createBiquadFilter](/minigame/dev/api/media/audio/WebAudioContext.createBiquadFilter)",
    "描述": "创建一个BiquadFilterNode"
  },
  {
    "接口名称": "[WebAudioContext.createBuffer](/minigame/dev/api/media/audio/WebAudioContext.createBuffer)",
    "描述": "创建一个AudioBuffer，代表着一段驻留在内存中的短音频"
  },
  {
    "接口名称": "[WebAudioContext.createBufferSource](/minigame/dev/api/media/audio/WebAudioContext.createBufferSource)",
    "描述": "创建一个BufferSourceNode实例，通过AudioBuffer对象来播放音频数据"
  },
  {
    "接口名称": "[WebAudioContext.createChannelMerger](/minigame/dev/api/media/audio/WebAudioContext.createChannelMerger)",
    "描述": "创建一个ChannelMergerNode"
  },
  {
    "接口名称": "[WebAudioContext.createChannelSplitter](/minigame/dev/api/media/audio/WebAudioContext.createChannelSplitter)",
    "描述": "创建一个ChannelSplitterNode"
  },
  {
    "接口名称": "[WebAudioContext.createConstantSource](/minigame/dev/api/media/audio/WebAudioContext.createConstantSource)",
    "描述": "创建一个ConstantSourceNode"
  },
  {
    "接口名称": "[WebAudioContext.createDelay](/minigame/dev/api/media/audio/WebAudioContext.createDelay)",
    "描述": "创建一个DelayNode"
  },
  {
    "接口名称": "[WebAudioContext.createDynamicsCompressor](/minigame/dev/api/media/audio/WebAudioContext.createDynamicsCompressor)",
    "描述": "创建一个DynamicsCompressorNode"
  },
  {
    "接口名称": "[WebAudioContext.createGain](/minigame/dev/api/media/audio/WebAudioContext.createGain)",
    "描述": "创建一个GainNode"
  },
  {
    "接口名称": "[WebAudioContext.createIIRFilter](/minigame/dev/api/media/audio/WebAudioContext.createIIRFilter)",
    "描述": "创建一个IIRFilterNode"
  },
  {
    "接口名称": "[WebAudioContext.createOscillator](/minigame/dev/api/media/audio/WebAudioContext.createOscillator)",
    "描述": "创建一个OscillatorNode"
  },
  {
    "接口名称": "[WebAudioContext.createPanner](/minigame/dev/api/media/audio/WebAudioContext.createPanner)",
    "描述": "创建一个PannerNode"
  },
  {
    "接口名称": "[WebAudioContext.createPeriodicWave](/minigame/dev/api/media/audio/WebAudioContext.createPeriodicWave)",
    "描述": "创建一个PeriodicWaveNode"
  },
  {
    "接口名称": "[WebAudioContext.createScriptProcessor](/minigame/dev/api/media/audio/WebAudioContext.createScriptProcessor)",
    "描述": "创建一个ScriptProcessorNode"
  },
  {
    "接口名称": "[WebAudioContext.createWaveShaper](/minigame/dev/api/media/audio/WebAudioContext.createWaveShaper)",
    "描述": "创建一个WaveShaperNode"
  },
  {
    "接口名称": "[WebAudioContext.decodeAudioData](/minigame/dev/api/media/audio/WebAudioContext.decodeAudioData)",
    "描述": "异步解码一段资源为AudioBuffer"
  },
  {
    "接口名称": "[WebAudioContext.resume](/minigame/dev/api/media/audio/WebAudioContext.resume)",
    "描述": "同步恢复已经被暂停的WebAudioContext上下文"
  },
  {
    "接口名称": "[WebAudioContext.suspend](/minigame/dev/api/media/audio/WebAudioContext.suspend)",
    "描述": "同步暂停WebAudioContext上下文"
  }
]
```

### 图片

```json
[
  {
    "接口名称": "[wx.saveImageToPhotosAlbum](/minigame/dev/api/media/image/wx.saveImageToPhotosAlbum)",
    "描述": "保存图片到系统相册"
  },
  {
    "接口名称": "[wx.previewMedia](/minigame/dev/api/media/image/wx.previewMedia)",
    "描述": "预览图片和视频"
  },
  {
    "接口名称": "[wx.previewImage](/minigame/dev/api/media/image/wx.previewImage)",
    "描述": "在新页面中全屏预览图片"
  },
  {
    "接口名称": "[wx.compressImage](/minigame/dev/api/media/image/wx.compressImage)",
    "描述": "压缩图片接口，可选压缩质量"
  },
  {
    "接口名称": "[wx.chooseMessageFile](/minigame/dev/api/media/image/wx.chooseMessageFile)",
    "描述": "从客户端会话选择文件"
  },
  {
    "接口名称": "[wx.chooseImage](/minigame/dev/api/media/image/wx.chooseImage)",
    "描述": "从本地相册选择图片或使用相机拍照"
  }
]
```

### 录音

```json
[
  {
    "接口名称": "[wx.getRecorderManager](/minigame/dev/api/media/recorder/wx.getRecorderManager)",
    "描述": "获取全局唯一的录音管理器 RecorderManager"
  }
]
```

#### RecorderManager

```json
[
  {
    "接口名称": "[RecorderManager.onError](/minigame/dev/api/media/recorder/RecorderManager.onError)",
    "描述": "监听录音错误事件"
  },
  {
    "接口名称": "[RecorderManager.onFrameRecorded](/minigame/dev/api/media/recorder/RecorderManager.onFrameRecorded)",
    "描述": "监听已录制完指定帧大小的文件事件"
  },
  {
    "接口名称": "[RecorderManager.onInterruptionBegin](/minigame/dev/api/media/recorder/RecorderManager.onInterruptionBegin)",
    "描述": "监听录音因为受到系统占用而被中断开始事件"
  },
  {
    "接口名称": "[RecorderManager.onInterruptionEnd](/minigame/dev/api/media/recorder/RecorderManager.onInterruptionEnd)",
    "描述": "监听录音中断结束事件"
  },
  {
    "接口名称": "[RecorderManager.onPause](/minigame/dev/api/media/recorder/RecorderManager.onPause)",
    "描述": "监听录音暂停事件"
  },
  {
    "接口名称": "[RecorderManager.onResume](/minigame/dev/api/media/recorder/RecorderManager.onResume)",
    "描述": "监听录音继续事件"
  },
  {
    "接口名称": "[RecorderManager.onStart](/minigame/dev/api/media/recorder/RecorderManager.onStart)",
    "描述": "监听录音开始事件"
  },
  {
    "接口名称": "[RecorderManager.onStop](/minigame/dev/api/media/recorder/RecorderManager.onStop)",
    "描述": "监听录音结束事件"
  },
  {
    "接口名称": "[RecorderManager.pause](/minigame/dev/api/media/recorder/RecorderManager.pause)",
    "描述": "暂停录音"
  },
  {
    "接口名称": "[RecorderManager.resume](/minigame/dev/api/media/recorder/RecorderManager.resume)",
    "描述": "继续录音"
  },
  {
    "接口名称": "[RecorderManager.start](/minigame/dev/api/media/recorder/RecorderManager.start)",
    "描述": "开始录音"
  },
  {
    "接口名称": "[RecorderManager.stop](/minigame/dev/api/media/recorder/RecorderManager.stop)",
    "描述": "停止录音"
  }
]
```

### 视频

```json
[
  {
    "接口名称": "[wx.createVideo](/minigame/dev/api/media/video/wx.createVideo)",
    "描述": "创建视频"
  },
  {
    "接口名称": "[wx.chooseMedia](/minigame/dev/api/media/video/wx.chooseMedia)",
    "描述": "拍摄或从手机相册中选择图片或视频"
  }
]
```

#### Video

```json
[
  {
    "接口名称": "[Video.destroy](/minigame/dev/api/media/video/Video.destroy)",
    "描述": "销毁视频"
  },
  {
    "接口名称": "[Video.exitFullScreen](/minigame/dev/api/media/video/Video.exitFullScreen)",
    "描述": "视频退出全屏"
  },
  {
    "接口名称": "[Video.offEnded](/minigame/dev/api/media/video/Video.offEnded)",
    "描述": "移除视频播放到末尾事件的监听函数"
  },
  {
    "接口名称": "[Video.offError](/minigame/dev/api/media/video/Video.offError)",
    "描述": "移除视频错误事件的监听函数"
  },
  {
    "接口名称": "[Video.offPause](/minigame/dev/api/media/video/Video.offPause)",
    "描述": "移除视频暂停事件的监听函数"
  },
  {
    "接口名称": "[Video.offPlay](/minigame/dev/api/media/video/Video.offPlay)",
    "描述": "移除视频播放事件的监听函数"
  },
  {
    "接口名称": "[Video.offProgress](/minigame/dev/api/media/video/Video.offProgress)",
    "描述": "移除视频下载（缓冲）事件的监听函数"
  },
  {
    "接口名称": "[Video.offTimeUpdate](/minigame/dev/api/media/video/Video.offTimeUpdate)",
    "描述": "移除视频播放进度更新事件的监听函数"
  },
  {
    "接口名称": "[Video.offWaiting](/minigame/dev/api/media/video/Video.offWaiting)",
    "描述": "移除视频由于需要缓冲下一帧而停止时触发的监听函数"
  },
  {
    "接口名称": "[Video.onEnded](/minigame/dev/api/media/video/Video.onEnded)",
    "描述": "监听视频播放到末尾事件"
  },
  {
    "接口名称": "[Video.onError](/minigame/dev/api/media/video/Video.onError)",
    "描述": "监听视频错误事件"
  },
  {
    "接口名称": "[Video.onPause](/minigame/dev/api/media/video/Video.onPause)",
    "描述": "监听视频暂停事件"
  },
  {
    "接口名称": "[Video.onPlay](/minigame/dev/api/media/video/Video.onPlay)",
    "描述": "监听视频播放事件"
  },
  {
    "接口名称": "[Video.onProgress](/minigame/dev/api/media/video/Video.onProgress)",
    "描述": "监听视频下载（缓冲）事件"
  },
  {
    "接口名称": "[Video.onTimeUpdate](/minigame/dev/api/media/video/Video.onTimeUpdate)",
    "描述": "监听视频播放进度更新事件"
  },
  {
    "接口名称": "[Video.onWaiting](/minigame/dev/api/media/video/Video.onWaiting)",
    "描述": "监听视频由于需要缓冲下一帧而停止时触发"
  },
  {
    "接口名称": "[Video.pause](/minigame/dev/api/media/video/Video.pause)",
    "描述": "暂停视频"
  },
  {
    "接口名称": "[Video.play](/minigame/dev/api/media/video/Video.play)",
    "描述": "播放视频"
  },
  {
    "接口名称": "[Video.requestFullScreen](/minigame/dev/api/media/video/Video.requestFullScreen)",
    "描述": "视频全屏"
  },
  {
    "接口名称": "[Video.seek](/minigame/dev/api/media/video/Video.seek)",
    "描述": "视频跳转"
  },
  {
    "接口名称": "[Video.stop](/minigame/dev/api/media/video/Video.stop)",
    "描述": "停止视频"
  }
]
```

### 相机

```json
[
  {
    "接口名称": "[wx.createCamera](/minigame/dev/api/media/camera/wx.createCamera)",
    "描述": "创建相机"
  }
]
```

#### Camera

```json
[
  {
    "接口名称": "[Camera.closeFrameChange](/minigame/dev/api/media/camera/Camera.closeFrameChange)",
    "描述": "关闭监听帧数据"
  },
  {
    "接口名称": "[Camera.destroy](/minigame/dev/api/media/camera/Camera.destroy)",
    "描述": "销毁相机"
  },
  {
    "接口名称": "[Camera.listenFrameChange](/minigame/dev/api/media/camera/Camera.listenFrameChange)",
    "描述": "开启监听帧数据"
  },
  {
    "接口名称": "[Camera.onAuthCancel](/minigame/dev/api/media/camera/Camera.onAuthCancel)",
    "描述": "监听用户不允许授权使用摄像头的情况"
  },
  {
    "接口名称": "[Camera.onCameraFrame](/minigame/dev/api/media/camera/Camera.onCameraFrame)",
    "描述": "监听摄像头实时帧数据"
  },
  {
    "接口名称": "[Camera.onStop](/minigame/dev/api/media/camera/Camera.onStop)",
    "描述": "监听摄像头非正常终止事件，如退出后台等情况"
  },
  {
    "接口名称": "[Camera.setZoom](/minigame/dev/api/media/camera/Camera.setZoom)",
    "描述": "设置缩放比例"
  },
  {
    "接口名称": "[Camera.startRecord](/minigame/dev/api/media/camera/Camera.startRecord)",
    "描述": "开始录像"
  },
  {
    "接口名称": "[Camera.stopRecord](/minigame/dev/api/media/camera/Camera.stopRecord)",
    "描述": "结束录像，成功则返回封面与视频"
  },
  {
    "接口名称": "[Camera.takePhoto](/minigame/dev/api/media/camera/Camera.takePhoto)",
    "描述": "拍照，可指定质量，成功则返回图片"
  }
]
```

### 视频解码器

```json
[
  {
    "接口名称": "[wx.createVideoDecoder](/minigame/dev/api/media/video-decoder/wx.createVideoDecoder)",
    "描述": "创建视频解码器，可逐帧获取解码后的数据"
  }
]
```

#### VideoDecoder

```json
[
  {
    "接口名称": "[VideoDecoder.getFrameData](/minigame/dev/api/media/video-decoder/VideoDecoder.getFrameData)",
    "描述": "获取下一帧的解码数据"
  },
  {
    "接口名称": "[VideoDecoder.off](/minigame/dev/api/media/video-decoder/VideoDecoder.off)",
    "描述": "取消监听录制事件"
  },
  {
    "接口名称": "[VideoDecoder.on](/minigame/dev/api/media/video-decoder/VideoDecoder.on)",
    "描述": "注册监听录制事件的回调函数"
  },
  {
    "接口名称": "[VideoDecoder.remove](/minigame/dev/api/media/video-decoder/VideoDecoder.remove)",
    "描述": "移除解码器"
  },
  {
    "接口名称": "[VideoDecoder.seek](/minigame/dev/api/media/video-decoder/VideoDecoder.seek)",
    "描述": "跳到某个时间点解码"
  },
  {
    "接口名称": "[VideoDecoder.start](/minigame/dev/api/media/video-decoder/VideoDecoder.start)",
    "描述": "开始解码"
  },
  {
    "接口名称": "[VideoDecoder.stop](/minigame/dev/api/media/video-decoder/VideoDecoder.stop)",
    "描述": "停止解码"
  }
]
```

### 实时语音

```json
[
  {
    "接口名称": "[wx.updateVoIPChatMuteConfig](/minigame/dev/api/media/voip/wx.updateVoIPChatMuteConfig)",
    "描述": "更新实时语音静音设置"
  },
  {
    "接口名称": "[wx.onVoIPChatStateChanged](/minigame/dev/api/media/voip/wx.onVoIPChatStateChanged)",
    "描述": "监听房间状态变化事件"
  },
  {
    "接口名称": "[wx.onVoIPChatSpeakersChanged](/minigame/dev/api/media/voip/wx.onVoIPChatSpeakersChanged)",
    "描述": "监听实时语音通话成员通话状态变化事件"
  },
  {
    "接口名称": "[wx.onVoIPChatMembersChanged](/minigame/dev/api/media/voip/wx.onVoIPChatMembersChanged)",
    "描述": "监听实时语音通话成员在线状态变化事件"
  },
  {
    "接口名称": "[wx.onVoIPChatInterrupted](/minigame/dev/api/media/voip/wx.onVoIPChatInterrupted)",
    "描述": "监听被动断开实时语音通话事件"
  },
  {
    "接口名称": "[wx.offVoIPChatStateChanged](/minigame/dev/api/media/voip/wx.offVoIPChatStateChanged)",
    "描述": "移除房间状态变化事件的监听函数"
  },
  {
    "接口名称": "[wx.offVoIPChatSpeakersChanged](/minigame/dev/api/media/voip/wx.offVoIPChatSpeakersChanged)",
    "描述": "移除实时语音通话成员通话状态变化事件的监听函数"
  },
  {
    "接口名称": "[wx.offVoIPChatMembersChanged](/minigame/dev/api/media/voip/wx.offVoIPChatMembersChanged)",
    "描述": "移除实时语音通话成员在线状态变化事件的监听函数"
  },
  {
    "接口名称": "[wx.offVoIPChatInterrupted](/minigame/dev/api/media/voip/wx.offVoIPChatInterrupted)",
    "描述": "移除被动断开实时语音通话事件的监听函数"
  },
  {
    "接口名称": "[wx.joinVoIPChat](/minigame/dev/api/media/voip/wx.joinVoIPChat)",
    "描述": "加入 (创建) 实时语音通话，更多信息可见 实时语音指南)"
  },
  {
    "接口名称": "[wx.exitVoIPChat](/minigame/dev/api/media/voip/wx.exitVoIPChat)",
    "描述": "退出（销毁）实时语音通话"
  }
]
```

## 位置

```json
[
  {
    "接口名称": "[wx.getLocation](/minigame/dev/api/location/wx.getLocation)",
    "描述": "获取当前的地理位置、速度"
  },
  {
    "接口名称": "[wx.getFuzzyLocation](/minigame/dev/api/location/wx.getFuzzyLocation)",
    "描述": "获取当前的模糊地理位置"
  }
]
```

## 文件

```json
[
  {
    "接口名称": "[wx.saveFileToDisk](/minigame/dev/api/file/wx.saveFileToDisk)",
    "描述": "保存文件系统的文件到用户磁盘，仅在 PC 端支持"
  },
  {
    "接口名称": "[wx.getFileSystemManager](/minigame/dev/api/file/wx.getFileSystemManager)",
    "描述": "获取全局唯一的文件管理器"
  },
  {
    "接口名称": "[FileStats](/minigame/dev/api/file/FileStats)",
    "描述": "每个 FileStats 对象包含 path 和 Stats"
  },
  {
    "接口名称": "[ReadResult](/minigame/dev/api/file/ReadResult)",
    "描述": "文件读取结果"
  },
  {
    "接口名称": "[WriteResult](/minigame/dev/api/file/WriteResult)",
    "描述": "文件写入结果"
  }
]
```

### FileSystemManager

```json
[
  {
    "接口名称": "[FileSystemManager.access](/minigame/dev/api/file/FileSystemManager.access)",
    "描述": "判断文件/目录是否存在"
  },
  {
    "接口名称": "[FileSystemManager.accessSync](/minigame/dev/api/file/FileSystemManager.accessSync)",
    "描述": "FileSystemManager.access) 的同步版本"
  },
  {
    "接口名称": "[FileSystemManager.appendFile](/minigame/dev/api/file/FileSystemManager.appendFile)",
    "描述": "在文件结尾追加内容"
  },
  {
    "接口名称": "[FileSystemManager.appendFileSync](/minigame/dev/api/file/FileSystemManager.appendFileSync)",
    "描述": "FileSystemManager.appendFile) 的同步版本"
  },
  {
    "接口名称": "[FileSystemManager.close](/minigame/dev/api/file/FileSystemManager.close)",
    "描述": "关闭文件"
  },
  {
    "接口名称": "[FileSystemManager.closeSync](/minigame/dev/api/file/FileSystemManager.closeSync)",
    "描述": "同步关闭文件"
  },
  {
    "接口名称": "[FileSystemManager.copyFile](/minigame/dev/api/file/FileSystemManager.copyFile)",
    "描述": "复制文件"
  },
  {
    "接口名称": "[FileSystemManager.copyFileSync](/minigame/dev/api/file/FileSystemManager.copyFileSync)",
    "描述": "FileSystemManager.copyFile) 的同步版本"
  },
  {
    "接口名称": "[FileSystemManager.fstat](/minigame/dev/api/file/FileSystemManager.fstat)",
    "描述": "获取文件的状态信息"
  },
  {
    "接口名称": "[FileSystemManager.fstatSync](/minigame/dev/api/file/FileSystemManager.fstatSync)",
    "描述": "同步获取文件的状态信息"
  },
  {
    "接口名称": "[FileSystemManager.ftruncate](/minigame/dev/api/file/FileSystemManager.ftruncate)",
    "描述": "对文件内容进行截断操作"
  },
  {
    "接口名称": "[FileSystemManager.ftruncateSync](/minigame/dev/api/file/FileSystemManager.ftruncateSync)",
    "描述": "对文件内容进行截断操作"
  },
  {
    "接口名称": "[FileSystemManager.getFileInfo](/minigame/dev/api/file/FileSystemManager.getFileInfo)",
    "描述": "获取该小程序下的 本地临时文件 或 本地缓存文件 信息"
  },
  {
    "接口名称": "[FileSystemManager.getSavedFileList](/minigame/dev/api/file/FileSystemManager.getSavedFileList)",
    "描述": "获取该小程序下已保存的本地缓存文件列表"
  },
  {
    "接口名称": "[FileSystemManager.mkdir](/minigame/dev/api/file/FileSystemManager.mkdir)",
    "描述": "创建目录"
  },
  {
    "接口名称": "[FileSystemManager.mkdirSync](/minigame/dev/api/file/FileSystemManager.mkdirSync)",
    "描述": "FileSystemManager.mkdir) 的同步版本"
  },
  {
    "接口名称": "[FileSystemManager.open](/minigame/dev/api/file/FileSystemManager.open)",
    "描述": "打开文件，返回文件描述符"
  },
  {
    "接口名称": "[FileSystemManager.openSync](/minigame/dev/api/file/FileSystemManager.openSync)",
    "描述": "同步打开文件，返回文件描述符"
  },
  {
    "接口名称": "[FileSystemManager.read](/minigame/dev/api/file/FileSystemManager.read)",
    "描述": "读文件"
  },
  {
    "接口名称": "[FileSystemManager.readCompressedFile](/minigame/dev/api/file/FileSystemManager.readCompressedFile)",
    "描述": "读取指定压缩类型的本地文件内容"
  },
  {
    "接口名称": "[FileSystemManager.readCompressedFileSync](/minigame/dev/api/file/FileSystemManager.readCompressedFileSync)",
    "描述": "同步读取指定压缩类型的本地文件内容"
  },
  {
    "接口名称": "[FileSystemManager.readdir](/minigame/dev/api/file/FileSystemManager.readdir)",
    "描述": "读取目录内文件列表"
  },
  {
    "接口名称": "[FileSystemManager.readdirSync](/minigame/dev/api/file/FileSystemManager.readdirSync)",
    "描述": "FileSystemManager.readdir) 的同步版本"
  },
  {
    "接口名称": "[FileSystemManager.readFile](/minigame/dev/api/file/FileSystemManager.readFile)",
    "描述": "读取本地文件内容"
  },
  {
    "接口名称": "[FileSystemManager.readFileSync](/minigame/dev/api/file/FileSystemManager.readFileSync)",
    "描述": "FileSystemManager.readFile) 的同步版本"
  },
  {
    "接口名称": "[FileSystemManager.readSync](/minigame/dev/api/file/FileSystemManager.readSync)",
    "描述": "读文件"
  },
  {
    "接口名称": "[FileSystemManager.readZipEntry](/minigame/dev/api/file/FileSystemManager.readZipEntry)",
    "描述": "读取压缩包内的文件"
  },
  {
    "接口名称": "[FileSystemManager.removeSavedFile](/minigame/dev/api/file/FileSystemManager.removeSavedFile)",
    "描述": "删除该小程序下已保存的本地缓存文件"
  },
  {
    "接口名称": "[FileSystemManager.rename](/minigame/dev/api/file/FileSystemManager.rename)",
    "描述": "重命名文件"
  },
  {
    "接口名称": "[FileSystemManager.renameSync](/minigame/dev/api/file/FileSystemManager.renameSync)",
    "描述": "FileSystemManager.rename) 的同步版本"
  },
  {
    "接口名称": "[FileSystemManager.rmdir](/minigame/dev/api/file/FileSystemManager.rmdir)",
    "描述": "删除目录"
  },
  {
    "接口名称": "[FileSystemManager.rmdirSync](/minigame/dev/api/file/FileSystemManager.rmdirSync)",
    "描述": "FileSystemManager.rmdir) 的同步版本"
  },
  {
    "接口名称": "[FileSystemManager.saveFile](/minigame/dev/api/file/FileSystemManager.saveFile)",
    "描述": "保存临时文件到本地"
  },
  {
    "接口名称": "[FileSystemManager.saveFileSync](/minigame/dev/api/file/FileSystemManager.saveFileSync)",
    "描述": "FileSystemManager.saveFile) 的同步版本"
  },
  {
    "接口名称": "[FileSystemManager.stat](/minigame/dev/api/file/FileSystemManager.stat)",
    "描述": "获取文件 Stats 对象"
  },
  {
    "接口名称": "[FileSystemManager.statSync](/minigame/dev/api/file/FileSystemManager.statSync)",
    "描述": "FileSystemManager.stat) 的同步版本"
  },
  {
    "接口名称": "[FileSystemManager.truncate](/minigame/dev/api/file/FileSystemManager.truncate)",
    "描述": "对文件内容进行截断操作"
  },
  {
    "接口名称": "[FileSystemManager.truncateSync](/minigame/dev/api/file/FileSystemManager.truncateSync)",
    "描述": "对文件内容进行截断操作 (truncate 的同步版本)"
  },
  {
    "接口名称": "[FileSystemManager.unlink](/minigame/dev/api/file/FileSystemManager.unlink)",
    "描述": "删除文件"
  },
  {
    "接口名称": "[FileSystemManager.unlinkSync](/minigame/dev/api/file/FileSystemManager.unlinkSync)",
    "描述": "FileSystemManager.unlink) 的同步版本"
  },
  {
    "接口名称": "[FileSystemManager.unzip](/minigame/dev/api/file/FileSystemManager.unzip)",
    "描述": "解压文件"
  },
  {
    "接口名称": "[FileSystemManager.write](/minigame/dev/api/file/FileSystemManager.write)",
    "描述": "写入文件"
  },
  {
    "接口名称": "[FileSystemManager.writeFile](/minigame/dev/api/file/FileSystemManager.writeFile)",
    "描述": "写文件"
  },
  {
    "接口名称": "[FileSystemManager.writeFileSync](/minigame/dev/api/file/FileSystemManager.writeFileSync)",
    "描述": "FileSystemManager.writeFile) 的同步版本"
  },
  {
    "接口名称": "[FileSystemManager.writeSync](/minigame/dev/api/file/FileSystemManager.writeSync)",
    "描述": "同步写入文件"
  }
]
```

### Stats

```json
[
  {
    "接口名称": "[Stats.isDirectory](/minigame/dev/api/file/Stats.isDirectory)",
    "描述": "判断当前文件是否一个目录"
  },
  {
    "接口名称": "[Stats.isFile](/minigame/dev/api/file/Stats.isFile)",
    "描述": "判断当前文件是否一个普通文件"
  }
]
```

## 开放接口

```json
[
  {
    "接口名称": "[防沉迷](/minigame/dev/api/open-api/anti-addiction)",
    "描述": "-"
  }
]
```

### 用户信息

```json
[
  {
    "接口名称": "[wx.getUserInfo](/minigame/dev/api/open-api/user-info/wx.getUserInfo)",
    "描述": "获取用户信息"
  },
  {
    "接口名称": "[wx.getPhoneNumber](/minigame/dev/api/open-api/user-info/wx.getPhoneNumber)",
    "描述": "手机号快速验证，向用户申请，并在用户同意后，快速填写和验证手机 具体说明"
  },
  {
    "接口名称": "[wx.createUserInfoButton](/minigame/dev/api/open-api/user-info/wx.createUserInfoButton)",
    "描述": "创建用户信息按钮"
  },
  {
    "接口名称": "[UserInfo](/minigame/dev/api/open-api/user-info/UserInfo)",
    "描述": "用户信息"
  }
]
```

#### UserInfoButton

```json
[
  {
    "接口名称": "[UserInfoButton.destroy](/minigame/dev/api/open-api/user-info/UserInfoButton.destroy)",
    "描述": "销毁用户信息按钮"
  },
  {
    "接口名称": "[UserInfoButton.hide](/minigame/dev/api/open-api/user-info/UserInfoButton.hide)",
    "描述": "隐藏用户信息按钮"
  },
  {
    "接口名称": "[UserInfoButton.offTap](/minigame/dev/api/open-api/user-info/UserInfoButton.offTap)",
    "描述": "移除用户信息按钮的点击事件的监听函数"
  },
  {
    "接口名称": "[UserInfoButton.onTap](/minigame/dev/api/open-api/user-info/UserInfoButton.onTap)",
    "描述": "监听用户信息按钮的点击事件"
  },
  {
    "接口名称": "[UserInfoButton.show](/minigame/dev/api/open-api/user-info/UserInfoButton.show)",
    "描述": "显示用户信息按钮"
  }
]
```

### 登录

```json
[
  {
    "接口名称": "[wx.login](/minigame/dev/api/open-api/login/wx.login)",
    "描述": "调用接口获取登录凭证（code）"
  },
  {
    "接口名称": "[wx.checkSession](/minigame/dev/api/open-api/login/wx.checkSession)",
    "描述": "检查登录态 session_key 是否过期"
  }
]
```

### 授权

```json
[
  {
    "接口名称": "[wx.authorize](/minigame/dev/api/open-api/authorize/wx.authorize)",
    "描述": "提前向用户发起授权请求"
  }
]
```

### 开放数据

```json
[
  {
    "接口名称": "[wx.shareMessageToFriend](/minigame/dev/api/open-api/data/wx.shareMessageToFriend)",
    "描述": "给指定的好友分享游戏信息，该接口只可在开放数据域下使用"
  },
  {
    "接口名称": "[wx.setUserCloudStorage](/minigame/dev/api/open-api/data/wx.setUserCloudStorage)",
    "描述": "对用户托管数据进行写数据操作"
  },
  {
    "接口名称": "[wx.sendGiftToFriend](/minigame/dev/api/open-api/data/wx.sendGiftToFriend)",
    "描述": "指定 openid 给他好友送礼，该接口只在开放数据域下可用"
  },
  {
    "接口名称": "[wx.removeUserCloudStorage](/minigame/dev/api/open-api/data/wx.removeUserCloudStorage)",
    "描述": "删除用户托管数据当中对应 key 的数据"
  },
  {
    "接口名称": "[wx.onInteractiveStorageModified](/minigame/dev/api/open-api/data/wx.onInteractiveStorageModified)",
    "描述": "监听成功修改好友的互动型托管数据事件，该接口在游戏主域使用"
  },
  {
    "接口名称": "[wx.offInteractiveStorageModified](/minigame/dev/api/open-api/data/wx.offInteractiveStorageModified)",
    "描述": "取消监听成功修改好友的互动型托管数据事件，该接口在游戏主域使用"
  },
  {
    "接口名称": "[wx.modifyFriendInteractiveStorage](/minigame/dev/api/open-api/data/wx.modifyFriendInteractiveStorage)",
    "描述": "修改好友的互动型托管数据，该接口只可在开放数据域下使用"
  },
  {
    "接口名称": "[wx.getUserInteractiveStorage](/minigame/dev/api/open-api/data/wx.getUserInteractiveStorage)",
    "描述": "获取当前用户互动型托管数据对应 key 的数据"
  },
  {
    "接口名称": "[wx.getUserCloudStorageKeys](/minigame/dev/api/open-api/data/wx.getUserCloudStorageKeys)",
    "描述": "获取当前用户托管数据当中所有的 key"
  },
  {
    "接口名称": "[wx.getUserCloudStorage](/minigame/dev/api/open-api/data/wx.getUserCloudStorage)",
    "描述": "获取当前用户托管数据当中对应 key 的数据"
  },
  {
    "接口名称": "[wx.getSharedCanvas](/minigame/dev/api/open-api/data/wx.getSharedCanvas)",
    "描述": "获取主域和开放数据域共享的 sharedCanvas"
  },
  {
    "接口名称": "[wx.getRelationFriendList](/minigame/dev/api/open-api/data/wx.getRelationFriendList)",
    "描述": "获取小游戏同玩互动好友列表"
  },
  {
    "接口名称": "[wx.getPotentialFriendList](/minigame/dev/api/open-api/data/wx.getPotentialFriendList)",
    "描述": "获取可能对游戏感兴趣的未注册的好友名单"
  },
  {
    "接口名称": "[wx.getGroupMembersInfo](/minigame/dev/api/open-api/data/wx.getGroupMembersInfo)",
    "描述": "获取所选群成员的头像、昵称，自行在开放数据域中渲染"
  },
  {
    "接口名称": "[wx.getGroupInfo](/minigame/dev/api/open-api/data/wx.getGroupInfo)",
    "描述": "获取群信息"
  },
  {
    "接口名称": "[wx.getGroupCloudStorage](/minigame/dev/api/open-api/data/wx.getGroupCloudStorage)",
    "描述": "获取群同玩成员的游戏数据"
  },
  {
    "接口名称": "[wx.getFriendSendGiftStatus](/minigame/dev/api/open-api/data/wx.getFriendSendGiftStatus)",
    "描述": "指定一批 openid 查询好友送礼状态，该接口只在开放数据域下可用"
  },
  {
    "接口名称": "[wx.getFriendCloudStorage](/minigame/dev/api/open-api/data/wx.getFriendCloudStorage)",
    "描述": "拉取当前用户所有同玩好友的托管数据"
  },
  {
    "接口名称": "[FriendInfo](/minigame/dev/api/open-api/data/FriendInfo)",
    "描述": "用户信息"
  },
  {
    "接口名称": "[FriendSendGiftStatus](/minigame/dev/api/open-api/data/FriendSendGiftStatus)",
    "描述": "用户送礼状态信息"
  },
  {
    "接口名称": "[KVData](/minigame/dev/api/open-api/data/KVData)",
    "描述": "托管的 KV 数据"
  },
  {
    "接口名称": "[OpenDataContextUserInfo](/minigame/dev/api/open-api/data/OpenDataContextUserInfo)",
    "描述": "用户信息"
  },
  {
    "接口名称": "[UserGameData](/minigame/dev/api/open-api/data/UserGameData)",
    "描述": "托管数据"
  },
  {
    "接口名称": "[OpenDataContext-wx.getUserInfo](/minigame/dev/api/open-api/data/OpenDataContext-wx.getUserInfo)",
    "描述": "批量获取用户信息，仅支持获取自己和好友的用户信息"
  }
]
```

### 开放数据域

```json
[
  {
    "接口名称": "[wx.onMessage](/minigame/dev/api/open-api/context/wx.onMessage)",
    "描述": "监听主域发送的消息"
  },
  {
    "接口名称": "[wx.getOpenDataContext](/minigame/dev/api/open-api/context/wx.getOpenDataContext)",
    "描述": "获取开放数据域"
  }
]
```

#### OpenDataContext

```json
[
  {
    "接口名称": "[OpenDataContext.postMessage](/minigame/dev/api/open-api/context/OpenDataContext.postMessage)",
    "描述": "向开放数据域发送消息"
  }
]
```

### 意见反馈

```json
[
  {
    "接口名称": "[wx.createFeedbackButton](/minigame/dev/api/open-api/feedback/wx.createFeedbackButton)",
    "描述": "创建打开意见反馈页面的按钮"
  }
]
```

#### FeedbackButton

```json
[
  {
    "接口名称": "[FeedbackButton.destroy](/minigame/dev/api/open-api/feedback/FeedbackButton.destroy)",
    "描述": "销毁意见反馈按钮"
  },
  {
    "接口名称": "[FeedbackButton.hide](/minigame/dev/api/open-api/feedback/FeedbackButton.hide)",
    "描述": "隐藏意见反馈按钮"
  },
  {
    "接口名称": "[FeedbackButton.offTap](/minigame/dev/api/open-api/feedback/FeedbackButton.offTap)",
    "描述": "移除意见反馈按钮的点击事件的监听函数"
  },
  {
    "接口名称": "[FeedbackButton.onTap](/minigame/dev/api/open-api/feedback/FeedbackButton.onTap)",
    "描述": "监听意见反馈按钮的点击事件"
  },
  {
    "接口名称": "[FeedbackButton.show](/minigame/dev/api/open-api/feedback/FeedbackButton.show)",
    "描述": "显示意见反馈按钮"
  }
]
```

### 设置

```json
[
  {
    "接口名称": "[wx.openSetting](/minigame/dev/api/open-api/setting/wx.openSetting)",
    "描述": "调起客户端小程序设置界面，返回用户设置的操作结果"
  },
  {
    "接口名称": "[wx.getSetting](/minigame/dev/api/open-api/setting/wx.getSetting)",
    "描述": "获取用户的当前设置"
  },
  {
    "接口名称": "[wx.createOpenSettingButton](/minigame/dev/api/open-api/setting/wx.createOpenSettingButton)",
    "描述": "创建打开设置页面的按钮"
  },
  {
    "接口名称": "[AuthSetting](/minigame/dev/api/open-api/setting/AuthSetting)",
    "描述": "用户授权设置信息，详情参考权限)"
  },
  {
    "接口名称": "[SubscriptionsSetting](/minigame/dev/api/open-api/setting/SubscriptionsSetting)",
    "描述": "订阅消息设置"
  }
]
```

#### OpenSettingButton

```json
[
  {
    "接口名称": "[OpenSettingButton.destroy](/minigame/dev/api/open-api/setting/OpenSettingButton.destroy)",
    "描述": "销毁打开设置页面按钮"
  },
  {
    "接口名称": "[OpenSettingButton.hide](/minigame/dev/api/open-api/setting/OpenSettingButton.hide)",
    "描述": "隐藏打开设置页面按钮"
  },
  {
    "接口名称": "[OpenSettingButton.offTap](/minigame/dev/api/open-api/setting/OpenSettingButton.offTap)",
    "描述": "移除设置页面按钮的点击事件的监听函数"
  },
  {
    "接口名称": "[OpenSettingButton.onTap](/minigame/dev/api/open-api/setting/OpenSettingButton.onTap)",
    "描述": "监听设置页面按钮的点击事件"
  },
  {
    "接口名称": "[OpenSettingButton.show](/minigame/dev/api/open-api/setting/OpenSettingButton.show)",
    "描述": "显示打开设置页面按钮"
  }
]
```

### 游戏圈

```json
[
  {
    "接口名称": "[wx.getGameClubData](/minigame/dev/api/open-api/game-club/wx.getGameClubData)",
    "描述": "获取游戏圈数据"
  },
  {
    "接口名称": "[wx.createGameClubButton](/minigame/dev/api/open-api/game-club/wx.createGameClubButton)",
    "描述": "创建游戏圈按钮"
  }
]
```

#### GameClubButton

```json
[
  {
    "接口名称": "[GameClubButton.destroy](/minigame/dev/api/open-api/game-club/GameClubButton.destroy)",
    "描述": "销毁游戏圈按钮"
  },
  {
    "接口名称": "[GameClubButton.hide](/minigame/dev/api/open-api/game-club/GameClubButton.hide)",
    "描述": "隐藏游戏圈按钮"
  },
  {
    "接口名称": "[GameClubButton.offTap](/minigame/dev/api/open-api/game-club/GameClubButton.offTap)",
    "描述": "移除游戏圈按钮的点击事件的监听函数"
  },
  {
    "接口名称": "[GameClubButton.onTap](/minigame/dev/api/open-api/game-club/GameClubButton.onTap)",
    "描述": "监听游戏圈按钮的点击事件"
  },
  {
    "接口名称": "[GameClubButton.show](/minigame/dev/api/open-api/game-club/GameClubButton.show)",
    "描述": "显示游戏圈按钮"
  }
]
```

### 客服消息

```json
[
  {
    "接口名称": "[wx.openCustomerServiceConversation](/minigame/dev/api/open-api/customer-message/wx.openCustomerServiceConversation)",
    "描述": "进入客服会话"
  }
]
```

### 微信运动

```json
[
  {
    "接口名称": "[wx.getWeRunData](/minigame/dev/api/open-api/werun/wx.getWeRunData)",
    "描述": "获取用户过去三十一天微信运动步数"
  }
]
```

### OPENLINK

```json
[
  {
    "接口名称": "[wx.createPageManager](/minigame/dev/api/open-api/openlink/wx.createPageManager)",
    "描述": "小游戏开放页面管理器，用于启动微信内置的各种小游戏活动、功能页面"
  }
]
```

#### PageManager

```json
[
  {
    "接口名称": "[PageManager.destroy](/minigame/dev/api/open-api/openlink/PageManager.destroy)",
    "描述": "销毁开放页面实例"
  },
  {
    "接口名称": "[PageManager.load](/minigame/dev/api/open-api/openlink/PageManager.load)",
    "描述": "提供OPENLINK加载活动、功能信息"
  },
  {
    "接口名称": "[PageManager.off](/minigame/dev/api/open-api/openlink/PageManager.off)",
    "描述": "取消监听来自活动、功能向开发者产生的某些事件"
  },
  {
    "接口名称": "[PageManager.on](/minigame/dev/api/open-api/openlink/PageManager.on)",
    "描述": "监听来自活动、功能向开发者产生的某些事件"
  },
  {
    "接口名称": "[PageManager.show](/minigame/dev/api/open-api/openlink/PageManager.show)",
    "描述": "显示已经成功加载信息的开放页面活动、功能"
  }
]
```

### 平台组件

```json
[
  {
    "接口名称": "[wx.getRankManager](/minigame/dev/api/open-api/game-component/wx.getRankManager)",
    "描述": "初始化并返回一个擂台赛管理器实例，用于管理游戏得分存取、得分排行榜（开发中）以及擂台赛功能"
  }
]
```

#### RankManager

```json
[
  {
    "接口名称": "[RankManager.abort](/minigame/dev/api/open-api/game-component/RankManager.abort)",
    "描述": "中途退出擂台赛"
  },
  {
    "接口名称": "[RankManager.createChallenge](/minigame/dev/api/open-api/game-component/RankManager.createChallenge)",
    "描述": "创建擂台赛，唤起擂台赛起始页"
  },
  {
    "接口名称": "[RankManager.getScore](/minigame/dev/api/open-api/game-component/RankManager.getScore)",
    "描述": "查询当前用户得分数据"
  },
  {
    "接口名称": "[RankManager.middleUpdate](/minigame/dev/api/open-api/game-component/RankManager.middleUpdate)",
    "描述": "游戏中途更新分数信息，用于在游戏进行过程中实时上报分数"
  },
  {
    "接口名称": "[RankManager.offChallengeStart](/minigame/dev/api/open-api/game-component/RankManager.offChallengeStart)",
    "描述": "取消监听擂台赛开始事件"
  },
  {
    "接口名称": "[RankManager.onChallengeStart](/minigame/dev/api/open-api/game-component/RankManager.onChallengeStart)",
    "描述": "监听擂台赛开始事件"
  },
  {
    "接口名称": "[RankManager.update](/minigame/dev/api/open-api/game-component/RankManager.update)",
    "描述": "上报用户分数信息"
  }
]
```

### 微信小店

```json
[
  {
    "接口名称": "[wx.createStoreGift](/minigame/dev/api/open-api/store-gift/wx.createStoreGift)",
    "描述": "创建蓝包组件"
  }
]
```

#### StoreGift

```json
[
  {
    "接口名称": "[StoreGift.getOrderInfo](/minigame/dev/api/open-api/store-gift/StoreGift.getOrderInfo)",
    "描述": "查询订单状态"
  },
  {
    "接口名称": "[StoreGift.isSupported](/minigame/dev/api/open-api/store-gift/StoreGift.isSupported)",
    "描述": "获取当前环境是否支持礼物组件"
  },
  {
    "接口名称": "[StoreGift.open](/minigame/dev/api/open-api/store-gift/StoreGift.open)",
    "描述": "打开礼物，请注意，这里的回调仅仅是打开礼物界面的回调，并不是收下礼物的回调"
  }
]
```

### 卡券

```json
[
  {
    "接口名称": "[wx.openCard](/minigame/dev/api/open-api/card/wx.openCard)",
    "描述": "查看微信卡包中的卡券"
  },
  {
    "接口名称": "[wx.addCard](/minigame/dev/api/open-api/card/wx.addCard)",
    "描述": "批量添加卡券"
  }
]
```

### 我的小程序

```json
[
  {
    "接口名称": "[wx.checkIsAddedToMyMiniProgram](/minigame/dev/api/open-api/my-miniprogram/wx.checkIsAddedToMyMiniProgram)",
    "描述": "检查小程序是否被添加至 「我的小程序」"
  }
]
```

### 人脸检测

```json
[
  {
    "接口名称": "[wx.requestFacialVerify](/minigame/dev/api/open-api/face/wx.requestFacialVerify)",
    "描述": "对用户实名信息进行基于生物识别的人脸核身验证"
  },
  {
    "接口名称": "[wx.checkIsSupportFacialRecognition](/minigame/dev/api/open-api/face/wx.checkIsSupportFacialRecognition)",
    "描述": "检查当前设备是否支持人脸识别能力"
  }
]
```

### 账号信息

```json
[
  {
    "接口名称": "[wx.requestFacialRecognition](/minigame/dev/api/open-api/account-info/wx.requestFacialRecognition)",
    "描述": "腾讯游戏人脸识别验证功能是基于健康系统防沉迷体系，用于识别疑似未成年人冒用成年人账号游玩游戏的行为，是防止未成年人沉迷网络游戏的一项重要措施"
  },
  {
    "接口名称": "[wx.getAccountInfoSync](/minigame/dev/api/open-api/account-info/wx.getAccountInfoSync)",
    "描述": "获取当前账号信息"
  }
]
```

### 视频号

```json
[
  {
    "接口名称": "[wx.reserveChannelsLive](/minigame/dev/api/open-api/channels/wx.reserveChannelsLive)",
    "描述": "预约视频号直播"
  },
  {
    "接口名称": "[wx.openChannelsUserProfile](/minigame/dev/api/open-api/channels/wx.openChannelsUserProfile)",
    "描述": "打开视频号主页"
  },
  {
    "接口名称": "[wx.openChannelsLive](/minigame/dev/api/open-api/channels/wx.openChannelsLive)",
    "描述": "打开视频号直播"
  },
  {
    "接口名称": "[wx.openChannelsEvent](/minigame/dev/api/open-api/channels/wx.openChannelsEvent)",
    "描述": "打开视频号活动页"
  },
  {
    "接口名称": "[wx.openChannelsActivity](/minigame/dev/api/open-api/channels/wx.openChannelsActivity)",
    "描述": "打开视频号视频"
  },
  {
    "接口名称": "[wx.getChannelsLiveNoticeInfo](/minigame/dev/api/open-api/channels/wx.getChannelsLiveNoticeInfo)",
    "描述": "获取视频号直播预告信息"
  },
  {
    "接口名称": "[wx.getChannelsLiveInfo](/minigame/dev/api/open-api/channels/wx.getChannelsLiveInfo)",
    "描述": "获取视频号直播信息"
  }
]
```

### 微信群

```json
[
  {
    "接口名称": "[wx.getGroupEnterInfo](/minigame/dev/api/open-api/group/wx.getGroupEnterInfo)",
    "描述": "获取微信群聊场景下的小程序启动信息"
  }
]
```

### 隐私信息授权

```json
[
  {
    "接口名称": "[wx.requirePrivacyAuthorize](/minigame/dev/api/open-api/privacy/wx.requirePrivacyAuthorize)",
    "描述": "模拟隐私接口调用，并触发隐私弹窗逻辑"
  },
  {
    "接口名称": "[wx.openPrivacyContract](/minigame/dev/api/open-api/privacy/wx.openPrivacyContract)",
    "描述": "跳转至隐私协议页面"
  },
  {
    "接口名称": "[wx.onNeedPrivacyAuthorization](/minigame/dev/api/open-api/privacy/wx.onNeedPrivacyAuthorization)",
    "描述": "监听隐私接口需要用户授权事件"
  },
  {
    "接口名称": "[wx.getPrivacySetting](/minigame/dev/api/open-api/privacy/wx.getPrivacySetting)",
    "描述": "查询隐私授权情况"
  }
]
```

### 微信客服

```json
[
  {
    "接口名称": "[wx.openCustomerServiceChat](/minigame/dev/api/open-api/service-chat/wx.openCustomerServiceChat)",
    "描述": "打开微信客服，页面产生点击事件后才可调用"
  }
]
```

### 订阅消息

```json
[
  {
    "接口名称": "[wx.requestSubscribeSystemMessage](/minigame/dev/api/open-api/subscribe-message/wx.requestSubscribeSystemMessage)",
    "描述": "调起小游戏系统订阅消息界面，返回用户订阅消息的操作结果"
  },
  {
    "接口名称": "[wx.requestSubscribeMessage](/minigame/dev/api/open-api/subscribe-message/wx.requestSubscribeMessage)",
    "描述": "调起客户端小游戏订阅消息界面，返回用户订阅消息的操作结果"
  }
]
```

## 设备

### 键盘

```json
[
  {
    "接口名称": "[wx.updateKeyboard](/minigame/dev/api/device/keyboard/wx.updateKeyboard)",
    "描述": "更新键盘输入框内容"
  },
  {
    "接口名称": "[wx.showKeyboard](/minigame/dev/api/device/keyboard/wx.showKeyboard)",
    "描述": "显示键盘"
  },
  {
    "接口名称": "[wx.onKeyUp](/minigame/dev/api/device/keyboard/wx.onKeyUp)",
    "描述": "监听键盘按键弹起事件，仅适用于 PC 平台"
  },
  {
    "接口名称": "[wx.onKeyDown](/minigame/dev/api/device/keyboard/wx.onKeyDown)",
    "描述": "监听键盘按键按下事件，仅适用于 PC 平台"
  },
  {
    "接口名称": "[wx.onKeyboardInput](/minigame/dev/api/device/keyboard/wx.onKeyboardInput)",
    "描述": "监听键盘输入事件"
  },
  {
    "接口名称": "[wx.onKeyboardHeightChange](/minigame/dev/api/device/keyboard/wx.onKeyboardHeightChange)",
    "描述": "监听键盘高度变化事件"
  },
  {
    "接口名称": "[wx.onKeyboardConfirm](/minigame/dev/api/device/keyboard/wx.onKeyboardConfirm)",
    "描述": "监听用户点击键盘 Confirm 按钮时的事件"
  },
  {
    "接口名称": "[wx.onKeyboardComplete](/minigame/dev/api/device/keyboard/wx.onKeyboardComplete)",
    "描述": "监听键盘收起的事件"
  },
  {
    "接口名称": "[wx.offKeyUp](/minigame/dev/api/device/keyboard/wx.offKeyUp)",
    "描述": "移除键盘按键弹起事件的监听函数"
  },
  {
    "接口名称": "[wx.offKeyDown](/minigame/dev/api/device/keyboard/wx.offKeyDown)",
    "描述": "移除键盘按键按下事件的监听函数"
  },
  {
    "接口名称": "[wx.offKeyboardInput](/minigame/dev/api/device/keyboard/wx.offKeyboardInput)",
    "描述": "移除键盘输入事件的监听函数"
  },
  {
    "接口名称": "[wx.offKeyboardHeightChange](/minigame/dev/api/device/keyboard/wx.offKeyboardHeightChange)",
    "描述": "移除键盘高度变化事件的监听函数"
  },
  {
    "接口名称": "[wx.offKeyboardConfirm](/minigame/dev/api/device/keyboard/wx.offKeyboardConfirm)",
    "描述": "移除用户点击键盘 Confirm 按钮时的事件的监听函数"
  },
  {
    "接口名称": "[wx.offKeyboardComplete](/minigame/dev/api/device/keyboard/wx.offKeyboardComplete)",
    "描述": "移除键盘收起的事件的监听函数"
  },
  {
    "接口名称": "[wx.hideKeyboard](/minigame/dev/api/device/keyboard/wx.hideKeyboard)",
    "描述": "隐藏键盘"
  }
]
```

### 触摸

```json
[
  {
    "接口名称": "[wx.onTouchStart](/minigame/dev/api/device/touch-event/wx.onTouchStart)",
    "描述": "监听开始触摸事件"
  },
  {
    "接口名称": "[wx.onTouchMove](/minigame/dev/api/device/touch-event/wx.onTouchMove)",
    "描述": "监听触点移动事件"
  },
  {
    "接口名称": "[wx.onTouchEnd](/minigame/dev/api/device/touch-event/wx.onTouchEnd)",
    "描述": "监听触摸结束事件"
  },
  {
    "接口名称": "[wx.onTouchCancel](/minigame/dev/api/device/touch-event/wx.onTouchCancel)",
    "描述": "监听触点失效事件"
  },
  {
    "接口名称": "[wx.offTouchStart](/minigame/dev/api/device/touch-event/wx.offTouchStart)",
    "描述": "移除开始触摸事件的监听函数"
  },
  {
    "接口名称": "[wx.offTouchMove](/minigame/dev/api/device/touch-event/wx.offTouchMove)",
    "描述": "移除触点移动事件的监听函数"
  },
  {
    "接口名称": "[wx.offTouchEnd](/minigame/dev/api/device/touch-event/wx.offTouchEnd)",
    "描述": "移除触摸结束事件的监听函数"
  },
  {
    "接口名称": "[wx.offTouchCancel](/minigame/dev/api/device/touch-event/wx.offTouchCancel)",
    "描述": "移除触点失效事件的监听函数"
  },
  {
    "接口名称": "[Touch](/minigame/dev/api/device/touch-event/Touch)",
    "描述": "在触控设备上的触摸点"
  }
]
```

### 鼠标

```json
[
  {
    "接口名称": "[wx.onMouseUp](/minigame/dev/api/device/mouse-event/wx.onMouseUp)",
    "描述": "监听鼠标按键弹起事件"
  },
  {
    "接口名称": "[wx.onMouseMove](/minigame/dev/api/device/mouse-event/wx.onMouseMove)",
    "描述": "监听鼠标移动事件"
  },
  {
    "接口名称": "[wx.onMouseDown](/minigame/dev/api/device/mouse-event/wx.onMouseDown)",
    "描述": "监听鼠标按键按下事件"
  },
  {
    "接口名称": "[wx.offMouseUp](/minigame/dev/api/device/mouse-event/wx.offMouseUp)",
    "描述": "移除鼠标按键弹起事件的监听函数"
  },
  {
    "接口名称": "[wx.offMouseMove](/minigame/dev/api/device/mouse-event/wx.offMouseMove)",
    "描述": "移除鼠标移动事件的监听函数"
  },
  {
    "接口名称": "[wx.offMouseDown](/minigame/dev/api/device/mouse-event/wx.offMouseDown)",
    "描述": "移除鼠标按键按下事件的监听函数"
  }
]
```

### 滚轮

```json
[
  {
    "接口名称": "[wx.onWheel](/minigame/dev/api/device/wheel-event/wx.onWheel)",
    "描述": "监听鼠标滚轮事件"
  },
  {
    "接口名称": "[wx.offWheel](/minigame/dev/api/device/wheel-event/wx.offWheel)",
    "描述": "移除鼠标滚轮事件的监听函数"
  }
]
```

### 蓝牙-信标(Beacon)

```json
[
  {
    "接口名称": "[wx.stopBeaconDiscovery](/minigame/dev/api/device/ibeacon/wx.stopBeaconDiscovery)",
    "描述": "停止搜索附近的 Beacon 设备"
  },
  {
    "接口名称": "[wx.startBeaconDiscovery](/minigame/dev/api/device/ibeacon/wx.startBeaconDiscovery)",
    "描述": "开始搜索附近的 Beacon 设备"
  },
  {
    "接口名称": "[wx.onBeaconUpdate](/minigame/dev/api/device/ibeacon/wx.onBeaconUpdate)",
    "描述": "监听 Beacon 设备更新事件，仅能注册一个监听"
  },
  {
    "接口名称": "[wx.onBeaconServiceChange](/minigame/dev/api/device/ibeacon/wx.onBeaconServiceChange)",
    "描述": "监听 Beacon 服务状态变化事件，仅能注册一个监听"
  },
  {
    "接口名称": "[wx.offBeaconUpdate](/minigame/dev/api/device/ibeacon/wx.offBeaconUpdate)",
    "描述": "移除 Beacon 设备更新事件的全部监听函数"
  },
  {
    "接口名称": "[wx.offBeaconServiceChange](/minigame/dev/api/device/ibeacon/wx.offBeaconServiceChange)",
    "描述": "移除 Beacon 服务状态变化事件的全部监听函数"
  },
  {
    "接口名称": "[wx.getBeacons](/minigame/dev/api/device/ibeacon/wx.getBeacons)",
    "描述": "获取所有已搜索到的 Beacon 设备"
  },
  {
    "接口名称": "[BeaconInfo](/minigame/dev/api/device/ibeacon/BeaconInfo)",
    "描述": "Beacon 设备"
  }
]
```

### 蓝牙-低功耗外围设备

```json
[
  {
    "接口名称": "[wx.onBLEPeripheralConnectionStateChanged](/minigame/dev/api/device/bluetooth-peripheral/wx.onBLEPeripheralConnectionStateChanged)",
    "描述": "监听当前外围设备被连接或断开连接事件"
  },
  {
    "接口名称": "[wx.offBLEPeripheralConnectionStateChanged](/minigame/dev/api/device/bluetooth-peripheral/wx.offBLEPeripheralConnectionStateChanged)",
    "描述": "移除当前外围设备被连接或断开连接事件的监听函数"
  },
  {
    "接口名称": "[wx.createBLEPeripheralServer](/minigame/dev/api/device/bluetooth-peripheral/wx.createBLEPeripheralServer)",
    "描述": "建立本地作为蓝牙低功耗外围设备的服务端，可创建多个"
  }
]
```

#### BLEPeripheralServer

```json
[
  {
    "接口名称": "[BLEPeripheralServer.addService](/minigame/dev/api/device/bluetooth-peripheral/BLEPeripheralServer.addService)",
    "描述": "添加服务"
  },
  {
    "接口名称": "[BLEPeripheralServer.offCharacteristicReadRequest](/minigame/dev/api/device/bluetooth-peripheral/BLEPeripheralServer.offCharacteristicReadRequest)",
    "描述": "移除已连接的设备请求读当前外围设备的特征值事件的监听函数"
  },
  {
    "接口名称": "[BLEPeripheralServer.offCharacteristicSubscribed](/minigame/dev/api/device/bluetooth-peripheral/BLEPeripheralServer.offCharacteristicSubscribed)",
    "描述": "移除特征订阅事件的监听函数"
  },
  {
    "接口名称": "[BLEPeripheralServer.offCharacteristicUnsubscribed](/minigame/dev/api/device/bluetooth-peripheral/BLEPeripheralServer.offCharacteristicUnsubscribed)",
    "描述": "移除取消特征订阅事件的监听函数"
  },
  {
    "接口名称": "[BLEPeripheralServer.offCharacteristicWriteRequest](/minigame/dev/api/device/bluetooth-peripheral/BLEPeripheralServer.offCharacteristicWriteRequest)",
    "描述": "移除已连接的设备请求写当前外围设备的特征值事件的监听函数"
  },
  {
    "接口名称": "[BLEPeripheralServer.onCharacteristicReadRequest](/minigame/dev/api/device/bluetooth-peripheral/BLEPeripheralServer.onCharacteristicReadRequest)",
    "描述": "监听已连接的设备请求读当前外围设备的特征值事件"
  },
  {
    "接口名称": "[BLEPeripheralServer.onCharacteristicSubscribed](/minigame/dev/api/device/bluetooth-peripheral/BLEPeripheralServer.onCharacteristicSubscribed)",
    "描述": "监听特征订阅事件，仅 iOS 支持"
  },
  {
    "接口名称": "[BLEPeripheralServer.onCharacteristicUnsubscribed](/minigame/dev/api/device/bluetooth-peripheral/BLEPeripheralServer.onCharacteristicUnsubscribed)",
    "描述": "监听取消特征订阅事件，仅 iOS 支持"
  },
  {
    "接口名称": "[BLEPeripheralServer.onCharacteristicWriteRequest](/minigame/dev/api/device/bluetooth-peripheral/BLEPeripheralServer.onCharacteristicWriteRequest)",
    "描述": "监听已连接的设备请求写当前外围设备的特征值事件"
  },
  {
    "接口名称": "[BLEPeripheralServer.removeService](/minigame/dev/api/device/bluetooth-peripheral/BLEPeripheralServer.removeService)",
    "描述": "移除服务"
  },
  {
    "接口名称": "[BLEPeripheralServer.startAdvertising](/minigame/dev/api/device/bluetooth-peripheral/BLEPeripheralServer.startAdvertising)",
    "描述": "开始广播本地创建的外围设备"
  },
  {
    "接口名称": "[BLEPeripheralServer.stopAdvertising](/minigame/dev/api/device/bluetooth-peripheral/BLEPeripheralServer.stopAdvertising)",
    "描述": "停止广播"
  },
  {
    "接口名称": "[BLEPeripheralServer.writeCharacteristicValue](/minigame/dev/api/device/bluetooth-peripheral/BLEPeripheralServer.writeCharacteristicValue)",
    "描述": "往指定特征写入二进制数据值，并通知已连接的主机，从机的特征值已发生变化，该接口会处理是走回包还是走订阅"
  }
]
```

### 蓝牙-低功耗中心设备

```json
[
  {
    "接口名称": "[wx.writeBLECharacteristicValue](/minigame/dev/api/device/bluetooth-ble/wx.writeBLECharacteristicValue)",
    "描述": "向蓝牙低功耗设备特征值中写入二进制数据"
  },
  {
    "接口名称": "[wx.setBLEMTU](/minigame/dev/api/device/bluetooth-ble/wx.setBLEMTU)",
    "描述": "协商设置蓝牙低功耗的最大传输单元 (Maximum Transmission Unit, MTU)"
  },
  {
    "接口名称": "[wx.readBLECharacteristicValue](/minigame/dev/api/device/bluetooth-ble/wx.readBLECharacteristicValue)",
    "描述": "读取蓝牙低功耗设备特征值的二进制数据"
  },
  {
    "接口名称": "[wx.onBLEMTUChange](/minigame/dev/api/device/bluetooth-ble/wx.onBLEMTUChange)",
    "描述": "监听蓝牙低功耗的最大传输单元变化事件（仅安卓触发）"
  },
  {
    "接口名称": "[wx.onBLEConnectionStateChange](/minigame/dev/api/device/bluetooth-ble/wx.onBLEConnectionStateChange)",
    "描述": "监听蓝牙低功耗连接状态改变事件"
  },
  {
    "接口名称": "[wx.onBLECharacteristicValueChange](/minigame/dev/api/device/bluetooth-ble/wx.onBLECharacteristicValueChange)",
    "描述": "监听蓝牙低功耗设备的特征值变化事件"
  },
  {
    "接口名称": "[wx.offBLEMTUChange](/minigame/dev/api/device/bluetooth-ble/wx.offBLEMTUChange)",
    "描述": "移除蓝牙低功耗的最大传输单元变化事件的监听函数"
  },
  {
    "接口名称": "[wx.offBLEConnectionStateChange](/minigame/dev/api/device/bluetooth-ble/wx.offBLEConnectionStateChange)",
    "描述": "移除蓝牙低功耗连接状态改变事件的监听函数"
  },
  {
    "接口名称": "[wx.offBLECharacteristicValueChange](/minigame/dev/api/device/bluetooth-ble/wx.offBLECharacteristicValueChange)",
    "描述": "移除蓝牙低功耗设备的特征值变化事件的全部监听函数"
  },
  {
    "接口名称": "[wx.notifyBLECharacteristicValueChange](/minigame/dev/api/device/bluetooth-ble/wx.notifyBLECharacteristicValueChange)",
    "描述": "启用蓝牙低功耗设备特征值变化时的 notify 功能，订阅特征"
  },
  {
    "接口名称": "[wx.getBLEMTU](/minigame/dev/api/device/bluetooth-ble/wx.getBLEMTU)",
    "描述": "获取蓝牙低功耗的最大传输单元"
  },
  {
    "接口名称": "[wx.getBLEDeviceServices](/minigame/dev/api/device/bluetooth-ble/wx.getBLEDeviceServices)",
    "描述": "获取蓝牙低功耗设备所有服务 (service)"
  },
  {
    "接口名称": "[wx.getBLEDeviceRSSI](/minigame/dev/api/device/bluetooth-ble/wx.getBLEDeviceRSSI)",
    "描述": "获取蓝牙低功耗设备的信号强度 (Received Signal Strength Indication, RSSI)"
  },
  {
    "接口名称": "[wx.getBLEDeviceCharacteristics](/minigame/dev/api/device/bluetooth-ble/wx.getBLEDeviceCharacteristics)",
    "描述": "获取蓝牙低功耗设备某个服务中所有特征 (characteristic)"
  },
  {
    "接口名称": "[wx.createBLEConnection](/minigame/dev/api/device/bluetooth-ble/wx.createBLEConnection)",
    "描述": "连接蓝牙低功耗设备"
  },
  {
    "接口名称": "[wx.closeBLEConnection](/minigame/dev/api/device/bluetooth-ble/wx.closeBLEConnection)",
    "描述": "断开与蓝牙低功耗设备的连接"
  }
]
```

### 蓝牙-通用

```json
[
  {
    "接口名称": "[wx.stopBluetoothDevicesDiscovery](/minigame/dev/api/device/bluetooth/wx.stopBluetoothDevicesDiscovery)",
    "描述": "停止搜寻附近的蓝牙外围设备"
  },
  {
    "接口名称": "[wx.startBluetoothDevicesDiscovery](/minigame/dev/api/device/bluetooth/wx.startBluetoothDevicesDiscovery)",
    "描述": "开始搜寻附近的蓝牙外围设备"
  },
  {
    "接口名称": "[wx.openBluetoothAdapter](/minigame/dev/api/device/bluetooth/wx.openBluetoothAdapter)",
    "描述": "初始化蓝牙模块"
  },
  {
    "接口名称": "[wx.onBluetoothDeviceFound](/minigame/dev/api/device/bluetooth/wx.onBluetoothDeviceFound)",
    "描述": "监听搜索到新设备的事件"
  },
  {
    "接口名称": "[wx.onBluetoothAdapterStateChange](/minigame/dev/api/device/bluetooth/wx.onBluetoothAdapterStateChange)",
    "描述": "监听蓝牙适配器状态变化事件"
  },
  {
    "接口名称": "[wx.offBluetoothDeviceFound](/minigame/dev/api/device/bluetooth/wx.offBluetoothDeviceFound)",
    "描述": "移除搜索到新设备的事件的全部监听函数"
  },
  {
    "接口名称": "[wx.offBluetoothAdapterStateChange](/minigame/dev/api/device/bluetooth/wx.offBluetoothAdapterStateChange)",
    "描述": "移除蓝牙适配器状态变化事件的全部监听函数"
  },
  {
    "接口名称": "[wx.makeBluetoothPair](/minigame/dev/api/device/bluetooth/wx.makeBluetoothPair)",
    "描述": "蓝牙配对接口，仅安卓支持"
  },
  {
    "接口名称": "[wx.isBluetoothDevicePaired](/minigame/dev/api/device/bluetooth/wx.isBluetoothDevicePaired)",
    "描述": "查询蓝牙设备是否配对，仅安卓支持"
  },
  {
    "接口名称": "[wx.getConnectedBluetoothDevices](/minigame/dev/api/device/bluetooth/wx.getConnectedBluetoothDevices)",
    "描述": "根据主服务 UUID 获取已连接的蓝牙设备"
  },
  {
    "接口名称": "[wx.getBluetoothDevices](/minigame/dev/api/device/bluetooth/wx.getBluetoothDevices)",
    "描述": "获取在蓝牙模块生效期间所有搜索到的蓝牙设备"
  },
  {
    "接口名称": "[wx.getBluetoothAdapterState](/minigame/dev/api/device/bluetooth/wx.getBluetoothAdapterState)",
    "描述": "获取本机蓝牙适配器状态"
  },
  {
    "接口名称": "[wx.closeBluetoothAdapter](/minigame/dev/api/device/bluetooth/wx.closeBluetoothAdapter)",
    "描述": "关闭蓝牙模块"
  }
]
```

### 电量

```json
[
  {
    "接口名称": "[wx.getBatteryInfoSync](/minigame/dev/api/device/battery/wx.getBatteryInfoSync)",
    "描述": "wx.getBatteryInfo) 的同步版本"
  },
  {
    "接口名称": "[wx.getBatteryInfo](/minigame/dev/api/device/battery/wx.getBatteryInfo)",
    "描述": "获取设备电池信息"
  }
]
```

### 剪贴板

```json
[
  {
    "接口名称": "[wx.setClipboardData](/minigame/dev/api/device/clipboard/wx.setClipboardData)",
    "描述": "设置系统剪贴板的内容"
  },
  {
    "接口名称": "[wx.getClipboardData](/minigame/dev/api/device/clipboard/wx.getClipboardData)",
    "描述": "获取系统剪贴板的内容"
  }
]
```

### 游戏手柄

```json
[
  {
    "接口名称": "[wx.onGamepadDisconnected](/minigame/dev/api/device/gamepad/wx.onGamepadDisconnected)",
    "描述": "监听用户断开游戏手柄的事件"
  },
  {
    "接口名称": "[wx.onGamepadConnected](/minigame/dev/api/device/gamepad/wx.onGamepadConnected)",
    "描述": "监听用户已连接游戏手柄的事件"
  },
  {
    "接口名称": "[wx.getGamepads](/minigame/dev/api/device/gamepad/wx.getGamepads)",
    "描述": "获取已连接的游戏手柄信息，仅在 PC 平台支持"
  }
]
```

### 网络

```json
[
  {
    "接口名称": "[wx.onNetworkWeakChange](/minigame/dev/api/device/network/wx.onNetworkWeakChange)",
    "描述": "监听弱网状态变化事件"
  },
  {
    "接口名称": "[wx.onNetworkStatusChange](/minigame/dev/api/device/network/wx.onNetworkStatusChange)",
    "描述": "监听网络状态变化事件"
  },
  {
    "接口名称": "[wx.offNetworkWeakChange](/minigame/dev/api/device/network/wx.offNetworkWeakChange)",
    "描述": "移除弱网状态变化事件的监听函数"
  },
  {
    "接口名称": "[wx.offNetworkStatusChange](/minigame/dev/api/device/network/wx.offNetworkStatusChange)",
    "描述": "移除网络状态变化事件的监听函数"
  },
  {
    "接口名称": "[wx.getNetworkType](/minigame/dev/api/device/network/wx.getNetworkType)",
    "描述": "获取网络类型"
  },
  {
    "接口名称": "[wx.getLocalIPAddress](/minigame/dev/api/device/network/wx.getLocalIPAddress)",
    "描述": "获取局域网IP地址"
  }
]
```

### 屏幕

```json
[
  {
    "接口名称": "[wx.setVisualEffectOnCapture](/minigame/dev/api/device/screen/wx.setVisualEffectOnCapture)",
    "描述": "设置截屏/录屏时屏幕表现"
  },
  {
    "接口名称": "[wx.setScreenBrightness](/minigame/dev/api/device/screen/wx.setScreenBrightness)",
    "描述": "设置屏幕亮度"
  },
  {
    "接口名称": "[wx.setKeepScreenOn](/minigame/dev/api/device/screen/wx.setKeepScreenOn)",
    "描述": "设置是否保持常亮状态"
  },
  {
    "接口名称": "[wx.onUserCaptureScreen](/minigame/dev/api/device/screen/wx.onUserCaptureScreen)",
    "描述": "监听用户主动截屏事件"
  },
  {
    "接口名称": "[wx.onScreenRecordingStateChanged](/minigame/dev/api/device/screen/wx.onScreenRecordingStateChanged)",
    "描述": "监听用户录屏事件"
  },
  {
    "接口名称": "[wx.offUserCaptureScreen](/minigame/dev/api/device/screen/wx.offUserCaptureScreen)",
    "描述": "用户主动截屏事件"
  },
  {
    "接口名称": "[wx.offScreenRecordingStateChanged](/minigame/dev/api/device/screen/wx.offScreenRecordingStateChanged)",
    "描述": "移除用户录屏事件的监听函数"
  },
  {
    "接口名称": "[wx.getScreenRecordingState](/minigame/dev/api/device/screen/wx.getScreenRecordingState)",
    "描述": "查询用户是否在录屏"
  },
  {
    "接口名称": "[wx.getScreenBrightness](/minigame/dev/api/device/screen/wx.getScreenBrightness)",
    "描述": "获取屏幕亮度"
  }
]
```

### 加速计

```json
[
  {
    "接口名称": "[wx.stopAccelerometer](/minigame/dev/api/device/accelerometer/wx.stopAccelerometer)",
    "描述": "停止监听加速度数据"
  },
  {
    "接口名称": "[wx.startAccelerometer](/minigame/dev/api/device/accelerometer/wx.startAccelerometer)",
    "描述": "开始监听加速度数据"
  },
  {
    "接口名称": "[wx.onAccelerometerChange](/minigame/dev/api/device/accelerometer/wx.onAccelerometerChange)",
    "描述": "监听加速度数据事件"
  },
  {
    "接口名称": "[wx.offAccelerometerChange](/minigame/dev/api/device/accelerometer/wx.offAccelerometerChange)",
    "描述": "移除加速度数据事件的监听函数"
  }
]
```

### 罗盘

```json
[
  {
    "接口名称": "[wx.stopCompass](/minigame/dev/api/device/compass/wx.stopCompass)",
    "描述": "停止监听罗盘数据"
  },
  {
    "接口名称": "[wx.startCompass](/minigame/dev/api/device/compass/wx.startCompass)",
    "描述": "开始监听罗盘数据"
  },
  {
    "接口名称": "[wx.onCompassChange](/minigame/dev/api/device/compass/wx.onCompassChange)",
    "描述": "监听罗盘数据变化事件"
  },
  {
    "接口名称": "[wx.offCompassChange](/minigame/dev/api/device/compass/wx.offCompassChange)",
    "描述": "移除罗盘数据变化事件的监听函数"
  }
]
```

### 设备方向

```json
[
  {
    "接口名称": "[wx.stopDeviceMotionListening](/minigame/dev/api/device/motion/wx.stopDeviceMotionListening)",
    "描述": "停止监听设备方向的变化"
  },
  {
    "接口名称": "[wx.startDeviceMotionListening](/minigame/dev/api/device/motion/wx.startDeviceMotionListening)",
    "描述": "开始监听设备方向的变化"
  },
  {
    "接口名称": "[wx.onDeviceMotionChange](/minigame/dev/api/device/motion/wx.onDeviceMotionChange)",
    "描述": "监听设备方向变化事件"
  },
  {
    "接口名称": "[wx.offDeviceMotionChange](/minigame/dev/api/device/motion/wx.offDeviceMotionChange)",
    "描述": "移除设备方向变化事件的监听函数"
  }
]
```

### 转屏

```json
[
  {
    "接口名称": "[wx.setDeviceOrientation](/minigame/dev/api/device/orientation/wx.setDeviceOrientation)",
    "描述": "切换横竖屏"
  },
  {
    "接口名称": "[wx.onDeviceOrientationChange](/minigame/dev/api/device/orientation/wx.onDeviceOrientationChange)",
    "描述": "监听屏幕转向切换事件"
  },
  {
    "接口名称": "[wx.offDeviceOrientationChange](/minigame/dev/api/device/orientation/wx.offDeviceOrientationChange)",
    "描述": "移除屏幕转向切换事件的监听函数"
  }
]
```

### 陀螺仪

```json
[
  {
    "接口名称": "[wx.stopGyroscope](/minigame/dev/api/device/gyroscope/wx.stopGyroscope)",
    "描述": "停止监听陀螺仪数据"
  },
  {
    "接口名称": "[wx.startGyroscope](/minigame/dev/api/device/gyroscope/wx.startGyroscope)",
    "描述": "开始监听陀螺仪数据"
  },
  {
    "接口名称": "[wx.onGyroscopeChange](/minigame/dev/api/device/gyroscope/wx.onGyroscopeChange)",
    "描述": "监听陀螺仪数据变化事件"
  },
  {
    "接口名称": "[wx.offGyroscopeChange](/minigame/dev/api/device/gyroscope/wx.offGyroscopeChange)",
    "描述": "移除陀螺仪数据变化事件的监听函数"
  }
]
```

### 内存

```json
[
  {
    "接口名称": "[wx.onMemoryWarning](/minigame/dev/api/device/memory/wx.onMemoryWarning)",
    "描述": "监听内存不足告警事件"
  },
  {
    "接口名称": "[wx.offMemoryWarning](/minigame/dev/api/device/memory/wx.offMemoryWarning)",
    "描述": "移除内存不足告警事件的监听函数"
  }
]
```

### 扫码

```json
[
  {
    "接口名称": "[wx.scanCode](/minigame/dev/api/device/scan/wx.scanCode)",
    "描述": "调起客户端扫码界面进行扫码"
  }
]
```

### 振动

```json
[
  {
    "接口名称": "[wx.vibrateShort](/minigame/dev/api/device/vibrate/wx.vibrateShort)",
    "描述": "使手机发生较短时间的振动（15 ms）"
  },
  {
    "接口名称": "[wx.vibrateLong](/minigame/dev/api/device/vibrate/wx.vibrateLong)",
    "描述": "使手机发生较长时间的振动（400 ms)"
  }
]
```

## AI

### AI 推理

```json
[
  {
    "接口名称": "[wx.getInferenceEnvInfo](/minigame/dev/api/ai/inference/wx.getInferenceEnvInfo)",
    "描述": "获取通用AI推理引擎版本"
  },
  {
    "接口名称": "[wx.createInferenceSession](/minigame/dev/api/ai/inference/wx.createInferenceSession)",
    "描述": "创建 AI 推理 Session"
  },
  {
    "接口名称": "[Tensor](/minigame/dev/api/ai/inference/Tensor)",
    "描述": "Tensor"
  },
  {
    "接口名称": "[Tensors](/minigame/dev/api/ai/inference/Tensors)",
    "描述": "Tensors 是 key-value 形式的对象，对象的 key 会作为 input/output name，对象的 value 则是 Tensor"
  }
]
```

#### InferenceSession

```json
[
  {
    "接口名称": "[InferenceSession.destroy](/minigame/dev/api/ai/inference/InferenceSession.destroy)",
    "描述": "销毁 InferenceSession 实例"
  },
  {
    "接口名称": "[InferenceSession.offError](/minigame/dev/api/ai/inference/InferenceSession.offError)",
    "描述": "取消监听模型加载失败事件"
  },
  {
    "接口名称": "[InferenceSession.offLoad](/minigame/dev/api/ai/inference/InferenceSession.offLoad)",
    "描述": "取消监听模型加载完成事件"
  },
  {
    "接口名称": "[InferenceSession.onError](/minigame/dev/api/ai/inference/InferenceSession.onError)",
    "描述": "监听模型加载失败事件"
  },
  {
    "接口名称": "[InferenceSession.onLoad](/minigame/dev/api/ai/inference/InferenceSession.onLoad)",
    "描述": "监听模型加载完成事件"
  },
  {
    "接口名称": "[InferenceSession.run](/minigame/dev/api/ai/inference/InferenceSession.run)",
    "描述": "运行推断"
  }
]
```

### 视觉算法

```json
[
  {
    "接口名称": "[wx.isVKSupport](/minigame/dev/api/ai/visionkit/wx.isVKSupport)",
    "描述": "判断支持版本"
  },
  {
    "接口名称": "[wx.createVKSession](/minigame/dev/api/ai/visionkit/wx.createVKSession)",
    "描述": "创建 vision kit 会话对象"
  },
  {
    "接口名称": "[VKBodyAnchor](/minigame/dev/api/ai/visionkit/VKBodyAnchor)",
    "描述": "人体 anchor"
  },
  {
    "接口名称": "[VKDepthAnchor](/minigame/dev/api/ai/visionkit/VKDepthAnchor)",
    "描述": "depth anchor"
  },
  {
    "接口名称": "[VKFaceAnchor](/minigame/dev/api/ai/visionkit/VKFaceAnchor)",
    "描述": "人脸 anchor"
  },
  {
    "接口名称": "[VKHandAnchor](/minigame/dev/api/ai/visionkit/VKHandAnchor)",
    "描述": "手势 anchor"
  },
  {
    "接口名称": "[VKMarkerAnchor](/minigame/dev/api/ai/visionkit/VKMarkerAnchor)",
    "描述": "marker anchor"
  },
  {
    "接口名称": "[VKOCRAnchor](/minigame/dev/api/ai/visionkit/VKOCRAnchor)",
    "描述": "OCR anchor"
  },
  {
    "接口名称": "[VKOSDAnchor](/minigame/dev/api/ai/visionkit/VKOSDAnchor)",
    "描述": "OSD anchor"
  },
  {
    "接口名称": "[VKPlaneAnchor](/minigame/dev/api/ai/visionkit/VKPlaneAnchor)",
    "描述": "平面 anchor，只有 v2 版本支持"
  }
]
```

#### VKCamera

```json
[
  {
    "接口名称": "[VKCamera.getProjectionMatrix](/minigame/dev/api/ai/visionkit/VKCamera.getProjectionMatrix)",
    "描述": "获取投影矩阵"
  }
]
```

#### VKFrame

```json
[
  {
    "接口名称": "[VKFrame.getCameraBuffer](/minigame/dev/api/ai/visionkit/VKFrame.getCameraBuffer)",
    "描述": "获取当前帧 rgba buffer"
  },
  {
    "接口名称": "[VKFrame.getCameraJpgBuffer](/minigame/dev/api/ai/visionkit/VKFrame.getCameraJpgBuffer)",
    "描述": "获取当前帧的 jpg 信息Buffer"
  },
  {
    "接口名称": "[VKFrame.getCameraTexture](/minigame/dev/api/ai/visionkit/VKFrame.getCameraTexture)",
    "描述": "获取当前帧纹理，目前只支持 YUV 纹理"
  },
  {
    "接口名称": "[VKFrame.getDepthBuffer](/minigame/dev/api/ai/visionkit/VKFrame.getDepthBuffer)",
    "描述": "获取每帧的深度图信息Buffer"
  },
  {
    "接口名称": "[VKFrame.getDisplayTransform](/minigame/dev/api/ai/visionkit/VKFrame.getDisplayTransform)",
    "描述": "获取纹理调整矩阵"
  },
  {
    "接口名称": "[VKFrame.getLegSegmentBuffer](/minigame/dev/api/ai/visionkit/VKFrame.getLegSegmentBuffer)",
    "描述": "获取每帧的腿部分割信息Buffer，安卓微信 8.0.43，iOS微信 8.0.43 开始支持"
  }
]
```

#### VKSession

```json
[
  {
    "接口名称": "[VKSession.addMarker](/minigame/dev/api/ai/visionkit/VKSession.addMarker)",
    "描述": "添加一个 marker，要求调 wx.createVKSession) 时传入的 track.marker 为 true"
  },
  {
    "接口名称": "[VKSession.addOSDMarker](/minigame/dev/api/ai/visionkit/VKSession.addOSDMarker)",
    "描述": "添加一个 OSD marker（one-shot detection marker），要求调 wx.createVKSession) 时传入的 track.OS"
  },
  {
    "接口名称": "[VKSession.cancelAnimationFrame](/minigame/dev/api/ai/visionkit/VKSession.cancelAnimationFrame)",
    "描述": "取消由 requestAnimationFrame 添加到计划中的动画帧请求"
  },
  {
    "接口名称": "[VKSession.destroy](/minigame/dev/api/ai/visionkit/VKSession.destroy)",
    "描述": "销毁会话"
  },
  {
    "接口名称": "[VKSession.detectBody](/minigame/dev/api/ai/visionkit/VKSession.detectBody)",
    "描述": "静态图像人体关键点检测"
  },
  {
    "接口名称": "[VKSession.detectDepth](/minigame/dev/api/ai/visionkit/VKSession.detectDepth)",
    "描述": "深度识别"
  },
  {
    "接口名称": "[VKSession.detectFace](/minigame/dev/api/ai/visionkit/VKSession.detectFace)",
    "描述": "静态图像人脸关键点检测"
  },
  {
    "接口名称": "[VKSession.detectHand](/minigame/dev/api/ai/visionkit/VKSession.detectHand)",
    "描述": "静态图像手势关键点检测"
  },
  {
    "接口名称": "[VKSession.getAllMarker](/minigame/dev/api/ai/visionkit/VKSession.getAllMarker)",
    "描述": "获取所有 marker，要求调 wx.createVKSession) 时传入的 track.marker 为 true"
  },
  {
    "接口名称": "[VKSession.getAllOSDMarker](/minigame/dev/api/ai/visionkit/VKSession.getAllOSDMarker)",
    "描述": "获取所有 OSD marker，要求调 wx.createVKSession) 时传入的 track.OSD 为 true"
  },
  {
    "接口名称": "[VKSession.getVKFrame](/minigame/dev/api/ai/visionkit/VKSession.getVKFrame)",
    "描述": "获取帧对象，每调用一次都会触发一次帧分析过程"
  },
  {
    "接口名称": "[VKSession.hitTest](/minigame/dev/api/ai/visionkit/VKSession.hitTest)",
    "描述": "触摸检测，v1 版本只支持单平面（即 hitTest 生成一次平面后，后续 hitTest 均不会再生成平面，而是以之前生成的平面为基础进行检测）"
  },
  {
    "接口名称": "[VKSession.off](/minigame/dev/api/ai/visionkit/VKSession.off)",
    "描述": "取消监听会话事件"
  },
  {
    "接口名称": "[VKSession.on](/minigame/dev/api/ai/visionkit/VKSession.on)",
    "描述": "监听会话事件"
  },
  {
    "接口名称": "[VKSession.removeMarker](/minigame/dev/api/ai/visionkit/VKSession.removeMarker)",
    "描述": "删除一个 marker，要求调 wx.createVKSession) 时传入的 track.marker 为 true"
  },
  {
    "接口名称": "[VKSession.removeOSDMarker](/minigame/dev/api/ai/visionkit/VKSession.removeOSDMarker)",
    "描述": "删除一个 OSD marker，要求调 wx.createVKSession) 时传入的 track.OSD 为 true"
  },
  {
    "接口名称": "[VKSession.requestAnimationFrame](/minigame/dev/api/ai/visionkit/VKSession.requestAnimationFrame)",
    "描述": "在下次进行重绘时执行"
  },
  {
    "接口名称": "[VKSession.runOCR](/minigame/dev/api/ai/visionkit/VKSession.runOCR)",
    "描述": "静态图像OCR检测"
  },
  {
    "接口名称": "[VKSession.setDepthOccRange](/minigame/dev/api/ai/visionkit/VKSession.setDepthOccRange)",
    "描述": "更新 深度遮挡 Occ范围，要求调 wx.createVKSession) 时传入 {track: {depth: {mode: 2} } }"
  },
  {
    "接口名称": "[VKSession.start](/minigame/dev/api/ai/visionkit/VKSession.start)",
    "描述": "开启会话"
  },
  {
    "接口名称": "[VKSession.stop](/minigame/dev/api/ai/visionkit/VKSession.stop)",
    "描述": "停止会话"
  },
  {
    "接口名称": "[VKSession.update3DMode](/minigame/dev/api/ai/visionkit/VKSession.update3DMode)",
    "描述": "更新三维识别相关配置，要求调 wx.createVKSession) 时使用 face / hand / body"
  },
  {
    "接口名称": "[VKSession.updateMaskMode](/minigame/dev/api/ai/visionkit/VKSession.updateMaskMode)",
    "描述": "设置裁剪相关配置，要求调 wx.createVKSession) 时使用 shoe"
  },
  {
    "接口名称": "[VKSession.updateOSDThreshold](/minigame/dev/api/ai/visionkit/VKSession.updateOSDThreshold)",
    "描述": "更新 OSD 识别精确度，要求调 wx.createVKSession) 时传入的 track.OSD 为 true"
  }
]
```

### 人脸检测

```json
[
  {
    "接口名称": "[wx.stopFaceDetect](/minigame/dev/api/ai/face/wx.stopFaceDetect)",
    "描述": "停止人脸检测"
  },
  {
    "接口名称": "[wx.initFaceDetect](/minigame/dev/api/ai/face/wx.initFaceDetect)",
    "描述": "初始化人脸检测"
  },
  {
    "接口名称": "[wx.faceDetect](/minigame/dev/api/ai/face/wx.faceDetect)",
    "描述": "人脸检测，使用前需要通过 wx.initFaceDetect 进行一次初始化，推荐使用相机接口返回的帧数据"
  }
]
```

## Worker

```json
[
  {
    "接口名称": "[wx.createWorker](/minigame/dev/api/worker/wx.createWorker)",
    "描述": "创建一个 Worker 线程"
  }
]
```

### Worker

```json
[
  {
    "接口名称": "[Worker.getCameraFrameData](/minigame/dev/api/worker/Worker.getCameraFrameData)",
    "描述": "获取摄像头当前帧图像，返回ArrayBuffer数据"
  },
  {
    "接口名称": "[Worker.onError](/minigame/dev/api/worker/Worker.onError)",
    "描述": "监听 Worker 线程错误事件"
  },
  {
    "接口名称": "[Worker.onMessage](/minigame/dev/api/worker/Worker.onMessage)",
    "描述": "监听主线程/Worker 线程向当前线程发送的消息的事件"
  },
  {
    "接口名称": "[Worker.onProcessKilled](/minigame/dev/api/worker/Worker.onProcessKilled)",
    "描述": "监听 worker线程被系统回收事件（开启 useExperimentalWorker 后，当iOS系统资源紧张时，ExperimentalWorker 线程存"
  },
  {
    "接口名称": "[Worker.postMessage](/minigame/dev/api/worker/Worker.postMessage)",
    "描述": "向主线程/Worker 线程发送的消息"
  },
  {
    "接口名称": "[Worker.terminate](/minigame/dev/api/worker/Worker.terminate)",
    "描述": "结束当前 Worker 线程"
  },
  {
    "接口名称": "[Worker.testOnProcessKilled](/minigame/dev/api/worker/Worker.testOnProcessKilled)",
    "描述": "用于模拟 iOS ExperimentalWorker 线程被系统回收事件，以便于调试"
  }
]
```

## 游戏对局回放

```json
[
  {
    "接口名称": "[wx.operateGameRecorderVideo](/minigame/dev/api/game-recorder/wx.operateGameRecorderVideo)",
    "描述": "分享游戏对局回放"
  },
  {
    "接口名称": "[wx.getGameRecorder](/minigame/dev/api/game-recorder/wx.getGameRecorder)",
    "描述": "获取全局唯一的游戏画面录制对象"
  },
  {
    "接口名称": "[wx.createGameRecorderShareButton](/minigame/dev/api/game-recorder/wx.createGameRecorderShareButton)",
    "描述": "创建游戏对局回放分享按钮，返回一个单例对象"
  }
]
```

### GameRecorder

```json
[
  {
    "接口名称": "[GameRecorder.abort](/minigame/dev/api/game-recorder/GameRecorder.abort)",
    "描述": "放弃录制游戏画面"
  },
  {
    "接口名称": "[GameRecorder.isAtempoSupported](/minigame/dev/api/game-recorder/GameRecorder.isAtempoSupported)",
    "描述": "获取是否支持调节录制视频的播放速率"
  },
  {
    "接口名称": "[GameRecorder.isFrameSupported](/minigame/dev/api/game-recorder/GameRecorder.isFrameSupported)",
    "描述": "获取是否支持录制游戏画面"
  },
  {
    "接口名称": "[GameRecorder.isSoundSupported](/minigame/dev/api/game-recorder/GameRecorder.isSoundSupported)",
    "描述": "获取是否在录制游戏画面的同时支持录制游戏音频的信息"
  },
  {
    "接口名称": "[GameRecorder.isVolumeSupported](/minigame/dev/api/game-recorder/GameRecorder.isVolumeSupported)",
    "描述": "获取是否支持调节录制视频的音量"
  },
  {
    "接口名称": "[GameRecorder.off](/minigame/dev/api/game-recorder/GameRecorder.off)",
    "描述": "取消监听录制事件"
  },
  {
    "接口名称": "[GameRecorder.on](/minigame/dev/api/game-recorder/GameRecorder.on)",
    "描述": "注册监听录制事件的回调函数"
  },
  {
    "接口名称": "[GameRecorder.pause](/minigame/dev/api/game-recorder/GameRecorder.pause)",
    "描述": "暂停录制游戏画面"
  },
  {
    "接口名称": "[GameRecorder.resume](/minigame/dev/api/game-recorder/GameRecorder.resume)",
    "描述": "恢复录制游戏画面"
  },
  {
    "接口名称": "[GameRecorder.start](/minigame/dev/api/game-recorder/GameRecorder.start)",
    "描述": "开始录制游戏画面"
  },
  {
    "接口名称": "[GameRecorder.stop](/minigame/dev/api/game-recorder/GameRecorder.stop)",
    "描述": "结束录制游戏画面"
  }
]
```

### GameRecorderShareButton

```json
[
  {
    "接口名称": "[GameRecorderShareButton.hide](/minigame/dev/api/game-recorder/GameRecorderShareButton.hide)",
    "描述": "隐藏游戏对局回放分享按钮"
  },
  {
    "接口名称": "[GameRecorderShareButton.offTap](/minigame/dev/api/game-recorder/GameRecorderShareButton.offTap)",
    "描述": "移除游戏对局回放分享按钮的点击事件的监听函数"
  },
  {
    "接口名称": "[GameRecorderShareButton.onTap](/minigame/dev/api/game-recorder/GameRecorderShareButton.onTap)",
    "描述": "监听游戏对局回放分享按钮的点击事件"
  },
  {
    "接口名称": "[GameRecorderShareButton.show](/minigame/dev/api/game-recorder/GameRecorderShareButton.show)",
    "描述": "显示游戏对局回放分享按钮"
  }
]
```

## 游戏服务

```json
[
  {
    "接口名称": "[wx.getGameServerManager](/minigame/dev/api/game-server-manager/wx.getGameServerManager)",
    "描述": "获取 全局唯一 的游戏服务管理器"
  },
  {
    "接口名称": "[ReconnectSuccessRes](/minigame/dev/api/game-server-manager/ReconnectSuccessRes)",
    "描述": "GameServerManager.reconnect 接口 resolve 后的返回值"
  }
]
```

### GameServerManager

```json
[
  {
    "接口名称": "[GameServerManager.broadcastInRoom](/minigame/dev/api/game-server-manager/GameServerManager.broadcastInRoom)",
    "描述": "在房间内广播"
  },
  {
    "接口名称": "[GameServerManager.cancelMatch](/minigame/dev/api/game-server-manager/GameServerManager.cancelMatch)",
    "描述": "取消游戏匹配"
  },
  {
    "接口名称": "[GameServerManager.changeSeat](/minigame/dev/api/game-server-manager/GameServerManager.changeSeat)",
    "描述": "玩家换座位"
  },
  {
    "接口名称": "[GameServerManager.createRoom](/minigame/dev/api/game-server-manager/GameServerManager.createRoom)",
    "描述": "创建游戏房间"
  },
  {
    "接口名称": "[GameServerManager.endGame](/minigame/dev/api/game-server-manager/GameServerManager.endGame)",
    "描述": "结束帧同步"
  },
  {
    "接口名称": "[GameServerManager.endStateService](/minigame/dev/api/game-server-manager/GameServerManager.endStateService)",
    "描述": "结束游戏状态同步服务"
  },
  {
    "接口名称": "[GameServerManager.getFriendsStateData](/minigame/dev/api/game-server-manager/GameServerManager.getFriendsStateData)",
    "描述": "获取所有好友的在线状态及信息"
  },
  {
    "接口名称": "[GameServerManager.getJoinVoIPChatSignature](/minigame/dev/api/game-server-manager/GameServerManager.getJoinVoIPChatSignature)",
    "描述": "获取实时语音签名，签名的 groupId 与当前房间服务的房间 ID 绑定"
  },
  {
    "接口名称": "[GameServerManager.getLastRoomInfo](/minigame/dev/api/game-server-manager/GameServerManager.getLastRoomInfo)",
    "描述": "获取最近参与房间的 accessInfo"
  },
  {
    "接口名称": "[GameServerManager.getLostFrames](/minigame/dev/api/game-server-manager/GameServerManager.getLostFrames)",
    "描述": "补帧，补帧区间为 [beginFrameId, endFrameId)，即左闭右合"
  },
  {
    "接口名称": "[GameServerManager.getRoomInfo](/minigame/dev/api/game-server-manager/GameServerManager.getRoomInfo)",
    "描述": "获取房间详情"
  },
  {
    "接口名称": "[GameServerManager.inviteFriend](/minigame/dev/api/game-server-manager/GameServerManager.inviteFriend)",
    "描述": "邀请好友，该好友的系统状态必须为在线（该接口需要在开放数据域使用）该接口没有回调也没有返回值"
  },
  {
    "接口名称": "[GameServerManager.joinRoom](/minigame/dev/api/game-server-manager/GameServerManager.joinRoom)",
    "描述": "加入游戏房间"
  },
  {
    "接口名称": "[GameServerManager.kickoutMember](/minigame/dev/api/game-server-manager/GameServerManager.kickoutMember)",
    "描述": "把一名玩家踢出房间（仅房主有权限）"
  },
  {
    "接口名称": "[GameServerManager.login](/minigame/dev/api/game-server-manager/GameServerManager.login)",
    "描述": "登录游戏服务"
  },
  {
    "接口名称": "[GameServerManager.logout](/minigame/dev/api/game-server-manager/GameServerManager.logout)",
    "描述": "登出游戏服务"
  },
  {
    "接口名称": "[GameServerManager.memberLeaveRoom](/minigame/dev/api/game-server-manager/GameServerManager.memberLeaveRoom)",
    "描述": "普通成员退出房间"
  },
  {
    "接口名称": "[GameServerManager.offBeKickedOut](/minigame/dev/api/game-server-manager/GameServerManager.offBeKickedOut)",
    "描述": "移除自己被踢出当前房间的监听函数"
  },
  {
    "接口名称": "[GameServerManager.offBroadcast](/minigame/dev/api/game-server-manager/GameServerManager.offBroadcast)",
    "描述": "移除收到同个房间内的广播消息的监听函数"
  },
  {
    "接口名称": "[GameServerManager.offDisconnect](/minigame/dev/api/game-server-manager/GameServerManager.offDisconnect)",
    "描述": "移除断开连接，收到此事件的监听函数"
  },
  {
    "接口名称": "[GameServerManager.offGameEnd](/minigame/dev/api/game-server-manager/GameServerManager.offGameEnd)",
    "描述": "移除帧同步游戏结束的监听函数"
  },
  {
    "接口名称": "[GameServerManager.offGameStart](/minigame/dev/api/game-server-manager/GameServerManager.offGameStart)",
    "描述": "移除帧同步游戏开始的监听函数"
  },
  {
    "接口名称": "[GameServerManager.offInvite](/minigame/dev/api/game-server-manager/GameServerManager.offInvite)",
    "描述": "移除接收邀请，当用户确认邀请之后会收到此事件的监听函数"
  },
  {
    "接口名称": "[GameServerManager.offLockStepError](/minigame/dev/api/game-server-manager/GameServerManager.offLockStepError)",
    "描述": "移除帧同步出错的监听函数"
  },
  {
    "接口名称": "[GameServerManager.offLogout](/minigame/dev/api/game-server-manager/GameServerManager.offLogout)",
    "描述": "移除用户登出游戏服务事件的监听函数"
  },
  {
    "接口名称": "[GameServerManager.offMatch](/minigame/dev/api/game-server-manager/GameServerManager.offMatch)",
    "描述": "移除游戏匹配成功的事件的监听函数"
  },
  {
    "接口名称": "[GameServerManager.offRoomInfoChange](/minigame/dev/api/game-server-manager/GameServerManager.offRoomInfoChange)",
    "描述": "移除房间信息更新的监听函数"
  },
  {
    "接口名称": "[GameServerManager.offStateUpdate](/minigame/dev/api/game-server-manager/GameServerManager.offStateUpdate)",
    "描述": "移除好友在线状态变更（该接口需要在开放数据域使用）的监听函数"
  },
  {
    "接口名称": "[GameServerManager.offSyncFrame](/minigame/dev/api/game-server-manager/GameServerManager.offSyncFrame)",
    "描述": "移除收到同个房间的帧同步消息的监听函数"
  },
  {
    "接口名称": "[GameServerManager.onBeKickedOut](/minigame/dev/api/game-server-manager/GameServerManager.onBeKickedOut)",
    "描述": "监听自己被踢出当前房间"
  },
  {
    "接口名称": "[GameServerManager.onBroadcast](/minigame/dev/api/game-server-manager/GameServerManager.onBroadcast)",
    "描述": "监听收到同个房间内的广播消息"
  },
  {
    "接口名称": "[GameServerManager.onDisconnect](/minigame/dev/api/game-server-manager/GameServerManager.onDisconnect)",
    "描述": "监听断开连接，收到此事件后，需要调用  进行重连"
  },
  {
    "接口名称": "[GameServerManager.onGameEnd](/minigame/dev/api/game-server-manager/GameServerManager.onGameEnd)",
    "描述": "监听帧同步游戏结束"
  },
  {
    "接口名称": "[GameServerManager.onGameStart](/minigame/dev/api/game-server-manager/GameServerManager.onGameStart)",
    "描述": "监听帧同步游戏开始"
  },
  {
    "接口名称": "[GameServerManager.onInvite](/minigame/dev/api/game-server-manager/GameServerManager.onInvite)",
    "描述": "监听接收邀请，当用户确认邀请之后会收到此事件"
  },
  {
    "接口名称": "[GameServerManager.onLockStepError](/minigame/dev/api/game-server-manager/GameServerManager.onLockStepError)",
    "描述": "监听帧同步出错"
  },
  {
    "接口名称": "[GameServerManager.onLogout](/minigame/dev/api/game-server-manager/GameServerManager.onLogout)",
    "描述": "监听用户登出游戏服务事件，可能是主动登出也可能是其他原因被动登出"
  },
  {
    "接口名称": "[GameServerManager.onMatch](/minigame/dev/api/game-server-manager/GameServerManager.onMatch)",
    "描述": "监听游戏匹配成功的事件"
  },
  {
    "接口名称": "[GameServerManager.onRoomInfoChange](/minigame/dev/api/game-server-manager/GameServerManager.onRoomInfoChange)",
    "描述": "监听房间信息更新"
  },
  {
    "接口名称": "[GameServerManager.onStateUpdate](/minigame/dev/api/game-server-manager/GameServerManager.onStateUpdate)",
    "描述": "监听好友在线状态变更（该接口需要在开放数据域使用）"
  },
  {
    "接口名称": "[GameServerManager.onSyncFrame](/minigame/dev/api/game-server-manager/GameServerManager.onSyncFrame)",
    "描述": "监听收到同个房间的帧同步消息"
  },
  {
    "接口名称": "[GameServerManager.ownerLeaveRoom](/minigame/dev/api/game-server-manager/GameServerManager.ownerLeaveRoom)",
    "描述": "房主退出房间， 参数被优先处理，其次是 ，如果二者都没有被设置，则房主退出且房间销毁"
  },
  {
    "接口名称": "[GameServerManager.reconnect](/minigame/dev/api/game-server-manager/GameServerManager.reconnect)",
    "描述": "重连游戏服务"
  },
  {
    "接口名称": "[GameServerManager.restart](/minigame/dev/api/game-server-manager/GameServerManager.restart)",
    "描述": "重启游戏并进入\"组队中\"的状态"
  },
  {
    "接口名称": "[GameServerManager.setInviteData](/minigame/dev/api/game-server-manager/GameServerManager.setInviteData)",
    "描述": "设置邀请好友附带的数据"
  },
  {
    "接口名称": "[GameServerManager.setState](/minigame/dev/api/game-server-manager/GameServerManager.setState)",
    "描述": "更新玩家状态信息"
  },
  {
    "接口名称": "[GameServerManager.startGame](/minigame/dev/api/game-server-manager/GameServerManager.startGame)",
    "描述": "启动帧同步"
  },
  {
    "接口名称": "[GameServerManager.startMatch](/minigame/dev/api/game-server-manager/GameServerManager.startMatch)",
    "描述": "开始游戏匹配"
  },
  {
    "接口名称": "[GameServerManager.startStateService](/minigame/dev/api/game-server-manager/GameServerManager.startStateService)",
    "描述": "开启状态管理服务，只有开启状态管理服务，才能获取在线好友列表以及接收好友邀请"
  },
  {
    "接口名称": "[GameServerManager.updateReadyStatus](/minigame/dev/api/game-server-manager/GameServerManager.updateReadyStatus)",
    "描述": "更新玩家准备信息"
  },
  {
    "接口名称": "[GameServerManager.uploadFrame](/minigame/dev/api/game-server-manager/GameServerManager.uploadFrame)",
    "描述": "上传游戏帧"
  }
]
```

## 第三方平台

```json
[
  {
    "接口名称": "[wx.getExtConfigSync](/minigame/dev/api/ext/wx.getExtConfigSync)",
    "描述": "wx.getExtConfig) 的同步版本"
  },
  {
    "接口名称": "[wx.getExtConfig](/minigame/dev/api/ext/wx.getExtConfig)",
    "描述": "获取第三方平台)自定义的数据字段"
  }
]
```

## 广告

```json
[
  {
    "接口名称": "[wx.onDirectAdStatusChange](/minigame/dev/api/ad/wx.onDirectAdStatusChange)",
    "描述": "监听监听直玩广告状态变化"
  },
  {
    "接口名称": "[wx.offDirectAdStatusChange](/minigame/dev/api/ad/wx.offDirectAdStatusChange)",
    "描述": "移除监听直玩广告状态变化的监听函数"
  },
  {
    "接口名称": "[wx.getShowSplashAdStatus](/minigame/dev/api/ad/wx.getShowSplashAdStatus)",
    "描述": "获取封面广告组件展示状态"
  },
  {
    "接口名称": "[wx.getDirectAdStatusSync](/minigame/dev/api/ad/wx.getDirectAdStatusSync)",
    "描述": "获取直玩广告组件展示状态"
  },
  {
    "接口名称": "[wx.createRewardedVideoAd](/minigame/dev/api/ad/wx.createRewardedVideoAd)",
    "描述": "创建激励视频广告组件"
  },
  {
    "接口名称": "[wx.createInterstitialAd](/minigame/dev/api/ad/wx.createInterstitialAd)",
    "描述": "创建插屏广告组件"
  },
  {
    "接口名称": "[wx.createGridAd](/minigame/dev/api/ad/wx.createGridAd)",
    "描述": "创建 grid(格子)"
  },
  {
    "接口名称": "[wx.createCustomAd](/minigame/dev/api/ad/wx.createCustomAd)",
    "描述": "创建原生模板广告组件"
  },
  {
    "接口名称": "[wx.createBannerAd](/minigame/dev/api/ad/wx.createBannerAd)",
    "描述": "创建 banner 广告组件"
  },
  {
    "接口名称": "[wx.createAdSkipCard](/minigame/dev/api/ad/wx.createAdSkipCard)",
    "描述": "创建并返回广告跳过卡（畅玩卡）管理器 AdSkipCard 实例（单例）"
  }
]
```

### BannerAd

```json
[
  {
    "接口名称": "[BannerAd.destroy](/minigame/dev/api/ad/BannerAd.destroy)",
    "描述": "销毁 banner 广告"
  },
  {
    "接口名称": "[BannerAd.hide](/minigame/dev/api/ad/BannerAd.hide)",
    "描述": "隐藏 banner 广告"
  },
  {
    "接口名称": "[BannerAd.offError](/minigame/dev/api/ad/BannerAd.offError)",
    "描述": "移除 banner 广告错误事件的监听函数"
  },
  {
    "接口名称": "[BannerAd.offLoad](/minigame/dev/api/ad/BannerAd.offLoad)",
    "描述": "移除 banner 广告加载事件的监听函数"
  },
  {
    "接口名称": "[BannerAd.offResize](/minigame/dev/api/ad/BannerAd.offResize)",
    "描述": "移除 banner 广告尺寸变化事件的监听函数"
  },
  {
    "接口名称": "[BannerAd.onError](/minigame/dev/api/ad/BannerAd.onError)",
    "描述": "监听 banner 广告错误事件"
  },
  {
    "接口名称": "[BannerAd.onLoad](/minigame/dev/api/ad/BannerAd.onLoad)",
    "描述": "监听 banner 广告加载事件"
  },
  {
    "接口名称": "[BannerAd.onResize](/minigame/dev/api/ad/BannerAd.onResize)",
    "描述": "监听 banner 广告尺寸变化事件"
  },
  {
    "接口名称": "[BannerAd.show](/minigame/dev/api/ad/BannerAd.show)",
    "描述": "显示 banner 广告"
  }
]
```

### CustomAd

```json
[
  {
    "接口名称": "[CustomAd.destroy](/minigame/dev/api/ad/CustomAd.destroy)",
    "描述": "销毁原生模板广告"
  },
  {
    "接口名称": "[CustomAd.hide](/minigame/dev/api/ad/CustomAd.hide)",
    "描述": "隐藏原生模板广告"
  },
  {
    "接口名称": "[CustomAd.isShow](/minigame/dev/api/ad/CustomAd.isShow)",
    "描述": "查询原生模板广告展示状态"
  },
  {
    "接口名称": "[CustomAd.offClose](/minigame/dev/api/ad/CustomAd.offClose)",
    "描述": "移除原生模板广告关闭事件的监听函数"
  },
  {
    "接口名称": "[CustomAd.offError](/minigame/dev/api/ad/CustomAd.offError)",
    "描述": "移除原生模板广告错误事件的监听函数"
  },
  {
    "接口名称": "[CustomAd.offHide](/minigame/dev/api/ad/CustomAd.offHide)",
    "描述": "移除原生模板广告隐藏事件的监听函数"
  },
  {
    "接口名称": "[CustomAd.offLoad](/minigame/dev/api/ad/CustomAd.offLoad)",
    "描述": "移除原生模板广告加载事件的监听函数"
  },
  {
    "接口名称": "[CustomAd.offResize](/minigame/dev/api/ad/CustomAd.offResize)",
    "描述": "移除原生模板广告宽高回调事件的监听函数"
  },
  {
    "接口名称": "[CustomAd.onClose](/minigame/dev/api/ad/CustomAd.onClose)",
    "描述": "监听原生模板广告关闭事件（仅部分可被用户关闭的模板支持）"
  },
  {
    "接口名称": "[CustomAd.onError](/minigame/dev/api/ad/CustomAd.onError)",
    "描述": "监听原生模板广告错误事件"
  },
  {
    "接口名称": "[CustomAd.onHide](/minigame/dev/api/ad/CustomAd.onHide)",
    "描述": "监听原生模板广告隐藏事件, 某些模板如矩阵格子模板用户点击关闭时也会触发该事件"
  },
  {
    "接口名称": "[CustomAd.onLoad](/minigame/dev/api/ad/CustomAd.onLoad)",
    "描述": "监听原生模板广告加载事件"
  },
  {
    "接口名称": "[CustomAd.onResize](/minigame/dev/api/ad/CustomAd.onResize)",
    "描述": "监听原生模板广告宽高回调事件（部分横幅模板支持）"
  },
  {
    "接口名称": "[CustomAd.show](/minigame/dev/api/ad/CustomAd.show)",
    "描述": "显示原生模板广告"
  }
]
```

### GridAd

```json
[
  {
    "接口名称": "[GridAd.destroy](/minigame/dev/api/ad/GridAd.destroy)",
    "描述": "销毁 grid(格子) 广告"
  },
  {
    "接口名称": "[GridAd.hide](/minigame/dev/api/ad/GridAd.hide)",
    "描述": "隐藏 grid(格子) 广告"
  },
  {
    "接口名称": "[GridAd.offError](/minigame/dev/api/ad/GridAd.offError)",
    "描述": "移除 grid(格子) 广告错误事件的监听函数"
  },
  {
    "接口名称": "[GridAd.offLoad](/minigame/dev/api/ad/GridAd.offLoad)",
    "描述": "移除 grid(格子) 广告加载事件的监听函数"
  },
  {
    "接口名称": "[GridAd.offResize](/minigame/dev/api/ad/GridAd.offResize)",
    "描述": "移除 grid(格子) 广告尺寸变化事件的监听函数"
  },
  {
    "接口名称": "[GridAd.onError](/minigame/dev/api/ad/GridAd.onError)",
    "描述": "监听 grid(格子) 广告错误事件"
  },
  {
    "接口名称": "[GridAd.onLoad](/minigame/dev/api/ad/GridAd.onLoad)",
    "描述": "监听 grid(格子) 广告加载事件"
  },
  {
    "接口名称": "[GridAd.onResize](/minigame/dev/api/ad/GridAd.onResize)",
    "描述": "监听 grid(格子) 广告尺寸变化事件"
  },
  {
    "接口名称": "[GridAd.show](/minigame/dev/api/ad/GridAd.show)",
    "描述": "显示 grid(格子) 广告"
  }
]
```

### InterstitialAd

```json
[
  {
    "接口名称": "[InterstitialAd.destroy](/minigame/dev/api/ad/InterstitialAd.destroy)",
    "描述": "销毁插屏广告实例"
  },
  {
    "接口名称": "[InterstitialAd.load](/minigame/dev/api/ad/InterstitialAd.load)",
    "描述": "加载插屏广告"
  },
  {
    "接口名称": "[InterstitialAd.offClose](/minigame/dev/api/ad/InterstitialAd.offClose)",
    "描述": "移除插屏广告关闭事件的监听函数"
  },
  {
    "接口名称": "[InterstitialAd.offError](/minigame/dev/api/ad/InterstitialAd.offError)",
    "描述": "移除插屏错误事件的监听函数"
  },
  {
    "接口名称": "[InterstitialAd.offLoad](/minigame/dev/api/ad/InterstitialAd.offLoad)",
    "描述": "移除插屏广告加载事件的监听函数"
  },
  {
    "接口名称": "[InterstitialAd.onClose](/minigame/dev/api/ad/InterstitialAd.onClose)",
    "描述": "监听插屏广告关闭事件"
  },
  {
    "接口名称": "[InterstitialAd.onError](/minigame/dev/api/ad/InterstitialAd.onError)",
    "描述": "监听插屏错误事件"
  },
  {
    "接口名称": "[InterstitialAd.onLoad](/minigame/dev/api/ad/InterstitialAd.onLoad)",
    "描述": "监听插屏广告加载事件"
  },
  {
    "接口名称": "[InterstitialAd.show](/minigame/dev/api/ad/InterstitialAd.show)",
    "描述": "显示插屏广告"
  }
]
```

### RewardedVideoAd

```json
[
  {
    "接口名称": "[RewardedVideoAd.destroy](/minigame/dev/api/ad/RewardedVideoAd.destroy)",
    "描述": "销毁激励视频广告实例"
  },
  {
    "接口名称": "[RewardedVideoAd.load](/minigame/dev/api/ad/RewardedVideoAd.load)",
    "描述": "加载激励视频广告"
  },
  {
    "接口名称": "[RewardedVideoAd.offClose](/minigame/dev/api/ad/RewardedVideoAd.offClose)",
    "描述": "移除用户点击  按钮的事件的监听函数"
  },
  {
    "接口名称": "[RewardedVideoAd.offError](/minigame/dev/api/ad/RewardedVideoAd.offError)",
    "描述": "移除激励视频错误事件的监听函数"
  },
  {
    "接口名称": "[RewardedVideoAd.offLoad](/minigame/dev/api/ad/RewardedVideoAd.offLoad)",
    "描述": "移除激励视频广告加载事件的监听函数"
  },
  {
    "接口名称": "[RewardedVideoAd.onClose](/minigame/dev/api/ad/RewardedVideoAd.onClose)",
    "描述": "监听用户点击  按钮的事件"
  },
  {
    "接口名称": "[RewardedVideoAd.onError](/minigame/dev/api/ad/RewardedVideoAd.onError)",
    "描述": "监听激励视频错误事件"
  },
  {
    "接口名称": "[RewardedVideoAd.onLoad](/minigame/dev/api/ad/RewardedVideoAd.onLoad)",
    "描述": "监听激励视频广告加载事件"
  },
  {
    "接口名称": "[RewardedVideoAd.setMiniGameAutoIntelligenceInfo](/minigame/dev/api/ad/RewardedVideoAd.setMiniGameAutoIntelligenceInfo)",
    "描述": "设置小游戏智能托管关卡信息"
  },
  {
    "接口名称": "[RewardedVideoAd.setServerSideVerificationData](/minigame/dev/api/ad/RewardedVideoAd.setServerSideVerificationData)",
    "描述": "设置激励广告服务端校验的自定义透传字段"
  },
  {
    "接口名称": "[RewardedVideoAd.show](/minigame/dev/api/ad/RewardedVideoAd.show)",
    "描述": "显示激励视频广告"
  }
]
```

## 工具

```json
[
  {
    "接口名称": "[wx.encode](/minigame/dev/api/util/wx.encode)",
    "描述": "将字符串按照指定的编码格式编码成 ArrayBuffer"
  },
  {
    "接口名称": "[wx.decode](/minigame/dev/api/util/wx.decode)",
    "描述": "将 ArrayBuffer 按照指定的编码格式解码成字符串"
  }
]
```

## offline-mode

```json
[
  {
    "接口名称": "[wx.onOfflineModeStateChange](/minigame/dev/api/offline-mode/wx.onOfflineModeStateChange)",
    "描述": "监听离线模式状态变化事件"
  },
  {
    "接口名称": "[wx.offOfflineModeStateChange](/minigame/dev/api/offline-mode/wx.offOfflineModeStateChange)",
    "描述": "取消监听离线模式状态变化事件"
  },
  {
    "接口名称": "[wx.enableOfflineModeDebug](/minigame/dev/api/offline-mode/wx.enableOfflineModeDebug)",
    "描述": "开启或关闭离线模式调试"
  }
]
```