import Context from "android.content.Context";
import {
  LoginOptions, LogoutOptions, SetSelfInfoOptions,
  FetchLiveListOptions, CreateLiveOptions, JoinLiveOptions, EndLiveOptions, LeaveLiveOptions, UpdateLiveInfoOptions, UpdateLiveMetaDataOptions,
  LockSeatOptions, TakeSeatOptions, LeaveSeatOptions,
  MuteMicrophoneOptions, UnmuteMicrophoneOptions, KickUserOutOfSeatOptions, MoveUserToSeatOptions,
  UnlockSeatOptions, OpenRemoteCameraOptions, CloseRemoteCameraOptions,
  OpenRemoteMicrophoneOptions, CloseRemoteMicrophoneOptions,
  FetchAudienceListOptions, SetAdministratorOptions, RevokeAdministratorOptions, KickUserOutOfRoomOptions, DisableSendMessageOptions,
  OpenLocalMicrophoneOptions, SetAudioRouteOptions, OpenLocalCameraOptions, SwitchCameraOptions, SwitchMirrorOptions,
  UpdateVideoQualityOptions,
  DisconnectOptions, ApplyForSeatOptions, CancelApplicationOptions, AcceptApplicationOptions, RejectApplicationOptions,
  InviteToSeatOptions, CancelInvitationOptions, AcceptInvitationOptions, RejectInvitationOptions,
  SendTextMessageOptions, SendCustomMessageOptions, SendGiftOptions, SetSmoothLevelOptions,
  SetWhitenessLevelOptions, SetRuddyLevelOptions, SetVoiceEarMonitorEnableOptions,
  SendLikeOptions, CallExperimentalAPIOptions, VolumeOptions, RequestHostConnectionOptions, AcceptHostConnectionOptions,
  CancelHostConnectionOptions, RejectHostConnectionOptions, ExitHostConnectionOptions, AppendLocalTipOptions,
  RefreshUsableGiftsOptions, SetAudioReverbTypeOptions, SetAudioChangerTypeOptions, ILiveListener,
  RequestBattleOptions, CancelBattleRequestOptions, AcceptBattleOptions, RejectBattleOptions, ExitBattleOptions, SetLanguageOptions
} from "../../../tuikit-atomic-x/utssdk/interface";
import { ParamsCovert } from "./utils/ParamsCovert";

import {
  LoginStoreObserver, LiveListStoreObserver, LiveSeatStoreObserver, LiveAudienceStoreObserver,
  CoHostStoreObserver, CoGuestStoreObserver,
  BarrageStoreObserver, GiftStoreObserver, DeviceStoreObserver,
  BaseBeautyStoreObserver, AudioEffectStoreObserver, LiveSummaryStoreObserver, LikeStoreObserver, BattleStoreObserver
} from 'uts.sdk.modules.atomicx.observer';
import { Logger, ExperimentalApiInvoker } from 'uts.sdk.modules.atomicx.kotlin';
import {
  TGiftListener, TLikeListener, TLiveAudienceListener, TLiveListListener, TLiveSeatListener,
  TCoGuestHostListener, TCoGuestGuestListener, TCoHostListener, TBattleListener,
  NativeLiveListener, createLiveListEventDispatcher, liveListListenerMap, liveSeatListenerMap, createLiveSeatEventDispatcher,
  createAudienceEventDispatcher, audienceListenerMap, createCoHostEventDispatcher, coHostListenerMap,
  createCoGuestHostEventDispatcher, coGuestHostListenerMap, createCoGuestGuestEventDispatcher, coGuestGuestListenerMap,
  createGiftEventDispatcher, giftListenerMap, createLikeEventDispatcher, likeListenerMap,
  createBattleEventDispatcher, battleListenerMap,
} from "./listener/LiveListener";
import Gson from " com.google.gson.Gson";
// from native aar
import { TUIRoomDefine, TUIRoomEngine } from 'com.tencent.cloud.tuikit.engine.room';
import { TUICommonDefine } from 'com.tencent.cloud.tuikit.engine.common';
import { TUILiveListManager } from 'com.tencent.cloud.tuikit.engine.extension';
import { VideoForegroundService } from 'com.trtc.tuikit.common.foregroundservice';
import {
  CompletionHandler,
} from 'io.trtc.tuikit.atomicxcore.api';
import { StopLiveCompletionHandler, LiveInfoCompletionHandler } from 'io.trtc.tuikit.atomicxcore.api.live'
import { LoginStore, UserProfile } from 'io.trtc.tuikit.atomicxcore.api.login';
import {
  LiveListStore, LiveSeatStore, LiveAudienceStore, LikeStore, BattleStore, CoHostStore, CoGuestStore,
  LiveInfo, BattleConfig, BattleRequestCallback, BattleInfo, DeviceControlPolicy, CoHostLayoutTemplate,

} from 'io.trtc.tuikit.atomicxcore.api.live';
import { GiftStore } from 'io.trtc.tuikit.atomicxcore.api.gift';
import { BaseBeautyStore, AudioEffectStore, DeviceStore, AudioRoute, MirrorType, } from 'io.trtc.tuikit.atomicxcore.api.device';
import { BarrageStore, Barrage } from 'io.trtc.tuikit.atomicxcore.api.barrage';
const RTC_TAG = "UTS-Login: "
const LIVE_TAG = "UTS-Live: "
const SEAT_TAG = "UTS-LiveSeat: "
const AUDIENCE_TAG = "UTS-LiveAudience: "
const GIFT_TAG = "UTS-Gift: "
const DEVICE_TAG = "UTS-Device: "
const COHOST_TAG = "UTS-CoHost: "
const COGUEST_TAG = "UTS-CoGuest: "
const BARRAGE_TAG = "UTS-Barrage: "
const BEAUTY_TAG = "UTS-Beauty: "
const AUDIOEFFECT_TAG = "UTS-AudioEffect: "
const BATTLE_TAG = "UTS-Battle: "
const SUMMARY_TAG = "UTS-Summary: "

const context : Context = UTSAndroid.getAppContext() as Context;

export class RTCRoomEngineManager {
  nativeGiftListener ?: TGiftListener = null;
  nativeLikeListener ?: TLikeListener = null;
  nativeAudienceListener ?: TLiveAudienceListener = null;
  nativeLiveListListener ?: TLiveListListener = null;
  nativeLiveSeatListener ?: TLiveSeatListener = null;
  nativeCoGuestHostListener ?: TCoGuestHostListener = null;
  nativeCoGuestGuestListener ?: TCoGuestGuestListener = null;
  nativeCoHostListener ?: TCoHostListener = null;
  nativeBattleListener ?: TBattleListener = null;

  constructor() {
    console.log(`${RTC_TAG} constructor start`);
  }
  //================= LoginStore 相关接口 =================
  public login(options : LoginOptions) {
    UTSAndroid.getDispatcher("main").async(function (_) {
      console.log(`${RTC_TAG} login, data: ${JSON.stringify(options)}`);
      this.setFramework()
      const callback = new (class implements CompletionHandler {
        override onSuccess() : void {

          TUIRoomEngine.login(context, options.sdkAppID.toInt(), options.userID, options.userSig,
            new (class implements TUIRoomDefine.ActionCallback {
              override onSuccess() : void {
                console.log(`${RTC_TAG} login success`);
                options?.success?.();
              }
              override onError(error ?: TUICommonDefine.Error, message ?: string) : void {
                console.log(`${RTC_TAG} login failed ,errorCode: ${error}, message: ${message}`);
                options?.fail?.(error?.getValue() ?? 0, message ?? "");
              }
            })
          );
        }
        override onFailure(error : Int, errMsg : string) : void {
          console.log(`${RTC_TAG} login failed ,error: ${error}, errMsg: ${errMsg}`);
          options?.fail?.(error, errMsg);
        }
      });
      LoginStore.shared.login(context, options.sdkAppID.toInt(), options.userID, options.userSig, callback);
    }, null)
  }

  private setFramework() {
    const data = { "api": "setFramework", "params": { "framework": 11, "component": 21 } }
    TUIRoomEngine.sharedInstance().callExperimentalAPI(JSON.stringify(data), null)
  }
  public logout(options : LogoutOptions) {
    UTSAndroid.getDispatcher("main").async(function (_) {
      console.warn(`${RTC_TAG} logout, data: ${JSON.stringify(options)}`);
      const callback = new (class implements CompletionHandler {
        override onSuccess() {
          options.success?.();
        }

        override onFailure(code : Int, desc : String) {
          options.fail?.(Number.from(code), desc);
        }
      });
      LoginStore.shared.logout(callback);
    }, null)
  }

  public setSelfInfo(options : SetSelfInfoOptions) {
    UTSAndroid.getDispatcher("main").async(function (_) {
      console.warn(`${RTC_TAG} setSelfInfo, data: ${JSON.stringify(options)}`);
      Logger.i(RTC_TAG + "setSelfInfo, data: " + JSON.stringify(options))

      let userProfile : UserProfile = ParamsCovert.convertUserProfile(options.userProfile)
      const callback = new (class implements CompletionHandler {
        override onSuccess() {
          options.success?.();
        }
        override onFailure(code : Int, desc : String) {
          console.error(`${RTC_TAG} setSelfInfo failed, code: ${code}, desc: ${desc}`);
          Logger.e(RTC_TAG + "setSelfInfo failed, code: " + code + ", desc: " + desc)
          options.fail?.(Number.from(code), desc);
        }
      });
      LoginStore.shared.setSelfInfo(userProfile, callback);
    }, null)
  }

  //================= LiveListStore 相关接口 =================
  @UTSJS.keepAlive
  public addLiveListListener(eventName : string, listener : ILiveListener) : void {
    UTSAndroid.getDispatcher("main").async(function (_) {
      if (this.nativeLiveListListener == null) {
        this.nativeLiveListListener = new TLiveListListener(createLiveListEventDispatcher())
      }
      if (liveListListenerMap.size === 0 && this.nativeLiveListListener != null) {
        LiveListStore.shared().addLiveListListener(this.nativeLiveListListener!!);
      }

      const listenerArray = liveListListenerMap.get(eventName) ?? new Array<ILiveListener>()
      if (!listenerArray.includes(listener)) {
        listenerArray.push(listener)
      }
      liveListListenerMap.set(eventName, listenerArray);
    }, null)
  }

  @UTSJS.keepAlive
  public removeLiveListListener(eventName : string, listener : ILiveListener) : void {
    UTSAndroid.getDispatcher("main").async(function (_) {
      let listenerArray = liveListListenerMap.get(eventName) ?? new Array<ILiveListener>()
      let index = listenerArray.indexOf(listener)
      listenerArray.splice(index, 1)
      if (listenerArray.length == 0) {
        liveListListenerMap.delete(eventName);
      }
    }, null)
  }
  public fetchLiveList(options : FetchLiveListOptions) {
    UTSAndroid.getDispatcher("main").async(function (_) {
      console.warn(`${LIVE_TAG} fetchLiveList, data: ${JSON.stringify(options)}`);
      Logger.i(LIVE_TAG + "fetchLiveList, data: " + JSON.stringify(options))

      const callback = new (class implements CompletionHandler {
        override onSuccess() {
          options.success?.();
        }
        override onFailure(code : Int, desc : String) {
          options.fail?.(Number.from(code), desc);
        }
      });
      LiveListStore.shared().fetchLiveList(options.cursor, options.count?.toInt() ?? 0, callback);
    }, null)
  }
  public createLive(options : CreateLiveOptions) {
    UTSAndroid.getDispatcher("main").async(function (_) {
      console.warn(`${LIVE_TAG} createLive, data: ${JSON.stringify(options)}`);
      Logger.i(LIVE_TAG + "createLive, data: " + JSON.stringify(options))

      let nativeLiveInfo : LiveInfo = ParamsCovert.convertLiveInfo(options.liveInfo)
      const callback = new (class implements LiveInfoCompletionHandler {
        override onSuccess(liveInfo : LiveInfo) {
          let liveInfoStr = Gson().toJson(liveInfo)
          console.error(`${LIVE_TAG} createLive success, liveInfo: ${liveInfoStr}`)
          options.success?.(liveInfoStr);
          //主播创建房间成功，开始保活
          startForegroundService()
        }
        override onFailure(code : Int, desc : String) {
          console.error(`${LIVE_TAG} createLive failed, code: ${code}, desc: ${desc}`);
          Logger.e(LIVE_TAG + "createLive failed, code: " + code + ", desc: " + desc)
          options.fail?.(Number.from(code), desc);
        }
      });
      LiveListStore.shared().createLive(nativeLiveInfo, callback);
    }, null)
  }
  public joinLive(options : JoinLiveOptions) {
    UTSAndroid.getDispatcher("main").async(function (_) {
      console.warn(`${LIVE_TAG} joinLive, data: ${JSON.stringify(options)}}`);
      Logger.i(LIVE_TAG + "joinLive, data: " + JSON.stringify(options))

      const callback = new (class implements LiveInfoCompletionHandler {
        override onSuccess(liveInfo : LiveInfo) {
          let liveInfoStr = Gson().toJson(liveInfo)
          console.error(`${LIVE_TAG} joinLive success, liveInfo: ${liveInfoStr}`)
          options.success?.(liveInfoStr);
          //观众进入房间成功，开始保活
          startForegroundService()
        }
        override onFailure(code : Int, desc : String) {
          console.error(`${LIVE_TAG} joinLive failed, code: ${code}, desc: ${desc}`);
          Logger.e(LIVE_TAG + "joinLive failed, code: " + code + ", desc: " + desc)
          options.fail?.(Number.from(code), desc);
        }
      });
      LiveListStore.shared().joinLive(options?.liveID, callback);
    }, null)
  }
  public leaveLive(options : LeaveLiveOptions) {
    UTSAndroid.getDispatcher("main").async(function (_) {
      console.warn(`${LIVE_TAG} leaveLive, data: ${JSON.stringify(options)}`);
      Logger.i(LIVE_TAG + "leaveLive, data: " + JSON.stringify(options))

      const callback = new (class implements CompletionHandler {
        override onSuccess() {
          options.success?.();
        }
        override onFailure(code : Int, desc : String) {
          console.error(`${LIVE_TAG} leaveLive failed, code: ${code}, desc: ${desc}`);
          Logger.e(LIVE_TAG + "leaveLive failed, code: " + code + ", desc: " + desc)
          options.fail?.(Number.from(code), desc);
        }
      });
      LiveListStore.shared().leaveLive(callback);
      //离开房间，结束保活
      stopForegroundService()
    }, null)
  }
  public endLive(options : EndLiveOptions) {
    UTSAndroid.getDispatcher("main").async(function (_) {
      console.warn(`${LIVE_TAG} endLive, data: ${JSON.stringify(options)}`);
      Logger.i(LIVE_TAG + "endLive, data: " + JSON.stringify(options))

      const callback = new (class implements StopLiveCompletionHandler {
        override onSuccess(data : TUILiveListManager.LiveStatisticsData) {
          let staticsData = Gson().toJson(data)
          console.error(`${LIVE_TAG} endLive success, liveStatisticsData: ${staticsData}`)
          options.success?.(staticsData);
        }
        override onFailure(code : Int, desc : String) {
          console.error(`${LIVE_TAG} endLive failed, code: ${code}, desc: ${desc}`);
          Logger.e(LIVE_TAG + "endLive failed, code: " + code + ", desc: " + desc)
          options.fail?.(Number.from(code), desc);
        }
      });
      LiveListStore.shared().endLive(callback);
      //结束房间，结束保活
      stopForegroundService()
    }, null)
  }
  public updateLiveInfo(options : UpdateLiveInfoOptions) {
    UTSAndroid.getDispatcher("main").async(function (_) {
      console.warn(`${LIVE_TAG} updateLiveInfo, data: ${JSON.stringify(options)}`);
      Logger.i(LIVE_TAG + "updateLiveInfo, data: " + JSON.stringify(options))

      let nativeLiveInfo : LiveInfo = ParamsCovert.convertLiveInfo(options.liveInfo)
      let modifyFlagList : List<LiveInfo.ModifyFlag> = ParamsCovert.convertModifyFlagList(options.modifyFlagList)
      const callback = new (class implements CompletionHandler {
        override onSuccess() {
          options.success?.();
        }
        override onFailure(code : Int, desc : String) {
          options.fail?.(Number.from(code), desc);
        }
      });
      LiveListStore.shared().updateLiveInfo(nativeLiveInfo, modifyFlagList, callback);
    }, null)
  }
  public updateLiveMetaData(options : UpdateLiveMetaDataOptions) {
    UTSAndroid.getDispatcher("main").async(function (_) {
      console.warn(`${LIVE_TAG} updateLiveMetaData, data: ${JSON.stringify(options)}`);
      Logger.i(LIVE_TAG + "updateLiveMetaData, data: " + JSON.stringify(options))

      const callback = new (class implements CompletionHandler {
        override onSuccess() {
          options.success?.();
        }
        override onFailure(code : Int, desc : String) {
          options.fail?.(Number.from(code), desc);
        }
      });

      let jsonObject = ParamsCovert.convertJsonToUTSJSONObject(options.metaData)
      let metaData = new Map<string,string>()
      jsonObject.toMap().forEach(function (value: any | null, key: string) {
          metaData.set(key, JSON.stringify(value))
      })
      console.warn(`${LIVE_TAG} updateLiveMetaData, metaData 222: ${JSON.stringify(metaData)}`);
      LiveListStore.shared().updateLiveMetaData(metaData, callback);
    }, null)
  }

  // ================= LiveSeatStore 相关接口 =================
  @UTSJS.keepAlive
  public addLiveSeatEventListener(liveID : string, eventName : string, listener : ILiveListener) : void {
    UTSAndroid.getDispatcher("main").async(function (_) {
      if (this.nativeLiveSeatListener == null) {
        this.nativeLiveSeatListener = new TLiveSeatListener(createLiveSeatEventDispatcher())
      }
      if (this.nativeLiveSeatListener != null) {
        LiveSeatStore.create(liveID).addLiveSeatEventListener(this.nativeLiveSeatListener);
      }
      const listenerArray = liveSeatListenerMap.get(eventName) ?? new Array<ILiveListener>()
      if (!listenerArray.includes(listener)) {
        listenerArray.push(listener)
      }
      liveSeatListenerMap.set(eventName, listenerArray);
    }, null)
  }
  @UTSJS.keepAlive
  public removeLiveSeatEventListener(liveID : string, eventName : string, listener ?: ILiveListener) : void {
    UTSAndroid.getDispatcher("main").async(function (_) {
      let listenerArray = liveSeatListenerMap.get(eventName) ?? new Array<ILiveListener>()
      let index = listenerArray.indexOf(listener)
      listenerArray.splice(index, 1)
      if (listenerArray.length == 0) {
        liveSeatListenerMap.delete(eventName);
      }
      if (liveSeatListenerMap.size === 0) {
        LiveSeatStore.create(liveID).removeLiveSeatEventListener(this.nativeLiveSeatListener)
      }
    }, null)
  }
  public takeSeat(options : TakeSeatOptions) {
    UTSAndroid.getDispatcher("main").async(function (_) {
      console.warn(`${SEAT_TAG} takeSeat, data: ${JSON.stringify(options)}`);
      Logger.i(SEAT_TAG + "takeSeat, data: " + JSON.stringify(options));
      const callback = new (class implements CompletionHandler {
        override onSuccess() {
          options.success?.();
        }
        override onFailure(code : Int, desc : String) {
          console.error(`${SEAT_TAG} takeSeat failed, code: ${code}, desc: ${desc}`);
          Logger.e(SEAT_TAG + "takeSeat failed, code: " + code + ", desc: " + desc)
          options.fail?.(Number.from(code), desc);
        }
      });
      LiveSeatStore.create(options.liveID).takeSeat(options.seatIndex.toInt(), callback);
    }, null)
  }
  public leaveSeat(options : LeaveSeatOptions) {
    UTSAndroid.getDispatcher("main").async(function (_) {
      console.warn(`${SEAT_TAG} leaveSeat, data: ${JSON.stringify(options)}`);
      Logger.i(SEAT_TAG + "leaveSeat, data: " + JSON.stringify(options));
      const callback = new (class implements CompletionHandler {
        override onSuccess() {
          options.success?.();
        }
        override onFailure(code : Int, desc : String) {
          options.fail?.(Number.from(code), desc);
        }
      });
      LiveSeatStore.create(options.liveID).leaveSeat(callback);
    }, null)
  }
  public muteMicrophone(options : MuteMicrophoneOptions) {
    UTSAndroid.getDispatcher("main").async(function (_) {
      console.warn(`${SEAT_TAG} muteMicrophone, data: ${JSON.stringify(options)}`);
      Logger.i(SEAT_TAG + "muteMicrophone, data: " + JSON.stringify(options));
      LiveSeatStore.create(options.liveID).muteMicrophone();
    }, null)
  }
  public unmuteMicrophone(options : UnmuteMicrophoneOptions) {
    UTSAndroid.getDispatcher("main").async(function (_) {
      console.warn(`${SEAT_TAG} unmuteMicrophone, data: ${JSON.stringify(options)}`);
      Logger.i(SEAT_TAG + "unmuteMicrophone, data: " + JSON.stringify(options));
      const callback = new (class implements CompletionHandler {
        override onSuccess() {
          options.success?.();
        }
        override onFailure(code : Int, desc : String) {
          options.fail?.(Number.from(code), desc);
        }
      });
      LiveSeatStore.create(options.liveID).unmuteMicrophone(callback);
    }, null)
  }
  public kickUserOutOfSeat(options : KickUserOutOfSeatOptions) {
    UTSAndroid.getDispatcher("main").async(function (_) {
      console.warn(`${SEAT_TAG} kickUserOutOfSeat, data: ${JSON.stringify(options)}`);
      Logger.i(SEAT_TAG + "kickUserOutOfSeat, data: " + JSON.stringify(options));
      const callback = new (class implements CompletionHandler {
        override onSuccess() {
          options.success?.();
        }
        override onFailure(code : Int, desc : String) {
          console.error(`${SEAT_TAG} kickUserOutOfSeat failed, code: ${code}, desc: ${desc}`);
          Logger.e(SEAT_TAG + "kickUserOutOfSeat failed, code: " + code + ", desc: " + desc)
          options.fail?.(Number.from(code), desc);
        }
      });
      LiveSeatStore.create(options.liveID).kickUserOutOfSeat(options.userID, callback);
    }, null);
  }
  public moveUserToSeat(options : MoveUserToSeatOptions) {
    UTSAndroid.getDispatcher("main").async(function (_) {
      console.warn(`${SEAT_TAG} moveUserToSeat, data: ${JSON.stringify(options)}`);
      Logger.i(SEAT_TAG + "moveUserToSeat, data: " + JSON.stringify(options));
      const callback = new (class implements CompletionHandler {
        override onSuccess() {
          options.success?.();
        }
        override onFailure(code : Int, desc : String) {
          console.error(`${SEAT_TAG} moveUserToSeat failed, code: ${code}, desc: ${desc}`);
          Logger.e(SEAT_TAG + "moveUserToSeat failed, code: " + code + ", desc: " + desc)
          options.fail?.(Number.from(code), desc);
        }
      });
      let policy = ParamsCovert.convertMoveSeatPolicy(options.policy)
      LiveSeatStore.create(options.liveID).moveUserToSeat(options.userID, options.targetIndex.toInt(), policy, callback);
    }, null);
  }
  public lockSeat(options : LockSeatOptions) {
    UTSAndroid.getDispatcher("main").async(function (_) {
      console.warn(`${SEAT_TAG} lockSeat, data: ${JSON.stringify(options)}`);
      Logger.i(SEAT_TAG + "lockSeat, data: " + JSON.stringify(options));
      const callback = new (class implements CompletionHandler {
        override onSuccess() {
          options.success?.();
        }
        override onFailure(code : Int, desc : String) {
          console.error(`${SEAT_TAG} lockSeat failed, code: ${code}, desc: ${desc}`);
          Logger.e(SEAT_TAG + "lockSeat failed, code: " + code + ", desc: " + desc)
          options.fail?.(Number.from(code), desc);
        }
      });
      LiveSeatStore.create(options.liveID).lockSeat(options.seatIndex.toInt(), callback);
    }, null);
  }
  public unlockSeat(options : UnlockSeatOptions) {
    UTSAndroid.getDispatcher("main").async(function (_) {
      console.warn(`${SEAT_TAG} unlockSeat, data: ${JSON.stringify(options)}`);
      Logger.i(SEAT_TAG + "unlockSeat, data: " + JSON.stringify(options));
      const callback = new (class implements CompletionHandler {
        override onSuccess() {
          options.success?.();
        }
        override onFailure(code : Int, desc : String) {
          console.error(`${SEAT_TAG} unlockSeat failed, code: ${code}, desc: ${desc}`);
          Logger.e(SEAT_TAG + "unlockSeat failed, code: " + code + ", desc: " + desc)
          options.fail?.(Number.from(code), desc);
        }
      });
      LiveSeatStore.create(options.liveID).unlockSeat(options.seatIndex.toInt(), callback);
    }, null);
  }
  public openRemoteCamera(options : OpenRemoteCameraOptions) {
    UTSAndroid.getDispatcher("main").async(function (_) {
      console.warn(`${SEAT_TAG} openRemoteCamera, data: ${JSON.stringify(options)}`);
      Logger.i(SEAT_TAG + "openRemoteCamera, data: " + JSON.stringify(options));
      const callback = new (class implements CompletionHandler {
        override onSuccess() {
          options.success?.();
        }
        override onFailure(code : Int, desc : String) {
          console.error(`${SEAT_TAG} openRemoteCamera failed, code: ${code}, desc: ${desc}`);
          Logger.e(SEAT_TAG + "openRemoteCamera failed, code: " + code + ", desc: " + desc)
          options.fail?.(Number.from(code), desc);
        }
      });
      // TODO : 底层暂时删除
      // let devicePolicy = DeviceControlPolicy.FORCE_OPEN
      // if (options.policy == 'UNLOCK_ONLY') {
      //     devicePolicy = DeviceControlPolicy.UNLOCK_ONLY
      // }
      let devicePolicy = DeviceControlPolicy.UNLOCK_ONLY
      LiveSeatStore.create(options.liveID).openRemoteCamera(options.userID, devicePolicy, callback);
    }, null);
  }

  public closeRemoteCamera(options : CloseRemoteCameraOptions) {
    UTSAndroid.getDispatcher("main").async(function (_) {
      console.warn(`${SEAT_TAG} closeRemoteCamera, data: ${JSON.stringify(options)}`);
      Logger.i(SEAT_TAG + "closeRemoteCamera, data: " + JSON.stringify(options));
      const callback = new (class implements CompletionHandler {
        override onSuccess() {
          options.success?.();
        }
        override onFailure(code : Int, desc : String) {
          console.error(`${SEAT_TAG} closeRemoteCamera failed, code: ${code}, desc: ${desc}`);
          Logger.e(SEAT_TAG + "closeRemoteCamera failed, code: " + code + ", desc: " + desc)
          options.fail?.(Number.from(code), desc);
        }
      });
      LiveSeatStore.create(options.liveID).closeRemoteCamera(options.userID, callback);
    }, null);
  }

  public openRemoteMicrophone(options : OpenRemoteMicrophoneOptions) {
    UTSAndroid.getDispatcher("main").async(function (_) {
      console.warn(`${SEAT_TAG} openRemoteMicrophone, data: ${JSON.stringify(options)}`);
      Logger.i(SEAT_TAG + "openRemoteMicrophone, data: " + JSON.stringify(options));
      const callback = new (class implements CompletionHandler {
        override onSuccess() {
          options.success?.();
        }
        override onFailure(code : Int, desc : String) {
          console.error(`${SEAT_TAG} openRemoteMicrophone failed, code: ${code}, desc: ${desc}`);
          Logger.e(SEAT_TAG + "openRemoteMicrophone failed, code: " + code + ", desc: " + desc)
          options.fail?.(Number.from(code), desc);
        }
      });
      // TODO: 底层暂时删除
      // let devicePolicy = DeviceControlPolicy.FORCE_OPEN
      // if (options.policy == 'UNLOCK_ONLY') {
      //     devicePolicy = DeviceControlPolicy.UNLOCK_ONLY
      // }
      let devicePolicy = DeviceControlPolicy.UNLOCK_ONLY
      LiveSeatStore.create(options.liveID).openRemoteMicrophone(options.userID, devicePolicy, callback);
    }, null);
  }

  public closeRemoteMicrophone(options : CloseRemoteMicrophoneOptions) {
    UTSAndroid.getDispatcher("main").async(function (_) {
      console.warn(`${SEAT_TAG} closeRemoteMicrophone, data: ${JSON.stringify(options)}`);
      Logger.i(SEAT_TAG + "closeRemoteMicrophone, data: " + JSON.stringify(options));
      const callback = new (class implements CompletionHandler {
        override onSuccess() {
          options.success?.();
        }
        override onFailure(code : Int, desc : String) {
          console.error(`${SEAT_TAG} closeRemoteMicrophone failed, code: ${code}, desc: ${desc}`);
          Logger.e(SEAT_TAG + "closeRemoteMicrophone failed, code: " + code + ", desc: " + desc)
          options.fail?.(Number.from(code), desc);
        }
      });
      LiveSeatStore.create(options.liveID).closeRemoteMicrophone(options.userID, callback);
    }, null)
  }

  // ================= LiveAudienceStore 相关接口 =================
  @UTSJS.keepAlive
  public addAudienceListener(liveID : string, eventName : string, listener : ILiveListener) : void {
    UTSAndroid.getDispatcher("main").async(function (_) {
      if (this.nativeAudienceListener == null) {
        this.nativeAudienceListener = new TLiveAudienceListener(createAudienceEventDispatcher())
      }
      if (this.nativeAudienceListener != null) {
        LiveAudienceStore.create(liveID).addLiveAudienceListener(this.nativeAudienceListener!!);
      }
      const listenerArray = audienceListenerMap.get(eventName) ?? new Array<ILiveListener>()
      if (!listenerArray.includes(listener)) {
        listenerArray.push(listener)
      }
      audienceListenerMap.set(eventName, listenerArray);
    }, null)
  }

  @UTSJS.keepAlive
  public removeAudienceListener(liveID : string, eventName : string, listener ?: ILiveListener) : void {
    UTSAndroid.getDispatcher("main").async(function (_) {
      let listenerArray = audienceListenerMap.get(eventName) ?? new Array<ILiveListener>()
      let index = listenerArray.indexOf(listener)
      listenerArray.splice(index, 1)
      if (listenerArray.length == 0) {
        audienceListenerMap.delete(eventName);
      }
      if (this.nativeAudienceListener != null) {
        LiveAudienceStore.create(liveID).removeLiveAudienceListener(this.nativeAudienceListener!!)
      }
    }, null)
  }
  public fetchAudienceList(options : FetchAudienceListOptions) {
    UTSAndroid.getDispatcher("main").async(function (_) {
      console.warn(`${AUDIENCE_TAG} fetchAudienceList, data: ${JSON.stringify(options)}`);
      Logger.i(AUDIENCE_TAG + "fetchAudienceList, data: " + JSON.stringify(options));
      const callback = new (class implements CompletionHandler {
        override onSuccess() {
          options.success?.();
        }
        override onFailure(code : Int, desc : String) {
          console.error(`${AUDIENCE_TAG} fetchAudienceList failed, code: ${code}, desc: ${desc}`);
          Logger.e(AUDIENCE_TAG + "fetchAudienceList failed, code: " + code + ", desc: " + desc)
          options.fail?.(Number.from(code), desc);
        }
      });
      LiveAudienceStore.create(options.liveID).fetchAudienceList(callback);
    }, null)
  }
  public setAdministrator(options : SetAdministratorOptions) {
    UTSAndroid.getDispatcher("main").async(function (_) {
      console.warn(`${AUDIENCE_TAG} setAdministrator, data: ${JSON.stringify(options)}`);
      Logger.i(AUDIENCE_TAG + "setAdministrator, data: " + JSON.stringify(options))

      const callback = new (class implements CompletionHandler {
        override onSuccess() {
          options.success?.();
        }
        override onFailure(code : Int, desc : String) {
          options.fail?.(Number.from(code), desc);
        }
      });
      LiveAudienceStore.create(options.liveID).setAdministrator(options.userID, callback);
    }, null)
  }
  public revokeAdministrator(options : RevokeAdministratorOptions) {
    UTSAndroid.getDispatcher("main").async(function (_) {
      console.warn(`${AUDIENCE_TAG} revokeAdministrator, data: ${JSON.stringify(options)}`);
      Logger.i(AUDIENCE_TAG + "revokeAdministrator, data: " + JSON.stringify(options))

      const callback = new (class implements CompletionHandler {
        override onSuccess() {
          options.success?.();
        }
        override onFailure(code : Int, desc : String) {
          options.fail?.(Number.from(code), desc);
        }
      });
      LiveAudienceStore.create(options.liveID).revokeAdministrator(options.userID, callback);
    }, null)
  }

  public kickUserOutOfRoom(options : KickUserOutOfRoomOptions) {
    UTSAndroid.getDispatcher("main").async(function (_) {
      console.warn(`${AUDIENCE_TAG} kickUserOutOfRoom, data: ${JSON.stringify(options)}`);
      Logger.i(AUDIENCE_TAG + "kickUserOutOfRoom, data: " + JSON.stringify(options));
      const callback = new (class implements CompletionHandler {
        override onSuccess() {
          options.success?.();
        }
        override onFailure(code : Int, desc : String) {
          options.fail?.(Number.from(code), desc);
        }
      });
      LiveAudienceStore.create(options.liveID).kickUserOutOfRoom(options.userID, callback);
    }, null)
  }

  public disableSendMessage(options : DisableSendMessageOptions) {
    UTSAndroid.getDispatcher("main").async(function (_) {
      console.warn(`${AUDIENCE_TAG} disableSendMessage, data: ${JSON.stringify(options)}`);
      Logger.i(AUDIENCE_TAG + "disableSendMessage, data: " + JSON.stringify(options));
      const callback = new (class implements CompletionHandler {
        override onSuccess() {
          options.success?.();
        }
        override onFailure(code : Int, desc : String) {
          console.error(`${AUDIENCE_TAG} disableSendMessage failed, code: ${code}, desc: ${desc}`);
          Logger.e(AUDIENCE_TAG + "disableSendMessage failed, code: " + code + ", desc: " + desc)
          options.fail?.(Number.from(code), desc);
        }
      });
      LiveAudienceStore.create(options.liveID).disableSendMessage(options.userID, options.isDisable, callback);
    }, null)
  }

  // ================= DeviceStore 相关接口 =================
  public openLocalMicrophone(options : OpenLocalMicrophoneOptions) {
    UTSAndroid.getDispatcher("main").async(function (_) {
      console.warn(`${DEVICE_TAG} openLocalMicrophone, data: ${JSON.stringify(options)}`);
      Logger.i(DEVICE_TAG + "openLocalMicrophone, data: " + JSON.stringify(options));
      const callback = new (class implements CompletionHandler {
        override onSuccess() {
          options.success?.();
        }
        override onFailure(code : Int, desc : String) {
          console.error(`${DEVICE_TAG} openLocalMicrophone failed, code: ${code}, desc: ${desc}`);
          Logger.e(DEVICE_TAG + "openLocalMicrophone failed, code: " + code + ", desc: " + desc)
          options.fail?.(Number.from(code), desc);
        }
      });
      DeviceStore.shared().openLocalMicrophone(callback);
    }, null)
  }
  public closeLocalMicrophone() {
    UTSAndroid.getDispatcher("main").async(function (_) {
      console.warn(`${DEVICE_TAG} closeLocalMicrophone`);
      Logger.i(DEVICE_TAG + "closeLocalMicrophone");
      DeviceStore.shared().closeLocalMicrophone();
    }, null)
  }
  public setCaptureVolume(options : VolumeOptions) {
    UTSAndroid.getDispatcher("main").async(function (_) {
      console.warn(`${DEVICE_TAG} setCaptureVolume, data: ${JSON.stringify(options)}`);
      Logger.i(DEVICE_TAG + "setCaptureVolume, data: " + JSON.stringify(options));
      DeviceStore.shared().setCaptureVolume(options.volume.toInt());
    }, null)
  }
  public setOutputVolume(options : VolumeOptions) {
    UTSAndroid.getDispatcher("main").async(function (_) {
      console.warn(`${DEVICE_TAG} setOutputVolume, data: ${JSON.stringify(options)}`);
      Logger.i(DEVICE_TAG + "setOutputVolume, data: " + JSON.stringify(options));
      DeviceStore.shared().setOutputVolume(options.volume.toInt());
    }, null)
  }
  public setAudioRoute(options : SetAudioRouteOptions) {
    UTSAndroid.getDispatcher("main").async(function (_) {
      console.warn(`${DEVICE_TAG} setAudioRoute, data: ${JSON.stringify(options)}`);
      Logger.i(DEVICE_TAG + "setAudioRoute, data: " + JSON.stringify(options));

      let audioRoute = AudioRoute.SPEAKERPHONE
      if (options.route == 'EARPIECE') {
        audioRoute = AudioRoute.EARPIECE
      }
      DeviceStore.shared().setAudioRoute(audioRoute);
    }, null)
  }
  public openLocalCamera(options : OpenLocalCameraOptions) {
    UTSAndroid.getDispatcher("main").async(function (_) {
      console.warn(`${DEVICE_TAG} openLocalCamera, data: ${JSON.stringify(options)}`);
      Logger.i(DEVICE_TAG + "openLocalCamera, data: " + JSON.stringify(options));
      const callback = new (class implements CompletionHandler {
        override onSuccess() {
          options.success?.();
        }
        override onFailure(code : Int, desc : String) {
          options.fail?.(Number.from(code), desc);
        }
      });
      DeviceStore.shared().openLocalCamera(options.isFront ?? true, callback);
    }, null)
  }
  public closeLocalCamera() {
    UTSAndroid.getDispatcher("main").async(function (_) {
      console.warn(`${DEVICE_TAG} closeLocalCamera`);
      Logger.i(DEVICE_TAG + "closeLocalCamera");
      DeviceStore.shared().closeLocalCamera();
    }, null)
  }
  public switchCamera(options : SwitchCameraOptions) {
    UTSAndroid.getDispatcher("main").async(function (_) {
      console.warn(`${DEVICE_TAG} switchCamera, data: ${JSON.stringify(options)}`);
      Logger.i(DEVICE_TAG + "switchCamera, data: " + JSON.stringify(options));
      DeviceStore.shared().switchCamera(options.isFront ?? false);
    }, null)
  }
  public switchMirror(options : SwitchMirrorOptions) {
    UTSAndroid.getDispatcher("main").async(function (_) {
      console.warn(`${DEVICE_TAG} switchMirror, data: ${JSON.stringify(options)}`);
      Logger.i(DEVICE_TAG + "switchMirror, data: " + JSON.stringify(options));
      let type = MirrorType.AUTO
      if (options.mirrorType == 'DISABLE') {
        type = MirrorType.DISABLE
      } else if (options.mirrorType == 'ENABLE') {
        type = MirrorType.ENABLE
      }
      DeviceStore.shared().switchMirror(type);
    }, null)
  }
  public updateVideoQuality(options : UpdateVideoQualityOptions) {
    UTSAndroid.getDispatcher("main").async(function (_) {
      console.warn(`${DEVICE_TAG} updateVideoQuality, data: ${JSON.stringify(options)}`);
      Logger.i(DEVICE_TAG + "updateVideoQuality, data: " + JSON.stringify(options));
      let quality = ParamsCovert.covertVideoQuality(options.quality)
      DeviceStore.shared().updateVideoQuality(quality);
    }, null)
  }
  public startScreenShare() {
    UTSAndroid.getDispatcher("main").async(function (_) {
      console.warn(`${DEVICE_TAG} startScreenShare`);
      Logger.i(DEVICE_TAG + "startScreenShare");
      DeviceStore.shared().startScreenShare();
    }, null)
  }
  public stopScreenShare() {
    UTSAndroid.getDispatcher("main").async(function (_) {
      console.warn(`${DEVICE_TAG} stopScreenShare`);
      Logger.i(DEVICE_TAG + "stopScreenShare");
      DeviceStore.shared().stopScreenShare();
    }, null)
  }

  // ================= CoHostStore 相关接口 ================= 
  @UTSJS.keepAlive
  public addCoHostListener(liveID : string, eventName : string, listener : ILiveListener) : void {
    UTSAndroid.getDispatcher("main").async(function (_) {
      if (this.nativeCoHostListener == null) {
        this.nativeCoHostListener = new TCoHostListener(createCoHostEventDispatcher())
      }
      if (this.nativeCoHostListener != null) {
        CoHostStore.create(liveID).addCoHostListener(this.nativeCoHostListener);
      }
      const listenerArray = coHostListenerMap.get(eventName) ?? new Array<ILiveListener>()
      if (!listenerArray.includes(listener)) {
        listenerArray.push(listener)
      }
      coHostListenerMap.set(eventName, listenerArray);
    }, null)
  }

  @UTSJS.keepAlive
  public removeCoHostListener(liveID : string, eventName : string, listener ?: ILiveListener) : void {
    UTSAndroid.getDispatcher("main").async(function (_) {
      let listenerArray = coHostListenerMap.get(eventName) ?? new Array<ILiveListener>()
      let index = listenerArray.indexOf(listener)
      listenerArray.splice(index, 1)
      if (listenerArray.length == 0) {
        coHostListenerMap.delete(eventName);
      }
      if (coHostListenerMap.size === 0) {
        CoHostStore.create(liveID).removeCoHostListener(this.nativeCoHostListener)
      }
    }, null)
  }

  public requestHostConnection(options : RequestHostConnectionOptions) {
    UTSAndroid.getDispatcher("main").async(function (_) {
      console.warn(`${COHOST_TAG} requestHostConnection, data: ${JSON.stringify(options)}`);
      Logger.i(COHOST_TAG + "requestHostConnection, data: " + JSON.stringify(options));
      const callback = new (class implements CompletionHandler {
        override onSuccess() {
          options.success?.();
        }
        override onFailure(code : Int, desc : String) {
          options.fail?.(Number.from(code), desc);
        }
      });
      let template = CoHostLayoutTemplate.HOST_DYNAMIC_GRID
      if (options.layoutTemplate == 'HOST_DYNAMIC_1V6') {
        template = CoHostLayoutTemplate.HOST_DYNAMIC_1V6
      }
      CoHostStore.create(options.liveID).requestHostConnection(options.targetHostLiveID, template,
        options.timeout?.toInt() ?? 0, options.extensionInfo, callback);
    }, null)
  }
  public cancelHostConnection(options : CancelHostConnectionOptions) {
    UTSAndroid.getDispatcher("main").async(function (_) {
      console.warn(`${COHOST_TAG} cancelHostConnection, data: ${JSON.stringify(options)}`);
      Logger.i(COHOST_TAG + "cancelHostConnection, data: " + JSON.stringify(options));
      const callback = new (class implements CompletionHandler {
        override onSuccess() {
          options.success?.();
        }
        override onFailure(code : Int, desc : String) {
          options.fail?.(Number.from(code), desc);
        }
      });
      CoHostStore.create(options.liveID).cancelHostConnection(options.toHostLiveID, callback);
    }, null)
  }
  public acceptHostConnection(options : AcceptHostConnectionOptions) {
    UTSAndroid.getDispatcher("main").async(function (_) {
      console.warn(`${COHOST_TAG} acceptHostConnection, data: ${JSON.stringify(options)}`);
      Logger.i(COHOST_TAG + "acceptHostConnection, data: " + JSON.stringify(options));
      const callback = new (class implements CompletionHandler {
        override onSuccess() {
          options.success?.();
        }
        override onFailure(code : Int, desc : String) {
          options.fail?.(Number.from(code), desc);
        }
      });
      CoHostStore.create(options.liveID).acceptHostConnection(options.fromHostLiveID, callback);
    }, null)
  }
  public rejectHostConnection(options : RejectHostConnectionOptions) {
    UTSAndroid.getDispatcher("main").async(function (_) {
      console.warn(`${COHOST_TAG} rejectHostConnection, data: ${JSON.stringify(options)}`);
      Logger.i(COHOST_TAG + "rejectHostConnection, data: " + JSON.stringify(options));
      const callback = new (class implements CompletionHandler {
        override onSuccess() {
          options.success?.();
        }
        override onFailure(code : Int, desc : String) {
          options.fail?.(Number.from(code), desc);
        }
      });
      CoHostStore.create(options.liveID).rejectHostConnection(options.fromHostLiveID, callback);
    }, null)
  }
  public exitHostConnection(options : ExitHostConnectionOptions) {
    UTSAndroid.getDispatcher("main").async(function (_) {
      console.warn(`${COHOST_TAG} exitHostConnection, data: ${JSON.stringify(options)}`);
      Logger.i(COHOST_TAG + "exitHostConnection, data: " + JSON.stringify(options));
      const callback = new (class implements CompletionHandler {
        override onSuccess() {
          options.success?.();
        }
        override onFailure(code : Int, desc : String) {
          options.fail?.(Number.from(code), desc);
        }
      });
      CoHostStore.create(options.liveID).exitHostConnection(callback);
    }, null)
  }

  // ================= CoGuestStore 相关接口 =================
  @UTSJS.keepAlive
  public addCoGuestHostListener(liveID : string, eventName : string, listener : ILiveListener) : void {
    UTSAndroid.getDispatcher("main").async(function (_) {
      if (this.nativeCoGuestHostListener == null) {
        this.nativeCoGuestHostListener = new TCoGuestHostListener(createCoGuestHostEventDispatcher())
      }
      if (this.nativeCoGuestHostListener != null) {
        CoGuestStore.create(liveID).addHostListener(this.nativeCoGuestHostListener);
      }
      const listenerArray = coGuestHostListenerMap.get(eventName) ?? new Array<ILiveListener>()
      if (!listenerArray.includes(listener)) {
        listenerArray.push(listener)
      }
      coGuestHostListenerMap.set(eventName, listenerArray);
    }, null)
  }

  @UTSJS.keepAlive
  public removeCoGuestHostListener(liveID : string, eventName : string, listener ?: ILiveListener) : void {
    UTSAndroid.getDispatcher("main").async(function (_) {
      let listenerArray = coGuestHostListenerMap.get(eventName) ?? new Array<ILiveListener>()
      let index = listenerArray.indexOf(listener)
      listenerArray.splice(index, 1)
      if (listenerArray.length == 0) {
        coGuestHostListenerMap.delete(eventName);
      }
      if (coGuestHostListenerMap.size === 0) {
        CoGuestStore.create(liveID).removeHostListener(this.nativeCoGuestHostListener)
      }
    }, null)
  }

  @UTSJS.keepAlive
  public addCoGuestGuestListener(liveID : string, eventName : string, listener : ILiveListener) : void {
    UTSAndroid.getDispatcher("main").async(function (_) {
      if (this.nativeCoGuestGuestListener == null) {
        this.nativeCoGuestGuestListener = new TCoGuestGuestListener(createCoGuestGuestEventDispatcher())
      }
      if (this.nativeCoGuestGuestListener != null) {
        CoGuestStore.create(liveID).addGuestListener(this.nativeCoGuestGuestListener);
      }
      const listenerArray = coGuestGuestListenerMap.get(eventName) ?? new Array<ILiveListener>()
      if (!listenerArray.includes(listener)) {
        listenerArray.push(listener)
      }
      coGuestGuestListenerMap.set(eventName, listenerArray);
    }, null)
  }
  @UTSJS.keepAlive
  public removeCoGuestGuestListener(liveID : string, eventName : string, listener ?: ILiveListener) : void {
    UTSAndroid.getDispatcher("main").async(function (_) {
      let listenerArray = coGuestGuestListenerMap.get(eventName) ?? new Array<ILiveListener>()
      let index = listenerArray.indexOf(listener)
      listenerArray.splice(index, 1)
      if (listenerArray.length == 0) {
        coGuestGuestListenerMap.delete(eventName);
      }
      if (coGuestGuestListenerMap.size === 0) {
        CoGuestStore.create(liveID).removeGuestListener(this.nativeCoGuestGuestListener)
      }
    }, null)
  }
  public applyForSeat(options : ApplyForSeatOptions) {
    UTSAndroid.getDispatcher("main").async(function (_) {
      console.warn(`${COGUEST_TAG} applyForSeat, data: ${JSON.stringify(options)}`);
      Logger.i(COGUEST_TAG + "applyForSeat, data: " + JSON.stringify(options));
      const callback = new (class implements CompletionHandler {
        override onSuccess() {
          options.success?.();
        }
        override onFailure(code : Int, desc : String) {
          options.fail?.(Number.from(code), desc);
        }
      });
      CoGuestStore.create(options.liveID).applyForSeat(options.seatIndex.toInt(), options.timeout?.toInt() ?? 0,
        options.extraInfo, callback);
    }, null)
  }

  public cancelApplication(options : CancelApplicationOptions) {
    UTSAndroid.getDispatcher("main").async(function (_) {
      console.warn(`${COGUEST_TAG} cancelApplication, data: ${JSON.stringify(options)}`);
      Logger.i(COGUEST_TAG + "cancelApplication, data: " + JSON.stringify(options));
      const callback = new (class implements CompletionHandler {
        override onSuccess() {
          options.success?.();
        }
        override onFailure(code : Int, desc : String) {
          options.fail?.(Number.from(code), desc);
        }
      });
      CoGuestStore.create(options.liveID).cancelApplication(callback);
    }, null);
  }

  public acceptApplication(options : AcceptApplicationOptions) {
    UTSAndroid.getDispatcher("main").async(function (_) {
      console.warn(`${COGUEST_TAG} acceptApplication, data: ${JSON.stringify(options)}`);
      Logger.i(COGUEST_TAG + "acceptApplication, data: " + JSON.stringify(options));
      const callback = new (class implements CompletionHandler {
        override onSuccess() {
          options.success?.();
        }
        override onFailure(code : Int, desc : String) {
          options.fail?.(Number.from(code), desc);
        }
      });
      CoGuestStore.create(options.liveID).acceptApplication(options.userID, callback);
    }, null);
  }

  public rejectApplication(options : RejectApplicationOptions) {
    UTSAndroid.getDispatcher("main").async(function (_) {
      console.warn(`${COGUEST_TAG} rejectApplication, data: ${JSON.stringify(options)}`);
      Logger.i(COGUEST_TAG + "rejectApplication, data: " + JSON.stringify(options));
      const callback = new (class implements CompletionHandler {
        override onSuccess() {
          options.success?.();
        }
        override onFailure(code : Int, desc : String) {
          options.fail?.(Number.from(code), desc);
        }
      });
      CoGuestStore.create(options.liveID).rejectApplication(options.userID, callback);
    }, null);
  }

  public inviteToSeat(options : InviteToSeatOptions) {
    UTSAndroid.getDispatcher("main").async(function (_) {
      console.warn(`${COGUEST_TAG} inviteToSeat, data: ${JSON.stringify(options)}`);
      Logger.i(COGUEST_TAG + "inviteToSeat, data: " + JSON.stringify(options));
      const callback = new (class implements CompletionHandler {
        override onSuccess() {
          options.success?.();
        }
        override onFailure(code : Int, desc : String) {
          options.fail?.(Number.from(code), desc);
        }
      });
      CoGuestStore.create(options.liveID).inviteToSeat(options.inviteeID, options.seatIndex.toInt(),
        options.timeout?.toInt() ?? 0, options.extraInfo, callback);
    }, null);
  }

  public cancelInvitation(options : CancelInvitationOptions) {
    UTSAndroid.getDispatcher("main").async(function (_) {
      console.warn(`${COGUEST_TAG} cancelInvitation, data: ${JSON.stringify(options)}`);
      Logger.i(COGUEST_TAG + "cancelInvitation, data: " + JSON.stringify(options));
      const callback = new (class implements CompletionHandler {
        override onSuccess() {
          options.success?.();
        }
        override onFailure(code : Int, desc : String) {
          options.fail?.(Number.from(code), desc);
        }
      });
      CoGuestStore.create(options.liveID).cancelInvitation(options.inviteeID, callback);
    }, null);
  }

  public acceptInvitation(options : AcceptInvitationOptions) {
    UTSAndroid.getDispatcher("main").async(function (_) {
      console.warn(`${COGUEST_TAG} acceptInvitation, data: ${JSON.stringify(options)}`);
      Logger.i(COGUEST_TAG + "acceptInvitation, data: " + JSON.stringify(options));
      const callback = new (class implements CompletionHandler {
        override onSuccess() {
          options.success?.();
        }
        override onFailure(code : Int, desc : String) {
          options.fail?.(Number.from(code), desc);
        }
      });
      CoGuestStore.create(options.liveID).acceptInvitation(options.inviterID, callback);
    }, null);
  }

  public rejectInvitation(options : RejectInvitationOptions) {
    UTSAndroid.getDispatcher("main").async(function (_) {
      console.warn(`${COGUEST_TAG} rejectInvitation, data: ${JSON.stringify(options)}`);
      Logger.i(COGUEST_TAG + "rejectInvitation, data: " + JSON.stringify(options));
      const callback = new (class implements CompletionHandler {
        override onSuccess() {
          options.success?.();
        }
        override onFailure(code : Int, desc : String) {
          options.fail?.(Number.from(code), desc);
        }
      });
      CoGuestStore.create(options.liveID).rejectInvitation(options.inviterID, callback);
    }, null);
  }
  public disconnect(options : DisconnectOptions) {
    UTSAndroid.getDispatcher("main").async(function (_) {
      console.warn(`${COGUEST_TAG} disconnect, data: ${JSON.stringify(options)}`);
      Logger.i(COGUEST_TAG + "disconnect, data: " + JSON.stringify(options));
      const callback = new (class implements CompletionHandler {
        override onSuccess() {
          options.success?.();
        }
        override onFailure(code : Int, desc : String) {
          options.fail?.(Number.from(code), desc);
        }
      });
      CoGuestStore.create(options.liveID).disconnect(callback);
    }, null);
  }

  // ================= BarrageStore 相关接口 =================
  public sendTextMessage(options : SendTextMessageOptions) {
    UTSAndroid.getDispatcher("main").async(function (_) {
      console.warn(`${BARRAGE_TAG} sendTextMessage, data: ${JSON.stringify(options)}`);
      Logger.i(BARRAGE_TAG + "sendTextMessage, data: " + JSON.stringify(options));
      const callback = new (class implements CompletionHandler {
        override onSuccess() {
          options.success?.();
        }
        override onFailure(code : Int, desc : String) {
          options.fail?.(Number.from(code), desc);
        }
      });
      let jsonObject = ParamsCovert.convertJsonToUTSJSONObject(options.extensionInfo)
      let mapData = new Map<string,string>()
      jsonObject.toMap().forEach(function (value: any | null, key: string) {
          mapData.set(key, JSON.stringify(value))
      })
      BarrageStore.create(options.liveID).sendTextMessage(options.text, mapData, callback);
    }, null);
  }
  public sendCustomMessage(options : SendCustomMessageOptions) {
    UTSAndroid.getDispatcher("main").async(function (_) {
      console.warn(`${BARRAGE_TAG} sendCustomMessage, data: ${JSON.stringify(options)}`);
      Logger.i(BARRAGE_TAG + "sendCustomMessage, data: " + JSON.stringify(options));
      const callback = new (class implements CompletionHandler {
        override onSuccess() {
          options.success?.();
        }
        override onFailure(code : Int, desc : String) {
          options.fail?.(Number.from(code), desc);
        }
      });
      BarrageStore.create(options.liveID).sendCustomMessage(options.businessID, options.data, callback);
    }, null);
  }
  public appendLocalTip(options : AppendLocalTipOptions) {
    UTSAndroid.getDispatcher("main").async(function (_) {
      console.warn(`${BARRAGE_TAG} appendLocalTip, data: ${JSON.stringify(options)}`);
      Logger.i(BARRAGE_TAG + "appendLocalTip, data: " + JSON.stringify(options));
      let message : Barrage = ParamsCovert.convertBarrage(options)
      BarrageStore.create(options.liveID).appendLocalTip(message);
    }, null);
  }

  // ================= GiftStore 相关接口 =================
  @UTSJS.keepAlive
  public addGiftListener(liveID : string, eventName : string, listener : ILiveListener) : void {
    UTSAndroid.getDispatcher("main").async(function (_) {
      if (this.nativeGiftListener == null) {
        this.nativeGiftListener = new TGiftListener(createGiftEventDispatcher())
      }
      if (this.nativeGiftListener != null) {
        GiftStore.create(liveID).addGiftListener(this.nativeGiftListener);
      }
      const listenerArray = giftListenerMap.get(eventName) ?? new Array<ILiveListener>()
      if (!listenerArray.includes(listener)) {
        listenerArray.push(listener)
      }
      giftListenerMap.set(eventName, listenerArray);
    }, null);
  }
  @UTSJS.keepAlive
  public removeGiftListener(liveID : string, eventName : string, listener ?: ILiveListener) : void {
    UTSAndroid.getDispatcher("main").async(function (_) {
      let listenerArray = giftListenerMap.get(eventName) ?? new Array<ILiveListener>()
      let index = listenerArray.indexOf(listener)
      listenerArray.splice(index, 1)
      if (listenerArray.length == 0) {
        giftListenerMap.delete(eventName);
      }
      if (giftListenerMap.size === 0) {
        GiftStore.create(liveID).removeGiftListener(this.nativeGiftListener)
      }
    }, null);
  }
  public refreshUsableGifts(options : RefreshUsableGiftsOptions) {
    UTSAndroid.getDispatcher("main").async(function (_) {
      console.warn(`${GIFT_TAG} refreshUsableGifts, data: ${JSON.stringify(options)}`);
      const callback = new (class implements CompletionHandler {
        override onSuccess() {
          options.success?.();
        }
        override onFailure(code : Int, desc : String) {
          options.fail?.(Number.from(code), desc);
        }
      });
      GiftStore.create(options.liveID).refreshUsableGifts(callback);
    }, null);
  }
  public sendGift(options : SendGiftOptions) {
    UTSAndroid.getDispatcher("main").async(function (_) {
      console.warn(`${GIFT_TAG} sendGift, data: ${JSON.stringify(options)}`);
      Logger.i(GIFT_TAG + "sendGift, data: " + JSON.stringify(options));
      const callback = new (class implements CompletionHandler {
        override onSuccess() {
          options.success?.();
        }
        override onFailure(code : Int, desc : String) {
          options.fail?.(Number.from(code), desc);
        }
      });
      GiftStore.create(options.liveID).sendGift(options.giftID, options.count.toInt(), callback);
    }, null);
  }

  public setLanguage(options : SetLanguageOptions) {
    UTSAndroid.getDispatcher("main").async(function (_) {
      console.warn(`${GIFT_TAG} setLanguage, data: ${JSON.stringify(options)}`);
      Logger.i(GIFT_TAG + "setLanguage, data: " + JSON.stringify(options));
      GiftStore.create(options.liveID).setLanguage(options.language);
    }, null);
  }


  // ================= BaseBeautyStore 相关接口 =================
  public setSmoothLevel(options : SetSmoothLevelOptions) {
    UTSAndroid.getDispatcher("main").async(function (_) {
      console.warn(`${BEAUTY_TAG} setSmoothLevel, data: ${JSON.stringify(options)}`);
      Logger.i(BEAUTY_TAG + "setSmoothLevel, data: " + JSON.stringify(options));
      BaseBeautyStore.shared().setSmoothLevel(options.smoothLevel.toFloat());
    }, null);
  }

  public setWhitenessLevel(options : SetWhitenessLevelOptions) {
    UTSAndroid.getDispatcher("main").async(function (_) {
      console.warn(`${BEAUTY_TAG} setWhitenessLevel, data: ${JSON.stringify(options)}`);
      Logger.i(BEAUTY_TAG + "setWhitenessLevel, data: " + JSON.stringify(options));
      BaseBeautyStore.shared().setWhitenessLevel(options.whitenessLevel.toFloat());
    }, null);
  }

  public setRuddyLevel(options : SetRuddyLevelOptions) {
    UTSAndroid.getDispatcher("main").async(function (_) {
      console.warn(`${BEAUTY_TAG} setRuddyLevel, data: ${JSON.stringify(options)}`);
      Logger.i(BEAUTY_TAG + "setRuddyLevel, data: " + JSON.stringify(options));
      BaseBeautyStore.shared().setRuddyLevel(options.ruddyLevel.toFloat());
    }, null);
  }

  // ================= AudioEffectStore 相关接口 =================
  public setAudioChangerType(options : SetAudioChangerTypeOptions) {
    UTSAndroid.getDispatcher("main").async(function (_) {
      console.warn(`${AUDIOEFFECT_TAG} setAudioChangerType, data: ${JSON.stringify(options)}`);
      Logger.i(AUDIOEFFECT_TAG + "setAudioChangerType, data: " + JSON.stringify(options));
      let type = ParamsCovert.convertAudioChangerType(options.changerType)
      AudioEffectStore.shared().setAudioChangerType(type);
    }, null);
  }

  public setAudioReverbType(options : SetAudioReverbTypeOptions) {
    UTSAndroid.getDispatcher("main").async(function (_) {
      console.warn(`${AUDIOEFFECT_TAG} setAudioReverbType, data: ${JSON.stringify(options)}`);
      Logger.i(AUDIOEFFECT_TAG + "setAudioReverbType, data: " + JSON.stringify(options));
      let type = ParamsCovert.convertAudioReverbType(options.reverbType)
      AudioEffectStore.shared().setAudioReverbType(type);
    }, null);
  }

  public setVoiceEarMonitorEnable(options : SetVoiceEarMonitorEnableOptions) {
    UTSAndroid.getDispatcher("main").async(function (_) {
      console.warn(`${AUDIOEFFECT_TAG} setVoiceEarMonitorEnable, data: ${JSON.stringify(options)}`);
      Logger.i(AUDIOEFFECT_TAG + "setVoiceEarMonitorEnable, data: " + JSON.stringify(options));
      AudioEffectStore.shared().setVoiceEarMonitorEnable(options.enable);
    }, null);
  }

  public setVoiceEarMonitorVolume(options : VolumeOptions) {
    UTSAndroid.getDispatcher("main").async(function (_) {
      console.warn(`${AUDIOEFFECT_TAG} setVoiceEarMonitorVolume, data: ${JSON.stringify(options)}`);
      Logger.i(AUDIOEFFECT_TAG + "setVoiceEarMonitorVolume, data: " + JSON.stringify(options));
      AudioEffectStore.shared().setVoiceEarMonitorVolume(options.volume.toInt());
    }, null);
  }

  // ================= LikeStore 相关接口 =================
  @UTSJS.keepAlive
  public addLikeListener(liveID : string, eventName : string, listener : ILiveListener) : void {
    UTSAndroid.getDispatcher("main").async(function (_) {
      if (this.nativeLikeListener == null) {
        this.nativeLikeListener = new TLikeListener(createLikeEventDispatcher())
      }
      if (this.nativeLikeListener != null) {
        LikeStore.create(liveID).addLikeListener(this.nativeLikeListener);
      }
      const listenerArray = likeListenerMap.get(eventName) ?? new Array<ILiveListener>()
      if (!listenerArray.includes(listener)) {
        listenerArray.push(listener)
      }
      likeListenerMap.set(eventName, listenerArray);
    }, null);
  }
  @UTSJS.keepAlive
  public removeLikeListener(liveID : string, eventName : string, listener ?: ILiveListener) : void {
    UTSAndroid.getDispatcher("main").async(function (_) {
      let listenerArray = likeListenerMap.get(eventName) ?? new Array<ILiveListener>()
      let index = listenerArray.indexOf(listener)
      listenerArray.splice(index, 1)
      if (listenerArray.length == 0) {
        likeListenerMap.delete(eventName);
      }
      if (likeListenerMap.size === 0) {
        LikeStore.create(liveID).removeLikeListener(this.nativeLikeListener)
      }
    }, null);
  }
  public sendLike(options : SendLikeOptions) {
    UTSAndroid.getDispatcher("main").async(function (_) {
      console.warn(`UTS-Like sendLike, data: ${JSON.stringify(options)}`);
      Logger.i("UTS-Like: " + "sendLike, data: " + JSON.stringify(options));
      const callback = new (class implements CompletionHandler {
        override onSuccess() {
          options.success?.();
        }
        override onFailure(code : Int, desc : String) {
          options.fail?.(Number.from(code), desc);
        }
      });
      LikeStore.create(options.liveID).sendLike(options.count?.toInt() ?? 1, callback);
    }, null);
  }

  // ================= BattleStore 相关接口 =================
  @UTSJS.keepAlive
  public addBattleListener(liveID : string, eventName : string, listener : ILiveListener) : void {
    UTSAndroid.getDispatcher("main").async(function (_) {
      if (this.nativeBattleListener == null) {
        this.nativeBattleListener = new TBattleListener(createBattleEventDispatcher())
      }
      if (this.nativeBattleListener != null) {
        BattleStore.create(liveID).addBattleListener(this.nativeBattleListener);
      }
      const listenerArray = battleListenerMap.get(eventName) ?? new Array<ILiveListener>();
      if (!listenerArray.includes(listener)) {
        listenerArray.push(listener)
      }
      battleListenerMap.set(eventName, listenerArray);
    }, null);
  }

  @UTSJS.keepAlive
  public removeBattleListener(liveID : string, eventName : string, listener ?: ILiveListener) : void {
    UTSAndroid.getDispatcher("main").async(function (_) {
      let listenerArray = battleListenerMap.get(eventName) ?? new Array<ILiveListener>();
      let index = listenerArray.indexOf(listener);
      listenerArray.splice(index, 1);
      if (listenerArray.length == 0) {
        battleListenerMap.delete(eventName);
      }
      if (battleListenerMap.size === 0) {
        BattleStore.create(liveID).removeBattleListener(this.nativeBattleListener);
      }
    }, null);
  }

  public requestBattle(options : RequestBattleOptions) {
    UTSAndroid.getDispatcher("main").async(function (_) {
      console.warn(`${BATTLE_TAG} requestBattle, data: ${JSON.stringify(options)}`);
      Logger.i(BATTLE_TAG + "requestBattle, data: " + JSON.stringify(options));

      let battleConfig = new BattleConfig();
      battleConfig.duration = options.config.duration?.toInt() ?? 0;
      battleConfig.needResponse = options.config.needResponse ?? false;
      battleConfig.extensionInfo = options.config.extensionInfo ?? "";

      const callback = new (class implements BattleRequestCallback {
        override onSuccess(battleInfo : BattleInfo, resultMap : kotlin.collections.Map<String, Int>) {
          let battleInfoStr = Gson().toJson(battleInfo)
          let resultMapData = Gson().toJson(resultMap)
          console.log(`${BATTLE_TAG} requestBattle success, battleInfo: ${battleInfoStr}, resultMap: ${resultMapData}`)
          options.success?.(battleInfoStr, resultMapData);
        }
        override onError(code : Int, desc : String) {
          console.error(`${BATTLE_TAG} requestBattle failed, errorCode: ${JSON.stringify(code)}, errorMsg: ${JSON.stringify(desc)}`)
          options.fail?.(Number.from(code), desc);
        }
      });
      BattleStore.create(options.liveID).requestBattle(
        battleConfig, options.userIDList, options.timeout.toInt(), callback
      );
    }, null);
  }

  public cancelBattleRequest(options : CancelBattleRequestOptions) {
    UTSAndroid.getDispatcher("main").async(function (_) {
      console.warn(`${BATTLE_TAG} cancelBattleRequest, data: ${JSON.stringify(options)}`);
      Logger.i(BATTLE_TAG + "cancelBattleRequest, data: " + JSON.stringify(options));

      const callback = new (class implements CompletionHandler {
        override onSuccess() {
          options.success?.();
        }
        override onFailure(code : Int, desc : String) {
          options.fail?.(Number.from(code), desc);
        }
      });
      BattleStore.create(options.liveID).cancelBattleRequest(options.battleID, options.userIDList, callback);
    }, null);
  }

  public acceptBattle(options : AcceptBattleOptions) {
    UTSAndroid.getDispatcher("main").async(function (_) {
      console.warn(`${BATTLE_TAG} acceptBattle, data: ${JSON.stringify(options)}`);
      Logger.i(BATTLE_TAG + "acceptBattle, data: " + JSON.stringify(options));

      const callback = new (class implements CompletionHandler {
        override onSuccess() {
          options.success?.();
        }
        override onFailure(code : Int, desc : String) {
          options.fail?.(Number.from(code), desc);
        }
      });
      BattleStore.create(options.liveID).acceptBattle(options.battleID, callback);
    }, null);
  }

  public rejectBattle(options : RejectBattleOptions) {
    UTSAndroid.getDispatcher("main").async(function (_) {
      console.warn(`${BATTLE_TAG} rejectBattle, data: ${JSON.stringify(options)}`);
      Logger.i(BATTLE_TAG + "rejectBattle, data: " + JSON.stringify(options));

      const callback = new (class implements CompletionHandler {
        override onSuccess() {
          options.success?.();
        }
        override onFailure(code : Int, desc : String) {
          options.fail?.(Number.from(code), desc);
        }
      });
      BattleStore.create(options.liveID).rejectBattle(options.battleID, callback);
    }, null);
  }

  public exitBattle(options : ExitBattleOptions) {
    UTSAndroid.getDispatcher("main").async(function (_) {
      console.warn(`${BATTLE_TAG} exitBattle, data: ${JSON.stringify(options)}`);
      Logger.i(BATTLE_TAG + "exitBattle, data: " + JSON.stringify(options));

      const callback = new (class implements CompletionHandler {
        override onSuccess() {
          options.success?.();
        }
        override onFailure(code : Int, desc : String) {
          options.fail?.(Number.from(code), desc);
        }
      });
      BattleStore.create(options.liveID).exitBattle(options.battleID, callback);
    }, null);
  }

  // ================= 实验性接口 =================
  public callExperimentalAPI(options : CallExperimentalAPIOptions) {
    UTSAndroid.getDispatcher("main").async(function (_) {
      const callback = new (class implements TUIRoomDefine.ExperimentalAPIResponseCallback {
        override onResponse(jsonData : string) : void {
          options.onResponse?.(jsonData)
        }
      });
      ExperimentalApiInvoker.callExperimentalAPI(options.jsonData, callback)
    }, null);
  }

  // ================= State event listener =================
  @UTSJS.keepAlive
  public on(eventName : string, listener : (key : string, res : string) => void, liveID : string) {
    UTSAndroid.getDispatcher("main").async(function (_) {
      console.log(`${RTC_TAG} observer, eventName: ${eventName}, liveID: ${liveID}`);

      if (eventName == "loginStoreChanged") {
        LoginStoreObserver.loginStoreChanged(function (key : string, data : string) {
          console.log(`${RTC_TAG} loginStoreChanged, key: ${key}, data: ${data}`);
          Logger.i(RTC_TAG + "loginStoreChanged, key: " + key + ", data: " + data);
          listener(key, data)
        })
      }
      if (eventName == "liveStoreChanged") {
        LiveListStoreObserver.liveStoreChanged(function (key : string, data : string) {
          console.log(`${LIVE_TAG} liveStoreChanged, key: ${key}, data: ${data}`);
          Logger.i(LIVE_TAG + "liveStoreChanged, key: " + key + ", data: " + data);
          listener(key, data)
        })
      }
      if (eventName == "liveSeatStoreChanged") {
        LiveSeatStoreObserver.liveSeatStoreChanged(liveID, function (key : string, data : string) {
          listener(key, data)
        })
      }
      if (eventName == "liveAudienceStoreChanged") {
        LiveAudienceStoreObserver.liveAudienceStoreChanged(liveID, function (key : string, data : string) {
          listener(key, data)
        })
      }
      if (eventName == "giftStoreChanged") {
        GiftStoreObserver.giftStoreChanged(liveID, function (key : string, data : string) {
          console.log(`${GIFT_TAG} giftStoreChanged, key: ${key}, data: ${data}`);
          listener(key, data)
        })
      }
      if (eventName == "deviceStoreChanged") {
        DeviceStoreObserver.deviceStoreChanged(function (key : string, data : string) {
          listener(key, data)
        })
      }
      if (eventName == "coHostStoreChanged") {
        CoHostStoreObserver.coHostStoreChanged(liveID, function (key : string, data : string) {
          console.log(`${COHOST_TAG} coHostStoreChanged, key: ${key}, data: ${data}`);
          Logger.i(COHOST_TAG + "coHostStoreChanged, key: " + key + ", data: " + data);
          listener(key, data)
        })
      }
      if (eventName == "coGuestStoreChanged") {
        CoGuestStoreObserver.coGuestStoreChanged(liveID, function (key : string, data : string) {
          console.log(`${COGUEST_TAG} coGuestStoreChanged, key: ${key}, data: ${data}`);
          Logger.i(COGUEST_TAG + "coGuestStoreChanged, key: " + key + ", data: " + data);
          listener(key, data)
        })
      }
      if (eventName == "barrageStoreChanged") {
        BarrageStoreObserver.barrageStoreChanged(liveID, function (key : string, data : string) {
          console.log(`${BARRAGE_TAG} barrageStoreChanged, key: ${key}, data: ${data}`);
          listener(key, data)
        })
      }
      if (eventName == "beautyStoreChanged") {
        BaseBeautyStoreObserver.beautyStoreChanged(function (key : string, data : string) {
          console.log(`${BEAUTY_TAG} beautyStoreChanged, key: ${key}, data: ${data}`);
          listener(key, data)
        })
      }
      if (eventName == "audioEffectStoreChanged") {
        AudioEffectStoreObserver.audioEffectStoreChanged(function (key : string, data : string) {
          console.log(`${AUDIOEFFECT_TAG} audioEffectStoreChanged, key: ${key}, data: ${data}`);
          listener(key, data)
        })
      }
      if (eventName == "liveSummaryStoreChanged") {
        LiveSummaryStoreObserver.liveSummaryStoreChanged(liveID, function (key : string, data : string) {
          console.log(`${SUMMARY_TAG} liveSummaryStoreChanged, key: ${key}, data: ${data}`);
          listener(key, data)
        })
      }

      if (eventName == "likeStoreChanged") {
        LikeStoreObserver.likeStoreChanged(liveID, function (key : string, data : string) {
          listener(key, data)
        })
      }
      if (eventName == "battleStoreChanged") {
        console.log(`${BATTLE_TAG} battleStoreChanged, liveID: ${liveID}`);
        BattleStoreObserver.battleStoreChanged(liveID, function (key : string, data : string) {
          console.log(`${BATTLE_TAG} battleStoreChanged, key: ${key}, data" ${data}`);
          listener(key, data)
        })
      }
    }, null);
  }
}

function startForegroundService() {
  console.log("UTS-Live: startForegroundService")
  VideoForegroundService.start(context, "", "", 0)
}

function stopForegroundService() {
  console.log("UTS-Live: stopForegroundService")
  VideoForegroundService.stop(context)
}