trtc-electron-sdk 12.2.115-beta.2 → 12.2.115-beta.21

package/liteav/extensions/MediaMixingManager/MediaMixingService.d.ts

@@ -0,0 +1,60 @@
+import TRTCMediaMixingManager from './MediaMixingManager';
+import { ITRTCMediaMixingService } from './types';
+/**
+ * @namespace TRTCMediaMixingServiceEvent
+ * @description 目前只支持 `Windows` 操作系统
+ */
+export declare enum TRTCMediaMixingServiceEvent {
+    /**
+     * @description 本地混流服务器连接丢失事件
+     *
+     * @event TRTCMediaMixingServiceEvent#onMediaMixingServerLost
+     */
+    onMediaMixingServerLost = "onMediaMixingServerLost"
+}
+/**
+ * 本地混流服务
+ *
+ * 目前只支持 `Windows` 操作系统
+ */
+declare class TRTCMediaMixingService implements ITRTCMediaMixingService {
+    private mediaMixingManager;
+    private eventEmitter;
+    constructor(mediaMixingManager: TRTCMediaMixingManager);
+    /**
+     * 启动独立混流渲染进程
+     *
+     * 开发模式，默认路径：node_modules\\trtc-electron-sdk\\build\\Release\\liteav_media_server.exe
+     *
+     * 构建模式，默认路径：${resourcesPath}\\liteav_media_server.exe
+     *
+     * 如果用户应用有特殊配置，默认路径可能找不到服务进程程序，需要自行传入路径。
+     *
+     * @param path {string} - 服务进程程序路径，不传入参数时，SDK 内部按照默认路径启动服务进程。
+     *
+     * @returns {Promise<void>}
+     */
+    startMediaMixingServer(path?: string): Promise<void>;
+    /**
+     * 关闭独立混流渲染进程
+     *
+     * @returns {Promise<void>}
+     */
+    stopMediaMixingServer(): Promise<void>;
+    destroy(): void;
+    /**
+     * 注册事件监听
+     *
+     * @param event {TRTCMediaMixingServiceEvent} - 事件名称
+     * @param func {Function} - 事件回调函数
+     */
+    on(event: TRTCMediaMixingServiceEvent, func: (...args: any[]) => void): void;
+    /**
+     * 取消事件监听
+     *
+     * @param event {TRTCMediaMixingServiceEvent} - 事件名
+     * @param func {Function} - 事件回调函数
+     */
+    off(event: TRTCMediaMixingServiceEvent, func: (...args: any[]) => void): void;
+}
+export default TRTCMediaMixingService;

package/liteav/extensions/MediaMixingManager/MediaMixingService.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TRTCMediaMixingServiceEvent = void 0;
+const events_1 = require("events");
+const MediaMixingManager_1 = require("./MediaMixingManager");
+/**
+ * @namespace TRTCMediaMixingServiceEvent
+ * @description 目前只支持 `Windows` 操作系统
+ */
+var TRTCMediaMixingServiceEvent;
+(function (TRTCMediaMixingServiceEvent) {
+    /**
+     * @description 本地混流服务器连接丢失事件
+     *
+     * @event TRTCMediaMixingServiceEvent#onMediaMixingServerLost
+     */
+    TRTCMediaMixingServiceEvent["onMediaMixingServerLost"] = "onMediaMixingServerLost";
+})(TRTCMediaMixingServiceEvent = exports.TRTCMediaMixingServiceEvent || (exports.TRTCMediaMixingServiceEvent = {}));
+/**
+ * 本地混流服务
+ *
+ * 目前只支持 `Windows` 操作系统
+ */
+class TRTCMediaMixingService {
+    constructor(mediaMixingManager) {
+        this.mediaMixingManager = mediaMixingManager;
+        this.eventEmitter = new events_1.EventEmitter();
+        this.mediaMixingManager.on(MediaMixingManager_1.TRTCMediaMixingEvent.onMediaMixingServerLost, () => {
+            this.eventEmitter.emit(TRTCMediaMixingServiceEvent.onMediaMixingServerLost);
+        });
+    }
+    /**
+     * 启动独立混流渲染进程
+     *
+     * 开发模式，默认路径：node_modules\\trtc-electron-sdk\\build\\Release\\liteav_media_server.exe
+     *
+     * 构建模式，默认路径：${resourcesPath}\\liteav_media_server.exe
+     *
+     * 如果用户应用有特殊配置，默认路径可能找不到服务进程程序，需要自行传入路径。
+     *
+     * @param path {string} - 服务进程程序路径，不传入参数时，SDK 内部按照默认路径启动服务进程。
+     *
+     * @returns {Promise<void>}
+     */
+    startMediaMixingServer(path) {
+        return this.mediaMixingManager.startMediaMixingServer(path);
+    }
+    /**
+     * 关闭独立混流渲染进程
+     *
+     * @returns {Promise<void>}
+     */
+    stopMediaMixingServer() {
+        return this.mediaMixingManager.stopMediaMixingServer();
+    }
+    destroy() {
+        this.eventEmitter.removeAllListeners();
+    }
+    /**
+     * 注册事件监听
+     *
+     * @param event {TRTCMediaMixingServiceEvent} - 事件名称
+     * @param func {Function} - 事件回调函数
+     */
+    on(event, func) {
+        var _a;
+        (_a = this.eventEmitter) === null || _a === void 0 ? void 0 : _a.on(event, func);
+    }
+    /**
+     * 取消事件监听
+     *
+     * @param event {TRTCMediaMixingServiceEvent} - 事件名
+     * @param func {Function} - 事件回调函数
+     */
+    off(event, func) {
+        var _a;
+        (_a = this.eventEmitter) === null || _a === void 0 ? void 0 : _a.off(event, func);
+    }
+}
+exports.default = TRTCMediaMixingService;

package/liteav/extensions/MediaMixingManager/StreamLayout/BaseStreamLayoutManager.d.ts

@@ -0,0 +1,32 @@
+import { TRTCStreamLayout, TRTCStreamLayoutMode } from "../types";
+import { ITRTCStreamLayoutManager, INativeStreamLayoutManager, TRTCStreamLayoutContext } from "./types";
+declare class BaseStreamLayoutManager implements ITRTCStreamLayoutManager {
+    protected logPrefix: string;
+    protected nativeStreamLayoutManager: INativeStreamLayoutManager;
+    protected layout: TRTCStreamLayout;
+    protected context: TRTCStreamLayoutContext | null;
+    protected container: HTMLElement | null;
+    protected displayArea: {
+        left: number;
+        top: number;
+        right: number;
+        bottom: number;
+        width: number;
+        height: number;
+    };
+    protected resizeObserver: ResizeObserver | null;
+    constructor(nativeStreamLayoutManager: INativeStreamLayoutManager, context: TRTCStreamLayoutContext);
+    setLayout(layout: TRTCStreamLayout): void;
+    getLayoutMode(): TRTCStreamLayoutMode;
+    updateOptions(options: {
+        width: number;
+        height: number;
+    }): void;
+    destroy(): void;
+    protected refreshLayout(): void;
+    private onResize;
+    private setResizeObserver;
+    private updateDisplayArea;
+    private onDevicePixelRatioChange;
+}
+export default BaseStreamLayoutManager;

package/liteav/extensions/MediaMixingManager/StreamLayout/BaseStreamLayoutManager.js

@@ -0,0 +1,114 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("../types");
+const DevicePixelRatioObserver_1 = __importDefault(require("../../../base/DevicePixelRatioObserver"));
+const utils_1 = require("../../../utils");
+const logger_1 = __importDefault(require("../../../logger"));
+class BaseStreamLayoutManager {
+    constructor(nativeStreamLayoutManager, context) {
+        this.logPrefix = "[BaseStreamLayoutManager]";
+        this.container = null;
+        this.displayArea = {
+            left: 0,
+            top: 0,
+            right: 0,
+            bottom: 0,
+            width: 0,
+            height: 0,
+        };
+        this.resizeObserver = null;
+        this.nativeStreamLayoutManager = nativeStreamLayoutManager;
+        this.layout = {
+            layoutMode: types_1.TRTCStreamLayoutMode.None,
+        };
+        this.context = context;
+        this.container = context.container;
+        this.onResize = (0, utils_1.debounce)(this.onResize.bind(this), 100);
+        if (this.container) {
+            this.setResizeObserver();
+            this.updateDisplayArea();
+        }
+        else {
+            logger_1.default.warn(`${this.logPrefix}constructor failed, no context.container.`);
+        }
+        this.onDevicePixelRatioChange = (0, utils_1.debounce)(this.onDevicePixelRatioChange.bind(this), 100);
+        DevicePixelRatioObserver_1.default.on('change', this.onDevicePixelRatioChange);
+    }
+    setLayout(layout) {
+        this.layout = layout;
+        this.refreshLayout();
+    }
+    getLayoutMode() {
+        return this.layout.layoutMode;
+    }
+    updateOptions(options) {
+        if (this.context && (this.context.mixingVideoSize.width !== options.width || this.context.mixingVideoSize.height !== options.height)) {
+            this.context.mixingVideoSize.width = options.width;
+            this.context.mixingVideoSize.height = options.height;
+            this.refreshLayout();
+        }
+    }
+    destroy() {
+        this.layout = {
+            layoutMode: types_1.TRTCStreamLayoutMode.None,
+        };
+        this.container = null;
+        this.context = null;
+        if (this.resizeObserver) {
+            this.resizeObserver.disconnect();
+            this.resizeObserver = null;
+        }
+        DevicePixelRatioObserver_1.default.off('change', this.onDevicePixelRatioChange);
+    }
+    refreshLayout() {
+        logger_1.default.warn(`${this.logPrefix}refreshLayout should be implemented by sub-class.`);
+    }
+    onResize(entries) {
+        logger_1.default.log(`${this.logPrefix}onResize entries:`, entries);
+        for (const entry of entries) {
+            if (entry.target === this.container) {
+                logger_1.default.debug(`${this.logPrefix}onResize:`, this.container.getBoundingClientRect());
+                this.updateDisplayArea();
+                this.refreshLayout();
+                break;
+            }
+        }
+    }
+    setResizeObserver() {
+        logger_1.default.debug(`${this.logPrefix}setResizeObserver container:`, this.container, ' resizeObserver:', this.resizeObserver);
+        if (this.resizeObserver) {
+            this.resizeObserver.disconnect();
+        }
+        if (this.container) {
+            this.resizeObserver = new ResizeObserver(this.onResize);
+            this.resizeObserver.observe(this.container);
+        }
+        else {
+            logger_1.default.warn(`${this.logPrefix}setResizeObserver failed, container is null.`);
+        }
+    }
+    updateDisplayArea() {
+        if (this.container) {
+            const containerRect = this.container.getBoundingClientRect();
+            this.displayArea = {
+                left: containerRect.left,
+                top: containerRect.top,
+                right: containerRect.right,
+                bottom: containerRect.bottom,
+                width: containerRect.width,
+                height: containerRect.height,
+            };
+        }
+        else {
+            logger_1.default.warn(`${this.logPrefix}updateDisplayArea failed, no container.`);
+        }
+    }
+    onDevicePixelRatioChange() {
+        logger_1.default.debug(`${this.logPrefix}onDevicePixelRatioChange:`, window.devicePixelRatio);
+        this.refreshLayout();
+    }
+}
+exports.default = BaseStreamLayoutManager;

package/liteav/extensions/MediaMixingManager/StreamLayout/CustomStreamLayoutManager.d.ts

@@ -0,0 +1,11 @@
+import BaseStreamLayoutManager from "./BaseStreamLayoutManager";
+import { TRTCStreamLayout } from "../types";
+import { INativeStreamLayoutManager, TRTCStreamLayoutContext } from "./types";
+declare class CustomStreamLayoutManager extends BaseStreamLayoutManager {
+    protected logPrefix: string;
+    constructor(nativeStreamLayoutManager: INativeStreamLayoutManager, context: TRTCStreamLayoutContext);
+    setLayout(layout: TRTCStreamLayout): void;
+    protected refreshLayout(): void;
+    private convertRelativeToAbsolute;
+}
+export default CustomStreamLayoutManager;

package/liteav/extensions/MediaMixingManager/StreamLayout/CustomStreamLayoutManager.js

@@ -0,0 +1,135 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const BaseStreamLayoutManager_1 = __importDefault(require("./BaseStreamLayoutManager"));
+const types_1 = require("../types");
+const trtc_define_1 = require("../../../trtc_define");
+const logger_1 = __importDefault(require("../../../logger"));
+const constant_1 = require("../../../constant");
+class CustomStreamLayoutManager extends BaseStreamLayoutManager_1.default {
+    constructor(nativeStreamLayoutManager, context) {
+        super(nativeStreamLayoutManager, context);
+        this.logPrefix = "[TRTCCustomStreamLayoutManager]";
+        this.layout = {
+            layoutMode: types_1.TRTCStreamLayoutMode.Custom,
+        };
+    }
+    setLayout(layout) {
+        this.layout = Object.assign(Object.assign({}, layout), { layoutMode: types_1.TRTCStreamLayoutMode.Custom });
+        this.refreshLayout();
+    }
+    refreshLayout() {
+        var _a;
+        if (this.layout.userList) {
+            let transferredUserList = this.layout.userList;
+            if (this.container) {
+                transferredUserList = this.layout.userList.map((user) => {
+                    if (user.rect) {
+                        return Object.assign(Object.assign({}, user), { rect: {
+                                left: user.rect.left * window.devicePixelRatio,
+                                right: user.rect.right * window.devicePixelRatio,
+                                top: user.rect.top * window.devicePixelRatio,
+                                bottom: user.rect.bottom * window.devicePixelRatio,
+                            } });
+                    }
+                    else {
+                        return user;
+                    }
+                });
+            }
+            this.nativeStreamLayoutManager.setStreamLayout(transferredUserList);
+        }
+        else if (this.layout.size && this.layout.streams) {
+            const userList = this.convertRelativeToAbsolute(this.layout);
+            if (userList) {
+                logger_1.default.debug(`${this.logPrefix}refreshLayout userList:`, userList);
+                const localUser = userList.filter(user => user.userId === constant_1.LOCAL_USER_ID)[0];
+                if ((localUser === null || localUser === void 0 ? void 0 : localUser.rect) && ((_a = this.context) === null || _a === void 0 ? void 0 : _a.mediaMixingDesigner)) {
+                    const workingArea = localUser.rect;
+                    this.context.mediaMixingDesigner.setWorkingArea({
+                        left: workingArea.left / this.displayArea.width,
+                        top: workingArea.top / this.displayArea.height,
+                        right: workingArea.right / this.displayArea.width,
+                        bottom: workingArea.bottom / this.displayArea.height,
+                    }, localUser.fillMode);
+                }
+                userList.forEach(user => {
+                    if (user.rect) {
+                        user.rect = {
+                            left: user.rect.left * window.devicePixelRatio,
+                            right: user.rect.right * window.devicePixelRatio,
+                            top: user.rect.top * window.devicePixelRatio,
+                            bottom: user.rect.bottom * window.devicePixelRatio,
+                        };
+                    }
+                });
+                logger_1.default.debug(`${this.logPrefix}refreshLayout transfer layout to pixel unit::`, userList);
+                this.nativeStreamLayoutManager.setStreamLayout(userList);
+            }
+            else {
+                logger_1.default.error(`${this.logPrefix}refreshLayout invalid parameter, no 'streams' or 'size'`, JSON.stringify(this.layout));
+            }
+        }
+        else {
+            logger_1.default.error(`${this.logPrefix}refreshLayout invalid parameter:`, JSON.stringify(this.layout));
+        }
+    }
+    convertRelativeToAbsolute(serverMixingLayout) {
+        if (!serverMixingLayout.streams || !serverMixingLayout.size) {
+            return null;
+        }
+        // 1. calculate valid video content width and height
+        let minX = 1;
+        let minY = 1;
+        let maxX = 0;
+        let maxY = 0;
+        for (let i = 0; i < serverMixingLayout.streams.length; i++) {
+            const stream = serverMixingLayout.streams[i];
+            minX = Math.min(minX, stream.x);
+            minY = Math.min(minY, stream.y);
+            maxX = Math.max(maxX, stream.x + stream.w);
+            maxY = Math.max(maxY, stream.y + stream.h);
+        }
+        const xLength = maxX - minX;
+        const yLength = maxY - minY;
+        const contentWidth = xLength * serverMixingLayout.size.width;
+        const contentHeight = yLength * serverMixingLayout.size.height;
+        // 2. calculate fitting scale rate and fitting area
+        const scaleRate = Math.min(this.displayArea.width / contentWidth, this.displayArea.height / contentHeight);
+        const fittingArea = {
+            width: contentWidth * scaleRate,
+            height: contentHeight * scaleRate,
+            left: (this.displayArea.width - contentWidth * scaleRate) / 2,
+            top: (this.displayArea.height - contentHeight * scaleRate) / 2,
+            right: (this.displayArea.width + contentWidth * scaleRate) / 2,
+            bottom: (this.displayArea.height + contentHeight * scaleRate) / 2,
+        };
+        // 3. transfer relative coordinates to absolute coordinates
+        return serverMixingLayout.streams.map((stream, index, list) => {
+            // 3.1 cut left and top black area
+            // 3.2 transfer relative video ratio to valid video content ratio
+            // 3.3 fit valid video content to dispaying area, that is fitting area
+            const result = {
+                x: (stream.x - minX) / xLength * contentWidth * scaleRate + fittingArea.left,
+                y: (stream.y - minY) / yLength * contentHeight * scaleRate + fittingArea.top,
+                w: (stream.w) / xLength * contentWidth * scaleRate,
+                h: (stream.h) / yLength * contentHeight * scaleRate,
+            };
+            // 3.4 convert to TRTCStreamLayout.userList item
+            return {
+                userId: stream.userId,
+                fillMode: list.length >= 2 ? trtc_define_1.TRTCVideoFillMode.TRTCVideoFillMode_Fill : trtc_define_1.TRTCVideoFillMode.TRTCVideoFillMode_Fit,
+                zOrder: index,
+                rect: {
+                    left: Math.round(result.x),
+                    top: Math.round(result.y),
+                    right: Math.round(result.x + result.w),
+                    bottom: Math.round(result.y + result.h),
+                }
+            };
+        });
+    }
+}
+exports.default = CustomStreamLayoutManager;

package/liteav/extensions/MediaMixingManager/StreamLayout/NoneStreamLayoutManager.d.ts

@@ -0,0 +1,11 @@
+import BaseStreamLayoutManager from "./BaseStreamLayoutManager";
+import { TRTCStreamLayout } from "../types";
+import { INativeStreamLayoutManager, TRTCStreamLayoutContext } from "./types";
+declare class NoneStreamLayoutManager extends BaseStreamLayoutManager {
+    protected logPrefix: string;
+    constructor(nativeStreamLayoutManager: INativeStreamLayoutManager, context: TRTCStreamLayoutContext);
+    setLayout(layout: TRTCStreamLayout): void;
+    protected refreshLayout(): void;
+    private centerLiveOwner;
+}
+export default NoneStreamLayoutManager;

package/liteav/extensions/MediaMixingManager/StreamLayout/NoneStreamLayoutManager.js

@@ -0,0 +1,73 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const BaseStreamLayoutManager_1 = __importDefault(require("./BaseStreamLayoutManager"));
+const types_1 = require("../types");
+const trtc_define_1 = require("../../../trtc_define");
+const logger_1 = __importDefault(require("../../../logger"));
+class NoneStreamLayoutManager extends BaseStreamLayoutManager_1.default {
+    constructor(nativeStreamLayoutManager, context) {
+        super(nativeStreamLayoutManager, context);
+        this.logPrefix = "[TRTCNoneStreamLayoutManager]";
+    }
+    setLayout(layout) {
+        this.layout = Object.assign(Object.assign({}, layout), { layoutMode: types_1.TRTCStreamLayoutMode.None, userList: [] });
+        this.refreshLayout();
+    }
+    refreshLayout() {
+        var _a, _b;
+        if (this.context && this.layout.userList) {
+            this.centerLiveOwner();
+            if (this.layout.userList.length === 1 && this.layout.userList[0].rect && this.displayArea.width !== 0 && this.displayArea.height !== 0 && window.devicePixelRatio !== 0) {
+                const workingArea = this.layout.userList[0].rect;
+                (_a = this.context.mediaMixingDesigner) === null || _a === void 0 ? void 0 : _a.setWorkingArea({
+                    left: workingArea.left / this.displayArea.width / window.devicePixelRatio,
+                    top: workingArea.top / this.displayArea.height / window.devicePixelRatio,
+                    right: workingArea.right / this.displayArea.width / window.devicePixelRatio,
+                    bottom: workingArea.bottom / this.displayArea.height / window.devicePixelRatio,
+                }, this.layout.userList[0].fillMode);
+            }
+            (_b = this.nativeStreamLayoutManager) === null || _b === void 0 ? void 0 : _b.setStreamLayout(this.layout.userList);
+        }
+        else {
+            logger_1.default.error(`${this.logPrefix}refreshLayout context is null or no user`);
+        }
+    }
+    centerLiveOwner() {
+        if (this.context && this.layout) {
+            const layoutPixelWidth = this.displayArea.width * window.devicePixelRatio;
+            const layoutPixelHeight = this.displayArea.height * window.devicePixelRatio;
+            const mixingVideoWidth = this.context.mixingVideoSize.width;
+            const mixingVideoHeight = this.context.mixingVideoSize.height;
+            // Live Owner(local user)
+            let scaleRate;
+            if (mixingVideoWidth === 0 || mixingVideoHeight === 0) {
+                scaleRate = 1;
+                logger_1.default.error(`${this.logPrefix}centerLiveOwner mixingVideoSize is 0, use default scaleRate '1'`);
+            }
+            else {
+                scaleRate = Math.min(layoutPixelWidth / mixingVideoWidth, layoutPixelHeight / mixingVideoHeight);
+            }
+            const previewWidth = mixingVideoWidth * scaleRate;
+            const previewHeight = mixingVideoHeight * scaleRate;
+            const previewLeft = (layoutPixelWidth - previewWidth) / 2;
+            const previewTop = (layoutPixelHeight - previewHeight) / 2;
+            const previewRight = previewLeft + previewWidth;
+            const previewBottom = previewTop + previewHeight;
+            this.layout.userList = [{
+                    userId: '',
+                    rect: {
+                        left: previewLeft,
+                        top: previewTop,
+                        right: previewRight,
+                        bottom: previewBottom,
+                    },
+                    fillMode: trtc_define_1.TRTCVideoFillMode.TRTCVideoFillMode_Fit,
+                    zOrder: 0
+                }];
+        }
+    }
+}
+exports.default = NoneStreamLayoutManager;

package/liteav/extensions/MediaMixingManager/StreamLayout/index.d.ts

@@ -0,0 +1,7 @@
+import { TRTCStreamLayoutMode } from '../types';
+import { ITRTCStreamLayoutManager, INativeStreamLayoutManager, TRTCStreamLayoutContext } from './types';
+export * from './types';
+declare function create(layoutMode: TRTCStreamLayoutMode, nativeStreamLayoutManager: INativeStreamLayoutManager, context: TRTCStreamLayoutContext): ITRTCStreamLayoutManager;
+export declare const StreamLayoutFactory: {
+    create: typeof create;
+};

package/liteav/extensions/MediaMixingManager/StreamLayout/index.js

@@ -0,0 +1,34 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamLayoutFactory = void 0;
+const CustomStreamLayoutManager_1 = __importDefault(require("./CustomStreamLayoutManager"));
+const NoneStreamLayoutManager_1 = __importDefault(require("./NoneStreamLayoutManager"));
+const types_1 = require("../types");
+__exportStar(require("./types"), exports);
+function create(layoutMode, nativeStreamLayoutManager, context) {
+    let layoutManager;
+    if (layoutMode === types_1.TRTCStreamLayoutMode.Custom) {
+        layoutManager = new CustomStreamLayoutManager_1.default(nativeStreamLayoutManager, context);
+    }
+    else {
+        // layoutMode === TRTCStreamLayoutMode.None
+        layoutManager = new NoneStreamLayoutManager_1.default(nativeStreamLayoutManager, context);
+    }
+    return layoutManager;
+}
+exports.StreamLayoutFactory = {
+    create: create,
+};

package/liteav/extensions/MediaMixingManager/StreamLayout/types.d.ts

@@ -0,0 +1,25 @@
+import { TRTCUserStream, TRTCStreamLayout, TRTCStreamLayoutMode } from '../types';
+import TRTCMediaMixingDesigner from '../../../MediaMixingDesigner';
+export interface INativeStreamLayoutManager {
+    setStreamLayout: (streamList: Array<TRTCUserStream>) => void;
+}
+export interface TRTCStreamLayoutContext {
+    container: HTMLElement | null;
+    mixingVideoSize: {
+        width: number;
+        height: number;
+    };
+    mediaMixingDesigner: TRTCMediaMixingDesigner | null;
+}
+export interface ITRTCStreamLayoutManager {
+    setLayout(layout: TRTCStreamLayout): void;
+    getLayoutMode(): TRTCStreamLayoutMode;
+    updateOptions(options: {
+        width: number;
+        height: number;
+    }): void;
+    destroy(): void;
+}
+export interface ITRTCStreamLayoutEvent {
+    onStreamLayoutChanged(streams: Array<TRTCUserStream>): void;
+}

package/liteav/extensions/MediaMixingManager/StreamLayout/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });