larksr_websdk 3.2.401 → 3.2.403

package/types/lark/webcodecs.generated.d.ts

@@ -0,0 +1,417 @@
+/////////////////////////////
+/// webcodecs APIs
+/////////////////////////////
+
+interface AudioDataCopyToOptions {
+    format?: AudioSampleFormat | undefined;
+    frameCount?: number | undefined;
+    frameOffset?: number | undefined;
+    planeIndex: number;
+}
+
+interface AudioDataInit {
+    data: AllowSharedBufferSource;
+    format: AudioSampleFormat;
+    numberOfChannels: number;
+    numberOfFrames: number;
+    sampleRate: number;
+    timestamp: number;
+}
+
+interface AudioDecoderConfig {
+    codec: string;
+    description?: AllowSharedBufferSource | undefined;
+    numberOfChannels: number;
+    sampleRate: number;
+}
+
+interface AudioDecoderInit {
+    error: WebCodecsErrorCallback;
+    output: AudioDataOutputCallback;
+}
+
+interface AudioDecoderSupport {
+    config: AudioDecoderConfig;
+    supported: boolean;
+}
+
+interface AudioEncoderConfig {
+    bitrate?: number | undefined;
+    codec: string;
+    numberOfChannels: number;
+    sampleRate: number;
+}
+
+interface AudioEncoderInit {
+    error: WebCodecsErrorCallback;
+    output: EncodedAudioChunkOutputCallback;
+}
+
+interface AudioEncoderSupport {
+    config: AudioEncoderConfig;
+    supported: boolean;
+}
+
+interface AvcEncoderConfig {
+    format?: AvcBitstreamFormat | undefined;
+}
+
+interface EncodedAudioChunkInit {
+    data: AllowSharedBufferSource;
+    duration?: number | undefined;
+    timestamp: number;
+    type: EncodedAudioChunkType;
+}
+
+interface EncodedAudioChunkMetadata {
+    decoderConfig?: AudioDecoderConfig | undefined;
+}
+
+interface EncodedVideoChunkInit {
+    data: AllowSharedBufferSource;
+    duration?: number | undefined;
+    timestamp: number;
+    type: EncodedVideoChunkType;
+}
+
+interface EncodedVideoChunkMetadata {
+    decoderConfig?: VideoDecoderConfig | undefined;
+    temporalLayerId?: number | undefined;
+}
+
+interface ImageDecodeOptions {
+    completeFramesOnly?: boolean | undefined;
+    frameIndex?: number | undefined;
+}
+
+interface ImageDecodeResult {
+    complete: boolean;
+    image: VideoFrame;
+}
+
+interface ImageDecoderInit {
+    colorSpaceConversion?: ColorSpaceConversion | undefined;
+    data: ImageBufferSource;
+    desiredHeight?: number | undefined;
+    desiredWidth?: number | undefined;
+    preferAnimation?: boolean | undefined;
+    premultiplyAlpha?: PremultiplyAlpha | undefined;
+    type: string;
+}
+
+interface PlaneLayout {
+    offset: number;
+    stride: number;
+}
+
+interface VideoColorSpaceInit {
+    fullRange?: boolean | null | undefined;
+    matrix?: VideoMatrixCoefficients | null | undefined;
+    primaries?: VideoColorPrimaries | null | undefined;
+    transfer?: VideoTransferCharacteristics | null | undefined;
+}
+
+interface VideoDecoderConfig {
+    codec: string;
+    codedHeight?: number | undefined;
+    codedWidth?: number | undefined;
+    colorSpace?: VideoColorSpaceInit | undefined;
+    description?: AllowSharedBufferSource | undefined;
+    displayAspectHeight?: number | undefined;
+    displayAspectWidth?: number | undefined;
+    hardwareAcceleration?: HardwarePreference | undefined;
+    optimizeForLatency?: boolean | undefined;
+}
+
+interface VideoDecoderInit {
+    error: WebCodecsErrorCallback;
+    output: VideoFrameOutputCallback;
+}
+
+interface VideoDecoderSupport {
+    config?: VideoDecoderConfig;
+    supported?: boolean;
+}
+
+interface VideoEncoderConfig {
+    alpha?: AlphaOption | undefined;
+    avc?: AvcEncoderConfig | undefined;
+    bitrate?: number | undefined;
+    bitrateMode?: VideoEncoderBitrateMode | undefined;
+    codec: string;
+    displayHeight?: number | undefined;
+    displayWidth?: number | undefined;
+    framerate?: number | undefined;
+    hardwareAcceleration?: HardwarePreference | undefined;
+    height: number;
+    latencyMode?: LatencyMode | undefined;
+    scalabilityMode?: string | undefined;
+    width: number;
+}
+
+interface VideoEncoderEncodeOptions {
+    keyFrame?: boolean;
+}
+
+interface VideoEncoderInit {
+    error: WebCodecsErrorCallback;
+    output: EncodedVideoChunkOutputCallback;
+}
+
+interface VideoEncoderSupport {
+    config?: VideoEncoderConfig;
+    supported?: boolean;
+}
+
+interface VideoFrameBufferInit {
+    codedHeight: number;
+    codedWidth: number;
+    colorSpace?: VideoColorSpaceInit | undefined;
+    displayHeight?: number | undefined;
+    displayWidth?: number | undefined;
+    duration?: number | undefined;
+    format: VideoPixelFormat;
+    layout?: PlaneLayout[] | undefined;
+    timestamp: number;
+    visibleRect?: DOMRectInit | undefined;
+}
+
+interface VideoFrameCopyToOptions {
+    layout?: PlaneLayout[] | undefined;
+    rect?: DOMRectInit | undefined;
+}
+
+interface VideoFrameInit {
+    alpha?: AlphaOption | undefined;
+    displayHeight?: number | undefined;
+    displayWidth?: number | undefined;
+    duration?: number | undefined;
+    timestamp?: number | undefined;
+    visibleRect?: DOMRectInit | undefined;
+}
+
+interface AudioData {
+    readonly duration: number;
+    readonly format: AudioSampleFormat;
+    readonly numberOfChannels: number;
+    readonly numberOfFrames: number;
+    readonly sampleRate: number;
+    readonly timestamp: number;
+    allocationSize(options: AudioDataCopyToOptions): number;
+    clone(): AudioData;
+    close(): void;
+    copyTo(destination: AllowSharedBufferSource, options: AudioDataCopyToOptions): void;
+}
+
+declare var AudioData: {
+    prototype: AudioData;
+    new(init: AudioDataInit): AudioData;
+};
+
+/** Available only in secure contexts. */
+interface AudioDecoder {
+    readonly decodeQueueSize: number;
+    readonly state: CodecState;
+    close(): void;
+    configure(config: AudioDecoderConfig): void;
+    decode(chunk: EncodedAudioChunk): void;
+    flush(): Promise<void>;
+    reset(): void;
+}
+
+declare var AudioDecoder: {
+    prototype: AudioDecoder;
+    new(init: AudioDecoderInit): AudioDecoder;
+    isConfigSupported(config: AudioDecoderConfig): Promise<AudioDecoderSupport>;
+};
+
+/** Available only in secure contexts. */
+interface AudioEncoder {
+    readonly encodeQueueSize: number;
+    readonly state: CodecState;
+    close(): void;
+    configure(config: AudioEncoderConfig): void;
+    encode(data: AudioData): void;
+    flush(): Promise<void>;
+    reset(): void;
+}
+
+declare var AudioEncoder: {
+    prototype: AudioEncoder;
+    new(init: AudioEncoderInit): AudioEncoder;
+    isConfigSupported(config: AudioEncoderConfig): Promise<AudioEncoderSupport>;
+};
+
+interface EncodedAudioChunk {
+    readonly byteLength: number;
+    readonly duration: number | null;
+    readonly timestamp: number;
+    readonly type: EncodedAudioChunkType;
+    copyTo(destination: AllowSharedBufferSource): void;
+}
+
+declare var EncodedAudioChunk: {
+    prototype: EncodedAudioChunk;
+    new(init: EncodedAudioChunkInit): EncodedAudioChunk;
+};
+
+interface EncodedVideoChunk {
+    readonly byteLength: number;
+    readonly duration: number | null;
+    readonly timestamp: number;
+    readonly type: EncodedVideoChunkType;
+    copyTo(destination: AllowSharedBufferSource): void;
+}
+
+declare var EncodedVideoChunk: {
+    prototype: EncodedVideoChunk;
+    new(init: EncodedVideoChunkInit): EncodedVideoChunk;
+};
+
+/** Available only in secure contexts. */
+interface ImageDecoder {
+    readonly complete: boolean;
+    readonly completed: Promise<void>;
+    readonly tracks: ImageTrackList;
+    readonly type: string;
+    close(): void;
+    decode(options?: ImageDecodeOptions): Promise<ImageDecodeResult>;
+    reset(): void;
+}
+
+declare var ImageDecoder: {
+    prototype: ImageDecoder;
+    new(init: ImageDecoderInit): ImageDecoder;
+    isTypeSupported(type: string): Promise<boolean>;
+};
+
+interface ImageTrack {
+    readonly animated: boolean;
+    readonly frameCount: number;
+    readonly repetitionCount: number;
+    selected: boolean;
+}
+
+declare var ImageTrack: {
+    prototype: ImageTrack;
+    new(): ImageTrack;
+};
+
+interface ImageTrackList {
+    readonly length: number;
+    readonly ready: Promise<void>;
+    readonly selectedIndex: number;
+    readonly selectedTrack: ImageTrack | null;
+    [index: number]: ImageTrack;
+}
+
+declare var ImageTrackList: {
+    prototype: ImageTrackList;
+    new(): ImageTrackList;
+};
+
+interface VideoColorSpace {
+    readonly fullRange: boolean | null;
+    readonly matrix: VideoMatrixCoefficients | null;
+    readonly primaries: VideoColorPrimaries | null;
+    readonly transfer: VideoTransferCharacteristics | null;
+    toJSON(): VideoColorSpaceInit;
+}
+
+declare var VideoColorSpace: {
+    prototype: VideoColorSpace;
+    new(init?: VideoColorSpaceInit): VideoColorSpace;
+};
+
+/** Available only in secure contexts. */
+interface VideoDecoder {
+    readonly decodeQueueSize: number;
+    readonly state: CodecState;
+    close(): void;
+    configure(config: VideoDecoderConfig): void;
+    decode(chunk: EncodedVideoChunk): void;
+    flush(): Promise<void>;
+    reset(): void;
+}
+
+declare var VideoDecoder: {
+    prototype: VideoDecoder;
+    new(init: VideoDecoderInit): VideoDecoder;
+    isConfigSupported(config: VideoDecoderConfig): Promise<VideoDecoderSupport>;
+};
+
+/** Available only in secure contexts. */
+interface VideoEncoder {
+    readonly encodeQueueSize: number;
+    readonly state: CodecState;
+    close(): void;
+    configure(config: VideoEncoderConfig): void;
+    encode(frame: VideoFrame, options?: VideoEncoderEncodeOptions): void;
+    flush(): Promise<void>;
+    reset(): void;
+}
+
+declare var VideoEncoder: {
+    prototype: VideoEncoder;
+    new(init: VideoEncoderInit): VideoEncoder;
+    isConfigSupported(config: VideoEncoderConfig): Promise<VideoEncoderSupport>;
+};
+
+interface VideoFrame {
+    readonly codedHeight: number;
+    readonly codedRect: DOMRectReadOnly | null;
+    readonly codedWidth: number;
+    readonly colorSpace: VideoColorSpace;
+    readonly displayHeight: number;
+    readonly displayWidth: number;
+    readonly duration: number | null;
+    readonly format: VideoPixelFormat | null;
+    readonly timestamp: number;
+    readonly visibleRect: DOMRectReadOnly | null;
+    allocationSize(options?: VideoFrameCopyToOptions): number;
+    clone(): VideoFrame;
+    close(): void;
+    copyTo(destination: AllowSharedBufferSource, options?: VideoFrameCopyToOptions): Promise<PlaneLayout[]>;
+}
+
+declare var VideoFrame: {
+    prototype: VideoFrame;
+    new(source: CanvasImageSource, init?: VideoFrameInit): VideoFrame;
+    new(data: AllowSharedBufferSource, init: VideoFrameBufferInit): VideoFrame;
+};
+
+interface AudioDataOutputCallback {
+    (output: AudioData): void;
+}
+
+interface EncodedAudioChunkOutputCallback {
+    (output: EncodedAudioChunk, metadata: EncodedAudioChunkMetadata): void;
+}
+
+interface EncodedVideoChunkOutputCallback {
+    (chunk: EncodedVideoChunk, metadata: EncodedVideoChunkMetadata): void;
+}
+
+interface VideoFrameOutputCallback {
+    (output: VideoFrame): void;
+}
+
+interface WebCodecsErrorCallback {
+    (error: DOMException): void;
+}
+
+// type AllowSharedBufferSource = ArrayBuffer | ArrayBufferView;
+// type BitrateMode = "constant" | "variable";
+type ImageBufferSource = ArrayBuffer | ArrayBufferView | ReadableStream;
+// type AlphaOption = "discard" | "keep";
+type AudioSampleFormat = "f32" | "f32-planar" | "s16" | "s16-planar" | "s32" | "s32-planar" | "u8" | "u8-planar";
+// type AvcBitstreamFormat = "annexb" | "avc";
+// type CodecState = "closed" | "configured" | "unconfigured";
+type EncodedAudioChunkType = "delta" | "key";
+// type EncodedVideoChunkType = "delta" | "key";
+type HardwarePreference = "no-preference" | "prefer-hardware" | "prefer-software";
+// type LatencyMode = "quality" | "realtime";
+// type VideoColorPrimaries = "bt470bg" | "bt709" | "smpte170m";
+// type VideoMatrixCoefficients = "bt470bg" | "bt709" | "rgb" | "smpte170m";
+// type VideoPixelFormat = "BGRA" | "BGRX" | "I420" | "I420A" | "I422" | "I444" | "NV12" | "RGBA" | "RGBX";
+// type VideoTransferCharacteristics = "bt709" | "iec61966-2-1" | "smpte170m";

package/types/lark/websocket_channel.d.ts

@@ -34,6 +34,7 @@ export default class WebsocketChannel extends EventBase<CHANNEL_EVENT_TYPE, Chan
     close(): Promise<void>;
     sendMsg(msg: Msg.CloudLark.ToServerMessage): void;
     sendBuffer(data: ArrayBuffer): void;
+    sendKeepAlive(): void;
     isOpen(): boolean;
     private startKeepAlive;
     private stopKeepAlive;

package/types/lark/websocket_proxy.d.ts

@@ -21,6 +21,7 @@ export default class WebsocketProxy extends EventBase<PROXY_EVENT_TYPE, ProxyEve
     private config;
     private connection;
     private keepAliveTimeout;
+    private timerWorker;
     private larksr;
     constructor(config: ProxyConfig, larksr: LarkSR);
     /**
@@ -34,6 +35,7 @@ export default class WebsocketProxy extends EventBase<PROXY_EVENT_TYPE, ProxyEve
     isOpen(): boolean;
     sendMsg(msg: Msg.CloudLark.ToServerMessage): void;
     sendBuffer(data: ArrayBuffer): void;
+    sendKeepAlive(): void;
     private startKeepAlive;
     private stopKeepAlive;
     /**

package/types/larksr.d.ts

@@ -241,7 +241,12 @@ declare enum LarkSRClientEvent {
      * 服务端 3.2.7.0 添加
      * rtmp 直播推流出错
      */
-    RTMP_STREAM_ERROR = "rtmpstreamerror"
+    RTMP_STREAM_ERROR = "rtmpstreamerror",
+    /**
+     * 服务端 3.2.2.x 添加
+     * 鸟瞰模式背景缩略图
+     */
+    AERIAL_VIEW_SCREEN = "aerialviewscreen"
 }
 /**
  * LarkSR 发出的事件
@@ -380,10 +385,10 @@ interface ILarkSRConfig {
     mobileForceLandscape?: boolean;
     /**
      * 可选项
-     * 初始化鼠标模式, true 锁定，false 非锁定
+     * 初始化鼠标模式, 0 自动判断 1 锁定 2 非锁定
      * 对应后台应用管理->应用编辑->通用高级设置->初始化鼠标模式,该配置优先级高于后台配置
      */
-    initCursorMode?: boolean;
+    initCursorMode?: number;
     /**
      * 可选项
      * 渲染服务器外网端口映射
@@ -430,10 +435,11 @@ interface ILarkSRConfig {
     /**
      * 可选项
      * 触摸指令，移动端的触摸指令对应为云端的触屏还是鼠标
-     * 'touchScreen' | 'mouse'
+     * 'touchScreen' | 'mouse' | 'mix'
+     * mix 客户端触摸指令同时对应为触摸和鼠标指令发送给云端
      * 触摸指令模式，对应后台应用管理->应用编辑->移动端高级设置->触摸指令模式 优先级高于后台配置
      */
-    touchOperateMode?: 'touchScreen' | 'mouse';
+    touchOperateMode?: 'touchScreen' | 'mouse' | 'mix';
     /**
      * 可选项
      * 优先使用渲染服务器点对点连接外网ip
@@ -457,8 +463,8 @@ interface ILarkSRConfig {
     showPlayButton?: boolean;
     /**
      * 可选项
-     * 语言设置,目前只支持种英文两种,默认中文
-     * zh-CN 中文 en 英文
+     * 语言设置,目前支持中文简体、中文繁体、英文三种,默认中文简体
+     * zh-CN 中文简体 zh-TW 中文繁体 en 英文
      */
     language?: string;
     /**
@@ -475,11 +481,25 @@ interface ILarkSRConfig {
      * 是否启用 canvas 渲染. 默认关闭
      */
     enableCanvasRender?: boolean;
+    /**
+     * 强制使用canvs2d模式，默认优先使用 webgl
+     */
+    forceCanvas2d?: boolean;
     /**
      * 可选项
      * loading页载入Logo版本
      */
     loadingLogoVersion?: string;
+    /**
+     * 初始化分辨率方式
+     * 1:适应客户端窗口】和【0:应用默认分辨率】,默认值：0
+     * 此处配置优先级大于管理后台配置
+     */
+    initResolutionType?: number;
+    /**
+     * 是否使用 webcodec
+     */
+    useWebcodec?: boolean;
 }
 declare class LarkSR extends EventBase<LarkSRClientEvent, LarkSREvent> {
     /**
@@ -517,6 +537,7 @@ declare class LarkSR extends EventBase<LarkSRClientEvent, LarkSREvent> {
     get remoteScreenReady(): boolean;
     set remoteScreenReady(ready: boolean);
     private _remoteScreenReady;
+    onFirstAppsize(width: number, height: number): void;
     /**
      * 当前的屏幕状态
      * @see ScreenState
@@ -628,10 +649,12 @@ declare class LarkSR extends EventBase<LarkSRClientEvent, LarkSREvent> {
     isTaskOwner(): boolean;
     _isTaskOwner: boolean;
     /**
-     * true：锁定模式 false：非锁定模式
+     * 0: 自动判断
+     * 1：锁定模式
+     * 2: 非锁定模式
      */
-    set initCursorMode(mode: boolean);
-    get initCursorMode(): boolean;
+    set initCursorMode(mode: number);
+    get initCursorMode(): number;
     /**
      * 当前打开的音频设备 ID，如果打开时没指定为空
      */
@@ -673,6 +696,50 @@ declare class LarkSR extends EventBase<LarkSRClientEvent, LarkSREvent> {
      * @param bitrateKbps
      */
     setVideoBitrateKbps(bitrateKbps: number): void;
+    /**
+     * 动态设置帧率
+     */
+    setVideoFps(fps: number): void;
+    /**
+     * 动态设置云端 debug 窗口
+     */
+    setCloudDebugLayout(open: boolean): void;
+    /**
+     * 重启云端应用
+     */
+    restartCloudApp(): void;
+    /**
+     * 设置云端应用大小
+     */
+    setCloudAppSize(width: number, height: number): void;
+    /**
+     * 当前云端应用窗口大小
+     */
+    get currentAppSize(): CloudLark.IAppResize | null | undefined;
+    /**
+     * 开始鸟瞰模式
+     */
+    startAerialview(viewbox: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }, interval: number | undefined, thumbnailWidth: 120, thumbnailHeight: 120): void;
+    /**
+     * 更新鸟瞰模式区域
+     */
+    updateAerialview(viewbox: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }): void;
+    /**
+     * 停止鸟瞰模式区域
+     */
+    stopAerialview(): void;
+    get syncClientViewport(): boolean;
+    set syncClientViewport(sync: boolean);
     /**
      * LarkSR 客户端。所有操作和事件通过该类传递
      * @param config 本地配置，优先级最高
@@ -700,7 +767,7 @@ declare class LarkSR extends EventBase<LarkSRClientEvent, LarkSREvent> {
         appliId: string;
         playerMode?: number;
         userType?: number;
-        roomCode?: string;
+        authCode?: string;
         taskId?: string;
         regionId?: string;
         groupId?: string;
@@ -738,7 +805,7 @@ declare class LarkSR extends EventBase<LarkSRClientEvent, LarkSREvent> {
         appliId: string;
         playerMode?: number;
         userType?: number;
-        roomCode?: string;
+        authCode?: string;
         taskId?: string;
         clientMac?: string;
         groupId?: string;
@@ -763,6 +830,10 @@ declare class LarkSR extends EventBase<LarkSRClientEvent, LarkSREvent> {
      * @returns 是否成功。主要校验授权码是否成功
      */
     start(): Promise<void>;
+    /**
+     * 主动调用发送心跳包
+     */
+    sendKeepAlive(): void;
     /**
      * 重新开始云渲染流程
      */
@@ -1238,6 +1309,7 @@ declare class LarkSR extends EventBase<LarkSRClientEvent, LarkSREvent> {
     private onRTCRetrySuccess;
     private onGotRemoteStream;
     private onGotRemoteAudioStream;
+    private onMediaPlayed;
     private onCursorStyle;
     private onAppResize;
     private onAppMouseMode;
@@ -1249,5 +1321,6 @@ declare class LarkSR extends EventBase<LarkSRClientEvent, LarkSREvent> {
     private onDataChannelClose;
     private onOperationTimeout;
     private onOperationInput;
+    private setCanvasMode;
 }
 export { LarkSR, ILarkSRConfig, PlayerModeType, UserType, LarkSREvent, LarkEventType, LarkSRClientEvent, AppliParams, AppliParamsUtils, LoadAppliParamsFromUrl, LoadAppliParamsStartAppInfo, EventBase, API, Operation, Capabilities, ScaleMode, VirtualKey, KEYMAP, CloudLark, FullScreen, LockPointer, Recorder, GESTURE_TYPE, };

package/types/localization/language.d.ts

@@ -1,6 +1,7 @@
 export declare enum SupportLanguage {
     CN = 0,
-    EN = 1
+    EN = 1,
+    TW = 2
 }
 export declare function isChinese(codeString: string): boolean;
 export declare function getSupportLanguageFromCodeStr(codeString: string): SupportLanguage;

package/types/operation/operation.d.ts

@@ -61,6 +61,11 @@ export default class Operation extends EventBase<OPREATION_EVENT_TYPE, Operation
     get lockPointer(): import("../larksr").LockPointer;
     get mouseZoomDirection(): number;
     set mouseZoomDirection(direction: number);
+    set aerialviewStatus(status: CloudLark.IAerialViewStatus | null);
+    get aerialviewStatus(): CloudLark.IAerialViewStatus | null;
+    _aerialviewStatus: CloudLark.IAerialViewStatus | null;
+    get aerialViewEnable(): boolean;
+    get aerialViewBox(): CloudLark.IAerialViewBox;
     constructor(rootElement: HTMLElement, larksr: LarkSR);
     setMouseEnable(enable: boolean): void;
     setKeyboardEnable(enable: boolean): void;