larksr_websdk 3.2.340 → 3.2.342

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

@@ -0,0 +1,101 @@
+import { EventBase, LocalEvent } from '../event/event_base';
+import { LarkSR } from '../larksr';
+import { MediaShareInterface, RTCMediaTrackBinding } from './media_share_interface';
+import { CloudLark } from '@/protobuf/cloudlark';
+export declare enum WEBRTC_MEDIA_SHARE_EVENT_TYPE {
+    RTC_SDP = 0,
+    RTC_ICECANDIDATE = 1,
+    ICE_STATE_CHANGE = 2,
+    ERROR = 3,
+    INFO = 4
+}
+export interface WebRTCMediaShareEvent extends LocalEvent<WEBRTC_MEDIA_SHARE_EVENT_TYPE> {
+    data?: any;
+}
+export interface WebRTCConfig {
+    serverIP: string;
+    preferPubOutIp: string;
+}
+export default class PeerConnectionMediaShare extends EventBase<WEBRTC_MEDIA_SHARE_EVENT_TYPE, WebRTCMediaShareEvent> implements MediaShareInterface {
+    get audioDeviceId(): string | undefined;
+    get audioTrack(): MediaStreamTrack | undefined;
+    get videoDeviceId(): string | undefined;
+    get videoTrack(): MediaStreamTrack | undefined;
+    get audioPaused(): boolean;
+    get videoPaused(): boolean;
+    private larksr;
+    private offerOptions;
+    private _pcConfig;
+    set pcConfig(config: CloudLark.IRTCConfiguration | null | undefined);
+    get pcConfig(): CloudLark.IRTCConfiguration | null | undefined;
+    private pc;
+    private audioBinding;
+    private videoBinding;
+    private sdpCreateSuccess;
+    private readonly sendStream;
+    private canvasRender;
+    constructor(larksr: LarkSR);
+    create(config?: CloudLark.IRTCConfiguration | null | undefined): Promise<void>;
+    createOffer(): void;
+    close(): void;
+    setAudioEnable(enable: boolean): void;
+    setVideoEnable(enable: boolean): void;
+    setShareEnable(enable: boolean): void;
+    stopLocalAudio(): void;
+    stopLocalVideo(): void;
+    stopLocalShare(): void;
+    pauseAudioSending(): false | undefined;
+    resumeAudioSending(): false | undefined;
+    pauseVideoSending(): false | undefined;
+    resumeVideoSending(): false | undefined;
+    closeAudio(): false | undefined;
+    closeVideo(): false | undefined;
+    closeShare(): false | undefined;
+    private stopLocalTrackBing;
+    openAudio(deviceId?: string): Promise<{
+        streams: MediaStream;
+        rtcRtpSenders: RTCMediaTrackBinding[];
+    }>;
+    openVideo(audio?: boolean, cameraId?: string, width?: number, height?: number, front?: boolean): Promise<{
+        streams: MediaStream;
+        rtcRtpSenders: RTCMediaTrackBinding[];
+    }>;
+    openDefaultMedia(video?: boolean, audio?: boolean): Promise<{
+        streams: MediaStream;
+        rtcRtpSenders: RTCMediaTrackBinding[];
+    }>;
+    openShareMediaDevice(): Promise<void>;
+    getConnectedAudioinputDevices(): Promise<MediaDeviceInfo[]>;
+    getConnectedAudioOutputDevices(): Promise<MediaDeviceInfo[]>;
+    getConnectedVideoinputDevices(): Promise<MediaDeviceInfo[]>;
+    getConnectedDevices(type: MediaDeviceKind): Promise<MediaDeviceInfo[]>;
+    openAudioDevice(deviceId: string, kind?: "audioinput" | "audiooutput"): Promise<{
+        streams: MediaStream;
+        rtcRtpSenders: RTCMediaTrackBinding[];
+    }>;
+    openCamera(cameraId: string, width?: number, height?: number, audio?: boolean, front?: boolean): Promise<{
+        streams: MediaStream;
+        rtcRtpSenders: RTCMediaTrackBinding[];
+    }>;
+    openUserMeida(constraints?: MediaStreamConstraints, reset?: boolean): Promise<{
+        streams: MediaStream;
+        rtcRtpSenders: RTCMediaTrackBinding[];
+    }>;
+    private resumeOrCreateBinding;
+    addMediaTrack(track: MediaStreamTrack, ...streams: MediaStream[]): boolean;
+    removeMediaTrack(track: RTCRtpSender): boolean;
+    requestUserMediaPermission(constraints?: MediaStreamConstraints): Promise<MediaStream>;
+    /**
+     * 接收到sdp
+     * @param des sdp
+     */
+    onRemoteDescription(des: RTCSessionDescriptionInit): void;
+    onReceiveCandidate(candateInit: RTCIceCandidateInit): void;
+    private addIceCandidate;
+    private onCreateOfferSuccess;
+    private onIceCandidate;
+    private onIceStateChange;
+    private iceStateChange;
+    private $emit;
+    private createEvent;
+}

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

@@ -0,0 +1,55 @@
+import { EventBase, LocalEvent } from '../event/event_base';
+export declare enum RECORDER_STATE {
+    READY = 0,
+    RECORDING = 1
+}
+export declare const RECODER_DEFAULT_CONFIG: {
+    sampleRate: number;
+    sampleBits: number;
+    bufferSize: number;
+};
+/**
+ * LarkSR 实例会发出的事件
+ */
+export declare enum RecodeEventType {
+    DATA = 0
+}
+/**
+ * LarkSR 发出的事件
+ */
+export interface RecodeEvent extends LocalEvent<RecodeEventType> {
+    voiceId: number;
+    sliceId: number;
+    data: Uint8Array;
+}
+export default class Recorder extends EventBase<RecodeEventType, RecodeEvent> {
+    get state(): RECORDER_STATE;
+    private _state;
+    private ctx;
+    private sampleRate;
+    private sampleBits;
+    private recorder;
+    private source;
+    private stream;
+    private buffer;
+    private bufferSize;
+    get voiceId(): number;
+    updateVoiceId(): number;
+    private _voiceId;
+    constructor({ bufferSize, sampleRate, sampleBits, }?: {
+        sampleRate: number;
+        sampleBits: number;
+        bufferSize: number;
+    });
+    start(): Promise<number>;
+    pause(): void;
+    clear(): void;
+    /**
+     * @deprecated
+     * @returns
+     */
+    private getRecord;
+    private merge;
+    private compress;
+    private encodeToPCM;
+}

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

@@ -0,0 +1,36 @@
+export default class SdpUtil {
+    private static vp8;
+    private static vp9;
+    private static h264;
+    private static av1x;
+    private static h265;
+    private static hevc;
+    private static svac;
+    private static tail;
+    private static config;
+    static isLoopIpAddress(ip: string): boolean;
+    static getRtpmapRegByMode(mode: 'VP8' | 'VP9' | 'H264' | 'AV1X' | 'H265' | 'HEVC' | 'SVAC'): RegExp;
+    static hasVp8(sdp: string): boolean;
+    static hasVp9(sdp: string): boolean;
+    static hasH264(sdp: string): boolean;
+    static hasAV1X(sdp: string): boolean;
+    static hasH265(sdp: string): boolean;
+    static hasHEVC(sdp: string): boolean;
+    static hasSVAC(sdp: string): boolean;
+    static hasMode(sdp: string, mode: 'VP8' | 'VP9' | 'H264' | 'AV1X' | 'H265' | 'HEVC' | 'SVAC'): boolean;
+    static setAudioBitrate(sdp: string, bitrate: number): string;
+    static setBitRate(sdp: string, startBitrate: number, maxBitrate: number, minBitrate: number): string;
+    static setModeBitRate(sdp: string, startBitrate: number, maxBitrate: number, minBitrate: number, mode: 'VP8' | 'VP9' | 'H264' | 'AV1X'): string;
+    static removeVp8(sdp: string): string;
+    static removeVp9(sdp: string): string;
+    static removeH264(sdp: string): string;
+    static removeAV1X(sdp: string): string;
+    static removeH265(sdp: string): string;
+    static removeHEVC(sdp: string): string;
+    static removeSVAC(sdp: string): string;
+    static sdpFilter(sdp: string, mode: 'VP8' | 'VP9' | 'H264' | 'AV1X' | 'H265' | 'HEVC' | 'SVAC'): string;
+    static sdpGooAttrLine(...attrs: string[]): string;
+    static sdpBlankAttrLine(...attrs: string[]): string;
+    static getBlankAttrs(sdpLine: string): string[];
+    static getAttrName(sdpLine: string): string;
+}

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

@@ -0,0 +1,54 @@
+import { EventBase, LocalEvent } from '../event/event_base';
+import { LarkSR } from '../larksr';
+export declare enum CHANNEL_EVENT_TYPE {
+    OPEN = 0,
+    CLOSE = 1,
+    ERROR = 2,
+    CLIENT_MSG = 3
+}
+export interface ChannelEvent extends LocalEvent<CHANNEL_EVENT_TYPE> {
+    data?: any;
+}
+export interface PixelStreamingWebscocketConfig {
+    serverAddress: string;
+    ip: string;
+    port: string;
+    path?: string;
+}
+export default class PixelStreamingWebsocketChannel extends EventBase<CHANNEL_EVENT_TYPE, ChannelEvent> {
+    private get wsServer();
+    private config;
+    private connection;
+    private keepAliveTimeout;
+    private larksr;
+    constructor(config: PixelStreamingWebscocketConfig, larksr: LarkSR);
+    /**
+     *
+     */
+    connect(): Promise<this>;
+    /**
+     *
+     */
+    close(): Promise<void>;
+    sendMsg(msg: any): void;
+    isOpen(): boolean;
+    private startKeepAlive;
+    private stopKeepAlive;
+    /**
+     *
+     */
+    private onMessage;
+    private onOpen;
+    /**
+     *
+     * @param e
+     */
+    private onWSError;
+    /**
+     *
+     * @param e
+     */
+    private onWSClose;
+    private $emit;
+    private createEvent;
+}

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

@@ -0,0 +1,57 @@
+import { EventBase, LocalEvent } from '../event/event_base';
+import * as Msg from '../protobuf/cloudlark';
+import { LarkSR } from '../larksr';
+export declare enum CHANNEL_EVENT_TYPE {
+    OPEN = 0,
+    CLOSE = 1,
+    ERROR = 2,
+    CLIENT_MSG = 3
+}
+export interface ChannelEvent extends LocalEvent<CHANNEL_EVENT_TYPE> {
+    data?: Msg.CloudLark.ToClientMessage;
+}
+export interface WebscocketConfig {
+    serverAddress: string;
+    ip: string;
+    port: string;
+    renderSSLServerPort?: string;
+    path?: string;
+}
+export default class WebsocketChannel extends EventBase<CHANNEL_EVENT_TYPE, ChannelEvent> {
+    private get wsServer();
+    private config;
+    private connection;
+    private keepAliveTimeout;
+    private larksr;
+    constructor(config: WebscocketConfig, larksr: LarkSR);
+    /**
+     *
+     */
+    connect(): Promise<this>;
+    /**
+     *
+     */
+    close(): Promise<void>;
+    sendMsg(msg: Msg.CloudLark.ToServerMessage): void;
+    sendBuffer(data: ArrayBuffer): void;
+    isOpen(): boolean;
+    private startKeepAlive;
+    private stopKeepAlive;
+    /**
+     *
+     */
+    private onMessage;
+    private onOpen;
+    /**
+     *
+     * @param e
+     */
+    private onWSError;
+    /**
+     *
+     * @param e
+     */
+    private onWSClose;
+    private $emit;
+    private createEvent;
+}

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

@@ -0,0 +1,56 @@
+import { EventBase, LocalEvent } from '../event/event_base';
+import * as Msg from '../protobuf/cloudlark';
+import { LarkSR } from '../larksr';
+export declare enum PROXY_EVENT_TYPE {
+    OPEN = 0,
+    CLOSE = 1,
+    ERROR = 2,
+    CLIENT_MSG = 3
+}
+export interface ProxyEvent extends LocalEvent<PROXY_EVENT_TYPE> {
+    data?: Msg.CloudLark.ToClientMessage;
+}
+export interface ProxyConfig {
+    serverAddress: string;
+    appServer: string;
+    appPort: string;
+}
+export declare const PROXY_PATH = "websocket";
+export default class WebsocketProxy extends EventBase<PROXY_EVENT_TYPE, ProxyEvent> {
+    private get wsServer();
+    private config;
+    private connection;
+    private keepAliveTimeout;
+    private larksr;
+    constructor(config: ProxyConfig, larksr: LarkSR);
+    /**
+     *
+     */
+    connect(): Promise<this>;
+    /**
+     *
+     */
+    close(): Promise<void>;
+    isOpen(): boolean;
+    sendMsg(msg: Msg.CloudLark.ToServerMessage): void;
+    sendBuffer(data: ArrayBuffer): void;
+    private startKeepAlive;
+    private stopKeepAlive;
+    /**
+     *
+     */
+    private onMessage;
+    private onOpen;
+    /**
+     *
+     * @param e
+     */
+    private onWSError;
+    /**
+     *
+     * @param e
+     */
+    private onWSClose;
+    private $emit;
+    private createEvent;
+}