larksr_websdk 3.2.402 → 3.2.404

package/dist/types/api.d.ts

@@ -132,6 +132,7 @@ export default class API {
     static GetTouchCtrMapping(server: string, appliId?: string): Promise<unknown>;
     static GetAppliList(server: string, params: any): Promise<unknown>;
     static RegionList(server: string, params: any): Promise<unknown>;
+    static heartbeat(server: string, taskId: string): Promise<unknown>;
     static joinParam(params: any): string;
 }
 export {};

package/dist/types/appli_params.d.ts

@@ -98,10 +98,11 @@ export interface IAppliParams {
     language: string;
     /**
      * 初始的鼠标锁定模式
-     * false：非锁定模式
-     * true：锁定模式
+     * 0：自动判断模式
+     * 1：锁定模式
+     * 2: 非锁定模式
      */
-    initCursorMode: boolean;
+    initCursorMode: number;
     /**
      * 背景颜色
      */
@@ -181,7 +182,7 @@ export interface IAppliParams {
     /**
      * 触摸操作对应的操作方式，触摸屏还是鼠标
      */
-    touchOperateMode: 'touchScreen' | 'mouse';
+    touchOperateMode: 'touchScreen' | 'mouse' | 'mix';
     /**
      * appid
      */
@@ -204,6 +205,7 @@ export interface IAppliParams {
     useSeparateMediaSharePeer: boolean;
     mobileKeyboardType: number;
     initResolutionType: number;
+    useWebcodec: boolean;
 }
 export declare enum AppliType {
     DESKTOP = 1,
@@ -240,7 +242,7 @@ export declare class AppliParams implements IAppliParams {
     frameRate: number;
     network: 'local' | 'public';
     language: string;
-    initCursorMode: boolean;
+    initCursorMode: number;
     bgColor: string;
     fullScreenMode: number;
     mobileFullScreenMode: number;
@@ -257,7 +259,7 @@ export declare class AppliParams implements IAppliParams {
     mouseZoomDirection: number;
     showPlayerList: boolean;
     preferDecoder: 'auto' | 'vp8' | 'vp9' | 'h264' | 'h265' | 'hevc' | 'av1' | 'av1x';
-    touchOperateMode: 'touchScreen' | 'mouse';
+    touchOperateMode: 'touchScreen' | 'mouse' | 'mix';
     appliId: string;
     syncLocalToCloudClipboard: boolean;
     enableRttIcon: boolean;
@@ -274,6 +276,7 @@ export declare class AppliParams implements IAppliParams {
     useSeparateMediaSharePeer: boolean;
     mobileKeyboardType: number;
     initResolutionType: number;
+    useWebcodec: boolean;
     static copyAndCreate(params?: IAppliParams): AppliParams;
     static setUpWithSDKConfig(params: IAppliParams, config: ILarkSRConfig): AppliParams;
 }

package/dist/types/config.d.ts

@@ -55,5 +55,4 @@ export default class Config {
      */
     static VirtualRackerScale: number;
     static ErrChromeAndroidVersion: string[];
-    static DownloadChromium: string;
 }

package/dist/types/lark/Worker.d.ts

@@ -0,0 +1,3 @@
+declare const ctx: Worker;
+declare var fading: boolean;
+declare var interval: any;

package/dist/types/lark/application.d.ts

@@ -6,6 +6,7 @@ import { LarkSR } from '../larksr';
 import PixelStreamingWebsocketChannel from './test_pixel_streaming';
 import { RECORDER_STATE } from './recoder';
 import PeerConnectionMediaShare from './peer_connection_media_share';
+import WebCodec from './webcodec';
 export declare enum APP_STATE {
     BEFORE_CREATE = 0,
     INITED = 1,
@@ -82,6 +83,8 @@ export default class Application extends EventBase<APP_EVENT_TYPE, AppEvent> {
     private recoder;
     private rtcConfig;
     get currentAppSize(): Msg.CloudLark.IAppResize | null | undefined;
+    get webcodecDecoder(): WebCodec;
+    private _webcodecDecoder;
     constructor(larksr: LarkSR);
     init(): void;
     initSharePc(): void;
@@ -118,18 +121,19 @@ export default class Application extends EventBase<APP_EVENT_TYPE, AppEvent> {
     private onRecoderData;
     start(): Promise<void>;
     connect(): Promise<PixelStreamingWebsocketChannel> | Promise<WebsocketProxy> | Promise<WebSocektChannel> | undefined;
+    sendKeepAlive(): void | undefined;
     disConnect(): void;
     closeRtc(): void;
     versionCheck(): void;
     task(): void;
-    startSteam(): void;
+    startSteam(): Promise<void>;
     startMonitorSteam(): void;
     restart(): void;
     restartApp(): void;
     rtcOffer(): Promise<void>;
     setAnswer(sdp: string): void;
     setIce(sdpMlineindex: number, sdpmid: string, candidate: string): void;
-    sendInput(input: Msg.CloudLark.ClientInput): void;
+    sendInput(input: Msg.CloudLark.ClientInput, needRemoteScreen?: boolean): void;
     sendInputBuffer(buffer: ArrayBuffer): void;
     private sendToWebsocektChannelBuffer;
     private sendToWebsocektChannelMsg;
@@ -157,6 +161,7 @@ export default class Application extends EventBase<APP_EVENT_TYPE, AppEvent> {
     retryPeerconnection(): void;
     private onAerialViewStatus;
     private onAerialViewScreen;
+    private onVideoFrame;
     private onShareMediaError;
     private onShareMediaInfo;
     private onShareMediaOffer;

package/dist/types/lark/custom.d.ts

@@ -0,0 +1,7 @@
+declare module "worker-loader!*" {
+  class WebpackWorker extends Worker {
+    constructor();
+  }
+
+  export = WebpackWorker;
+}

package/dist/types/lark/peer_connection.d.ts

@@ -36,7 +36,8 @@ export declare enum WEBRTC_EVENT_TYPE {
     RTMP_STREAM_ERROR = 23,
     INFO = 24,
     AerialViewStatus = 25,
-    AerialViewScreen = 26
+    AerialViewScreen = 26,
+    VideoFrame = 27
 }
 export interface GoogleBitRate {
     start: number;
@@ -177,7 +178,7 @@ export default class PeerConnection extends EventBase<WEBRTC_EVENT_TYPE, WebRTCE
     onReceiveCandidate(candateInit: RTCIceCandidateInit): void;
     startNetTest(): void;
     stopNetTest(): void;
-    sendInput(input: Input.CloudLark.ClientInput): void;
+    sendInput(input: Input.CloudLark.ClientInput, needRemoteScreen?: boolean): void;
     sendBuffer(buffer: ArrayBuffer): void;
     sendToAppTextMsg(msg: string): void;
     sendToAppBinaryMsg(binary: Uint8Array): void;

package/dist/types/lark/webcodec.d.ts

@@ -0,0 +1,40 @@
+import { LocalEvent } from "@/event/event_base";
+import { EventBase, LarkSR } from "@/larksr";
+import { CloudLark } from '@/protobuf/cloudlark';
+export declare enum WebCodecType {
+    WebCodecTypeH264 = "h264",
+    WebCodecTypeH265 = "h265",
+    WebCodecTypeNone = "none"
+}
+export declare enum WEB_CODEC_EVENT_TYPE {
+    PLAYED = 0
+}
+export interface WebCodecEvent extends LocalEvent<WEB_CODEC_EVENT_TYPE> {
+    data?: any;
+}
+export default class WebCodec extends EventBase<WEB_CODEC_EVENT_TYPE, WebCodecEvent> {
+    static AVC_High_PROFILE: string;
+    static HEVC_MAIN_PROFILE: string;
+    static checkSupport(codec: WebCodecType, width?: number, height?: number): Promise<boolean>;
+    static toWebCodecType(cloudType: CloudLark.StreamVideoFrame.Codec | null | undefined): WebCodecType;
+    static getProfileName(codec: WebCodecType): string;
+    private larksr;
+    private decoder;
+    private codec;
+    private width;
+    private height;
+    private canvas;
+    private context;
+    private frameData;
+    private dataOffset;
+    private firstFrame;
+    constructor(larksr: LarkSR);
+    setCanvas(canvas: HTMLCanvasElement, context: CanvasRenderingContext2D): void;
+    init(frame: CloudLark.IStreamVideoFrame): Promise<boolean | undefined>;
+    onStreamVideoFrame(frame: CloudLark.IStreamVideoFrame): Promise<void>;
+    private checkConfig;
+    private onFrameDecode;
+    private onFrameError;
+    private $emit;
+    private createAppEvent;
+}

package/dist/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/dist/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/dist/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;
     /**