agora-electron-sdk 4.3.2 → 4.4.0-dev.1

package/js/Renderer/IRenderer.js

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IRenderer = void 0;
-var AgoraBase_1 = require("../Private/AgoraBase");
-var AgoraMediaBase_1 = require("../Private/AgoraMediaBase");
-var IRenderer = /** @class */ (function () {
-    function IRenderer() {
+const AgoraBase_1 = require("../Private/AgoraBase");
+const AgoraMediaBase_1 = require("../Private/AgoraMediaBase");
+class IRenderer {
+    constructor() {
         this._context = {};
     }
-    IRenderer.prototype.bind = function (element) {
+    bind(element) {
         this.parentElement = element;
         this.container = document.createElement('div');
         Object.assign(this.container.style, {
@@ -22,58 +22,50 @@ var IRenderer = /** @class */ (function () {
         this.canvas = document.createElement('canvas');
         this.canvas.style.display = 'none';
         this.container.appendChild(this.canvas);
-    };
-    IRenderer.prototype.unbind = function () {
-        var _a, _b;
-        if (this.container && ((_a = this.canvas) === null || _a === void 0 ? void 0 : _a.parentNode) === this.container) {
+    }
+    unbind() {
+        if (this.container && this.canvas?.parentNode === this.container) {
             this.container.removeChild(this.canvas);
         }
         if (this.parentElement &&
-            ((_b = this.container) === null || _b === void 0 ? void 0 : _b.parentNode) === this.parentElement) {
+            this.container?.parentNode === this.parentElement) {
             this.parentElement.removeChild(this.container);
         }
         this.canvas = undefined;
         this.container = undefined;
         this.parentElement = undefined;
-    };
-    IRenderer.prototype.drawFrame = function (_videoFrame) {
+    }
+    drawFrame(_videoFrame) {
         if (!this.canvas)
             return;
-        //@ts-ignore
-        if (!this.canvas.checkVisibility()) {
+        if (this.canvas.style.display !== '') {
             this.canvas.style.display = '';
         }
-    };
-    Object.defineProperty(IRenderer.prototype, "context", {
-        get: function () {
-            return this._context;
-        },
-        set: function (_a) {
-            var renderMode = _a.renderMode, mirrorMode = _a.mirrorMode;
-            if (this.context.renderMode !== renderMode) {
-                this.context.renderMode = renderMode;
-                this.updateRenderMode();
-            }
-            if (this.context.mirrorMode !== mirrorMode) {
-                this.context.mirrorMode = mirrorMode;
-                this.updateMirrorMode();
-            }
-        },
-        enumerable: false,
-        configurable: true
-    });
-    IRenderer.prototype.updateRenderMode = function () {
-        var _a;
+    }
+    set context({ renderMode, mirrorMode }) {
+        if (this.context.renderMode !== renderMode) {
+            this.context.renderMode = renderMode;
+            this.updateRenderMode();
+        }
+        if (this.context.mirrorMode !== mirrorMode) {
+            this.context.mirrorMode = mirrorMode;
+            this.updateMirrorMode();
+        }
+    }
+    get context() {
+        return this._context;
+    }
+    updateRenderMode() {
         if (!this.canvas || !this.container)
             return;
-        var _b = this.container, clientWidth = _b.clientWidth, clientHeight = _b.clientHeight;
-        var _c = this.canvas, width = _c.width, height = _c.height;
-        var containerAspectRatio = clientWidth / clientHeight;
-        var canvasAspectRatio = width / height;
-        var widthScale = clientWidth / width;
-        var heightScale = clientHeight / height;
-        var isHidden = ((_a = this.context) === null || _a === void 0 ? void 0 : _a.renderMode) === AgoraMediaBase_1.RenderModeType.RenderModeHidden;
-        var scale = 1;
+        const { clientWidth, clientHeight } = this.container;
+        const { width, height } = this.canvas;
+        const containerAspectRatio = clientWidth / clientHeight;
+        const canvasAspectRatio = width / height;
+        const widthScale = clientWidth / width;
+        const heightScale = clientHeight / height;
+        const isHidden = this.context?.renderMode === AgoraMediaBase_1.RenderModeType.RenderModeHidden;
+        let scale = 1;
         // If container's aspect ratio is larger than canvas's aspect ratio
         if (containerAspectRatio > canvasAspectRatio) {
             // Scale canvas to fit container's width on hidden mode
@@ -85,9 +77,9 @@ var IRenderer = /** @class */ (function () {
             // Scale canvas to fit container's width on fit mode
             scale = isHidden ? heightScale : widthScale;
         }
-        this.canvas.style.transform = "scale(".concat(scale, ")");
-    };
-    IRenderer.prototype.updateMirrorMode = function () {
+        this.canvas.style.transform = `scale(${scale})`;
+    }
+    updateMirrorMode() {
         if (!this.parentElement)
             return;
         Object.assign(this.parentElement.style, {
@@ -95,9 +87,8 @@ var IRenderer = /** @class */ (function () {
                 ? 'rotateY(180deg)'
                 : '',
         });
-    };
-    IRenderer.prototype.rotateCanvas = function (_a) {
-        var width = _a.width, height = _a.height, rotation = _a.rotation;
+    }
+    rotateCanvas({ width, height, rotation }) {
         if (!this.canvas)
             return;
         if (rotation === 0 || rotation === 180) {
@@ -109,9 +100,8 @@ var IRenderer = /** @class */ (function () {
             this.canvas.width = height;
         }
         else {
-            throw new Error("Invalid rotation: ".concat(rotation, ", only 0, 90, 180, 270 are supported"));
+            throw new Error(`Invalid rotation: ${rotation}, only 0, 90, 180, 270 are supported`);
         }
-    };
-    return IRenderer;
-}());
+    }
+}
 exports.IRenderer = IRenderer;

package/js/Renderer/IRendererManager.js

@@ -1,26 +1,15 @@
 "use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IRendererManager = void 0;
-var AgoraBase_1 = require("../Private/AgoraBase");
-var AgoraMediaBase_1 = require("../Private/AgoraMediaBase");
-var Utils_1 = require("../Utils");
-var RendererCache_1 = require("./RendererCache");
+const AgoraBase_1 = require("../Private/AgoraBase");
+const AgoraMediaBase_1 = require("../Private/AgoraMediaBase");
+const Utils_1 = require("../Utils");
+const RendererCache_1 = require("./RendererCache");
 /**
  * @ignore
  */
-var IRendererManager = /** @class */ (function () {
-    function IRendererManager() {
+class IRendererManager {
+    constructor() {
         this._renderingFps = 15;
         this._currentFrameCount = 0;
         this._previousFirstFrameTime = 0;
@@ -30,59 +19,42 @@ var IRendererManager = /** @class */ (function () {
             mirrorMode: AgoraBase_1.VideoMirrorModeType.VideoMirrorModeDisabled,
         };
     }
-    Object.defineProperty(IRendererManager.prototype, "renderingFps", {
-        get: function () {
-            return this._renderingFps;
-        },
-        set: function (fps) {
-            if (this._renderingFps !== fps) {
-                this._renderingFps = fps;
-                if (this._renderingTimer) {
-                    this.stopRendering();
-                    this.startRendering();
-                }
+    set renderingFps(fps) {
+        if (this._renderingFps !== fps) {
+            this._renderingFps = fps;
+            if (this._renderingTimer) {
+                this.stopRendering();
+                this.startRendering();
             }
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(IRendererManager.prototype, "defaultChannelId", {
-        get: function () {
-            var _a;
-            return (_a = this._context.channelId) !== null && _a !== void 0 ? _a : '';
-        },
-        set: function (channelId) {
-            this._context.channelId = channelId;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(IRendererManager.prototype, "defaultRenderMode", {
-        get: function () {
-            return this._context.renderMode;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(IRendererManager.prototype, "defaultMirrorMode", {
-        get: function () {
-            return this._context.mirrorMode;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    IRendererManager.prototype.release = function () {
+        }
+    }
+    get renderingFps() {
+        return this._renderingFps;
+    }
+    set defaultChannelId(channelId) {
+        this._context.channelId = channelId;
+    }
+    get defaultChannelId() {
+        return this._context.channelId ?? '';
+    }
+    get defaultRenderMode() {
+        return this._context.renderMode;
+    }
+    get defaultMirrorMode() {
+        return this._context.mirrorMode;
+    }
+    release() {
         this.stopRendering();
         this.clearRendererCache();
-    };
-    IRendererManager.prototype.precheckRendererContext = function (context) {
-        var sourceType = context.sourceType, uid = context.uid, channelId = context.channelId, mediaPlayerId = context.mediaPlayerId, _a = context.renderMode, renderMode = _a === void 0 ? this.defaultRenderMode : _a, _b = context.mirrorMode, mirrorMode = _b === void 0 ? this.defaultMirrorMode : _b;
+    }
+    precheckRendererContext(context) {
+        let { sourceType, uid, channelId, mediaPlayerId, renderMode = this.defaultRenderMode, mirrorMode = this.defaultMirrorMode, } = context;
         switch (sourceType) {
             case AgoraMediaBase_1.VideoSourceType.VideoSourceRemote:
                 if (uid === undefined) {
                     throw new Error('uid is required');
                 }
-                channelId = channelId !== null && channelId !== void 0 ? channelId : this.defaultChannelId;
+                channelId = channelId ?? this.defaultChannelId;
                 break;
             case AgoraMediaBase_1.VideoSourceType.VideoSourceMediaPlayer:
                 if (mediaPlayerId === undefined) {
@@ -101,11 +73,11 @@ var IRendererManager = /** @class */ (function () {
                 uid = 0;
                 break;
         }
-        return __assign(__assign({}, context), { sourceType: sourceType, uid: uid, channelId: channelId, renderMode: renderMode, mirrorMode: mirrorMode });
-    };
-    IRendererManager.prototype.addOrRemoveRenderer = function (context) {
+        return { ...context, sourceType, uid, channelId, renderMode, mirrorMode };
+    }
+    addOrRemoveRenderer(context) {
         // To be compatible with the old API
-        var _a = context.setupMode, setupMode = _a === void 0 ? AgoraBase_1.VideoViewSetupMode.VideoViewSetupAdd : _a;
+        let { setupMode = AgoraBase_1.VideoViewSetupMode.VideoViewSetupAdd } = context;
         if (!context.view)
             setupMode = AgoraBase_1.VideoViewSetupMode.VideoViewSetupRemove;
         switch (setupMode) {
@@ -118,15 +90,15 @@ var IRendererManager = /** @class */ (function () {
                 this.removeRendererFromCache(context);
                 return this.addRendererToCache(context);
         }
-    };
-    IRendererManager.prototype.addRendererToCache = function (context) {
-        var checkedContext = this.precheckRendererContext(context);
+    }
+    addRendererToCache(context) {
+        const checkedContext = this.precheckRendererContext(context);
         if (!checkedContext.view)
             return undefined;
         if (this.findRenderer(checkedContext.view)) {
             throw new Error('You have already added this view to the renderer');
         }
-        var rendererCache = this.getRendererCache(checkedContext);
+        let rendererCache = this.getRendererCache(checkedContext);
         if (!rendererCache) {
             rendererCache = new RendererCache_1.RendererCache(checkedContext);
             this._rendererCaches.push(rendererCache);
@@ -134,84 +106,88 @@ var IRendererManager = /** @class */ (function () {
         rendererCache.addRenderer(this.createRenderer(checkedContext));
         this.startRendering();
         return rendererCache;
-    };
-    IRendererManager.prototype.removeRendererFromCache = function (context) {
-        var checkedContext = this.precheckRendererContext(context);
-        var rendererCache = this.getRendererCache(checkedContext);
-        if (!rendererCache)
-            return;
-        if (checkedContext.view) {
-            var renderer = rendererCache.findRenderer(checkedContext.view);
-            if (!renderer)
-                return;
-            rendererCache.removeRenderer(renderer);
+    }
+    removeRendererFromCache(context) {
+        const checkedContext = this.precheckRendererContext(context);
+        const rendererCache = this.getRendererCache(checkedContext);
+        if (rendererCache) {
+            if (checkedContext.view) {
+                const renderer = rendererCache.findRenderer(checkedContext.view);
+                if (!renderer)
+                    return;
+                rendererCache.removeRenderer(renderer);
+            }
+            else {
+                rendererCache.removeRenderer();
+            }
+            if (rendererCache.renderers.length === 0) {
+                this._rendererCaches.splice(this._rendererCaches.indexOf(rendererCache), 1);
+            }
         }
         else {
-            rendererCache.removeRenderer();
-        }
-        if (rendererCache.renderers.length === 0) {
-            this._rendererCaches.splice(this._rendererCaches.indexOf(rendererCache), 1);
+            this._rendererCaches = this._rendererCaches.filter((_rendererCache) => {
+                const renderer = _rendererCache.findRenderer(checkedContext.view);
+                if (renderer) {
+                    _rendererCache.removeRenderer(renderer);
+                }
+                return _rendererCache.renderers.length > 0;
+            });
         }
-    };
-    IRendererManager.prototype.clearRendererCache = function () {
-        for (var _i = 0, _a = this._rendererCaches; _i < _a.length; _i++) {
-            var rendererCache = _a[_i];
+    }
+    clearRendererCache() {
+        for (const rendererCache of this._rendererCaches) {
             rendererCache.removeRenderer();
         }
         this._rendererCaches.splice(0);
-    };
-    IRendererManager.prototype.getRendererCache = function (context) {
-        return this._rendererCaches.find(function (cache) { return cache.key === (0, RendererCache_1.generateRendererCacheKey)(context); });
-    };
-    IRendererManager.prototype.getRenderers = function (context) {
-        var _a;
-        return ((_a = this.getRendererCache(context)) === null || _a === void 0 ? void 0 : _a.renderers) || [];
-    };
-    IRendererManager.prototype.findRenderer = function (view) {
-        for (var _i = 0, _a = this._rendererCaches; _i < _a.length; _i++) {
-            var rendererCache = _a[_i];
-            var renderer = rendererCache.findRenderer(view);
+    }
+    getRendererCache(context) {
+        return this._rendererCaches.find((cache) => cache.key === (0, RendererCache_1.generateRendererCacheKey)(context));
+    }
+    getRenderers(context) {
+        return this.getRendererCache(context)?.renderers || [];
+    }
+    findRenderer(view) {
+        for (const rendererCache of this._rendererCaches) {
+            const renderer = rendererCache.findRenderer(view);
             if (renderer)
                 return renderer;
         }
         return undefined;
-    };
-    IRendererManager.prototype.startRendering = function () {
-        var _this = this;
+    }
+    startRendering() {
         if (this._renderingTimer)
             return;
-        var renderingLooper = function () {
-            if (_this._previousFirstFrameTime === 0) {
+        const renderingLooper = () => {
+            if (this._previousFirstFrameTime === 0) {
                 // Get the current time as the time of the first frame of per second
-                _this._previousFirstFrameTime = performance.now();
+                this._previousFirstFrameTime = performance.now();
                 // Reset the frame count
-                _this._currentFrameCount = 0;
+                this._currentFrameCount = 0;
             }
             // Increase the frame count
-            ++_this._currentFrameCount;
+            ++this._currentFrameCount;
             // Get the current time
-            var currentFrameTime = performance.now();
+            const currentFrameTime = performance.now();
             // Calculate the time difference between the current frame and the previous frame
-            var deltaTime = currentFrameTime - _this._previousFirstFrameTime;
+            const deltaTime = currentFrameTime - this._previousFirstFrameTime;
             // Calculate the expected time of the current frame
-            var expectedTime = (_this._currentFrameCount * 1000) / _this._renderingFps;
-            (0, Utils_1.logDebug)(new Date().toLocaleTimeString(), 'currentFrameCount', _this._currentFrameCount, 'expectedTime', expectedTime, 'deltaTime', deltaTime);
-            if (_this._rendererCaches.length === 0) {
+            const expectedTime = (this._currentFrameCount * 1000) / this._renderingFps;
+            (0, Utils_1.logDebug)(new Date().toLocaleTimeString(), 'currentFrameCount', this._currentFrameCount, 'expectedTime', expectedTime, 'deltaTime', deltaTime);
+            if (this._rendererCaches.length === 0) {
                 // If there is no renderer, stop rendering
-                _this.stopRendering();
+                this.stopRendering();
                 return;
             }
             // Render all renderers
-            for (var _i = 0, _a = _this._rendererCaches; _i < _a.length; _i++) {
-                var rendererCache = _a[_i];
-                _this.doRendering(rendererCache);
+            for (const rendererCache of this._rendererCaches) {
+                this.doRendering(rendererCache);
             }
-            if (_this._currentFrameCount >= _this.renderingFps) {
-                _this._previousFirstFrameTime = 0;
+            if (this._currentFrameCount >= this.renderingFps) {
+                this._previousFirstFrameTime = 0;
             }
             if (deltaTime < expectedTime) {
                 // If the time difference between the current frame and the previous frame is less than the expected time, then wait for the difference
-                _this._renderingTimer = window.setTimeout(renderingLooper, expectedTime - deltaTime);
+                this._renderingTimer = window.setTimeout(renderingLooper, expectedTime - deltaTime);
             }
             else {
                 // If the time difference between the current frame and the previous frame is greater than the expected time, then render immediately
@@ -219,24 +195,22 @@ var IRendererManager = /** @class */ (function () {
             }
         };
         renderingLooper();
-    };
-    IRendererManager.prototype.stopRendering = function () {
+    }
+    stopRendering() {
         if (this._renderingTimer) {
             window.clearTimeout(this._renderingTimer);
             this._renderingTimer = undefined;
         }
-    };
-    IRendererManager.prototype.setRendererContext = function (context) {
-        var checkedContext = this.precheckRendererContext(context);
-        for (var _i = 0, _a = this._rendererCaches; _i < _a.length; _i++) {
-            var rendererCache = _a[_i];
-            var result = rendererCache.setRendererContext(checkedContext);
+    }
+    setRendererContext(context) {
+        const checkedContext = this.precheckRendererContext(context);
+        for (const rendererCache of this._rendererCaches) {
+            const result = rendererCache.setRendererContext(checkedContext);
             if (result) {
                 return true;
             }
         }
         return false;
-    };
-    return IRendererManager;
-}());
+    }
+}
 exports.IRendererManager = IRendererManager;