@tiledev/sdk-apptile-live-selling 0.1.0

package/dist/engine.native.js

@@ -0,0 +1,815 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.engine = void 0;
+/**
+ * Live engine — NATIVE build (iOS / Android), driving `zego-express-engine-reactnative`.
+ *
+ * Sole owner of the Zego engine: a module singleton, because the engine *is* a process-wide singleton.
+ * The room is joined and left and the render target is rebindable, rather than the engine being created
+ * and destroyed per mount (which caused the re-login churn the source blames for an Android
+ * NetworkCallback leak).
+ *
+ * The Zego SDK is an OPTIONAL peer, pulled in with a lazy `require()` inside `createEngine` so this file
+ * carries no static import of it — that keeps the native SDK out of every non-native bundle and lets
+ * the pure `tsc --noEmit` pass without the Zego types installed. Metro resolves this file on-device and
+ * `engine.ts` (a no-op) everywhere else; keep the two signatures in lock-step.
+ *
+ * Ported from the app's `liveStreamService.ts`, with one app coupling lifted: the platform-level Zego
+ * app id comes from `configure({ zegoAppId })` rather than a config global.
+ *
+ * The engine also feeds the system picture-in-picture module — which stream is playing, and nothing
+ * more. It has to be told here rather than by the session, because only this file knows when the
+ * played id actually changes: a co-host mixer swap moves it from `{id}` to `{id}_mixed` with no
+ * involvement from React at all.
+ */
+const react_native_1 = require("react-native");
+const client_1 = require("./client");
+const wire_1 = require("./wire");
+const commentLinks_1 = require("./commentLinks");
+const pip_1 = require("./pip");
+const guest_1 = require("./guest");
+const polls_1 = require("./polls");
+/** The zego module and the constructors/enums it exports, captured once at engine create. */
+class NativeLiveEngine {
+    constructor() {
+        this.isNoop = false;
+        this.Z = null;
+        this.engineReady = false;
+        this.creating = null;
+        this.queue = Promise.resolve();
+        this.listeners = new Set();
+        this.joined = null;
+        this.playingStreamId = null;
+        this.boundTag = null;
+        this.playingTag = null;
+        this.mixerActive = false;
+        this.guest = null;
+        this.previewTag = null;
+        this.viewerNameOverride = null;
+        this.commentSeq = 0;
+        this.mutedDeviceIds = [];
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+    emit(event) {
+        for (const listener of this.listeners)
+            listener(event);
+    }
+    /**
+     * The loaded SDK. Only valid after `createEngine`, and every caller below is downstream of it —
+     * throwing beats the `undefined is not a constructor` a missing enum would produce deeper in.
+     */
+    get Zego() {
+        if (!this.Z)
+            throw new Error('Zego SDK is not loaded');
+        return this.Z;
+    }
+    /** The default export is the engine class; the enums/structs are named exports. */
+    get Engine() {
+        var _a;
+        const mod = this.Zego;
+        return ((_a = mod === null || mod === void 0 ? void 0 : mod.default) !== null && _a !== void 0 ? _a : mod);
+    }
+    async ensureEngine() {
+        if (this.engineReady)
+            return;
+        if (!this.creating)
+            this.creating = this.createEngine();
+        try {
+            await this.creating;
+        }
+        finally {
+            this.creating = null;
+        }
+    }
+    async createEngine() {
+        var _a;
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        this.Z = require('zego-express-engine-reactnative');
+        const Engine = this.Engine;
+        const { ZegoScenario } = this.Zego;
+        // The native engine outlives this module, so adopt an existing instance rather than creating a
+        // second — "multiple instances" is a documented failure.
+        let existing = null;
+        try {
+            existing = Engine.instance();
+        }
+        catch {
+            existing = null;
+        }
+        if (!existing) {
+            // appSign empty is the documented pairing for token auth; the token rides on the room config.
+            await Engine.createEngineWithProfile({
+                appID: (_a = (0, client_1.getConfig)().zegoAppId) !== null && _a !== void 0 ? _a : 0,
+                appSign: '',
+                scenario: ZegoScenario.Default,
+            });
+        }
+        // After the engine exists and before anything plays, and every time rather than only after a
+        // fresh create: the engine outlives this module, so an adopted one may never have been configured
+        // by this process. The native side ignores a second call.
+        try {
+            await pip_1.livePip.configure();
+        }
+        catch (caught) {
+            // A live stream without picture-in-picture is still a working live stream.
+            (0, client_1.getLogger)().error(caught, { at: 'liveEngine.configurePip' });
+        }
+        this.attachListeners();
+        this.engineReady = true;
+    }
+    /**
+     * Zego stops delivering video once the app leaves the foreground unless this is set. iOS only;
+     * Android's PIP window is the activity itself, which stays visible and keeps decoding.
+     */
+    async setBackgroundVideoEnabled(enabled) {
+        if (!this.engineReady)
+            return;
+        if (react_native_1.Platform.OS !== 'ios')
+            return;
+        await this.Engine.instance().callExperimentalAPI(JSON.stringify({ method: 'liveroom.video.enable_ios_multitask', params: { enable: enabled } }));
+    }
+    attachListeners() {
+        const engine = this.Engine.instance();
+        const { ZegoUpdateType } = this.Zego;
+        // Clear first: attaching twice would deliver every comment and reaction twice over.
+        for (const event of [
+            'roomStateUpdate',
+            'roomStreamUpdate',
+            'roomOnlineUserCountUpdate',
+            'playerMediaEvent',
+            'roomStreamExtraInfoUpdate',
+            'IMRecvBarrageMessage',
+            'IMRecvCustomCommand',
+            'IMRecvBroadcastMessage',
+        ]) {
+            try {
+                engine.off(event, undefined);
+            }
+            catch {
+                // Nothing attached yet.
+            }
+        }
+        engine.on('roomStateUpdate', (_roomId, stateVal) => {
+            this.emit({ type: 'roomState', connected: stateVal === 2 });
+            if (stateVal === 2)
+                this.announceJoin();
+        });
+        engine.on('roomStreamUpdate', (_roomId, updateType, streamList) => {
+            const ids = (0, wire_1.arr)(streamList).map((entry) => (0, wire_1.str)((0, wire_1.get)(entry, 'streamID')));
+            const isHost = ids.some((id) => { var _a, _b; return id === ((_a = this.joined) === null || _a === void 0 ? void 0 : _a.streamingId) || id === ((_b = this.joined) === null || _b === void 0 ? void 0 : _b.mixedStreamId); });
+            if (!isHost)
+                return;
+            this.emit({ type: 'publisher', publishing: updateType === ZegoUpdateType.Add });
+        });
+        engine.on('roomOnlineUserCountUpdate', (_roomId, count) => {
+            this.emit({ type: 'viewers', count });
+        });
+        engine.on('playerMediaEvent', (_streamId, event) => {
+            // 4/6 = video break/resume, 5/7 = audio break/resume. One field per event.
+            if (event === 4)
+                this.emit({ type: 'hostMedia', kind: 'video', broken: true });
+            if (event === 6)
+                this.emit({ type: 'hostMedia', kind: 'video', broken: false });
+            if (event === 5)
+                this.emit({ type: 'hostMedia', kind: 'audio', broken: true });
+            if (event === 7)
+                this.emit({ type: 'hostMedia', kind: 'audio', broken: false });
+        });
+        engine.on('playerQualityUpdate', (streamId, quality) => {
+            var _a;
+            if (streamId !== this.playingStreamId)
+                return;
+            this.emit({ type: 'hostVideo', receiving: ((_a = (0, wire_1.num)((0, wire_1.get)(quality, 'videoRecvFPS'))) !== null && _a !== void 0 ? _a : 0) > 0 });
+        });
+        engine.on('roomStreamExtraInfoUpdate', (_roomId, streamList) => {
+            const extra = (0, wire_1.get)((0, wire_1.arr)(streamList)[0], 'extraInfo');
+            if (!extra)
+                return;
+            this.handleExtraInfo(extra);
+        });
+        engine.on('IMRecvBarrageMessage', (_roomId, messageList) => {
+            this.handleBarrage((0, wire_1.arr)(messageList)[0]);
+        });
+        engine.on('IMRecvCustomCommand', (_roomId, _from, command) => {
+            this.handleCommand(command);
+        });
+        engine.on('IMRecvBroadcastMessage', (_roomId, messageList) => {
+            var _a;
+            // `sendTime` is the host's clock — the only reference an auction deadline can be read against.
+            const first = (0, wire_1.arr)(messageList)[0];
+            this.handleBroadcast((0, wire_1.get)(first, 'message'), (_a = (0, wire_1.num)((0, wire_1.get)(first, 'sendTime'))) !== null && _a !== void 0 ? _a : 0);
+        });
+    }
+    handleExtraInfo(raw) {
+        const payload = (0, wire_1.parseJson)(raw);
+        if (!(0, wire_1.isRecord)(payload))
+            return;
+        const lot = () => { var _a; return (_a = (0, wire_1.str)((0, wire_1.path)(payload, 'data', 'store_product_id'))) !== null && _a !== void 0 ? _a : (0, wire_1.str)((0, wire_1.path)(payload, 'data', 'product_id')); };
+        switch ((0, wire_1.str)(payload.event)) {
+            case 'PRODUCT_CHANGE': {
+                const id = lot();
+                if (id)
+                    this.emit({ type: 'productChange', storeProductId: id });
+                return;
+            }
+            case 'DELETE_PRODUCT': {
+                const id = lot();
+                if (id)
+                    this.emit({ type: 'productRemoved', storeProductId: id });
+                return;
+            }
+            case 'MULTIPLIER_CHANGE': {
+                const multiplier = (0, wire_1.num)(payload.count);
+                this.emit({
+                    type: 'viewerMultiplier',
+                    multiplier: multiplier !== null && multiplier > 0 ? multiplier : 1,
+                });
+                return;
+            }
+            default:
+                this.emit({ type: 'unknown', channel: 'extraInfo', payload });
+        }
+    }
+    handleBarrage(message) {
+        var _a, _b, _c;
+        const payload = (0, wire_1.parseJson)((0, wire_1.get)(message, 'message'));
+        if (!(0, wire_1.isRecord)(payload))
+            return;
+        // The host mutes a viewer for everyone by flagging their messages, not by dropping them.
+        if (payload.muted === true)
+            return;
+        // `payload.name` wins: a bid announcement is relayed by the host's own Zego identity, so
+        // `fromUser.userName` there is the HOST's name, not the bidder's.
+        const fromUser = (0, wire_1.str)((0, wire_1.path)(message, 'fromUser', 'userName'));
+        const userName = (_b = (_a = (0, wire_1.str)(payload.name)) !== null && _a !== void 0 ? _a : fromUser) !== null && _b !== void 0 ? _b : 'Anonymous';
+        this.emit({
+            type: 'comment',
+            comment: this.makeComment((_c = (0, wire_1.str)(payload.comment)) !== null && _c !== void 0 ? _c : '', userName, payload.source, undefined, false, payload.urlPreview),
+        });
+    }
+    makeComment(text, userName, source, tipAmount, isOwn, urlPreview) {
+        const known = source === 'HOST' || source === 'MODERATOR' || source === 'TIP' ? source : 'USER';
+        this.commentSeq += 1;
+        return {
+            id: `c${this.commentSeq}`,
+            text,
+            userName,
+            source: known,
+            tipAmount,
+            urlPreview: (0, commentLinks_1.toUrlPreview)(urlPreview),
+            isOwn,
+        };
+    }
+    handleCommand(raw) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+        const payload = (0, wire_1.parseJson)(raw);
+        if (!(0, wire_1.isRecord)(payload))
+            return;
+        switch ((0, wire_1.str)(payload.type)) {
+            case 'REACTION_ANNOUCEMENT':
+                this.emit({
+                    type: 'reaction',
+                    reactionUrl: (_a = (0, wire_1.str)(payload.reactionUrl)) !== null && _a !== void 0 ? _a : '',
+                    userName: (_b = (0, wire_1.str)(payload.userName)) !== null && _b !== void 0 ? _b : 'Anonymous',
+                });
+                return;
+            case 'CART_ANNOUCEMENT':
+                this.emit({
+                    type: 'cartAnnouncement',
+                    productTitle: (_c = (0, wire_1.str)(payload.productTitle)) !== null && _c !== void 0 ? _c : '',
+                    userName: (_d = (0, wire_1.str)(payload.userName)) !== null && _d !== void 0 ? _d : 'Anonymous',
+                });
+                return;
+            case 'DONATION_ANNOUCEMENT':
+                this.emit({
+                    type: 'comment',
+                    comment: this.makeComment('Sent a tip', (_e = (0, wire_1.str)(payload.userName)) !== null && _e !== void 0 ? _e : 'Anonymous', 'TIP', (_f = (0, wire_1.str)(payload.donationAmount)) !== null && _f !== void 0 ? _f : undefined, false),
+                });
+                return;
+            case 'PRODUCT_SOLD_ANNOUNCEMENT':
+                this.emit({
+                    type: 'sold',
+                    announcement: {
+                        productName: (_g = (0, wire_1.str)(payload.productName)) !== null && _g !== void 0 ? _g : '',
+                        variantLabel: (0, wire_1.str)(payload.variantLabel),
+                        quantity: (_h = (0, wire_1.num)(payload.qty)) !== null && _h !== void 0 ? _h : 1,
+                        productImage: (0, wire_1.str)(payload.productImage),
+                    },
+                });
+                return;
+            case 'START_POLL':
+                this.emitPollStarted((_j = payload.poll) !== null && _j !== void 0 ? _j : (0, wire_1.path)(payload, 'data', 'poll'));
+                return;
+            case 'MUTE_USER':
+                this.mutedDeviceIds = this.mutedIdsFrom(payload.mutedUsers);
+                this.emit({ type: 'mutedUsers', deviceIds: this.mutedDeviceIds });
+                return;
+            case 'START_BIDDING':
+                this.emitBiddingStarted(payload.data, (_k = (0, wire_1.num)((0, wire_1.path)(payload, 'data', 'timeStamp'))) !== null && _k !== void 0 ? _k : 0);
+                return;
+            case 'BROADCAST_BID_INFO':
+                this.emitBidInfo(payload.data, (_l = (0, wire_1.num)(payload.serverSentTime)) !== null && _l !== void 0 ? _l : 0);
+                return;
+            case 'giveaway_start':
+                this.emitGiveawayStarted(payload.eventData);
+                return;
+            case 'giveaway_end':
+                this.emitGiveawayEnded(payload.eventData);
+                return;
+            case 'user_registered': {
+                const count = (0, wire_1.num)((0, wire_1.path)(payload, 'eventData', 'usersCount'));
+                if (count !== null)
+                    this.emit({ type: 'giveawayEntries', count });
+                return;
+            }
+            default:
+                this.emit({ type: 'unknown', channel: 'customCommand', payload });
+        }
+    }
+    /** The moderator's Zego user id, whatever shape it arrived in — an object smuggled through crashes iOS. */
+    /**
+     * Device ids out of a host mute list.
+     *
+     * Entries with no id are dropped rather than passed through: the host dashboard can record a comment
+     * with no `deviceId`, and an id-less entry would match every viewer whose id is also absent —
+     * muting one person would silence the room.
+     */
+    mutedIdsFrom(raw) {
+        return (0, wire_1.arr)(raw)
+            .map((entry) => (0, wire_1.str)((0, wire_1.get)(entry, 'deviceId')))
+            .filter((id) => !!id);
+    }
+    moderatorIdFrom(raw) {
+        var _a, _b;
+        if (!raw)
+            return null;
+        if (typeof raw === 'string')
+            return raw;
+        if (typeof raw === 'object') {
+            const record = raw;
+            const id = (_b = (_a = record.userID) !== null && _a !== void 0 ? _a : record.userId) !== null && _b !== void 0 ? _b : record.user_id;
+            if (typeof id === 'string' && id)
+                return id;
+            if (typeof id === 'number')
+                return String(id);
+        }
+        return null;
+    }
+    emitBiddingStarted(data, serverNowMs) {
+        const wire = data;
+        const endsAtMs = (0, wire_1.num)((0, wire_1.get)(wire, 'endTimeStamp'));
+        if (endsAtMs === null || endsAtMs <= 0)
+            return;
+        this.emit({
+            type: 'biddingStarted',
+            endsAtMs,
+            serverNowMs: serverNowMs || endsAtMs,
+            storeProductId: (0, wire_1.str)((0, wire_1.get)(wire, 'selectedProductId')),
+            moderatorId: this.moderatorIdFrom((0, wire_1.get)(wire, 'moderatorInCharge')),
+        });
+    }
+    emitBidInfo(data, serverNowMs) {
+        var _a, _b, _c, _d;
+        const wire = data;
+        if (!(0, wire_1.isRecord)(wire))
+            return;
+        const endsAtMs = (0, wire_1.num)(wire.newEndTimeStamp);
+        const user = wire.user;
+        this.emit({
+            type: 'bidInfo',
+            highestBid: (_a = (0, wire_1.num)(wire.newHighestBid)) !== null && _a !== void 0 ? _a : 0,
+            nextBid: (_b = (0, wire_1.num)(wire.nextBid)) !== null && _b !== void 0 ? _b : 0,
+            endsAtMs: endsAtMs !== null && endsAtMs > 0 ? endsAtMs : null,
+            serverNowMs,
+            leader: (0, wire_1.isRecord)(user)
+                ? { userId: (_c = (0, wire_1.str)(user.userId)) !== null && _c !== void 0 ? _c : '', userName: (_d = (0, wire_1.str)(user.userName)) !== null && _d !== void 0 ? _d : '' }
+                : null,
+        });
+    }
+    emitGiveawayStarted(eventData) {
+        const wire = eventData;
+        const storeProductId = (0, wire_1.str)((0, wire_1.get)(wire, 'productId'));
+        if (!storeProductId)
+            return;
+        this.emit({
+            type: 'giveawayStarted',
+            storeProductId,
+            variantId: (0, wire_1.str)((0, wire_1.get)(wire, 'variantId')),
+            entryCount: (0, wire_1.num)((0, wire_1.get)(wire, 'userCount')),
+        });
+    }
+    emitGiveawayEnded(eventData) {
+        const storeProductId = (0, wire_1.str)((0, wire_1.get)(eventData, 'productId'));
+        if (!storeProductId)
+            return;
+        // The host sends the literal string "null" when a giveaway closes with nobody in it, so only an
+        // object is a real winner.
+        const winner = (0, wire_1.get)(eventData, 'winner');
+        const winnerName = (0, wire_1.isRecord)(winner) ? (0, wire_1.str)(winner.displayName) : null;
+        this.emit({ type: 'giveawayEnded', storeProductId, winnerName });
+    }
+    handleBroadcast(raw, serverNowMs = 0) {
+        var _a, _b, _c, _d, _e, _f;
+        const payload = (0, wire_1.parseJson)(raw);
+        if (!(0, wire_1.isRecord)(payload))
+            return;
+        switch ((0, wire_1.str)(payload.type)) {
+            case 'START_BIDDING':
+                this.emitBiddingStarted(payload.data, serverNowMs);
+                return;
+            case 'CLOSE_BIDDING':
+                this.emit({ type: 'biddingClosed' });
+                return;
+            case 'BID_WINNER_ANNOUNCEMENT': {
+                const wire = payload.data;
+                const meta = (0, wire_1.path)(wire, 'bidWinner', 'meta');
+                this.emit({
+                    type: 'auctionWon',
+                    win: {
+                        userName: (_a = (0, wire_1.str)((0, wire_1.path)(meta, 'user', 'userName'))) !== null && _a !== void 0 ? _a : '',
+                        winningBid: (_b = (0, wire_1.num)((0, wire_1.get)(meta, 'winningBid'))) !== null && _b !== void 0 ? _b : 0,
+                        storeProductId: (0, wire_1.str)((0, wire_1.path)(wire, 'auctionedProduct', 'store_product_id')),
+                    },
+                });
+                return;
+            }
+            case 'START_POLL':
+                this.emitPollStarted((0, wire_1.path)(payload, 'data', 'poll'));
+                return;
+            case 'BROADCAST_POLL_RESULTS': {
+                const results = (0, polls_1.toLivePollResults)((0, wire_1.path)(payload, 'data', 'pollResults'));
+                if (results)
+                    this.emit({ type: 'pollResults', results });
+                return;
+            }
+            case 'REACTION_ANNOUCEMENT':
+                this.emit({
+                    type: 'reaction',
+                    reactionUrl: (_d = (_c = (0, wire_1.str)((0, wire_1.path)(payload, 'data', 'reactionUrl'))) !== null && _c !== void 0 ? _c : (0, wire_1.str)(payload.reactionUrl)) !== null && _d !== void 0 ? _d : '',
+                    userName: (_f = (_e = (0, wire_1.str)((0, wire_1.path)(payload, 'data', 'userName'))) !== null && _e !== void 0 ? _e : (0, wire_1.str)(payload.userName)) !== null && _f !== void 0 ? _f : 'Anonymous',
+                });
+                return;
+            case 'END_POLL':
+                this.emit({ type: 'pollEnded' });
+                return;
+            case 'MUTE_USER':
+                this.mutedDeviceIds = this.mutedIdsFrom((0, wire_1.path)(payload, 'data', 'mutedUsers'));
+                this.emit({ type: 'mutedUsers', deviceIds: this.mutedDeviceIds });
+                return;
+            case 'STREAM_ENDED':
+                this.emit({ type: 'streamEnded' });
+                return;
+            case 'MIXER_STATE':
+                void this.applyMixerState(!!payload.active);
+                return;
+            case 'COHOST_ADMITTED':
+                if (!this.isOurSlot(payload.slot))
+                    return;
+                this.emit({
+                    type: 'guestAdmitted',
+                    slot: Number(payload.slot),
+                    mixerLayout: (0, guest_1.toMixerLayout)(payload.mixerLayout),
+                });
+                return;
+            case 'COHOST_REMOVED':
+                if (!this.isOurSlot(payload.slot))
+                    return;
+                this.emit({ type: 'guestRemoved', slot: Number(payload.slot) });
+                return;
+            case 'COHOST_MUTE_AUDIO':
+                if (!this.isOurSlot(payload.slot))
+                    return;
+                this.emit({ type: 'guestMutedByHost', slot: Number(payload.slot), muted: !!payload.muted });
+                return;
+            case 'COHOST_CAM_OFF':
+                if (!this.isOurSlot(payload.slot))
+                    return;
+                this.emit({ type: 'guestCameraOffByHost', slot: Number(payload.slot), off: !!payload.off });
+                return;
+            case 'LAYOUT_CHANGED': {
+                const layout = (0, guest_1.toMixerLayout)(payload.mixerLayout);
+                if (layout)
+                    this.emit({ type: 'mixerLayout', layout });
+                return;
+            }
+            case 'GUESTS_CHANGED':
+                return;
+            default:
+                this.emit({ type: 'unknown', channel: 'broadcast', payload });
+        }
+    }
+    isOurSlot(slot) {
+        return this.guest != null && Number(slot) === this.guest.slot;
+    }
+    emitPollStarted(raw) {
+        const poll = (0, polls_1.toLivePoll)(raw);
+        if (poll)
+            this.emit({ type: 'pollStarted', poll, results: (0, polls_1.toEmbeddedResults)(raw) });
+    }
+    async applyMixerState(active) {
+        this.mixerActive = active;
+        this.emit({ type: 'mixer', active });
+        const target = this.targetStreamId();
+        if (!target || target === this.playingStreamId)
+            return;
+        await this.playStream(target);
+    }
+    targetStreamId() {
+        if (!this.joined)
+            return null;
+        return this.mixerActive && this.joined.mixedStreamId ? this.joined.mixedStreamId : this.joined.streamingId;
+    }
+    announceJoin() {
+        if (!this.joined)
+            return;
+        this.Engine.instance()
+            .sendCustomCommand(this.joined.roomId, JSON.stringify({ type: 'USER_JOINED', userName: this.joined.viewerName }), [])
+            .catch((error) => (0, client_1.getLogger)().error('[liveSelling] announceJoin', error));
+    }
+    enqueue(operation) {
+        const result = this.queue.then(operation, operation);
+        this.queue = result.catch(() => undefined);
+        return result;
+    }
+    join(params) {
+        return this.enqueue(() => this.joinNow(params));
+    }
+    leave() {
+        // A guest owns the room login while one is active; `leaveGuest` is the way out of guest mode.
+        if (this.guest)
+            return Promise.resolve();
+        return this.enqueue(() => this.leaveNow());
+    }
+    async joinNow(params) {
+        var _a;
+        await this.ensureEngine();
+        if (((_a = this.joined) === null || _a === void 0 ? void 0 : _a.streamingId) === params.streamingId)
+            return;
+        if (this.joined)
+            await this.leaveNow();
+        const { ZegoUser, ZegoRoomConfig } = this.Zego;
+        this.joined = params;
+        this.mixerActive = false;
+        // Before the room is entered, so the first comment after a cold rejoin is already checked.
+        this.mutedDeviceIds = params.mutedDeviceIds;
+        const result = await this.Engine.instance().loginRoom(params.roomId, new ZegoUser(params.viewerId, params.viewerName), new ZegoRoomConfig(0, true, params.token));
+        if (result === null || result === void 0 ? void 0 : result.errorCode)
+            throw new Error(`loginRoom failed with ${result.errorCode}`);
+    }
+    async bindView(reactTag, force = false) {
+        return this.enqueue(() => this.bindViewNow(reactTag, force));
+    }
+    async bindViewNow(reactTag, force = false) {
+        const target = this.targetStreamId();
+        if (!force &&
+            reactTag === this.boundTag &&
+            reactTag === this.playingTag &&
+            target &&
+            target === this.playingStreamId) {
+            return;
+        }
+        this.boundTag = reactTag;
+        if (!target || reactTag == null)
+            return;
+        await this.playStream(target);
+    }
+    async refreshPlayback() {
+        return this.enqueue(() => this.refreshPlaybackNow());
+    }
+    async refreshPlaybackNow() {
+        const target = this.targetStreamId();
+        if (!target || this.boundTag == null)
+            return;
+        const { ZegoView, ZegoPlayerConfig } = this.Zego;
+        this.playingStreamId = target;
+        this.playingTag = this.boundTag;
+        void pip_1.livePip.setStream(target);
+        await this.Engine.instance().startPlayingStream(target, new ZegoView(this.boundTag, 1, 0), new ZegoPlayerConfig());
+    }
+    async stopPlayback() {
+        return this.enqueue(() => this.stopPlaybackNow());
+    }
+    async stopPlaybackNow() {
+        const playing = this.playingStreamId;
+        this.playingStreamId = null;
+        this.playingTag = null;
+        this.boundTag = null;
+        void pip_1.livePip.setStream(null);
+        if (!playing)
+            return;
+        await this.Engine.instance().stopPlayingStream(playing);
+    }
+    async playStream(streamId) {
+        if (this.boundTag == null)
+            return;
+        const { ZegoView, ZegoPlayerConfig } = this.Zego;
+        const previous = this.playingStreamId;
+        // Zego ignores a new canvas for a stream it is already playing, so moving the picture means
+        // stopping first.
+        const movingView = this.playingTag != null && this.playingTag !== this.boundTag;
+        if (previous && (previous !== streamId || movingView)) {
+            await this.Engine.instance().stopPlayingStream(previous);
+        }
+        this.playingStreamId = streamId;
+        this.playingTag = this.boundTag;
+        await this.Engine.instance().startPlayingStream(streamId, new ZegoView(this.boundTag, 1, 0), new ZegoPlayerConfig());
+        // Tracks the mixed id through a co-host swap, which is why it is set here rather than at join.
+        void pip_1.livePip.setStream(streamId);
+        this.emit({ type: 'videoBound', tag: this.playingTag });
+    }
+    // ─── Guest / co-host ──────────────────────────────────────────────────────
+    joinAsGuest(credentials, previewTag) {
+        return this.enqueue(() => this.joinAsGuestNow(credentials, previewTag));
+    }
+    async joinAsGuestNow(credentials, previewTag) {
+        await this.ensureEngine();
+        const engine = this.Engine.instance();
+        const { ZegoUser, ZegoRoomConfig, ZegoOrientation, ZegoPublishChannel } = this.Zego;
+        // The viewer login has to go first: one session per engine, and the publish privilege lives in
+        // the guest's token.
+        if (this.joined)
+            await this.leaveNow();
+        this.guest = credentials;
+        this.emit({ type: 'guestMode', active: true });
+        // Before publishing: without it the server-side MixStream output is rotated.
+        await engine.setAppOrientation(ZegoOrientation.PortraitUp, ZegoPublishChannel.Main);
+        await engine.useFrontCamera(true, ZegoPublishChannel.Main);
+        const result = await engine.loginRoom(credentials.roomId, new ZegoUser(credentials.userId, credentials.userName), new ZegoRoomConfig(0, true, credentials.token));
+        if (result === null || result === void 0 ? void 0 : result.errorCode) {
+            this.guest = null;
+            this.emit({ type: 'guestMode', active: false });
+            throw new Error(`guest loginRoom failed with ${result.errorCode}`);
+        }
+        if (previewTag != null)
+            await this.startPreviewNow(previewTag);
+        await engine.startPublishingStream(credentials.guestStreamId, ZegoPublishChannel.Main, {
+            roomID: credentials.roomId,
+        });
+    }
+    bindGuestPreview(reactTag) {
+        return this.enqueue(() => this.startPreviewNow(reactTag));
+    }
+    async startPreviewNow(reactTag) {
+        if (!this.guest || reactTag == null || reactTag === this.previewTag)
+            return;
+        const { ZegoView, ZegoPublishChannel } = this.Zego;
+        this.previewTag = reactTag;
+        await this.Engine.instance().startPreview(new ZegoView(reactTag, 1, 0), ZegoPublishChannel.Main);
+    }
+    bindGuestHostView(reactTag) {
+        return this.enqueue(async () => {
+            if (!this.guest || reactTag == null)
+                return;
+            const { ZegoView, ZegoPlayerConfig } = this.Zego;
+            // The host's raw stream, never `_mixed`: the mix contains this guest.
+            await this.Engine.instance().startPlayingStream(this.guest.streamingId, new ZegoView(reactTag, 1, 0), new ZegoPlayerConfig());
+        });
+    }
+    async setGuestMicMuted(muted) {
+        if (!this.guest)
+            return;
+        const engine = this.Engine.instance();
+        const { ZegoPublishChannel } = this.Zego;
+        await engine.muteMicrophone(muted);
+        await engine.mutePublishStreamAudio(muted, ZegoPublishChannel.Main);
+    }
+    async setGuestCameraOff(off) {
+        if (!this.guest)
+            return;
+        const engine = this.Engine.instance();
+        const { ZegoPublishChannel } = this.Zego;
+        await engine.enableCamera(!off, ZegoPublishChannel.Main);
+        await engine.mutePublishStreamVideo(off, ZegoPublishChannel.Main);
+    }
+    async flipGuestCamera(front) {
+        if (!this.guest)
+            return;
+        const { ZegoPublishChannel } = this.Zego;
+        await this.Engine.instance().useFrontCamera(front, ZegoPublishChannel.Main);
+    }
+    leaveGuest() {
+        return this.enqueue(() => this.leaveGuestNow());
+    }
+    async leaveGuestNow() {
+        const guest = this.guest;
+        if (!guest)
+            return;
+        const engine = this.Engine.instance();
+        const { ZegoPublishChannel } = this.Zego;
+        const logger = (0, client_1.getLogger)();
+        // Each guarded on its own: a failure part-way must not leave the room joined.
+        try {
+            await engine.stopPublishingStream(ZegoPublishChannel.Main);
+        }
+        catch (caught) {
+            logger.error('[liveSelling] stopPublishing', caught);
+        }
+        try {
+            await engine.stopPreview(ZegoPublishChannel.Main);
+        }
+        catch (caught) {
+            logger.error('[liveSelling] stopPreview', caught);
+        }
+        try {
+            await engine.stopPlayingStream(guest.streamingId);
+        }
+        catch {
+            // Nothing was playing — the guest may never have seen the host.
+        }
+        try {
+            await engine.logoutRoom(guest.roomId);
+        }
+        catch (caught) {
+            logger.error('[liveSelling] guestLogout', caught);
+        }
+        this.guest = null;
+        this.previewTag = null;
+        this.emit({ type: 'guestMode', active: false });
+    }
+    setMutedDeviceIds(ids) {
+        const changed = ids.length !== this.mutedDeviceIds.length || ids.some((id, index) => id !== this.mutedDeviceIds[index]);
+        if (!changed)
+            return;
+        this.mutedDeviceIds = ids;
+        this.emit({ type: 'mutedUsers', deviceIds: ids });
+    }
+    setViewerName(name) {
+        this.viewerNameOverride = (name === null || name === void 0 ? void 0 : name.trim()) || null;
+    }
+    get publishedName() {
+        var _a, _b, _c;
+        return (_c = (_a = this.viewerNameOverride) !== null && _a !== void 0 ? _a : (_b = this.joined) === null || _b === void 0 ? void 0 : _b.viewerName) !== null && _c !== void 0 ? _c : 'Anonymous';
+    }
+    setMuted(muted) {
+        if (!this.engineReady)
+            return;
+        this.Engine.instance().muteSpeaker(muted);
+    }
+    async sendComment(text, deviceId) {
+        if (!this.joined || !text.trim())
+            return null;
+        const muted = this.mutedDeviceIds.includes(deviceId);
+        await this.Engine.instance().sendBarrageMessage(this.joined.roomId, JSON.stringify({ name: this.publishedName, comment: text, source: 'USER', deviceId, muted, isBanned: false }));
+        return this.makeComment(text, this.publishedName, 'USER', undefined, true);
+    }
+    async sendReaction(reactionUrl) {
+        if (!this.joined)
+            return;
+        const userName = this.publishedName;
+        // `sendCustomCommand` does not echo to the sender, so emit the local event here.
+        await this.Engine.instance().sendCustomCommand(this.joined.roomId, JSON.stringify({ type: 'REACTION_ANNOUCEMENT', reactionUrl, userName, roomId: this.joined.roomId }), []);
+        this.emit({ type: 'reaction', reactionUrl, userName });
+    }
+    async sendBid(params) {
+        var _a;
+        if (!this.joined || !params.moderatorId)
+            return;
+        const { ZegoUser } = this.Zego;
+        // Coerced at the crash boundary: a non-string recipient id is an uncatchable native crash on iOS.
+        const moderatorId = String(params.moderatorId);
+        await this.Engine.instance().sendCustomCommand(this.joined.roomId, JSON.stringify({
+            type: 'BID_PLACED',
+            data: {
+                bidAmount: params.bidAmount,
+                user: params.bidder,
+                timeStamp: params.placedAtMs,
+                userOptedVariantId: (_a = params.variantId) !== null && _a !== void 0 ? _a : '',
+            },
+        }), [new ZegoUser(moderatorId, moderatorId)]);
+    }
+    async sendCartAnnouncement(productTitle) {
+        if (!this.joined || !productTitle.trim())
+            return;
+        const userName = this.publishedName;
+        await this.Engine.instance().sendCustomCommand(this.joined.roomId, JSON.stringify({ type: 'CART_ANNOUCEMENT', productTitle, userName, roomId: this.joined.roomId }), []);
+        this.emit({ type: 'cartAnnouncement', productTitle, userName });
+    }
+    async leaveNow() {
+        if (!this.engineReady || !this.joined)
+            return;
+        const engine = this.Engine.instance();
+        if (this.playingStreamId)
+            await engine.stopPlayingStream(this.playingStreamId);
+        await engine.logoutRoom(this.joined.roomId);
+        this.playingStreamId = null;
+        this.playingTag = null;
+        this.boundTag = null;
+        this.joined = null;
+        this.emit({ type: 'videoBound', tag: null });
+    }
+    async destroy() {
+        if (!this.engineReady)
+            return;
+        await this.leave();
+        this.creating = null;
+        this.Engine.destroyEngine();
+        this.engineReady = false;
+    }
+}
+exports.engine = new NativeLiveEngine();
+//# sourceMappingURL=engine.native.js.map