fcr-ui-scene 3.8.1 → 3.8.2

package/lib-es/modules/setting/audio-settings/index.css

@@ -0,0 +1,195 @@
+.fcr-device-settings-audio {
+  padding-top: 15px;
+}
+
+.fcr-device-settings-audio__section {
+  margin-top: 10px;
+  border-radius: var(--fcr_cornerradius_s);
+  width: 100%;
+  background: var(--fcr_mobile_ui_scene_color_popup_block5);
+}
+.fcr-device-settings-audio__section:first-child {
+  margin-top: 0;
+}
+
+.fcr-device-settings-audio__section:last-child {
+  margin-bottom: 10px;
+}
+
+.fcr-device-settings-audio__section:nth-child(2) {
+  margin-top: 15px;
+}
+
+.fcr-device-settings-audio__section-title {
+  padding: 0 10px 0 12px;
+  font-size: 13px;
+  line-height: 32px;
+  font-weight: 700;
+  color: var(--fcr_ui_scene_icontext1);
+}
+.fcr-device-settings-audio__switch-wrapper {
+  padding: 0 10px 0 12px;
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+}
+
+.fcr-device-settings-audio__switch-wrapper-switch {
+  flex-shrink: 0;
+}
+
+.fcr-device-settings-audio__switch-wrapper-orinalvoise-tip {
+  font-size: 12px;
+}
+
+.fcr-device-settings-audio__switch-title {
+  padding: 0 10px 0 12px;
+  font-size: 12px;
+  line-height: 18px;
+  color: var(--fcr_ui_scene_icontext1);
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+}
+
+.fcr-device-settings-audio__checkbox-item {
+  gap: 8px;
+  font-size: 12px;
+  line-height: 32px;
+  color: var(--fcr_ui_scene_icontext1);
+  display: flex;
+  align-items: center;
+}
+
+.fcr-device-settings-audio__options-section {
+  background-color: var(--fcr_mobile_ui_scene_color_popup_fill2);
+  border-radius: var(--fcr_cornerradius_s);
+  padding: 10px 12px;
+  margin: 10px;
+}
+/* .fcr-device-settings-audio__options {
+  padding-left: 28px;
+} */
+
+.fcr-device-settings-audio__section .fcr-radio {
+  min-width: 100px;
+  padding: 6px 10px;
+  align-items: start;
+}
+.fcr-device-settings-audio__section .fcr-radio .fcr-radio-label {
+  padding-left: 6px;
+  line-height: 20px;
+}
+.fcr-device-settings-audio__section-title + .fcr-radio {
+  margin-top: 4px;
+}
+
+.fcr-device-settings-audio__radio-label-addition {
+  font-size: 12px;
+  line-height: 1;
+  color: var(--fcr_ui_scene_icontext2);
+}
+
+.fcr-device-settings-audio__form-item {
+  height: 32px;
+  padding: 0 10px;
+  display: flex;
+  align-items: center;
+  column-gap: 22px;
+}
+.fcr-device-settings-audio__form-item .fcr-slider.is-disabled {
+  border: none;
+}
+
+.fcr-device-settings-audio__form-label {
+  font-size: 12px;
+  line-height: 16px;
+  font-weight: 300;
+  color: var(--fcr_ui_scene_icontext1);
+}
+
+.fcr-device-settings-audio__form-item .fcr-volume-indicator {
+  flex-grow: 1;
+}
+
+.fcr-device-settings-audio__form-item .fcr-slider {
+  flex-grow: 1;
+}
+
+.fcr-device-settings-audio__checkbox-wrapper--bordered {
+  margin-top: 5px;
+  border-top: 1px solid var(--fcr_ui_scene_line2);
+  /* height: 46px; */
+  padding: 8px 8px;
+  display: flex;
+  /* align-items: center; */
+  /* gap: 10px; */
+  flex-direction: column;
+}
+.fcr-device-settings-audio__checkbox-wrapper--bordered .fcr-checkbox {
+  /* height: 32px; */
+  align-items: start;
+  margin: 6px 0;
+}
+
+.fcr-device-settings-audio__checkbox-wrapper--bordered .fcr-checkbox-label {
+  font-size: 14px;
+  font-weight: 400;
+  color: var(--fcr_ui_scene_icontext1);
+  line-height: 20px;
+}
+
+.fcr-device-settings-audio__section-reduce-noise {
+  padding-bottom: 10px;
+}
+
+.fcr-device-settings-audio__section-reduce-noise .fcr-radio-label {
+  white-space: pre-wrap;
+  line-height: 16px;
+}
+
+.fcr-device-settings-audio__section-pro-audio {
+  padding-bottom: 10px;
+}
+
+.fcr-device-settings-audio__section-pro-audio .fcr-checkbox {
+  margin-top: 4px;
+  height: 32px;
+  padding: 0 8px;
+}
+
+.fcr-device-settings-audio .fcr-device-settings-advance-link {
+  margin-top: 10px;
+}
+
+.fcr-speaker-detection,
+.fcr-microphone-detection {
+  height: 32px;
+  padding: 0 10px;
+  display: flex;
+  align-items: center;
+  column-gap: 8px;
+}
+
+.fcr-speaker-detection .fcr-select-wrapper,
+.fcr-microphone-detection .fcr-select-wrapper {
+  flex-grow: 1;
+  min-width: 0;
+}
+
+.fcr-speaker-detection .fcr-button,
+.fcr-microphone-detection .fcr-button {
+  flex-shrink: 0;
+  border-radius: var(--fcr_cornerradius_xs);
+  padding: 0 4px;
+}
+.fcr-speaker-detection .fcr-button > div,
+.fcr-microphone-detection .fcr-button > div {
+  width: 100px;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.fcr-device-settings-audio__detection-wrapper {
+  margin-bottom: 8px;
+}

package/lib-es/modules/setting/audio-whiteList/audio-device-adaptation.js

@@ -0,0 +1,62 @@
+import { FcrUIAiDenoiseLevel } from '../../../type';
+/**
+ * Audio device whiteList configuration
+ */
+export var AUDIO_DEVICE_WHITE_LIST_CONFIG = {
+  whiteListDeviceIds: [
+  // Sennheiser-EPOS 20 EPOS EXPAND 20
+  '1395:0380',
+  // Sennheiser-EPOS 80 EPOS EXPAND 80
+  '1395:0093',
+  // Sennheiser-EPOS 80T EPOS EXPAND 80T
+  '1395:00CC',
+  // Poly-p15 Poly Studio P15
+  '095D:9290',
+  // A460 Speakerphone
+  '33F1:10AA',
+  // Huawei-MIC100 Mic 100会议音箱
+  '12D1:2308', //Hamedal Speak A20
+  "1FC9:826B", //Hamedal A21T TEA
+  "2A5F:2005", //HD Audio VA400
+  "33F1:1016"],
+  whiteListConfig: {
+    audioEchoCancellation: false,
+    audioAgc: false,
+    noiseReduce: 4
+  }
+};
+
+/**
+ * Audio device configuration for individual device
+ */
+
+/**
+ * Device profile with name and audio configuration
+ */
+
+/**
+ * Device-specific audio configurations
+ * Key: deviceId (format: "vendorId:productId")
+ * Value: device profile with name and config
+ */
+export var DEVICE_SPECIFIC_CONFIGS = {
+  // INNOTRIK I-90
+  '2F9D:0091': {
+    deviceName: 'INNOTRIK I-90',
+    config: {
+      audioEchoCancellation: true,
+      audioAgc: true,
+      noiseReduce: FcrUIAiDenoiseLevel.LOW
+    }
+  }
+};
+
+/**
+ * Get audio configuration for a specific device
+ * @param deviceId Device ID in format "vendorId:productId"
+ * @returns AudioDeviceConfig if device has specific config, undefined otherwise
+ */
+export function getDeviceSpecificConfig(deviceId) {
+  var _DEVICE_SPECIFIC_CONF;
+  return (_DEVICE_SPECIFIC_CONF = DEVICE_SPECIFIC_CONFIGS[deviceId]) === null || _DEVICE_SPECIFIC_CONF === void 0 ? void 0 : _DEVICE_SPECIFIC_CONF.config;
+}

package/lib-es/modules/setting/audio-whiteList/audio-whiteList-manager.js

@@ -0,0 +1,368 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+import "core-js/modules/es.symbol.js";
+import "core-js/modules/es.array.concat.js";
+import "core-js/modules/es.array.find.js";
+import "core-js/modules/es.array.for-each.js";
+import "core-js/modules/es.array.from.js";
+import "core-js/modules/es.array.includes.js";
+import "core-js/modules/es.array.filter.js";
+import "core-js/modules/es.array.iterator.js";
+import "core-js/modules/es.date.to-json.js";
+import "core-js/modules/es.json.stringify.js";
+import "core-js/modules/es.array.push.js";
+import "core-js/modules/es.map.js";
+import "core-js/modules/es.object.entries.js";
+import "core-js/modules/es.object.from-entries.js";
+import "core-js/modules/es.object.keys.js";
+import "core-js/modules/es.object.define-properties.js";
+import "core-js/modules/es.object.define-property.js";
+import "core-js/modules/es.object.get-own-property-descriptor.js";
+import "core-js/modules/es.object.get-own-property-descriptors.js";
+import "core-js/modules/es.object.to-string.js";
+import "core-js/modules/es.set.js";
+import "core-js/modules/es.string.includes.js";
+import "core-js/modules/es.string.iterator.js";
+import "core-js/modules/esnext.iterator.constructor.js";
+import "core-js/modules/esnext.iterator.find.js";
+import "core-js/modules/esnext.iterator.for-each.js";
+import "core-js/modules/esnext.json.parse.js";
+import "core-js/modules/esnext.iterator.filter.js";
+import "core-js/modules/esnext.map.delete-all.js";
+import "core-js/modules/esnext.map.emplace.js";
+import "core-js/modules/esnext.map.every.js";
+import "core-js/modules/esnext.map.filter.js";
+import "core-js/modules/esnext.map.find.js";
+import "core-js/modules/esnext.map.find-key.js";
+import "core-js/modules/esnext.map.includes.js";
+import "core-js/modules/esnext.map.key-of.js";
+import "core-js/modules/esnext.map.map-keys.js";
+import "core-js/modules/esnext.map.map-values.js";
+import "core-js/modules/esnext.map.merge.js";
+import "core-js/modules/esnext.map.reduce.js";
+import "core-js/modules/esnext.map.some.js";
+import "core-js/modules/esnext.map.update.js";
+import "core-js/modules/esnext.set.add-all.js";
+import "core-js/modules/esnext.set.delete-all.js";
+import "core-js/modules/esnext.set.difference.v2.js";
+import "core-js/modules/esnext.set.difference.js";
+import "core-js/modules/esnext.set.every.js";
+import "core-js/modules/esnext.set.filter.js";
+import "core-js/modules/esnext.set.find.js";
+import "core-js/modules/esnext.set.intersection.v2.js";
+import "core-js/modules/esnext.set.intersection.js";
+import "core-js/modules/esnext.set.is-disjoint-from.v2.js";
+import "core-js/modules/esnext.set.is-disjoint-from.js";
+import "core-js/modules/esnext.set.is-subset-of.v2.js";
+import "core-js/modules/esnext.set.is-subset-of.js";
+import "core-js/modules/esnext.set.is-superset-of.v2.js";
+import "core-js/modules/esnext.set.is-superset-of.js";
+import "core-js/modules/esnext.set.join.js";
+import "core-js/modules/esnext.set.map.js";
+import "core-js/modules/esnext.set.reduce.js";
+import "core-js/modules/esnext.set.some.js";
+import "core-js/modules/esnext.set.symmetric-difference.v2.js";
+import "core-js/modules/esnext.set.symmetric-difference.js";
+import "core-js/modules/esnext.set.union.v2.js";
+import "core-js/modules/esnext.set.union.js";
+import "core-js/modules/web.dom-collections.for-each.js";
+import "core-js/modules/web.dom-collections.iterator.js";
+import { createLogger } from '../../../utilities/logger';
+import { FcrUIAiDenoiseLevel } from '../../../type';
+import { AUDIO_DEVICE_WHITE_LIST_CONFIG, getDeviceSpecificConfig } from './audio-device-adaptation';
+// Local storage keys
+var STORAGE_KEY_DEVICE_CONFIGS = 'fcr_audio_device_configs';
+var STORAGE_KEY_WHITE_LIST_INITIALIZED = 'fcr_whitelist_device_initialized';
+// Default device ID for devices without vendorId/productId
+var DEFAULT_DEVICE_ID = 'default_device_id';
+// Default values for non-white list devices
+var DEFAULT_AUDIO_AGC = false;
+var DEFAULT_AUDIO_ECHO_CANCELLATION = true;
+var DEFAULT_NOISE_REDUCE_LEVEL = FcrUIAiDenoiseLevel.LOW;
+
+/**
+ * The manager delegates device operations and settings management to the implementing class
+ */
+
+export var AudioDeviceWhiteListManager = /*#__PURE__*/function () {
+  function AudioDeviceWhiteListManager(delegate) {
+    _classCallCheck(this, AudioDeviceWhiteListManager);
+    _defineProperty(this, "logger", createLogger({
+      prefix: 'AudioDeviceWhiteList'
+    }));
+    // Store 3A configurations for all devices, key is device ID (including white list and non-white list devices)
+    _defineProperty(this, "_deviceConfigs", new Map());
+    // Record whether white list device has applied default configuration, key is device ID
+    _defineProperty(this, "_whiteListDeviceUsed", new Set());
+    // Current device ID (microphone)
+    _defineProperty(this, "_currentDeviceId", null);
+    _defineProperty(this, "_delegate", null);
+    this._delegate = delegate;
+    this._whiteListDeviceIds = _toConsumableArray(AUDIO_DEVICE_WHITE_LIST_CONFIG.whiteListDeviceIds);
+    this._whiteListConfig = {
+      audioEchoCancellation: AUDIO_DEVICE_WHITE_LIST_CONFIG.whiteListConfig.audioEchoCancellation,
+      audioAgc: AUDIO_DEVICE_WHITE_LIST_CONFIG.whiteListConfig.audioAgc,
+      noiseReduce: AUDIO_DEVICE_WHITE_LIST_CONFIG.whiteListConfig.noiseReduce
+    };
+    this._loadFromLocalStorage();
+    this._initialize();
+  }
+  return _createClass(AudioDeviceWhiteListManager, [{
+    key: "_initialize",
+    value: function _initialize() {
+      var _this$_delegate;
+      this._initializeDeviceConfigsFromList();
+      var currentMicrophoneId = (_this$_delegate = this._delegate) === null || _this$_delegate === void 0 ? void 0 : _this$_delegate.getMicrophoneId();
+      if (!currentMicrophoneId) {
+        this.logger.warn('[AudioDeviceWhiteList] Current microphone ID is null');
+      }
+      var microphoneIdentifier = currentMicrophoneId ? this._getDeviceIdentifierFromList(currentMicrophoneId, 'microphone') : '';
+      var microphoneDeviceId = microphoneIdentifier || DEFAULT_DEVICE_ID;
+      if (currentMicrophoneId && !microphoneIdentifier) {
+        this.logger.warn('[AudioDeviceWhiteList] Current microphone has no vendorId/productId, using DEFAULT_DEVICE_ID');
+      }
+      var isMicrophoneInWhiteList = currentMicrophoneId ? this._isDeviceInWhiteList(microphoneDeviceId) : false;
+      this._currentDeviceId = currentMicrophoneId ? microphoneDeviceId : null;
+      this.logger.info("[AudioDeviceWhiteList] Initial state: microphone=".concat(microphoneDeviceId || 'none', ", isOnWhiteList=").concat(isMicrophoneInWhiteList));
+      if (isMicrophoneInWhiteList) {
+        this._applyWhiteListConfig();
+        this._whiteListDeviceUsed.add(microphoneDeviceId);
+        this._saveToLocalStorage();
+      }
+    }
+  }, {
+    key: "handleMicrophoneListUpdated",
+    value: function handleMicrophoneListUpdated(microphoneList) {
+      this.logger.info('[AudioDeviceWhiteList] Microphone list updated');
+      this._updateDeviceConfigs(microphoneList);
+    }
+  }, {
+    key: "handleMicrophoneChanged",
+    value: function handleMicrophoneChanged(microphoneId, productId, vendorId) {
+      this._handleDeviceChanged(productId, vendorId, 'microphone');
+    }
+  }, {
+    key: "_handleDeviceChanged",
+    value: function _handleDeviceChanged(productId, vendorId, deviceType) {
+      var deviceId = this._createDeviceIdentifier(productId, vendorId);
+      if (!deviceId) {
+        this.logger.warn("[AudioDeviceWhiteList] ".concat(deviceType, " has no vendorId/productId, using DEFAULT_DEVICE_ID"));
+        deviceId = DEFAULT_DEVICE_ID;
+      }
+      var isNewDeviceInWhiteList = this._isDeviceInWhiteList(deviceId);
+      var isFirstTimeUseWhiteList = isNewDeviceInWhiteList && !this._whiteListDeviceUsed.has(deviceId);
+      this.logger.info("[AudioDeviceWhiteList] Device changed: ".concat(deviceType, "=").concat(deviceId, ", isInWhiteList=").concat(isNewDeviceInWhiteList));
+      if (isFirstTimeUseWhiteList) {
+        this.logger.info('[AudioDeviceWhiteList] First time using white list device, applying default white list config');
+        this._applyWhiteListConfig();
+        this._deviceConfigs.set(deviceId, _objectSpread({}, this._whiteListConfig));
+        this._whiteListDeviceUsed.add(deviceId);
+        this._currentDeviceId = deviceId;
+        this._saveToLocalStorage();
+        return;
+      }
+      var logMessage = isNewDeviceInWhiteList ? '[AudioDeviceWhiteList] Using saved config for white list device' : '[AudioDeviceWhiteList] Switching to non-white list device, applying device config';
+      this.logger.info(logMessage);
+      this._applyDeviceConfig(deviceId);
+      this._currentDeviceId = deviceId;
+    }
+  }, {
+    key: "_createDeviceConfig",
+    value: function _createDeviceConfig(deviceId) {
+      var specificConfig = getDeviceSpecificConfig(deviceId);
+      if (specificConfig) {
+        this.logger.info("[AudioDeviceWhiteList] Using specific config for device: ".concat(deviceId));
+        return _objectSpread({}, specificConfig);
+      }
+      return {
+        audioEchoCancellation: DEFAULT_AUDIO_ECHO_CANCELLATION,
+        audioAgc: DEFAULT_AUDIO_AGC,
+        noiseReduce: DEFAULT_NOISE_REDUCE_LEVEL
+      };
+    }
+
+    /**
+     * Get device 3A configuration (use current settings if not exists)
+     */
+  }, {
+    key: "_getDeviceConfig",
+    value: function _getDeviceConfig(deviceId) {
+      if (!this._deviceConfigs.has(deviceId)) {
+        var config = this._createDeviceConfig(deviceId);
+        this._deviceConfigs.set(deviceId, config);
+        this.logger.info("[AudioDeviceWhiteList] Created config for device: ".concat(deviceId), config);
+      }
+      return this._deviceConfigs.get(deviceId);
+    }
+
+    /**
+     * Update device 3A configuration (save for both white list and non-white list devices)
+     */
+  }, {
+    key: "updateDeviceConfig",
+    value: function updateDeviceConfig(config) {
+      var deviceId = this._currentDeviceId || DEFAULT_DEVICE_ID;
+      if (!this._currentDeviceId) {
+        this.logger.warn('[AudioDeviceWhiteList] No current device ID, using DEFAULT_DEVICE_ID');
+      }
+      var deviceConfig = this._getDeviceConfig(deviceId);
+      if (config.audioEchoCancellation !== undefined) {
+        deviceConfig.audioEchoCancellation = config.audioEchoCancellation;
+      }
+      if (config.noiseReduce !== undefined) {
+        deviceConfig.noiseReduce = config.noiseReduce;
+      }
+      this._saveToLocalStorage();
+      this.logger.info("[AudioDeviceWhiteList] Updated config for device: ".concat(deviceId), deviceConfig);
+    }
+  }, {
+    key: "_applyAudioConfig",
+    value: function _applyAudioConfig(config) {
+      if (!this._delegate) {
+        this.logger.warn('[AudioDeviceWhiteList] Delegate is null');
+        return;
+      }
+      this._delegate.enableAudioEchoCancellation(config.audioEchoCancellation);
+      this._delegate.enableAudioGainControl(config.audioAgc);
+      this._delegate.setNoiseLevel(config.noiseReduce);
+
+      // Update UI settings
+      this._delegate.updateSettings({
+        audioEchoCancellation: config.audioEchoCancellation,
+        noiseReduce: config.noiseReduce
+      });
+    }
+  }, {
+    key: "_applyWhiteListConfig",
+    value: function _applyWhiteListConfig() {
+      this.logger.info('[AudioDeviceWhiteList] Applying default white list config');
+      this._applyAudioConfig(this._whiteListConfig);
+    }
+  }, {
+    key: "_applyDeviceConfig",
+    value: function _applyDeviceConfig(deviceId) {
+      var deviceConfig = this._getDeviceConfig(deviceId);
+      this._applyAudioConfig(deviceConfig);
+      this.logger.info("[AudioDeviceWhiteList] Applying saved config for device: ".concat(deviceId), deviceConfig);
+    }
+  }, {
+    key: "_createDeviceIdentifier",
+    value: function _createDeviceIdentifier(productId, vendorId) {
+      if (productId && vendorId) {
+        return "".concat(vendorId, ":").concat(productId);
+      }
+      return '';
+    }
+  }, {
+    key: "_getDeviceIdentifierFromList",
+    value: function _getDeviceIdentifierFromList(deviceId, deviceType) {
+      var _this$_delegate2;
+      var deviceList = (_this$_delegate2 = this._delegate) === null || _this$_delegate2 === void 0 ? void 0 : _this$_delegate2.getMicrophoneList();
+      if (!deviceList) {
+        return '';
+      }
+      var device = deviceList.find(function (d) {
+        return d.deviceId === deviceId;
+      });
+      if (device) {
+        return this._createDeviceIdentifier(device.productId, device.vendorId);
+      }
+      return '';
+    }
+  }, {
+    key: "_isDeviceInWhiteList",
+    value: function _isDeviceInWhiteList(deviceId) {
+      return this._whiteListDeviceIds.includes(deviceId);
+    }
+  }, {
+    key: "_initializeDeviceConfigsFromList",
+    value: function _initializeDeviceConfigsFromList() {
+      var _this$_delegate3;
+      var microphoneList = (_this$_delegate3 = this._delegate) === null || _this$_delegate3 === void 0 ? void 0 : _this$_delegate3.getMicrophoneList();
+      if (!microphoneList) {
+        this.logger.warn('[AudioDeviceWhiteList] Microphone list is null');
+        return;
+      }
+      this._updateDeviceConfigs(microphoneList);
+      this.logger.info("[AudioDeviceWhiteList] Initialized ".concat(this._deviceConfigs.size, " device configs"));
+    }
+  }, {
+    key: "_updateDeviceConfigs",
+    value: function _updateDeviceConfigs(deviceList) {
+      var _this = this;
+      var newDeviceCount = 0;
+      deviceList.forEach(function (device) {
+        var deviceIdentifier = _this._createDeviceIdentifier(device.productId, device.vendorId);
+        if (!deviceIdentifier) {
+          _this.logger.warn("[AudioDeviceWhiteList] Device has no vendorId/productId, skipping update device configs id: ".concat(device.deviceId, " name: ").concat(device.deviceName));
+          return;
+        }
+        if (_this._deviceConfigs.has(deviceIdentifier)) {
+          _this.logger.warn("[AudioDeviceWhiteList] Device already has config, skipping update device configs id: ".concat(device.deviceId, " name: ").concat(device.deviceName));
+          return;
+        }
+        var config = _this._createConfigForDevice(deviceIdentifier);
+        _this._deviceConfigs.set(deviceIdentifier, config);
+        newDeviceCount++;
+      });
+      if (newDeviceCount > 0) {
+        this._saveToLocalStorage();
+      }
+    }
+  }, {
+    key: "_createConfigForDevice",
+    value: function _createConfigForDevice(deviceIdentifier) {
+      var isWhiteListDevice = this._isDeviceInWhiteList(deviceIdentifier);
+      if (isWhiteListDevice) {
+        return _objectSpread({}, this._whiteListConfig);
+      }
+      return this._createDeviceConfig(deviceIdentifier);
+    }
+  }, {
+    key: "_loadFromLocalStorage",
+    value: function _loadFromLocalStorage() {
+      try {
+        var savedConfigs = localStorage.getItem(STORAGE_KEY_DEVICE_CONFIGS);
+        if (savedConfigs) {
+          var configsObject = JSON.parse(savedConfigs);
+          this._deviceConfigs = new Map(Object.entries(configsObject));
+          this.logger.info("[AudioDeviceWhiteList] Loaded ".concat(this._deviceConfigs.size, " device configs from localStorage"));
+        }
+        var savedInitialized = localStorage.getItem(STORAGE_KEY_WHITE_LIST_INITIALIZED);
+        if (savedInitialized) {
+          var initializedArray = JSON.parse(savedInitialized);
+          this._whiteListDeviceUsed = new Set(initializedArray);
+          this.logger.info("[AudioDeviceWhiteList] Loaded ".concat(this._whiteListDeviceUsed.size, " initialized white list devices from localStorage"));
+        }
+      } catch (error) {
+        this.logger.error('[AudioDeviceWhiteList] Failed to load from localStorage:', error);
+      }
+    }
+  }, {
+    key: "_saveToLocalStorage",
+    value: function _saveToLocalStorage() {
+      try {
+        var configsObject = Object.fromEntries(this._deviceConfigs.entries());
+        localStorage.setItem(STORAGE_KEY_DEVICE_CONFIGS, JSON.stringify(configsObject));
+        var initializedArray = Array.from(this._whiteListDeviceUsed);
+        localStorage.setItem(STORAGE_KEY_WHITE_LIST_INITIALIZED, JSON.stringify(initializedArray));
+        this.logger.info('[AudioDeviceWhiteList] Saved data to localStorage');
+      } catch (error) {
+        this.logger.error('[AudioDeviceWhiteList] Failed to save to localStorage:', error);
+      }
+    }
+  }, {
+    key: "release",
+    value: function release() {
+      this._saveToLocalStorage();
+      this._deviceConfigs.clear();
+      this._whiteListDeviceUsed.clear();
+      this._currentDeviceId = null;
+      this._delegate = null;
+    }
+  }]);
+}();