@zegocloud/zego-uikit-prebuilt 1.5.2 → 1.5.3

package/index.d.ts

@@ -1,6 +1,7 @@
 import { Root } from "react-dom/client";
 import { ZegoSuperBoardManager } from "zego-superboard-web";
-import { LiveRole, LiveStreamingMode, ScenarioModel, VideoResolution, ZegoCloudRoomConfig } from "./model/index";
+import ZIM from "zego-zim-web";
+import { LiveRole, LiveStreamingMode, ScenarioModel, VideoResolution, ZegoCallInvitationConfig, ZegoCloudRoomConfig, ZegoInvitationType, ZegoSignalingPluginNotificationConfig, ZegoUser } from "./model/index";
 import { ZegoCloudRTCCore } from "./modules/index";
 export declare class ZegoUIKitPrebuilt {
     static core: ZegoCloudRTCCore | undefined;
@@ -17,6 +18,8 @@ export declare class ZegoUIKitPrebuilt {
     static VideoResolution_480P: VideoResolution;
     static VideoResolution_720P: VideoResolution;
     static LiveStreamingMode: typeof LiveStreamingMode;
+    static InvitationTypeVoiceCall: ZegoInvitationType;
+    static InvitationTypeVideoCall: ZegoInvitationType;
     private hasJoinedRoom;
     root: Root | undefined;
     static generateKitTokenForTest(appID: number, serverSecret: string, roomID: string, userID: string, userName?: string, ExpirationSeconds?: number): string;
@@ -24,7 +27,18 @@ export declare class ZegoUIKitPrebuilt {
     static create(kitToken: string): ZegoUIKitPrebuilt;
     addPlugins(plugins?: {
         ZegoSuperBoardManager?: typeof ZegoSuperBoardManager;
+        ZIM?: typeof ZIM;
     }): void;
     joinRoom(roomConfig?: ZegoCloudRoomConfig): void;
     destroy(): void;
+    setCallInvitationConfig(config?: ZegoCallInvitationConfig): void;
+    sendCallInvitation(params: {
+        invitees: ZegoUser[];
+        type: ZegoInvitationType;
+        timeout?: number;
+        data?: string;
+        notificationConfig?: ZegoSignalingPluginNotificationConfig;
+    }): Promise<{
+        errorInvitees: ZegoUser[];
+    }>;
 }

package/model/index.d.ts

@@ -47,8 +47,16 @@ export interface ScenarioConfig {
     };
 }
 export declare enum LiveStreamingMode {
-    StandardLive = "StandardLive",
-    PremiumLive = "PremiumLive",
+    /**
+     * @Deprecated  StanderLive will be removed, please use LiveStreaming instead
+     */
+    StanderLive = "LiveStreaming",
+    /**
+     * @Deprecated  PremiumLive will be removed, please use InteractiveLiveStreaming instead
+     */
+    PremiumLive = "InteractiveLiveStreaming",
+    LiveStreaming = "LiveStreaming",
+    InteractiveLiveStreaming = "InteractiveLiveStreaming",
     RealTimeLive = "RealTimeLive"
 }
 export interface ZegoCloudRoomConfig {
@@ -98,14 +106,31 @@ export interface ZegoCloudRoomConfig {
     videoResolutionDefault?: VideoResolution;
     onLiveStart?: (user: ZegoUser) => void;
     onLiveEnd?: (user: ZegoUser) => void;
+    /**
+     * @deprecated facingMode will be removed
+     * */
     facingMode?: "user" | "environment";
+    /**
+     * @deprecated joinRoomCallback will be removed
+     * */
     joinRoomCallback?: () => void;
+    /**
+     * @deprecated leaveRoomCallback will be removed
+     * */
     leaveRoomCallback?: () => void;
+    /**
+     * @deprecated userUpdateCallback will be removed
+     * */
     userUpdateCallback?: (updateType: "DELETE" | "ADD", userList: ZegoUser[]) => void;
+    /**
+     * @deprecated roomTimerDisplayed will be removed
+     * */
     roomTimerDisplayed?: boolean;
     whiteboardConfig?: {
         showAddImageButton?: boolean;
+        showCreateAndCloseButton?: boolean;
     };
+    autoLeaveRoomWhenOnlySelfInRoom?: boolean;
 }
 export interface ZegoBrowserCheckProp {
     core: ZegoCloudRTCCore;
@@ -207,3 +232,41 @@ export declare enum CoreError {
     notSupportCDNLive = 10001,
     notSupportStandardLive = 10002
 }
+export declare enum ZegoInvitationType {
+    VoiceCall = 0,
+    VideoCall = 1
+}
+export interface ZegoCallInvitationConfig {
+    enableCustomCallInvitationWaitingPage?: boolean;
+    enableCustomCallInvitationDialog?: boolean;
+    enableNotifyWhenAppRunningInBackgroundOrQuit?: boolean;
+    onCallInvitationWaitingPageShowed?: (invitees: ZegoUser[], cancel: CancelCallInvitationFunc) => void;
+    onCallInvitationDialogShowed?: (type: ZegoInvitationType, inviter: ZegoUser, refuse: RefuseCallInvitationFunc, accept: AcceptCallInvitationFunc, data: string) => void;
+    onSetRoomConfigBeforeJoining?: (type: ZegoInvitationType) => ZegoCloudRoomConfig;
+    onCallInvitationEnded?: (reason: CallInvitationEndReason, data: string) => void;
+}
+export type CancelCallInvitationFunc = (data?: string) => void;
+export type AcceptCallInvitationFunc = (data?: string) => void;
+export type RefuseCallInvitationFunc = (data?: string) => void;
+export interface CallInvitationInfo {
+    callID: string;
+    roomID: string;
+    inviter: ZegoUser;
+    invitees: ZegoUser[];
+    /** 已接受邀请的用户 */
+    acceptedInvitees: ZegoUser[];
+    type: ZegoInvitationType;
+    isGroupCall: boolean;
+}
+export declare enum CallInvitationEndReason {
+    Declined = "Declined",
+    Timeout = "Timeout",
+    Canceled = "Canceled",
+    Busy = "Busy",
+    LeaveRoom = "LeaveRoom"
+}
+export interface ZegoSignalingPluginNotificationConfig {
+    resourcesID?: string;
+    title?: string;
+    message?: string;
+}

package/modules/index.d.ts

@@ -5,9 +5,12 @@ import { ZegoBroadcastMessageInfo } from "zego-express-engine-webrtm/sdk/code/zh
 import { ZegoCloudRemoteMedia, ZegoCloudRoomConfig, ZegoUser } from "../model";
 import { ZegoCloudUserList, ZegoCloudUserListManager } from "./tools/UserListManager";
 import { ZegoSuperBoardManager, ZegoSuperBoardView } from "zego-superboard-web";
+import ZIM from "zego-zim-web";
+import { ZimManager } from "./tools/ZimManager";
 export declare class ZegoCloudRTCCore {
     static _instance: ZegoCloudRTCCore;
     static _zg: ZegoExpressEngine;
+    _zimManager: ZimManager | null;
     zum: ZegoCloudUserListManager;
     _expressConfig: {
         appID: number;
@@ -22,8 +25,8 @@ export declare class ZegoCloudRTCCore {
     static getInstance(kitToken: string): ZegoCloudRTCCore;
     status: {
         loginRsp: boolean;
-        videoRefuse: boolean;
-        audioRefuse: boolean;
+        videoRefuse?: boolean;
+        audioRefuse?: boolean;
         micDeviceID?: string;
         cameraDeviceID?: string;
         speakerDeviceID?: string;
@@ -50,8 +53,10 @@ export declare class ZegoCloudRTCCore {
     get isCDNLive(): boolean;
     addPlugins(plugins: {
         ZegoSuperBoardManager?: typeof ZegoSuperBoardManager;
+        ZIM?: ZIM;
     }): void;
     setConfig(config: ZegoCloudRoomConfig): boolean;
+    private getLiveStreamingMode;
     checkWebRTC(): Promise<boolean>;
     setPin(userID?: string, pined?: boolean, stopUpdateUser?: boolean): void;
     setMaxScreenNum(num: number, stopUpdateUser?: boolean): Promise<void>;
@@ -102,7 +107,7 @@ export declare class ZegoCloudRTCCore {
     private onNetworkStatusQualityCallBack;
     onNetworkStatusQuality(func: (roomID: string, level: number) => void): void;
     private onRemoteUserUpdateCallBack;
-    onRemoteUserUpdate(func: (roomID: string, updateType: "DELETE" | "ADD", user: ZegoUser[]) => void): void;
+    onRemoteUserUpdate(func: (roomID: string, updateType: "DELETE" | "ADD", user: ZegoUser[], allUser: ZegoUser[]) => void): void;
     private onSoundLevelUpdateCallBack;
     onSoundLevelUpdate(func: (soundLevelList: ZegoSoundLevelInfo[]) => void): void;
     private onRoomLiveStateUpdateCallBack;
@@ -119,4 +124,5 @@ export declare class ZegoCloudRTCCore {
     onCoreError(func: (errCode: number, errMsg: string) => void): void;
     leaveRoom(): void;
     setStreamExtraInfo(streamID: string, extraInfo: string): Promise<ZegoServerResponse>;
+    private initZIM;
 }

package/modules/tools/UserListManager.d.ts

@@ -1,8 +1,8 @@
 import { ZegoExpressEngine } from "zego-express-engine-webrtc";
 import { ZegoUser } from "zego-express-engine-webrtm/sdk/code/zh/ZegoExpressEntity.d";
 import { LiveRole, LiveStreamingMode, ScenarioModel, ZegoCloudRemoteMedia } from "../../model";
-export declare type ZegoCloudUserList = ZegoCloudUser[];
-export declare type ZegoCloudUser = ZegoUser & {
+export type ZegoCloudUserList = ZegoCloudUser[];
+export type ZegoCloudUser = ZegoUser & {
     pin: boolean;
     overScreenMuteVideo?: boolean;
     streamList: ZegoCloudRemoteMedia[];

package/modules/tools/ZimManager.d.ts

@@ -0,0 +1,54 @@
+/// <reference types="node" />
+import ZIM from "zego-zim-web";
+import { CallInvitationEndReason, CallInvitationInfo, ScenarioModel, ZegoCallInvitationConfig, ZegoCloudRoomConfig, ZegoInvitationType, ZegoSignalingPluginNotificationConfig, ZegoUser } from "../../model";
+export declare class ZimManager {
+    _zim: ZIM | null;
+    isLogin: boolean;
+    isServiceActivated: boolean;
+    expressConfig: {
+        appID: number;
+        userID: string;
+        userName: string;
+        roomID: string;
+        token: string;
+    };
+    callInfo: CallInvitationInfo;
+    inSendOperation: boolean;
+    inRefuseOperation: boolean;
+    inAcceptOperation: boolean;
+    inCancelOperation: boolean;
+    config: ZegoCallInvitationConfig;
+    incomingTimer: NodeJS.Timer | null;
+    outgoingTimer: NodeJS.Timer | null;
+    constructor(ZIM: ZIM, expressConfig: {
+        appID: number;
+        userID: string;
+        userName: string;
+        roomID: string;
+        token: string;
+    });
+    private initListener;
+    private answeredTimeoutCallback;
+    sendInvitation(invitees: ZegoUser[], type: number, timeout: number, data: string, notificationConfig?: ZegoSignalingPluginNotificationConfig): Promise<{
+        errorInvitees: ZegoUser[];
+    }>;
+    cancelInvitation(data?: string): Promise<void>;
+    refuseInvitation(reason?: string, callID?: string, data?: string): Promise<void>;
+    acceptInvitation(data?: string): Promise<void>;
+    private clearCallInfo;
+    destroy(): void;
+    private notifyJoinRoomCallback;
+    /** 通知UI层调用joinRoom */
+    notifyJoinRoom(func: (type: ZegoInvitationType, roomConfig: ZegoCloudRoomConfig, mode: ScenarioModel) => void): void;
+    private notifyLeaveRoomCallback;
+    /** 通知UI层调用leaveRoom */
+    notifyLeaveRoom(func: () => void): void;
+    private onUpdateRoomIDCallback;
+    /**收到邀请后需要更新roomID*/
+    onUpdateRoomID(func: (roomID: string) => void): void;
+    /**结束 call,清除 callInfo */
+    endCall(reason: CallInvitationEndReason): void;
+    setCallInvitationConfig(config: ZegoCallInvitationConfig): void;
+    private clearOutgoingTimer;
+    private clearIncomingTimer;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
             "name": "@zegocloud/zego-uikit-prebuilt",
-            "version": "1.5.2",
+            "version": "1.5.3",
             "description": "zegocloud prebuilt meeting webrtc sdk",
             "main": "./zego-uikit-prebuilt.js",
             "typings": "./sdk/index.d.ts",

package/view/index.d.ts

@@ -2,6 +2,7 @@ import React from "react";
 import { ZegoCloudRTCCore } from "../modules";
 export declare class ZegoCloudRTCKitComponent extends React.Component<{
     core: ZegoCloudRTCCore;
+    unmount: () => void;
 }> {
     state: {
         step: number;
@@ -9,5 +10,6 @@ export declare class ZegoCloudRTCKitComponent extends React.Component<{
     };
     componentDidMount(): Promise<void>;
     nextPage(): void;
+    destroyNodeWhenNoView(): void;
     render(): React.ReactNode;
 }

package/view/pages/ZegoBrowserCheck/index.d.ts

@@ -29,8 +29,8 @@ export declare class ZegoBrowserCheck extends React.Component<ZegoBrowserCheckPr
     };
     videoRef: RefObject<HTMLVideoElement>;
     inviteRef: RefObject<HTMLInputElement>;
-    audioRefuse: boolean;
-    videoRefuse: boolean;
+    audioRefuse: boolean | undefined;
+    videoRefuse: boolean | undefined;
     constructor(props: ZegoBrowserCheckProp);
     componentDidMount(): Promise<void>;
     componentWillUnmount(): void;

package/view/pages/ZegoBrowserCheckMobile/index.d.ts

@@ -20,8 +20,8 @@ export declare class ZegoBrowserCheckMobile extends React.Component<ZegoBrowserC
     videoRef: RefObject<HTMLVideoElement>;
     inviteRef: RefObject<HTMLInputElement>;
     nameInputRef: RefObject<HTMLInputElement>;
-    audioRefuse: boolean;
-    videoRefuse: boolean;
+    audioRefuse: boolean | undefined;
+    videoRefuse: boolean | undefined;
     isAndroid: boolean;
     isIOS: boolean;
     clientHeight: number;

package/view/pages/ZegoCallInvitation/callInvitationControl.d.ts

@@ -0,0 +1,16 @@
+import { Root } from "react-dom/client";
+import { ZegoInvitationType, ZegoUser } from "../../../model";
+declare class CallInvitationControl {
+    isWaitingPageShow: boolean;
+    isDialogShow: boolean;
+    container: Element;
+    root: Root | undefined;
+    isPc: boolean;
+    constructor(container: Element);
+    callInvitationWaitingPageShow(invitee: ZegoUser, type: ZegoInvitationType, cancel: () => void): void;
+    callInvitationWaitingPageHide(): void;
+    callInvitationDialogShow(inviter: ZegoUser, refuse: Function, accept: Function): void;
+    callInvitationDialogHide(): void;
+}
+export declare const callInvitationControl: CallInvitationControl;
+export {};

package/view/pages/ZegoCallInvitation/callInvitationDialog.d.ts

@@ -0,0 +1,12 @@
+import React from "react";
+import { ZegoUser } from "zego-express-engine-webrtc/sdk/src/common/zego.entity";
+export declare class CallInvitationDialog extends React.Component<{
+    inviter: ZegoUser;
+    isPc: boolean;
+    refuse: Function;
+    accept: Function;
+}> {
+    audioRef: HTMLAudioElement | null;
+    componentWillUnmount(): void;
+    render(): React.ReactNode;
+}

package/view/pages/ZegoCallInvitation/callInvitationWaiting.d.ts

@@ -0,0 +1,14 @@
+import React from "react";
+import { ZegoUser } from "zego-express-engine-webrtc/sdk/src/common/zego.entity";
+import { ZegoInvitationType } from "../../../model";
+export declare class CallInvitationWaiting extends React.PureComponent<{
+    invitee: ZegoUser;
+    type: ZegoInvitationType;
+    isPc: boolean;
+    cancel: () => void;
+    outgoingCallUrl?: string;
+}> {
+    audioRef: HTMLAudioElement | null;
+    componentWillUnmount(): void;
+    render(): React.ReactNode;
+}

package/view/pages/ZegoRoom/index.d.ts

@@ -51,6 +51,7 @@ export declare class ZegoRoom extends React.PureComponent<ZegoBrowserCheckProp>
     fullScreen: boolean;
     showNotSupported: number;
     notSupportMultipleVideoNotice: number;
+    get showHeader(): boolean;
     get isCDNLive(): boolean;
     userUpdateCallBack: () => void;
     componentDidMount(): void;

package/view/pages/ZegoRoomMobile/index.d.ts

@@ -68,6 +68,7 @@ export declare class ZegoRoomMobile extends React.PureComponent<ZegoBrowserCheck
     }) => void;
     openMore(): void;
     leaveRoom(): void;
+    private confirmLeaveRoom;
     getAllUser(): ZegoCloudUserList;
     getAllMemberList(): ZegoCloudUserList;
     getShownUser(): ZegoCloudUserList;

package/view/pages/context/showManage.d.ts

@@ -1,6 +1,6 @@
 import React from "react";
 import { ZegoCloudUser } from "../../../modules/tools/UserListManager";
-export declare type ShowManageType = {
+export type ShowManageType = {
     show?: (user: ZegoCloudUser) => void;
     showPinButton: boolean;
     userInfo: {
@@ -15,6 +15,7 @@ export declare type ShowManageType = {
     whiteboard_isFontBold?: boolean;
     whiteboard_isFontItalic?: boolean;
     whiteboard_showAddImage?: boolean;
+    whiteboard_showCreateClose?: boolean;
 };
 declare const ShowManageContext: React.Context<ShowManageType>;
 export default ShowManageContext;