sinch-rtc/npm/src/rtc/IceServer.js

RTC JavaScript/Web SDK

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.toRTCIceServer = exports.createIceServerSetter = exports.onTurnFeatureFlagChanged = exports.createIceServerFetcher = void 0;
const constants_1 = require("../constants");
const models_1 = require("../models");
var IceServerKeys;
(function (IceServerKeys) {
    IceServerKeys["ValidUntil"] = "validUntil";
    IceServerKeys["Password"] = "password";
})(IceServerKeys || (IceServerKeys = {}));
const createIceServerFetcher = (apiClient, userId, instanceId) => () => __awaiter(void 0, void 0, void 0, function* () {
    try {
        const iceServersResponse = yield apiClient.getIceServers({
            userId: userId,
            instanceId: instanceId,
        });
        return iceServersResponse && iceServersResponse.iceServers;
    }
    catch (error) {
        console.error(error);
        return [];
    }
});
exports.createIceServerFetcher = createIceServerFetcher;
const onTurnFeatureFlagChanged = (instanceController) => (featureFlags) => {
    instanceController.toggleCapability(models_1.Capability.Turn, featureFlags.get(constants_1.FeatureFlag.UseTurn));
};
exports.onTurnFeatureFlagChanged = onTurnFeatureFlagChanged;
const createIceServerSetter = (peerConnectionClient) => (iceServers) => {
    peerConnectionClient.setIceServers(iceServers);
};
exports.createIceServerSetter = createIceServerSetter;
// converts IceServer or Ris to WebRTC's RTCIceServer type
const toRTCIceServer = (iceServers) => {
    if (!iceServers) {
        return [];
    }
    return iceServers.map((iceServer) => {
        const rtcIceServer = {};
        for (const [key, value] of Object.entries(iceServer)) {
            switch (key) {
                case IceServerKeys.Password:
                    rtcIceServer.credential = value;
                    break;
                case IceServerKeys.ValidUntil:
                    rtcIceServer.validUntil =
                        typeof value === "string" ? new Date(value) : value;
                    break;
                default:
                    rtcIceServer[key] = value;
            }
        }
        return rtcIceServer;
    });
};
exports.toRTCIceServer = toRTCIceServer;
//# sourceMappingURL=IceServer.js.map