hy-rtc-core-v3 3.0.1 → 3.0.2

package/dist/Client.d.ts

@@ -0,0 +1,32 @@
+import { MediaKind, RtpParameters } from "./proto/proto-ts/data_structures/rtp_parameters";
+import { ConsumerCreatedRequest, Speaker } from "./proto/proto-ts/data_structures/messages";
+import { Consumer } from "mediasoup-client/lib/Consumer";
+import { Transport } from "mediasoup-client/lib/Transport";
+interface ConsumerInfo {
+    producerId: string;
+    kind: MediaKind;
+    producerPaused: boolean;
+    speaker?: Speaker;
+    consumer?: Consumer;
+    rtpParameters?: RtpParameters;
+    mediaStream?: MediaStream;
+    mediaElement?: HTMLAudioElement | HTMLVideoElement;
+}
+declare class Client {
+    clientId: string | undefined;
+    rtpParameters: RtpParameters | undefined;
+    consumerList: Map<string, ConsumerInfo>;
+    constructor(consumerCreatedRequest: ConsumerCreatedRequest);
+    pushConsumerList(consumerInfo: ConsumerInfo): false | undefined;
+    genConsumer(consumerCreatedRequest: ConsumerCreatedRequest | undefined, consumerTransport: Transport | undefined): Promise<{
+        consumer: undefined;
+        producerId: string;
+    } | undefined>;
+    updateConsumerForConsumer(producerId: string, consumer: Consumer | undefined): void;
+    updateConsumerForStream(producerId: string, mediaStream: MediaStream): void;
+    updateConsumerForElement(producerId: string, mediaElement: HTMLAudioElement | HTMLVideoElement): void;
+    mediaStreamAddTrack(consumer: Consumer, mediaElement: HTMLAudioElement | HTMLVideoElement): void;
+    genAudioElement(producerId: string): HTMLAudioElement;
+    genVideoElement(producerId: string): HTMLVideoElement;
+}
+export { Client };

package/dist/EventEmitter.d.ts

@@ -0,0 +1,9 @@
+type Callback<T = any> = (args: T) => void;
+export declare class EventEmitter<Events extends Record<keyof any, any>> {
+    private map;
+    on<Name extends keyof Events>(name: Name, cb: Callback<Events[Name]>): void;
+    emit<Name extends keyof Events>(name: Name, args: Events[Name]): void;
+    off<Name extends keyof Events>(name?: Name, cb?: Callback<Events[Name]>): void;
+    once<Name extends keyof Events>(name: Name, cb: Callback<Events[Name]>): void;
+}
+export {};

package/dist/HyRtcCore.d.ts

@@ -0,0 +1,19 @@
+import { HyRtcCoreOptions, joinMonitorArgs, joinRoomArgs } from './interface/HyRtcCore';
+import { Message } from "./Message";
+import { EventEmitter } from './EventEmitter';
+import { Room } from "./Room";
+import { RoomManager } from "./RoomManager";
+export declare class HyRtcCore extends EventEmitter<any> {
+    HyRtcCoreOptions: HyRtcCoreOptions | undefined;
+    Message: Message | undefined;
+    RoomManager: RoomManager | undefined;
+    private readonly eventEmit;
+    constructor();
+    registerMessageEvents(): void;
+    init(HyRtcCoreOptions: HyRtcCoreOptions): Promise<unknown>;
+    NewMessage(): Message;
+    NewRoomManager(): void;
+    joinChannel(params: joinRoomArgs): Promise<Room | Error>;
+    joinMonitor(params: joinMonitorArgs): Promise<Room | Error>;
+    getAllRooms(): Map<string, Room> | undefined;
+}

package/dist/Message.d.ts

@@ -0,0 +1,43 @@
+import { authInfo, callbackFunction, HyRtcCoreOptions, joinMonitorArgs, joinRoomArgs, MessageOptions, replyParams, sendParams } from "./interface/HyRtcCore";
+import mqtt from "mqtt";
+import { IClientPublishOptions } from "mqtt/src/lib/client";
+import { Room } from "./Room";
+import { EventEmitter } from "./EventEmitter";
+declare class Message {
+    private readonly eventEmit;
+    mqttClient: mqtt.MqttClient | undefined;
+    authInfo: authInfo | undefined;
+    connectUrl: HyRtcCoreOptions['connectUrl'] | undefined;
+    constructor({ eventEmit }: {
+        eventEmit: EventEmitter<any>;
+    });
+    registerMessageEvents(): void;
+    connect({ authInfo }: MessageOptions, connectUrl: HyRtcCoreOptions['connectUrl']): Promise<unknown>;
+    handlerOnMessage: (topic: string, message: Uint8Array, packet: mqtt.IPublishPacket) => void;
+    subscribeMediaTopic(): void;
+    subscribeMediaAppTopic(): void;
+    subscribe(topic: string): void;
+    handlerMessageByte(messageType: string, msg: any): Uint8Array | "";
+    joinRoom(args: joinRoomArgs): Promise<Room>;
+    joinMonitor(args: joinMonitorArgs): Promise<Room>;
+    send(paramsOptions: sendParams): void;
+    /**
+     * 统一回复服务端的方法
+     * */
+    reply(paramsOptions: replyParams): void;
+    getClientId(): string | undefined;
+    getMqttClient(): mqtt.MqttClient | undefined;
+    nextCorrelationData(): {
+        correlationData: Uint8Array;
+        index: number;
+    };
+    correlationDataMapAdd(params: {
+        index: number;
+        topic: string;
+        payload: Uint8Array;
+        opts: IClientPublishOptions;
+        callback: callbackFunction | undefined;
+        responseMessageType: string;
+    }): void;
+}
+export { Message };

package/dist/Room.d.ts

@@ -0,0 +1,75 @@
+/// <reference types="node" />
+import { Message } from "./Message";
+import { TransportOptions } from "./interface/HyRtcCore";
+import { RtpCapabilitiesFinalized } from "./proto/proto-ts/data_structures/rtp_parameters";
+import { Device } from "mediasoup-client";
+import { EventEmitter } from "./EventEmitter";
+import { Transport } from "mediasoup-client/lib/Transport";
+import { ConsumerCreatedRequest } from "./proto/proto-ts/data_structures/messages";
+import { Client } from "./Client";
+import { RoomType } from "./enum/emum";
+import { Producer } from "mediasoup-client/lib/Producer";
+declare class Room {
+    private readonly eventEmit;
+    roomType: RoomType | undefined;
+    roomId: string | undefined;
+    clientId: string | undefined;
+    token: string | undefined;
+    message: Message | undefined;
+    consumerTransportOptions: TransportOptions | undefined;
+    producerTransportOptions: TransportOptions | undefined;
+    routerRtpCapabilities: RtpCapabilitiesFinalized | undefined;
+    rtpCapabilities: RtpCapabilitiesFinalized | undefined;
+    consumerTransport: Transport | undefined;
+    producerTransport: Transport | undefined;
+    audioProducerId: string;
+    videoProducerId: string;
+    clientList: Map<string, Client>;
+    device: Device | undefined;
+    keepaliveInterval: NodeJS.Timeout | undefined;
+    produceTag: string;
+    producerMap: Map<string, Producer>;
+    monitorDeviceId: string | undefined;
+    playElementBox: string | undefined;
+    constructor({ eventEmit }: {
+        eventEmit: EventEmitter<any>;
+    });
+    initRoom(): Promise<this>;
+    registerMessageEvents(): void;
+    setRoomId(roomId: string | undefined): this;
+    setClientId(clientId: string | undefined): this;
+    setPlayElementBox(playElementBox: string | undefined): this;
+    setToken(token: string | undefined): this;
+    setProduceTag(produceTag: string): this;
+    setRoomType(roomType: RoomType): this;
+    setMonitorDeviceId(monitorDeviceId: string | undefined): this;
+    publishChannel(): void;
+    publishMonitor(): Promise<unknown>;
+    joinMediaRoom(): void;
+    handlerRoomTransport(): Promise<void>;
+    keepalive(): void;
+    startConsuming(): Promise<void>;
+    createDevice(): Promise<void>;
+    createConsumerTransport(): Promise<void>;
+    createProducerTransport(): Promise<void>;
+    handlerProduce(trackList: MediaStreamTrack[]): Promise<void>;
+    getLocalAudioMedia(): Promise<MediaStream>;
+    getAudioMediaTrack(mediaStream: MediaStream): MediaStreamTrack[];
+    producerResume(): void;
+    producerPause(): void;
+    createNewClient(consumerCreatedRequest: ConsumerCreatedRequest): Promise<void>;
+    playMonitorElement(): void;
+    cleanMonitorElement(): void;
+    passiveLeaved(): void;
+    addClient(client: Client): void;
+    removeClient(clientId: string): void;
+    removeAllClient(): void;
+    getClient(clientId: string): Client | undefined;
+    getRoomId(): string | undefined;
+    leaveRoom(): void;
+    deleteRoom(): void;
+    clearKeepAlive(): void;
+    producerClose(): void;
+    destroyRoom(): void;
+}
+export { Room };

package/dist/RoomManager.d.ts

@@ -0,0 +1,18 @@
+import { EventEmitter } from "./EventEmitter";
+import { Room } from "./Room";
+declare class RoomManager extends EventEmitter<any> {
+    private readonly eventEmit;
+    roomList: Map<string, Room>;
+    constructor({ eventEmit }: {
+        eventEmit: EventEmitter<any>;
+    });
+    registerRoomEvents(): void;
+    addRoom(args: any): false | undefined;
+    deleteRoom(args: any): false | undefined;
+    getRoom({ roomId, callback }: {
+        roomId: string;
+        callback: any;
+    }): void;
+    getAllRooms(): Map<string, Room>;
+}
+export { RoomManager };

package/dist/enum/emum.d.ts

@@ -0,0 +1,5 @@
+export declare enum RoomType {
+    Channel = 0,// 群组房间
+    Monitor = 1,// 监控房间
+    BeMonitor = 2
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+import { HyRtcCore } from './HyRtcCore';
+export { HyRtcCore };

package/dist/interface/HyRtcCore.d.ts

@@ -0,0 +1,105 @@
+export interface HyRtcCoreOptions {
+    autoConnect: boolean;
+    connectUrl: string;
+    authInfo: authInfo;
+}
+export interface authInfo {
+    clientId: string;
+    username: string;
+    password: string;
+    protocol: string;
+}
+export interface MessageOptions {
+    authInfo: authInfo;
+}
+export interface publishChannelArgs {
+    roomId?: string;
+    callback?: callbackFunction;
+}
+export interface publishMonitorArgs {
+    deviceId?: string;
+    callback?: callbackFunction;
+}
+export interface joinRoomArgs {
+    roomId: string;
+    callback?: callbackFunction;
+}
+export interface joinMonitorArgs {
+    deviceId: string;
+    playElementBox: string;
+    callback?: callbackFunction;
+}
+export interface publishJoinArgs {
+    token?: string;
+    forceTcp: boolean;
+    roomId?: string;
+    callback: callbackFunction;
+}
+export interface startConsumingArgs {
+    codecs: RtpCodecCapabilityFinalized[];
+    headerExtensions: RtpHeaderExtension[];
+    roomId?: string;
+    callback?: callbackFunction;
+}
+export interface keepAliveArgs {
+    roomId?: string;
+    callback?: callbackFunction;
+}
+export interface connectConsumerTransportArgs {
+    roomId?: string;
+    callback?: callbackFunction;
+    dtlsParametersProto: DtlsParameters;
+    consumerTransportCallback: Function;
+}
+export interface connectProducerTransportArgs {
+    roomId?: string;
+    callback?: callbackFunction;
+    dtlsParametersProto: DtlsParameters;
+    producerTransportCallback: Function;
+}
+export interface produceArgs {
+    roomId?: string;
+    callback?: callbackFunction;
+    produceCallback: Function;
+    tag: string;
+    kind: MediaKind;
+    rtpParameters: RtpParameters;
+}
+export interface producerResumeArgs {
+    roomId?: string;
+    callback?: callbackFunction;
+    producerId: string;
+}
+export interface producerPauseArgs {
+    roomId?: string;
+    callback?: callbackFunction;
+    producerId: string;
+}
+export interface leaveArgs {
+    callback?: callbackFunction;
+    roomId?: string;
+}
+export interface callbackFunction {
+    (param: any): void;
+}
+export interface sendParams {
+    topic: string;
+    messageType: string;
+    message: object | undefined;
+    callback?: callbackFunction;
+    responseMessageType: string;
+    promise?: Promise<any>;
+}
+export interface replyParams {
+    topic: string;
+    messageType: string;
+    message: object | undefined;
+    correlationData: Uint8Array;
+}
+import { DtlsParameters, IceCandidate, IceParameters, MediaKind, RtpCodecCapabilityFinalized, RtpHeaderExtension, RtpParameters } from "../proto/proto-ts/data_structures/rtp_parameters";
+export interface TransportOptions {
+    id: string;
+    dtlsParameters: DtlsParameters | undefined;
+    iceCandidates: IceCandidate[];
+    iceParameters: IceParameters | undefined;
+}