@realsee/live 0.3.0-alpha.4 → 0.4.0-alpha.3

package/dist/realsee-live.cjs.development.js

@@ -0,0 +1,1813 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var amazonChimeSdkJs = require('amazon-chime-sdk-js');
+var TRTC = require('trtc-js-sdk');
+var React = require('react');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var TRTC__default = /*#__PURE__*/_interopDefaultLegacy(TRTC);
+var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
+
+const EVENT_SYMBOL = Symbol('$$REALSEE_LIVE_EVENT$$');
+function __generateEventIfNotExisted(instance) {
+    if (!instance[EVENT_SYMBOL]) {
+        instance[EVENT_SYMBOL] = {};
+    }
+    return instance[EVENT_SYMBOL];
+}
+function __removeEventIfNotExisted(instance) {
+    if (!instance[EVENT_SYMBOL]) {
+        delete instance[EVENT_SYMBOL];
+    }
+}
+/**
+ * 监听者模式
+ * @template T 预设的监听回调类型
+ * @example
+ * ```
+ * new Subscribe<{
+ * "foo": [arg1: number, arg2: string],
+ * "bar": [arg: boolean],
+ * }>()
+ * ```
+ */
+class Subscribe {
+    /**
+     * 判断是否注册了事件
+     * @param name  事件类型
+     */
+    hasListener(name) {
+        const events = __generateEventIfNotExisted(this);
+        return events && events[name] && events[name].length > 0;
+    }
+    /**
+     * 注册事件
+     * @param  name    事件类型
+     * @param  callback 事件回调函数
+     * @param  once     是否只执行一次
+     * @returns 解除事件
+     * @template K 预设的监听事件名称
+     * @template C 回调函数函数上下文
+     */
+    on(name, callback, once) {
+        const events = __generateEventIfNotExisted(this);
+        if (!events[name])
+            events[name] = [];
+        events[name].push([callback, once || false]);
+        return () => this.off(name, callback);
+    }
+    /**
+     * 注册事件(是否只执行一次)
+     * @param  name     事件类型
+     * @param  callback 事件回调函数
+     * @returns 解除事件
+     * @template K 预设的监听事件名称
+     * @template C 回调函数函数上下文
+     */
+    once(name, callback) {
+        return this.on(name, callback, true);
+    }
+    /**
+     * 解除事件
+     *
+     * 如果 name 不传的话解除对应所有事件
+     * 如果 name, callback 不传的话解除所有name的所有事件
+     * @param  name     事件类型
+     * @param  callback 事件回调函数
+     * @template K 预设的监听事件名称
+     */
+    off(name, callback) {
+        if (name === undefined) {
+            __removeEventIfNotExisted(this);
+            return;
+        }
+        const events = __generateEventIfNotExisted(this);
+        if (!events[name])
+            events[name] = [];
+        if (callback === undefined) {
+            events[name].length = 0;
+            return;
+        }
+        let index = 0;
+        for (; index < events[name].length; index++) {
+            if (events[name][index][0] === callback)
+                break;
+        }
+        if (index < events[name].length) {
+            events[name].splice(index, 1);
+        }
+    }
+    /**
+     * 触发事件
+     * @param  name  事件类型
+     * @param  data  触发事件的数据
+     * @returns canceled 是否被触发取消
+     * @template K 预设的监听事件名称
+     */
+    emit(name, ...data) {
+        let canceled = false;
+        const events = __generateEventIfNotExisted(this);
+        const event = events[name] || [];
+        for (let one of event.slice()) {
+            const [callback, once = false] = one;
+            const result = callback(...data);
+            if (once)
+                this.off(name, callback);
+            if (result === false)
+                canceled = true;
+        }
+        return canceled;
+    }
+}
+
+/**
+ * rtc 基础抽象类
+ */
+class CoreRTC extends Subscribe {
+}
+
+/**
+ * rtc 类型
+ */
+exports.RTCType = void 0;
+(function (RTCType) {
+    RTCType["RealseeBrowserRTC"] = "RealseeBrowserRTC";
+    RTCType["RealseeVRWebViewRTC"] = "RealseeVRWebViewRTC";
+    RTCType["RealseeBrowserChimeRTC"] = "RealseeBrowserChimeRTC";
+})(exports.RTCType || (exports.RTCType = {}));
+
+// uuid
+function S4() {
+    return (((1 + Math.random()) * 0x10000) | 0).toString(16).substring(1);
+}
+/**
+ * 基于伪随机数生成 **uuid**。
+ */
+function uuid() {
+    // then to call it, plus stitch in '4' in the third group
+    return (S4() +
+        S4() +
+        '-' +
+        S4() +
+        '-4' +
+        S4().substr(0, 3) +
+        '-' +
+        S4() +
+        '-' +
+        S4() +
+        S4() +
+        S4()).toLowerCase();
+}
+
+class BrowserRTC extends CoreRTC {
+    constructor(options) {
+        super();
+        this.type = exports.RTCType.RealseeBrowserRTC;
+        this.joined = false;
+        this.micro = false;
+        this.voiceId = '';
+        this._getVoiceSign = () => {
+            throw new Error('方法 getVoiceSign 未实现');
+        };
+        this.$dom = document.createElement('div');
+        this._trtc = {
+            client: null,
+            stream: null,
+        };
+        this.join = async (options) => {
+            var _a;
+            this.emit('joinWillStart');
+            const createClientOptions = await this._getVoiceSign({
+                voiceId: options.voiceId,
+                roomId: options.roomId,
+                userId: options.userId,
+            });
+            // 1.  创建client
+            this._trtc.client = TRTC__default["default"].createClient({
+                mode: 'rtc',
+                ...createClientOptions,
+            });
+            (_a = this._trtc.client) === null || _a === void 0 ? void 0 : _a.enableAudioVolumeEvaluation();
+            // 2. 订阅事件
+            this._registerRtcEvent();
+            // 3. 加入语音房间
+            let result = await new Promise((resolve) => {
+                var _a;
+                (_a = this._trtc.client) === null || _a === void 0 ? void 0 : _a.join({ roomId: Number(options.voiceId) }).then(() => resolve(true)).catch(() => resolve(false));
+            });
+            this.joined = result;
+            if (!result)
+                return false; // 进房失败
+            // 4. 创建本地流
+            this._trtc.stream = TRTC__default["default"].createStream({
+                userId: createClientOptions.userId,
+                audio: true,
+                video: false,
+            });
+            // 5. 初始化本地流
+            result = await new Promise((resolve) => {
+                var _a;
+                (_a = this._trtc.stream) === null || _a === void 0 ? void 0 : _a.initialize().then(() => resolve(true)).catch(() => resolve(false));
+            });
+            // 6. 发布本地流
+            result = await new Promise((resolve) => {
+                var _a;
+                (_a = this._trtc.client) === null || _a === void 0 ? void 0 : _a.publish(this._trtc.stream).then(() => resolve(true)).catch(() => resolve(false));
+            });
+            this.joined = result;
+            if (this.joined)
+                this.emit('joined');
+            return result;
+        };
+        this._handleStreamAdded = (event) => {
+            var _a;
+            const remoteStream = event.stream;
+            console.log('远端流增加: ' + remoteStream.getId());
+            //订阅远端流
+            (_a = this._trtc.client) === null || _a === void 0 ? void 0 : _a.subscribe(remoteStream);
+        };
+        this._handleStreamSubscribed = (event) => {
+            const remoteStream = event.stream;
+            console.log('远端流订阅成功：' + remoteStream.getId());
+            const playId = remoteStream.getId();
+            const domId = `rs-rtc-remote_stream-${playId}`;
+            const dom = document.createElement('div');
+            dom.id = domId;
+            this.$dom.appendChild(dom);
+            // 播放远端流
+            remoteStream.play(domId);
+        };
+        this._getVoiceSign = options.getVoiceSign;
+        this._initParentDom();
+    }
+    _initParentDom() {
+        this.$dom.id = `rs-rtc-${uuid()}`;
+        this.$dom.style.display = 'none';
+        document.body.appendChild(this.$dom);
+    }
+    quit() {
+        return new Promise(async (resolve) => {
+            var _a, _b;
+            this.joined = false;
+            if (this._trtc.stream) {
+                await ((_a = this._trtc.client) === null || _a === void 0 ? void 0 : _a.unpublish(this._trtc.stream));
+                this._trtc.stream.stop();
+                this._trtc.stream.close();
+                this._trtc.stream = null;
+            }
+            (_b = this._trtc.client) === null || _b === void 0 ? void 0 : _b.leave().then(() => (this._trtc.client = null)).then(() => resolve(true)).catch(() => resolve(false));
+        });
+    }
+    detectMicro() {
+        return new Promise((resolve) => {
+            const rule = { audio: true, video: false };
+            try {
+                navigator.mediaDevices
+                    .getUserMedia(rule)
+                    .then(() => resolve(true))
+                    .catch(() => resolve(false));
+            }
+            catch (e) {
+                console.error(e);
+                resolve(false);
+            }
+        });
+    }
+    toggleMicro(flag) {
+        var _a, _b, _c, _d;
+        return Promise.resolve((flag
+            ? (_b = (_a = this._trtc) === null || _a === void 0 ? void 0 : _a.stream) === null || _b === void 0 ? void 0 : _b.unmuteAudio()
+            : (_d = (_c = this._trtc) === null || _c === void 0 ? void 0 : _c.stream) === null || _d === void 0 ? void 0 : _d.muteAudio()) || false);
+    }
+    shock() {
+        throw new Error('Method not implemented.');
+    }
+    _registerRtcEvent() {
+        var _a, _b, _c, _d;
+        (_a = this._trtc.client) === null || _a === void 0 ? void 0 : _a.on('stream-added', this._handleStreamAdded);
+        (_b = this._trtc.client) === null || _b === void 0 ? void 0 : _b.on('stream-subscribed', this._handleStreamSubscribed);
+        (_c = this._trtc.client) === null || _c === void 0 ? void 0 : _c.on('audio-volume', (event) => this.emit('userVolumes', [
+            { userId: event.userId, audioVolume: event.audioVolume },
+        ]));
+        (_d = this._trtc.client) === null || _d === void 0 ? void 0 : _d.on('error', (event) => this.emit('error', event));
+    }
+}
+
+/**
+ * amazon-chime-sdk-js 适配的rtc实现
+ */
+class BrowserRTC4Chime extends CoreRTC {
+    constructor(options) {
+        super();
+        this.type = exports.RTCType.RealseeBrowserChimeRTC;
+        this.joined = false;
+        this.micro = false;
+        this.voiceId = '';
+        this.userId = '';
+        this.deviceChangeObserver = {};
+        this.audioVideoObserver = {};
+        this._getVoiceSign = () => {
+            throw new Error('方法 getVoiceSign 未实现');
+        };
+        this.$dom = document.createElement('div');
+        this.$audio = document.createElement('audio');
+        /**
+         * 对audio标签初始化
+         */
+        this._initDom = () => {
+            this.$audio.id = `rs-rtc-${uuid()}`;
+            this.$dom.id = `rs-rtc-${uuid()}`;
+            this.$dom.appendChild(this.$audio);
+            document.body.appendChild(this.$dom);
+        };
+        /**
+         * 初始化事件监听器
+         */
+        this.initObservers = () => {
+            // 输入输出设备变化的监听器
+            this.deviceChangeObserver = {
+                audioInputsChanged: (freshAudioInputDeviceList) => {
+                    // An array of MediaDeviceInfo objects
+                    freshAudioInputDeviceList === null || freshAudioInputDeviceList === void 0 ? void 0 : freshAudioInputDeviceList.forEach((mediaDeviceInfo) => {
+                        this.logger.info(`Device ID: ${mediaDeviceInfo.deviceId} Microphone: ${mediaDeviceInfo.label}`);
+                    });
+                },
+                audioOutputsChanged: (freshAudioOutputDeviceList) => {
+                    this.logger.info(`Audio outputs updated: ${freshAudioOutputDeviceList}`);
+                },
+                videoInputsChanged: (freshVideoInputDeviceList) => {
+                    this.logger.info(`Video inputs updated: ${freshVideoInputDeviceList}`);
+                },
+                audioInputMuteStateChanged: (device, muted) => {
+                    this.logger.info(`Device ${device.toString()}  ${muted ? 'is muted in hardware' : 'is not muted'}`);
+                },
+            };
+            // 流变化监听器
+            this.audioVideoObserver = {
+                audioVideoDidStart: () => {
+                    this.logger.info('Started');
+                },
+                audioVideoDidStop: (sessionStatus) => {
+                    // See the "Stopping a session" section for details.
+                    this.logger.info(`Stopped with a session status code: ${sessionStatus.statusCode()}`);
+                },
+                audioVideoDidStartConnecting: (reconnecting) => {
+                    if (reconnecting) {
+                        // e.g. the WiFi connection is dropped.
+                        this.logger.info('Attempting to reconnect');
+                    }
+                },
+            };
+        };
+        /**
+         * 注册rtc事件
+         */
+        this._registerRtcEvent = () => {
+            var _a, _b, _c, _d, _e, _f;
+            const presentAttendeeId = ((_c = (_b = (_a = this.meetingSession) === null || _a === void 0 ? void 0 : _a.configuration) === null || _b === void 0 ? void 0 : _b.credentials) === null || _c === void 0 ? void 0 : _c.attendeeId) || '';
+            if (presentAttendeeId) {
+                // 处理音量变化
+                const roster = new Map();
+                const getUserVolumes = () => {
+                    const result = [];
+                    roster.forEach((v, k) => {
+                        result.push({
+                            userId: v.userId,
+                            volume: v.muted || v.signalStrength === 0 || !Boolean(v.volume)
+                                ? 0
+                                : v.volume,
+                        });
+                    });
+                    return result;
+                };
+                (_d = this.meetingSession) === null || _d === void 0 ? void 0 : _d.audioVideo.realtimeSubscribeToAttendeeIdPresence((presentAttendeeId, present, externalUserId) => {
+                    var _a;
+                    if (!present) {
+                        roster.delete(presentAttendeeId);
+                        this.emit('userVolumes', getUserVolumes());
+                        return;
+                    }
+                    (_a = this.meetingSession) === null || _a === void 0 ? void 0 : _a.audioVideo.realtimeSubscribeToVolumeIndicator(presentAttendeeId, (attendeeId, volume, muted, signalStrength) => {
+                        const baseAttendeeId = new amazonChimeSdkJs.DefaultModality(attendeeId).base();
+                        if (baseAttendeeId !== attendeeId) {
+                            // Optional: Do not include the content attendee (attendee-id#content) in the roster.
+                            // See the "Screen and content share" section for details.
+                            return;
+                        }
+                        roster.set(attendeeId, {
+                            userId: externalUserId || attendeeId,
+                            volume,
+                            muted,
+                            signalStrength,
+                        });
+                        this.emit('userVolumes', getUserVolumes());
+                    });
+                });
+                // 弱网
+                (_e = this.meetingSession) === null || _e === void 0 ? void 0 : _e.audioVideo.realtimeSubscribeToVolumeIndicator(presentAttendeeId, (attendeeId, volume, muted, signalStrength) => {
+                    const baseAttendeeId = new amazonChimeSdkJs.DefaultModality(attendeeId).base();
+                    if (baseAttendeeId === attendeeId) {
+                        if (signalStrength !== null && signalStrength !== 1) {
+                            this.emit('weakNetwork');
+                        }
+                    }
+                });
+                // 报错
+                (_f = this.meetingSession) === null || _f === void 0 ? void 0 : _f.audioVideo.realtimeSubscribeToFatalError((error) => this.emit('error', error));
+            }
+        };
+        // 挂载签名钩子
+        this._getVoiceSign = options.getVoiceSign;
+        this._initDom();
+        this.logger = new amazonChimeSdkJs.ConsoleLogger('WebRTCLogger', options.logLevel || amazonChimeSdkJs.LogLevel.OFF);
+        this.deviceController = new amazonChimeSdkJs.DefaultDeviceController(this.logger);
+        this.initObservers();
+    }
+    /**
+     * 加入语音会议
+     * @param options
+     * @returns
+     */
+    async join(options) {
+        return new Promise(async (success, fail) => {
+            var _a;
+            this.emit('joinWillStart');
+            try {
+                // 取签名
+                const { sdkAppId, userId, roomId, userSig } = await this._getVoiceSign({
+                    ...options,
+                    roomId: options.roomId || 0,
+                });
+                this.userId = userId;
+                const { attendence, vendor_wrapper, } = JSON.parse(decodeURIComponent(userSig));
+                // 初始化配置
+                const configuration = new amazonChimeSdkJs.MeetingSessionConfiguration({
+                    Meeting: vendor_wrapper,
+                }, {
+                    Attendee: {
+                        ExternalUserId: attendence.external_user_id,
+                        AttendeeId: attendence.attendee_id,
+                        JoinToken: attendence.join_token,
+                    },
+                });
+                // 初始化会议会话
+                this.meetingSession = new amazonChimeSdkJs.DefaultMeetingSession(configuration, this.logger, this.deviceController);
+                // 注册事件
+                this._registerRtcEvent();
+                // 绑定监听器
+                this.meetingSession.audioVideo.addDeviceChangeObserver(this.deviceChangeObserver);
+                this.meetingSession.audioVideo.addObserver(this.audioVideoObserver);
+                // 绑定播放器
+                this.meetingSession.audioVideo.bindAudioElement(this.$audio);
+                const observer = {
+                    audioVideoDidStart: () => {
+                        var _a;
+                        (_a = this.meetingSession) === null || _a === void 0 ? void 0 : _a.audioVideo.realtimeMuteLocalAudio();
+                        this.joined = true;
+                        this.emit('joined');
+                        success(true);
+                    },
+                    audioVideoDidStop: () => {
+                        this.joined = false;
+                        success(false);
+                    },
+                };
+                this.meetingSession.audioVideo.addObserver(observer);
+                // 选择语音输入设备
+                const audioInputDevices = await this.deviceController.listAudioInputDevices(true);
+                const defaultAudioInput = audioInputDevices.find((device) => device.deviceId === 'default');
+                const otherAudioInput = audioInputDevices.find((device) => device.deviceId !== '');
+                this.audioInput = defaultAudioInput || otherAudioInput;
+                await this.meetingSession.audioVideo.chooseVideoInputDevice(null);
+                await this.meetingSession.audioVideo.chooseAudioInputDevice(((_a = this.audioInput) === null || _a === void 0 ? void 0 : _a.deviceId) || 'default');
+                this.meetingSession.audioVideo.start();
+            }
+            catch (e) {
+                this.emit('error', e);
+                this.logger.error(e.message);
+                success(false);
+            }
+        });
+    }
+    quit() {
+        return new Promise((success, fail) => {
+            var _a, _b;
+            this.joined = false;
+            const observer = {
+                audioVideoDidStop: (sessionStatus) => {
+                    const sessionStatusCode = sessionStatus.statusCode();
+                    if (sessionStatusCode === amazonChimeSdkJs.MeetingSessionStatusCode.Left) {
+                        /*
+                          - You called meetingSession.audioVideo.stop().
+                          - When closing a browser window or page, Chime SDK attempts to leave the session.
+                        */
+                        this.logger.info('You left the session');
+                        success(true);
+                    }
+                    else {
+                        this.logger.info(`Stopped with a session status code: ${sessionStatusCode}`);
+                        success(true);
+                    }
+                },
+            };
+            (_a = this.meetingSession) === null || _a === void 0 ? void 0 : _a.audioVideo.addObserver(observer);
+            (_b = this.meetingSession) === null || _b === void 0 ? void 0 : _b.audioVideo.stop();
+        });
+    }
+    async detectMicro() {
+        return new Promise((resolve) => {
+            const rule = { audio: true, video: false };
+            try {
+                navigator.mediaDevices
+                    .getUserMedia(rule)
+                    .then(() => resolve(true))
+                    .catch(() => resolve(false));
+            }
+            catch (e) {
+                this.logger.error(e.message);
+                resolve(false);
+            }
+        });
+    }
+    async toggleMicro(flag) {
+        var _a, _b, _c;
+        if (flag) {
+            (_a = this.meetingSession) === null || _a === void 0 ? void 0 : _a.audioVideo.realtimeUnmuteLocalAudio();
+        }
+        else {
+            (_b = this.meetingSession) === null || _b === void 0 ? void 0 : _b.audioVideo.realtimeMuteLocalAudio();
+        }
+        const muted = (_c = this.meetingSession) === null || _c === void 0 ? void 0 : _c.audioVideo.realtimeIsLocalAudioMuted();
+        if (muted !== undefined) {
+            return flag !== muted;
+        }
+        else {
+            return false;
+        }
+    }
+    shock() {
+        throw new Error('Method not implemented.');
+    }
+}
+
+/**
+ * rtc加入返回值code枚举
+ */
+exports.RTCJoinedInfoCodeEnum = void 0;
+(function (RTCJoinedInfoCodeEnum) {
+    /**
+     * 成功
+     */
+    RTCJoinedInfoCodeEnum[RTCJoinedInfoCodeEnum["Success"] = 0] = "Success";
+    /**
+     * 失败
+     */
+    RTCJoinedInfoCodeEnum[RTCJoinedInfoCodeEnum["Failure"] = 1] = "Failure";
+    /**
+     * 重复加入
+     */
+    RTCJoinedInfoCodeEnum[RTCJoinedInfoCodeEnum["ReJoin"] = 2] = "ReJoin";
+    /**
+     * 无麦克风权限
+     */
+    RTCJoinedInfoCodeEnum[RTCJoinedInfoCodeEnum["NoMicroPermission"] = 3] = "NoMicroPermission";
+})(exports.RTCJoinedInfoCodeEnum || (exports.RTCJoinedInfoCodeEnum = {}));
+
+class VRWebViewRTC extends CoreRTC {
+    constructor({ jsBridge, getVoiceSign }) {
+        super();
+        this.type = exports.RTCType.RealseeVRWebViewRTC;
+        this.joined = false;
+        this.micro = false;
+        this.voiceId = '';
+        this.options = { jsBridge, getVoiceSign };
+        this.jsBridge.callAndListen('live/userVolumes', (userVolumes) => {
+            this.emit('userVolumes', userVolumes);
+        });
+        this.jsBridge.callAndListen('live/weakNetwork', (weakNetwork) => {
+            if (weakNetwork)
+                this.emit('weakNetwork');
+        });
+    }
+    get jsBridge() {
+        return this.options.jsBridge;
+    }
+    async join(options) {
+        this.emit('joinWillStart');
+        const { sdkAppId, userId, userSig } = await this.options.getVoiceSign(options);
+        this.type = options.type;
+        const [res, error] = await this.jsBridge.callAndBackfeed(`live/join?sdkAppID=${sdkAppId}&userID=${userId}&roomID=${Number(options.voiceId)}&userSig=${userSig}`);
+        if (!res) {
+            this.emit('error', error ? error : new Error('加入房间失败：未知异常。'));
+            this.joined = false;
+        }
+        else {
+            if (res.code === exports.RTCJoinedInfoCodeEnum.Success) {
+                this.emit('joined');
+                this.joined = true;
+            }
+            else {
+                this.emit('error', res);
+                this.joined = false;
+            }
+        }
+        return this.joined;
+    }
+    async quit() {
+        const [res, error] = await this.jsBridge.callAndBackfeed('live/quit');
+        if (res === null) {
+            this.emit('error', error ? error : new Error('退出房间失败：未知异常。'));
+        }
+        this.joined = false;
+        return !!res;
+    }
+    async detectMicro() {
+        const [res, error] = await this.jsBridge.detectMicro();
+        if (res === null) {
+            this.emit('error', error ? error : new Error('麦克风监测异常！'));
+            return false;
+        }
+        return res;
+    }
+    async toggleMicro(flag) {
+        const [res, error] = await this.jsBridge.callAndBackfeed(`live/toggleMicro?flag=${!!flag ? 1 : 0}`);
+        if (res === null) {
+            this.emit('error', error ? error : new Error('麦克风监测异常！'));
+            return false;
+        }
+        this.micro = res;
+        return res;
+    }
+    shock() {
+        this.jsBridge.shock(1);
+    }
+}
+
+/**
+ * WebSocket 通信指令
+ * - 下行：服务端推送数据
+ * - 上行：客户端上报数据
+ */
+exports.Command = void 0;
+(function (Command) {
+    /* 当前用户信息：下行 */
+    Command["SelfUserInfo"] = "SELF_USER_INFO";
+    /* 房间信息：下行 */
+    Command["RoomInfo"] = "ROOM_INFO";
+    /* RTC信息：下行 */
+    Command["RTCInfo"] = "RTC_INFO";
+    /* 用户列表：下行 */
+    Command["UserList"] = "USER_LIST";
+    /* 内置消息：下行、上行 */
+    Command["BuiltinMsg"] = "BUILTIN_MSG";
+    /* 自定义广播事件消息：下行、上行 */
+    Command["CustomEvent"] = "CUSTOM_EVENT";
+    /* 帧数据同步：下行、上行 */
+    Command["KeyframeSync"] = "KEYFRAME_SYNC";
+    /* 被踢出房间：下行 */
+    Command["UserKickOut"] = "USER_KICK_OUT";
+})(exports.Command || (exports.Command = {}));
+/**
+ * 内置事件类型。
+ */
+exports.BuiltinEventType = void 0;
+(function (BuiltinEventType) {
+    /**
+     * 变更用户状态。
+     */
+    BuiltinEventType["UserChange"] = "user_change";
+    /**
+     * 变更房间状态。
+     */
+    BuiltinEventType["RoomChange"] = "room_change";
+})(exports.BuiltinEventType || (exports.BuiltinEventType = {}));
+/**
+ * 内置事件行为类型。
+ */
+exports.BuiltinActionType = void 0;
+(function (BuiltinActionType) {
+    /**
+     * 修改麦克风状态。
+     */
+    BuiltinActionType["UserMicroStatus"] = "change_micro_status";
+    /**
+     * 同步当前用户状态：客户端麦克风状态已经修改成功，通知服务端
+     */
+    BuiltinActionType["UserMicroStatusSync"] = "sync_micro_status";
+    /**
+     * 调整某些用户的权限。
+     */
+    BuiltinActionType["UserPermission"] = "change_permission";
+    /**
+     * 用户状态发生改变。
+     */
+    BuiltinActionType["UserStatus"] = "change_status";
+    /**
+     * 更新用户信息。
+     */
+    BuiltinActionType["UserInfo"] = "change_info";
+    /**
+     * 关闭房间。
+     */
+    BuiltinActionType["RoomClose"] = "close";
+})(exports.BuiltinActionType || (exports.BuiltinActionType = {}));
+/**
+ * 麦克风状态。
+ */
+exports.MicroStatus = void 0;
+(function (MicroStatus) {
+    MicroStatus["OPEN"] = "OPEN";
+    MicroStatus["CLOSE"] = "CLOSE";
+})(exports.MicroStatus || (exports.MicroStatus = {}));
+/**
+ * 解析下后端数据格式。
+ * @param jsonTxt - JSON序列化后的文本。
+ * @returns false 标识解析失败；解析成功返回 {@link LiveMsg} 实例。
+ */
+function parseLiveMsg(jsonTxt) {
+    try {
+        const msg = JSON.parse(jsonTxt);
+        const resMsg = {
+            code: msg.code,
+            message: msg.message,
+            command: msg.command,
+            roomCode: msg.room_code,
+            appID: msg.app_id,
+            requestId: msg.request_id,
+            frontRequestId: msg.front_request_id,
+            triggerUserID: msg.trigger_user_id,
+            data: msg.data || {},
+        };
+        const undefinedKeys = Object.keys(resMsg).filter((key) => resMsg[key] === undefined);
+        if (undefinedKeys.length > 0) {
+            console.warn(`推送数据格式异常：${undefinedKeys.join(" ")} 值不存在！`);
+        }
+        return resMsg;
+    }
+    catch (error) {
+        // notcare? 过滤掉所有不符合规范的数据
+        return false;
+    }
+}
+
+/**
+ * 用户当前状态枚举。
+ */
+exports.UserStatus = void 0;
+(function (UserStatus) {
+    /**
+     * 正常
+     */
+    UserStatus[UserStatus["Normal"] = 0] = "Normal";
+    /**
+     * 被移除
+     */
+    UserStatus[UserStatus["Removed"] = 1] = "Removed";
+    /**
+     * 被替换
+     */
+    UserStatus[UserStatus["Replaced"] = 2] = "Replaced";
+})(exports.UserStatus || (exports.UserStatus = {}));
+exports.MemUserStatus = void 0;
+(function (MemUserStatus) {
+    MemUserStatus["WAIT_ENTER"] = "WAIT_ENTER";
+    MemUserStatus["ONLINE"] = "ONLINE";
+    MemUserStatus["LEAVE"] = "LEAVE";
+    MemUserStatus["KICK_OUT"] = "KICK_OUT";
+    MemUserStatus["BE_REPLACE"] = "BE_REPLACE";
+    MemUserStatus["EXCEPTION"] = "EXCEPTION";
+})(exports.MemUserStatus || (exports.MemUserStatus = {}));
+
+/**
+ * WebSocket 连接状态枚举
+ */
+exports.WebSocketState = void 0;
+(function (WebSocketState) {
+    /**
+     * 尚未初始化
+     */
+    WebSocketState[WebSocketState["NOTINITIALIZED"] = -1] = "NOTINITIALIZED";
+    /**
+     * 正在链接中
+     */
+    WebSocketState[WebSocketState["CONNECTING"] = 0] = "CONNECTING";
+    /**
+     * 已经链接并且可以通讯
+     */
+    WebSocketState[WebSocketState["OPEN"] = 1] = "OPEN";
+    /**
+     * 连接正在关闭
+     */
+    WebSocketState[WebSocketState["CLOSING"] = 2] = "CLOSING";
+    /**
+     * 连接已关闭或者没有链接成功
+     */
+    WebSocketState[WebSocketState["CLOSED"] = 3] = "CLOSED";
+})(exports.WebSocketState || (exports.WebSocketState = {}));
+exports.WebSocketErrorType = void 0;
+(function (WebSocketErrorType) {
+    WebSocketErrorType["Error"] = "Error";
+    WebSocketErrorType["Close"] = "Close";
+    WebSocketErrorType["MicroAuth"] = "MicroAuth";
+    WebSocketErrorType["DuplicateConnect"] = "DuplicateConnect";
+    WebSocketErrorType["IllegalURL"] = "IllegalURL";
+    WebSocketErrorType["Unknown"] = "Unknown";
+    WebSocketErrorType["IllegalArgs"] = "IllegalArgs";
+})(exports.WebSocketErrorType || (exports.WebSocketErrorType = {}));
+/**
+ * WebSocket 异常关闭枚举：https://developer.mozilla.org/zh-CN/docs/Web/API/CloseEvent。
+ */
+exports.WebSocketCloseError = void 0;
+(function (WebSocketCloseError) {
+    /**
+     * 终端离开, 可能因为服务端错误, 也可能因为浏览器正从打开连接的页面跳转离开。
+     */
+    WebSocketCloseError["Err_1001"] = "CLOSE_GOING_AWAY";
+    /**
+     * 由于协议错误而中断连接。
+     */
+    WebSocketCloseError["Err_1002"] = "CLOSE_PROTOCOL_ERROR";
+    /**
+     * 由于接收到不允许的数据类型而断开连接 (如仅接收文本数据的终端接收到了二进制数据)。
+     */
+    WebSocketCloseError["Err_1003"] = "CLOSE_UNSUPPORTED";
+    /**
+     * 安全因素或WebSocket连接次数达到上限。
+     */
+    WebSocketCloseError["Err_1006"] = "CLOSE_ABNORMAL";
+    /**
+     * 由于收到了格式不符的数据而断开连接 (如文本消息中包含了非 UTF-8 数据)。
+     */
+    WebSocketCloseError["Err_1007"] = "Unsupported Data";
+    /**
+     * 由于收到不符合约定的数据而断开连接。
+     */
+    WebSocketCloseError["Err_1008"] = "Policy Violation";
+    /**
+     * 由于收到过大的数据帧而断开连接。
+     */
+    WebSocketCloseError["Err_1009"] = "CLOSE_TOO_LARGE";
+    /**
+     * 未知错误。
+     */
+    WebSocketCloseError["Err_unknown"] = "unknown";
+})(exports.WebSocketCloseError || (exports.WebSocketCloseError = {}));
+function parseWSClsErr(code) {
+    switch (code) {
+        case 1001: {
+            return exports.WebSocketCloseError.Err_1001;
+        }
+        case 1002: {
+            return exports.WebSocketCloseError.Err_1002;
+        }
+        case 1003: {
+            return exports.WebSocketCloseError.Err_1003;
+        }
+        case 1006: {
+            return exports.WebSocketCloseError.Err_1006;
+        }
+        case 1007: {
+            return exports.WebSocketCloseError.Err_1007;
+        }
+        case 1008: {
+            return exports.WebSocketCloseError.Err_1008;
+        }
+        case 1009: {
+            return exports.WebSocketCloseError.Err_1009;
+        }
+    }
+    return exports.WebSocketCloseError.Err_unknown;
+}
+
+function appendUri(uri, query) {
+    const hasQuery = uri.indexOf('?') !== -1;
+    const newQuery = Object.keys(query).reduce((accu, curr, idx) => `${accu}${(idx === 0 && !hasQuery) ? '?' : '&'}${curr}=${query[curr]}`, '');
+    return uri + newQuery;
+}
+
+/**
+ * 判断是否是真实的对象类型
+ * @param value
+ * @returns
+ */
+function isTrulyObject(value) {
+    return Object.prototype.toString.call(value) === '[object Object]';
+}
+/**
+ * 判断基础类型是否相等
+ * @param value
+ * @param other
+ * @returns
+ */
+function baseIsEqual(value, other) {
+    if (value === other)
+        return true;
+    if (typeof value !== typeof other)
+        return false;
+    if (Number.isNaN(value) && Number.isNaN(other))
+        return true;
+    return false;
+}
+/**
+ * 对象浅比较
+ * @param value
+ * @param other
+ * @returns
+ */
+function objEqualShallow(value, other) {
+    const valueProps = Object.getOwnPropertyNames(value);
+    const otherProps = Object.getOwnPropertyNames(other);
+    if (valueProps.length !== otherProps.length)
+        return false;
+    for (let i = 0, len = valueProps.length; i < len; i++) {
+        const propName = valueProps[i];
+        if (!baseIsEqual(value[propName], other[propName]))
+            return false;
+    }
+    return true;
+}
+/**
+ * 数组浅比较
+ * @param value
+ * @param other
+ * @returns
+ */
+function arrayEqualShallow(value, other) {
+    if (value.length !== other.length)
+        return false;
+    for (let i = 0, len = value.length; i < len; i++) {
+        if (!baseIsEqual(value[i], other[i]))
+            return false;
+    }
+    return true;
+}
+/**
+ * 变量浅比较
+ * @param value
+ * @param other
+ * @returns
+ */
+function isShallowEqual(value, other) {
+    if (baseIsEqual(value, other))
+        return true;
+    if (isTrulyObject(value) && isTrulyObject(other))
+        return objEqualShallow(value, other);
+    if (Array.isArray(value) && Array.isArray(other))
+        return arrayEqualShallow(value, other);
+    return false;
+}
+/**
+ * 对象深比较
+ * @param value
+ * @param other
+ * @returns
+ */
+function isDeepEqual(value, other) {
+    if (baseIsEqual(value, other))
+        return true;
+    if (isTrulyObject(value) && isTrulyObject(other))
+        return objEqualDeep(value, other);
+    if (Array.isArray(value) && Array.isArray(other))
+        return arrayEqualDeep(value, other);
+    return false;
+}
+/**
+ * 数组深比较
+ * @param value
+ * @param other
+ * @returns
+ */
+function arrayEqualDeep(value, other) {
+    if (value.length !== other.length)
+        return false;
+    for (let i = 0, len = value.length; i < len; i++) {
+        if (!isDeepEqual(value[i], other[i]))
+            return false;
+    }
+    return true;
+}
+/**
+ * 对象深比较
+ * @param value
+ * @param other
+ * @returns
+ */
+function objEqualDeep(value, other) {
+    const valueProps = Object.getOwnPropertyNames(value);
+    const otherProps = Object.getOwnPropertyNames(other);
+    if (valueProps.length !== otherProps.length)
+        return false;
+    for (let i = 0, len = valueProps.length; i < len; i++) {
+        const propName = valueProps[i];
+        if (!isDeepEqual(value[propName], other[propName]))
+            return false;
+    }
+    return true;
+}
+/**
+ * 对象比较。
+ * @param value 第一个比较的值。
+ * @param other 第二个比较的值。
+ * @param options 可选参数，可选项：`deep` 是否深比较。
+ * @returns {boolean} 是否相等。
+ */
+function equal(value, other, opt) {
+    if (!opt.deep)
+        return isShallowEqual(value, other);
+    return isDeepEqual(value, other);
+}
+
+class LiveController {
+    constructor(options) {
+        this.readyState = exports.WebSocketState.NOTINITIALIZED;
+        this.canSync = true;
+        this.connecting = false;
+        this.keyframes = {};
+        /**
+         * 检测 WebSocket.readyState 状态
+         */
+        this.checkReadyState = (live) => {
+            do {
+                if (!this.webSocket) {
+                    if (this.readyState !== exports.WebSocketState.NOTINITIALIZED) {
+                        this.readyState = exports.WebSocketState.NOTINITIALIZED;
+                        live.emit('ws.readyStateUpdate', this.readyState);
+                    }
+                    break;
+                }
+                const readyState = this.webSocket.readyState;
+                if (readyState !== this.readyState) {
+                    this.readyState = readyState;
+                    live.emit('ws.readyStateUpdate', this.readyState);
+                }
+            } while (false);
+            return this.readyState;
+        };
+        this.dispose = () => {
+            this.disposeWebSocket();
+            this.connecting = false;
+            if (this.healthCheckId) {
+                clearInterval(this.healthCheckId);
+                this.healthCheckId = undefined;
+            }
+        };
+        /**
+         * 销毁WebSocket相关依赖。
+         */
+        this.disposeWebSocket = () => {
+            if (!this.webSocket)
+                return;
+            if (this.onEvtOpnListener) {
+                this.webSocket.removeEventListener('open', this.onEvtOpnListener);
+                this.onEvtOpnListener = undefined;
+            }
+            if (this.onEvtMsgListener) {
+                this.webSocket.removeEventListener('message', this.onEvtMsgListener);
+                this.onEvtMsgListener = undefined;
+            }
+            if (this.onEvtErrListener) {
+                this.webSocket.removeEventListener('error', this.onEvtErrListener);
+                this.onEvtErrListener = undefined;
+            }
+            if (this.onEvtCLEListener) {
+                this.webSocket.removeEventListener('close', this.onEvtCLEListener);
+                this.onEvtCLEListener = undefined;
+            }
+            this.webSocket.close();
+            this.webSocket = undefined;
+        };
+        this.options = Object.assign({ autoConnect: true, healthCheck: 3000 }, options);
+    }
+    /**
+     * 解析数据
+     * @param liveMsg
+     * @param live
+     */
+    handleMessage(liveMsg, live) {
+        var _a, _b, _c;
+        const { command, data, frontRequestId, code, message } = liveMsg;
+        if (code === 'SUCCESS') {
+            switch (command) {
+                /**
+                 * 自己的状态变化
+                 */
+                case exports.Command.SelfUserInfo: {
+                    const selfInfo = data;
+                    if (equal(this.selfUserInfo, selfInfo, { deep: true }))
+                        return;
+                    this.selfUserInfo = selfInfo;
+                    live.emit('selfInfoUpdate', this.selfUserInfo, frontRequestId);
+                    break;
+                }
+                /**
+                 * 房间信息变化
+                 */
+                case exports.Command.RoomInfo: {
+                    const roomInfo = data;
+                    this.roomInfo = Object.assign({}, roomInfo);
+                    live.emit('readyKeyframeSync', (roomInfo.last_frame || {}));
+                    break;
+                }
+                /**
+                 * 语音信息变化
+                 */
+                case exports.Command.RTCInfo: {
+                    const { voice_id: voiceId, type } = data;
+                    /* 如果已经进入语音房间，则不重复进入 --> "RTCInfo" 指令可能会下发多次 */
+                    if (live.$RTC.joined) {
+                        break;
+                    }
+                    live.$RTC.join({
+                        voiceId,
+                        userId: ((_a = this.selfUserInfo) === null || _a === void 0 ? void 0 : _a.id) || '',
+                        roomId: (_b = this.roomInfo) === null || _b === void 0 ? void 0 : _b.info.room_code,
+                        type,
+                    });
+                    // 加入房间后 麦克风默认就开启了：需要发个指令。
+                    live.updateStatus(exports.BuiltinEventType.UserChange, exports.BuiltinActionType.UserMicroStatus, {
+                        status: exports.MicroStatus.OPEN,
+                    });
+                    break;
+                }
+                /**
+                 * 房间用户列表变化
+                 */
+                case exports.Command.UserList: {
+                    const userList = data;
+                    this.userList = userList;
+                    live.emit('userListUpdate', this.userList, frontRequestId);
+                    break;
+                }
+                /**
+                 * 自定义事件广播
+                 */
+                case exports.Command.CustomEvent: {
+                    const evtMsg = data;
+                    live.emit('broadcast', evtMsg, frontRequestId);
+                    break;
+                }
+                /**
+                 * 帧数据同步
+                 */
+                case exports.Command.KeyframeSync: {
+                    const remoteKeyframes = data;
+                    // 此处做一层 diff，仅跟本地数据不一致的情况下才广播数据。
+                    const keyframes = Object.keys(remoteKeyframes).reduce((accu, curr) => {
+                        if (equal(remoteKeyframes[curr], this.keyframes[curr], { deep: true })) {
+                            return accu;
+                        }
+                        const params = [
+                            remoteKeyframes[curr],
+                            this.keyframes[curr],
+                            frontRequestId,
+                        ];
+                        const evtName = curr;
+                        live.keyframes.emit(evtName, ...params);
+                        this.keyframes[curr] = remoteKeyframes[curr];
+                        accu[curr] = remoteKeyframes[curr];
+                        return accu;
+                    }, {});
+                    live.emit('keyframes', keyframes, frontRequestId);
+                    break;
+                }
+                /**
+                 * 内置消息
+                 */
+                case exports.Command.BuiltinMsg: {
+                    const builtinMsg = data;
+                    live.emit('builtinEvent', builtinMsg);
+                    if (builtinMsg.event_type === exports.BuiltinEventType.UserChange) {
+                        live.emit('userChange', builtinMsg);
+                    }
+                    if (builtinMsg.event_type === exports.BuiltinEventType.RoomChange) {
+                        live.emit('roomChange', builtinMsg);
+                    }
+                    /**
+                     * 下发指令自己操作麦克风
+                     */
+                    if (builtinMsg.event_type === exports.BuiltinEventType.UserChange &&
+                        builtinMsg.action === exports.BuiltinActionType.UserMicroStatus) {
+                        live.toggleMicro(builtinMsg.data.status === exports.MicroStatus.OPEN);
+                    }
+                    /**
+                     * 如果下发指令退出房间，则 关闭麦克风 及 销毁 WebSocket
+                     */
+                    if (builtinMsg.event_type === exports.BuiltinEventType.RoomChange &&
+                        builtinMsg.action === exports.BuiltinActionType.RoomClose) {
+                        (_c = this.options.rtc) === null || _c === void 0 ? void 0 : _c.quit();
+                        this.disposeWebSocket();
+                    }
+                    break;
+                }
+                /**
+                 * 被踢出房间
+                 */
+                case exports.Command.UserKickOut: {
+                    live.emit('kickOut');
+                    break;
+                }
+                /**
+                 * 其它未知广播
+                 */
+                default: {
+                    console.warn('unknown command: ', command);
+                }
+            }
+        }
+        else {
+            live.emit('error', liveMsg);
+        }
+    }
+    /**
+     * 发送数据
+     * @param data
+     */
+    sendMessage(data) {
+        if (!this.webSocket)
+            return console.warn('WebSocket has not yet been initialized!');
+        if (!data)
+            return console.warn('WebSocket messages is empty!');
+        this.webSocket.send(JSON.stringify(data));
+    }
+}
+
+const unimplementedGetVoiceSign = (params) => Promise.reject('unimplemented method GetVoiceSign');
+/**
+ * 创建 `live` 实例。
+ */
+function createLive(options) {
+    const liveController = new LiveController(options);
+    const createLiveMsg = (command, data = {}, toUserIds) => {
+        toUserIds = toUserIds
+            ? Array.isArray(toUserIds)
+                ? toUserIds
+                : [toUserIds]
+            : [];
+        if (toUserIds)
+            data['to_user_ids'] = toUserIds;
+        return { command, front_request_id: uuid(), data };
+    };
+    class LiveTpl extends Subscribe {
+        constructor() {
+            var _a;
+            super();
+            this.keyframes = new Subscribe();
+            // 没有传rtc实例时
+            if (!options.rtc) {
+                // 取指定的内部rtc类型
+                if (options.rtcType) {
+                    if (!options.getVoiceSign) {
+                        throw new Error('GetVoiceSign method must be passed when using built-in RTC instances');
+                    }
+                    const getVoiceSign = (_a = options.getVoiceSign) !== null && _a !== void 0 ? _a : unimplementedGetVoiceSign;
+                    switch (options.rtcType) {
+                        case exports.RTCType.RealseeVRWebViewRTC: {
+                            // 内置的 VRWebViewRTC
+                            if (!options.jsBridge) {
+                                throw new Error('JsBridge instance must be passed when using built-in VRWebViewRTC instances');
+                            }
+                            liveController.options.rtc = new VRWebViewRTC({
+                                jsBridge: options.jsBridge,
+                                getVoiceSign,
+                            });
+                            break;
+                        }
+                        case exports.RTCType.RealseeBrowserChimeRTC: {
+                            // 内置的 RealseeBrowserChimeRTC
+                            liveController.options.rtc = new BrowserRTC4Chime({
+                                getVoiceSign,
+                                logLevel: options.__debug__ ? amazonChimeSdkJs.LogLevel.DEBUG : amazonChimeSdkJs.LogLevel.ERROR,
+                            });
+                            break;
+                        }
+                        case exports.RTCType.RealseeBrowserRTC: {
+                            // 内置的 RealseeBrowserRTC
+                            liveController.options.rtc = new BrowserRTC({
+                                getVoiceSign,
+                            });
+                            break;
+                        }
+                        default: {
+                            throw new Error('unknown built-in RTC type');
+                        }
+                    }
+                }
+            }
+            if (!liveController.options.rtc) {
+                console.warn('unused rtc');
+            }
+            // 默认自动连接
+            if (liveController.options.url && liveController.options.getTicket) {
+                this.connect();
+            }
+            // 健康检查：WHY --> 在某些WebView特殊场景下 WebSocket.readyState 发生变化时不会出发error\close等事件;
+            //         因此，开启一个定时任务监测 WebSocket.readyState 状态的更新
+            const healthCheck = ((healthCheck) => {
+                if (!healthCheck)
+                    return 0;
+                if (healthCheck === true)
+                    return 3000;
+                const duration = Number(healthCheck);
+                if (duration > 0)
+                    return duration;
+                return 3000;
+            })(liveController.options.healthCheck);
+            if (healthCheck) {
+                liveController.healthCheckId = setInterval(() => liveController.checkReadyState(this), healthCheck);
+            }
+        }
+        get options() {
+            return Object.freeze(Object.assign({}, liveController.options));
+        }
+        get readyState() {
+            liveController.checkReadyState(this);
+            return liveController.readyState;
+        }
+        get url() {
+            var _a;
+            return ((_a = liveController.webSocket) === null || _a === void 0 ? void 0 : _a.url) || '';
+        }
+        get selfInfo() {
+            return liveController.selfUserInfo;
+        }
+        get userList() {
+            return liveController.userList || [];
+        }
+        get snapshot() {
+            return liveController.keyframes || {};
+        }
+        get $RTC() {
+            return liveController.options.rtc;
+        }
+        async setSelfInfo(userInfo) {
+            if (this.readyState !== exports.WebSocketState.OPEN) {
+                return new Error('The connection is not open and ready to communicate.');
+            }
+            try {
+                return await this.updateStatus(exports.BuiltinEventType.UserChange, exports.BuiltinActionType.UserInfo, userInfo);
+            }
+            catch (error) {
+                return error;
+            }
+        }
+        getFramesByKey(key) {
+            return liveController.keyframes[key];
+        }
+        sendKeyframe(key, frame) {
+            if (this.readyState !== exports.WebSocketState.OPEN) {
+                return new Error('The connection is not open and ready to communicate.');
+            }
+            liveController.keyframes[key] = frame;
+            const liveMsg = createLiveMsg(exports.Command.KeyframeSync, this.snapshot);
+            liveController.sendMessage(liveMsg);
+            return true;
+        }
+        broadcast(data, toUserIds, timeout) {
+            if (this.readyState !== exports.WebSocketState.OPEN) {
+                return new Error('The connection is not open and ready to communicate.');
+            }
+            return new Promise((resolve, reject) => {
+                const customEvent = createLiveMsg(exports.Command.CustomEvent, data, toUserIds);
+                const front_request_id = customEvent.front_request_id;
+                liveController.sendMessage(customEvent);
+                const timeoutId = timeout
+                    ? setTimeout(() => {
+                        reject(new Error('RESPONSE TIMEOUT'));
+                        this.off('broadcast', broadcast);
+                    }, timeout)
+                    : undefined;
+                const broadcast = (data, frontRequestId) => {
+                    if (frontRequestId !== front_request_id)
+                        return;
+                    this.off('broadcast', broadcast);
+                    resolve(data);
+                    if (timeoutId)
+                        clearInterval(timeoutId);
+                };
+                this.on('broadcast', broadcast);
+            });
+        }
+        async updateStatus(evtType, atnType, status, toUserIds) {
+            // TODO 统一规则，不能联合类型
+            if (this.readyState !== exports.WebSocketState.OPEN) {
+                return false;
+            }
+            const data = Object.assign({ event_type: evtType, action: atnType }, { data: status });
+            const liveMsg = createLiveMsg(exports.Command.BuiltinMsg, data, toUserIds);
+            liveController.sendMessage(liveMsg);
+            return true;
+        }
+        // 仅用于用户自己的麦克风控制
+        async toggleMicro(microStatus) {
+            var _a, _b;
+            if (!((_b = (_a = this.selfInfo) === null || _a === void 0 ? void 0 : _a.permission) === null || _b === void 0 ? void 0 : _b.control_own_micro))
+                return false;
+            await this.$RTC.toggleMicro(microStatus);
+            return await this.updateStatus(exports.BuiltinEventType.UserChange, exports.BuiltinActionType.UserMicroStatus, {
+                status: microStatus ? exports.MicroStatus.OPEN : exports.MicroStatus.CLOSE,
+            }, []);
+        }
+        async forbidMicro(microStatus, toUserIds) {
+            var _a, _b;
+            if (liveController.options.canForbidUserMicro &&
+                !liveController.options.canForbidUserMicro(toUserIds)) {
+                return false;
+            }
+            if (!((_b = (_a = this.selfInfo) === null || _a === void 0 ? void 0 : _a.permission) === null || _b === void 0 ? void 0 : _b.control_other_micro)) {
+                return false;
+            }
+            return await this.updateStatus(exports.BuiltinEventType.UserChange, exports.BuiltinActionType.UserMicroStatus, {
+                status: microStatus,
+            }, toUserIds);
+        }
+        /**
+         * @deprecated 暂不可用
+         */
+        async forbidSync(sync, toUserIds) {
+            var _a, _b;
+            if (liveController.options.canForbidUserSync &&
+                !liveController.options.canForbidUserSync(toUserIds)) {
+                return false;
+            }
+            if (!((_b = (_a = this.selfInfo) === null || _a === void 0 ? void 0 : _a.permission) === null || _b === void 0 ? void 0 : _b.control_other_sync)) {
+                return false;
+            }
+            return await this.updateStatus(exports.BuiltinEventType.UserChange, exports.BuiltinActionType.UserPermission, { sync_frame: sync }, toUserIds);
+        }
+        async kick(toUserIds) {
+            var _a, _b;
+            if (liveController.options.canForbidUserKick &&
+                !liveController.options.canForbidUserKick(toUserIds)) {
+                return false;
+            }
+            if (!((_b = (_a = this.selfInfo) === null || _a === void 0 ? void 0 : _a.permission) === null || _b === void 0 ? void 0 : _b.change_other_status)) {
+                return false;
+            }
+            return await this.updateStatus(exports.BuiltinEventType.UserChange, exports.BuiltinActionType.UserStatus, {
+                status: 'KICK_OUT',
+            }, toUserIds);
+        }
+        async exit() {
+            /** 退出强制关闭语音(?) */
+            await this.$RTC.quit();
+            return await this.updateStatus(exports.BuiltinEventType.RoomChange, exports.BuiltinActionType.RoomClose, {});
+        }
+        async connect(options = {}) {
+            // 连接 WebSocket 前验证麦克风权限
+            const microAuth = await this.$RTC.detectMicro();
+            if (!microAuth) {
+                const error = new Error('系统监测麦克风未授权~');
+                this.emit('ws.error', { type: exports.WebSocketErrorType.MicroAuth, error });
+                return error;
+            }
+            // WebSocket 正在连接中，规避重复连接
+            if (liveController.connecting) {
+                const error = new Error('WebSocket 正在连接中，请勿重复连接 ...');
+                this.emit('ws.error', {
+                    type: exports.WebSocketErrorType.DuplicateConnect,
+                    error,
+                });
+                return error;
+            }
+            // 非强制连接场景下，如果已经完成 WebSocket 连接则不执行后续逻辑
+            const { force } = options;
+            if (!force) {
+                if (this.readyState === exports.WebSocketState.CONNECTING ||
+                    this.readyState === exports.WebSocketState.OPEN) {
+                    return true;
+                }
+            }
+            // WebSocket URL 逻辑
+            if (options.url) {
+                liveController.options.url = options.url;
+            }
+            if (options.getTicket) {
+                liveController.options.getTicket = options.getTicket;
+            }
+            if (!liveController.options.url ||
+                !liveController.options.url.startsWith('ws')) {
+                const error = new Error(`WebSocket URL 未配置或格式不合法："${liveController.options.url}"`);
+                this.emit('ws.error', { type: exports.WebSocketErrorType.IllegalURL, error });
+                return error;
+            }
+            if (!liveController.options.getTicket) {
+                const error = new Error(`getTicket() 未配置!`);
+                this.emit('ws.error', { type: exports.WebSocketErrorType.IllegalArgs, error });
+                return error;
+            }
+            // 连接锁
+            liveController.connecting = true;
+            // 连接前销毁之前绑定的事件
+            liveController.disposeWebSocket();
+            this.emit('ws.beforeConnect');
+            const url = force || options.url || !this.url
+                ? appendUri(liveController.options.url, {
+                    ticket: await liveController.options.getTicket(),
+                    force: Number(!!force),
+                })
+                : this.url;
+            liveController.webSocket = new WebSocket(url);
+            liveController.onEvtOpnListener = () => {
+                liveController.checkReadyState(this);
+                this.emit('ws.afterConnect');
+            };
+            liveController.onEvtMsgListener = (evt) => {
+                liveController.checkReadyState(this);
+                try {
+                    const liveMsg = parseLiveMsg(evt.data);
+                    if (liveMsg === false)
+                        return;
+                    liveController.handleMessage(liveMsg, this);
+                }
+                catch (error) {
+                    // 未知错误
+                    this.emit('ws.error', {
+                        type: exports.WebSocketErrorType.Unknown,
+                        error,
+                        target: evt,
+                    });
+                }
+            };
+            liveController.onEvtErrListener = (evt) => {
+                live.emit('ws.error', { type: exports.WebSocketErrorType.Error, target: evt });
+                liveController.checkReadyState(this);
+            };
+            liveController.onEvtCLEListener = (evt) => {
+                liveController.checkReadyState(this);
+                const code = Number(evt.code);
+                if (code === 1000)
+                    return;
+                // 异常退出不一定会触发'error'事件，根据 evt.code 一些类型的退出也算是 error 行为
+                const errMsg = parseWSClsErr(code);
+                live.emit('ws.error', {
+                    target: evt,
+                    type: exports.WebSocketErrorType.Close,
+                    closeError: errMsg,
+                });
+            };
+            liveController.webSocket.addEventListener('open', liveController.onEvtOpnListener);
+            liveController.webSocket.addEventListener('message', liveController.onEvtMsgListener);
+            liveController.webSocket.addEventListener('error', liveController.onEvtErrListener);
+            liveController.webSocket.addEventListener('close', liveController.onEvtCLEListener);
+            return await new Promise((resolve, reject) => {
+                const success = () => {
+                    resolve(true);
+                    liveController.connecting = false;
+                    this.off('ws.error', fail);
+                };
+                const fail = (error) => {
+                    reject(error.error
+                        ? error.error
+                        : new Error('WebSocket connection failed!'));
+                    liveController.connecting = false;
+                    this.off('ws.afterConnect', success);
+                };
+                this.once('ws.afterConnect', success);
+                this.once('ws.error', fail);
+            });
+        }
+        async revoke() {
+            return true;
+        }
+    }
+    const live = new LiveTpl();
+    // 如果是调试环境则将内部状态暴露出来
+    if (options.__debug__) {
+        Object.assign(live, { __controller__: liveController });
+        Object.assign(window, { $live: live });
+    }
+    return live;
+}
+
+/**
+ * 创建 {@link LiveReact} 实例，并提供 `React` 技术栈相关工具链。
+ */
+function createLiveReact(options) {
+    const LiveContext = React__default["default"].createContext(null);
+    const live = createLive(options);
+    function LiveProvider(props) {
+        return (React__default["default"].createElement(LiveContext.Provider, { value: props.live || live }, props.children));
+    }
+    function useLiveInstance() {
+        const context = React__default["default"].useContext(LiveContext);
+        if (!context)
+            throw new Error('LiveProvider never found.');
+        return context;
+    }
+    /**
+     * @deprecated
+     * @returns
+     */
+    function unsafe__useLiveInstance() {
+        return useLiveInstance();
+    }
+    function useRTCInstance() {
+        const live = useLiveInstance();
+        return live.$RTC;
+    }
+    /**
+     * @deprecated
+     * @returns
+     */
+    function unsafe__useRTCInstance() {
+        return useRTCInstance();
+    }
+    function useConnect() {
+        const live = useLiveInstance();
+        return async (options) => await live.connect(options);
+    }
+    function useCurrentWebSocketUrl() {
+        const live = useLiveInstance();
+        const [state, setState] = React__default["default"].useState(undefined);
+        React__default["default"].useEffect(() => {
+            const onWSBeforeConnect = () => setState(live.url);
+            live.on('ws.beforeConnect', onWSBeforeConnect);
+            return () => live.off('ws.beforeConnect', onWSBeforeConnect);
+        }, [live]);
+        return state;
+    }
+    function useKeyframeUpdateCallback(name, callback, deps = []) {
+        const live = useLiveInstance();
+        const dependencyList = [live, name, ...deps];
+        const dispose = () => live.keyframes.off(name, callback);
+        React__default["default"].useEffect(() => {
+            live.keyframes.on(name, callback);
+            return dispose;
+        }, dependencyList);
+        return dispose;
+    }
+    function useLiveAction() {
+        const live = useLiveInstance();
+        const toggleMicro = React__default["default"].useCallback((microStatus) => live.toggleMicro(microStatus), [live]);
+        const broadcast = React__default["default"].useCallback((data, toUserIds, timeout = 0) => live.broadcast(data, toUserIds, timeout), [live]);
+        const exit = React__default["default"].useCallback(() => live.exit(), [live]);
+        const kick = React__default["default"].useCallback((toUserIds) => live.kick(toUserIds), [live]);
+        const forbidMicro = React__default["default"].useCallback((micro, toUserIds) => live.forbidMicro(micro, toUserIds), [live]);
+        // const forbidSync = React.useCallback(
+        //   (sync: boolean, toUserIds?: string | string[] | undefined) =>
+        //     live.forbidSync(sync, toUserIds),
+        //   [live],
+        // );
+        const getFramesByKey = React__default["default"].useCallback((key) => live.getFramesByKey(key), [live]);
+        const sendKeyframe = React__default["default"].useCallback((key, frame) => live.sendKeyframe(key, frame), [live]);
+        const setSelfInfo = React__default["default"].useCallback((userInfo) => live.setSelfInfo(userInfo), [live]);
+        const updateStatus = React__default["default"].useCallback((evtType, atnType, status, toUserIds) => live.updateStatus(evtType, atnType, status, toUserIds), [live]);
+        return {
+            broadcast,
+            exit,
+            kick,
+            toggleMicro,
+            forbidMicro,
+            // forbidSync,
+            sendKeyframe,
+            getFramesByKey,
+            setSelfInfo,
+            updateStatus,
+        };
+    }
+    function useKeyframe(key) {
+        const live = useLiveInstance();
+        const [state, updateState] = React__default["default"].useState(live.getFramesByKey(key));
+        React__default["default"].useEffect(() => {
+            const onUpdate = (nextKeyframes) => updateState(nextKeyframes);
+            const evtName = key;
+            const callback = onUpdate;
+            live.keyframes.on(evtName, callback);
+            return () => live.keyframes.off(evtName, callback);
+        }, [live]);
+        const setState = React__default["default"].useCallback((frame) => live.sendKeyframe(key, frame), [live]);
+        return [state, setState];
+    }
+    function useLiveEventCallback(name, callback, deps = []) {
+        const live = useLiveInstance();
+        const dispose = () => live.off(name, callback);
+        const dependencyList = [live, name, ...deps];
+        React__default["default"].useEffect(() => {
+            live.on(name, callback);
+            return dispose;
+        }, dependencyList);
+        return dispose;
+    }
+    /**
+     * @deprecated
+     * @returns
+     */
+    function useReadyState() {
+        const live = useLiveInstance();
+        const [state, updateState] = React__default["default"].useState(live.readyState);
+        React__default["default"].useEffect(() => {
+            const readyStateUpdate = (readyState) => updateState(readyState);
+            live.on('ws.readyStateUpdate', readyStateUpdate);
+            return () => live.off('ws.readyStateUpdate', readyStateUpdate);
+        }, [live]);
+        return state;
+    }
+    function useRTCAction() {
+        const live = useLiveInstance();
+        const join = React__default["default"].useCallback((options) => live.$RTC.join(options), [live]);
+        const quit = React__default["default"].useCallback(() => live.$RTC.quit(), [live]);
+        const shock = React__default["default"].useCallback(() => { var _a, _b; return (_b = (_a = live.$RTC).shock) === null || _b === void 0 ? void 0 : _b.call(_a); }, [live]);
+        const toggleMicro = React__default["default"].useCallback((flag) => live.$RTC.toggleMicro(flag), [live]);
+        const detectMicro = React__default["default"].useCallback(() => live.$RTC.detectMicro(), [live]);
+        return {
+            join,
+            quit,
+            shock,
+            toggleMicro,
+            detectMicro,
+        };
+    }
+    function useRTCEventCallback(name, callback, deps = []) {
+        const live = useLiveInstance();
+        const dispose = () => live.$RTC.off(name, callback);
+        const dependencyList = [live, name, ...deps];
+        React__default["default"].useEffect(() => {
+            live.$RTC.on(name, callback);
+            return dispose;
+        }, dependencyList);
+        return dispose;
+    }
+    function useSelfInfo() {
+        const live = useLiveInstance();
+        const [state, updateState] = React__default["default"].useState(live.selfInfo || {});
+        const selfInfoUpdate = (userInfo) => updateState(userInfo);
+        React__default["default"].useEffect(() => {
+            live.on('selfInfoUpdate', selfInfoUpdate);
+            return () => live.off('selfInfoUpdate', selfInfoUpdate);
+        }, [live]);
+        const setState = React__default["default"].useCallback(async (userInfo) => {
+            return await live.setSelfInfo(userInfo);
+        }, [live]);
+        return [state, setState];
+    }
+    function useSnapshot() {
+        const live = useLiveInstance();
+        const [state, setState] = React__default["default"].useState(live.snapshot);
+        React__default["default"].useEffect(() => {
+            const onKeyframes = (keyframes) => setState(keyframes);
+            live.on('keyframes', onKeyframes);
+            return () => live.off('keyframes', onKeyframes);
+        });
+        return state;
+    }
+    function useUserList() {
+        const live = useLiveInstance();
+        const [state, updateState] = React__default["default"].useState(live.userList);
+        const userListUpdate = (userList) => updateState(userList);
+        React__default["default"].useEffect(() => {
+            live.on('userListUpdate', userListUpdate);
+            return () => live.off('userListUpdate', userListUpdate);
+        }, [live]);
+        return state;
+    }
+    /**
+     *
+     * @param name
+     * @param callback
+     * @param deps
+     * @returns
+     * @deprecated
+     */
+    function useWebSocketEventCallback(name, callback, deps = []) {
+        const live = useLiveInstance();
+        const dispose = () => live.off(name, callback);
+        const dependencyList = [live, name, ...deps];
+        React__default["default"].useEffect(() => {
+            live.on(name, callback);
+            return dispose;
+        }, dependencyList);
+        return dispose;
+    }
+    return {
+        live,
+        LiveProvider,
+        unsafe__useLiveInstance,
+        unsafe__useRTCInstance,
+        useCurrentWebSocketUrl,
+        useConnect,
+        useKeyframe,
+        useKeyframeUpdateCallback,
+        useLiveAction,
+        useLiveEventCallback,
+        useReadyState,
+        useRTCAction,
+        useRTCEventCallback,
+        useSelfInfo,
+        useSnapshot,
+        useUserList,
+        useWebSocketEventCallback,
+    };
+}
+
+exports.BrowserRTC = BrowserRTC;
+exports.BrowserRTC4Chime = BrowserRTC4Chime;
+exports.CoreRTC = CoreRTC;
+exports.VRWebViewRTC = VRWebViewRTC;
+exports.createLive = createLive;
+exports.createLiveReact = createLiveReact;
+exports.parseLiveMsg = parseLiveMsg;
+exports.parseWSClsErr = parseWSClsErr;
+//# sourceMappingURL=realsee-live.cjs.development.js.map