@dronedeploy/rocos-js-sdk 3.0.1-alpha.3 → 3.0.1-alpha.5

package/esm/services/ProfileService.d.ts

@@ -0,0 +1,244 @@
+import { RocosError } from '../models/RocosError';
+import { BaseServiceAbstract } from './BaseServiceAbstract';
+import { IBaseService } from '../models/IBaseService';
+import { IRocosSDKConfig } from '../models/IRocosSDKConfig';
+export declare class ProfileService extends BaseServiceAbstract implements IBaseService {
+    constructor(config: IRocosSDKConfig);
+    protected getError(e: Error): RocosError;
+    getStatus(): boolean;
+    /**
+     *  Create a robot definition
+     *
+     * @param projectId - Project Id
+     * @param model - Payload
+     * @description - Renamed from robotDefsCreate
+     */
+    create(projectId: string, model: any): Promise<any>;
+    /**
+     * Get robot definitions
+     *
+     * @param projectId - Project Id
+     * @description - Renamed from robotDefsList
+     */
+    list(projectId: string): Promise<any>;
+    /**
+     * Delete robot definitions
+     *
+     * @param projectId - Project Id
+     * @param defIds - Definition Id's
+     * @description - Renamed from robotDefsRemove
+     */
+    remove(projectId: string, defIds: string[]): Promise<any>;
+    /**
+     * Get a robot definition
+     *
+     * @param projectId - Project Id
+     * @param definitionId - Definition Id
+     * @description - Renamed from robotDefsGetOne
+     */
+    get(projectId: string, definitionId: string): Promise<any>;
+    /**
+     * Delete a robot definition
+     *
+     * @param projectId - Project Id
+     * @param definitionId - Definition Id
+     * @description - Renamed from robotDefsDeleteOne
+     */
+    delete(projectId: string, definitionId: string): Promise<any>;
+    /**
+     * Update a robot definition
+     *
+     * @param projectId - Project Id
+     * @param definitionId - Definition Id
+     * @param model - Definition payload
+     * @description - Renamed from robotDefsUpdateOne
+     */
+    update(projectId: string, definitionId: string, model: any): Promise<any>;
+    /**
+     * Get definitions for a robot
+     *
+     * @param projectId - Project Id
+     * @param callsign - Robot callsign
+     * @description - Renamed from robotDefsForRobot
+     */
+    getForRobot(projectId: string, callsign: string): Promise<any>;
+    /**
+     * Update storage streams for a robot definition
+     *
+     * @param projectId - Project Id
+     * @param definitionId - Definition Id
+     * @param model - Payload
+     * @description - Renamed from robotDefsUpdateStorageStreams
+     */
+    updateStorageStreams(projectId: string, definitionId: string, model: any): Promise<any>;
+    /**
+     * Copy a robot definition
+     *
+     * @param projectId - Project Id
+     * @param definitionId - Definition Id
+     * @param model - Payload
+     * @description - Renamed from robotDefCopyDef
+     */
+    copyDef(projectId: string, definitionId: string, model: any): Promise<any>;
+    /**
+     * Get robot list got a robot definition
+     *
+     * @param projectId - Project Id
+     * @param definitionId - Definition Id
+     * @description - Renamed from robotListForDefs
+     */
+    robotList(projectId: string, definitionId: string): Promise<any>;
+    /**
+     * Get dashboards for a definition
+     *
+     * @param projectId - Project Id
+     * @param profileId - Profile Id
+     * @description - Renamed from robotDefDashboards
+     */
+    dashboards(projectId: string, profileId: string): Promise<any>;
+    /**
+     * Get Dashboard data which stored in Azure Blob.
+     *
+     * @param projectId - Project Id
+     * @param definitionId - Robot Profile Id
+     * @description - Renamed from robotDefDashboardBlob
+     */
+    dashboardBlob(projectId: string, definitionId: string): Promise<any>;
+    /**
+     * Update dashboard for a robot definition
+     *
+     * @param projectId - Project Id
+     * @param definitionId - Robot Profile Id
+     * @param model - Payload
+     * @description - Renamed from robotDefUpdateDashboards
+     */
+    updateDashboards(projectId: string, definitionId: string, model: any): Promise<any>;
+    /**
+     * Get settings for a robot definition
+     *
+     * @param projectId - Project Id
+     * @param definitionId - Robot Profile Id
+     * @description - Renamed from robotDefGetSettings
+     */
+    getSettings(projectId: string, definitionId: string): Promise<any>;
+    /**
+     * Update settings for a robot definition
+     *
+     * @param projectId - Project Id
+     * @param definitionId - Robot Profile Id
+     * @param model - Payload
+     * @description - Renamed from robotDefUpdateSettings
+     */
+    updateSettings(projectId: string, definitionId: string, model: any): Promise<any>;
+    /**
+     * Get agent settings
+     *
+     * @param projectId - Project Id
+     * @param definitionId - Robot definition Id
+     * @description - Renamed from robotDefGetAgentSettings
+     */
+    getAgentSettings(projectId: string, definitionId: string): Promise<any>;
+    /**
+     * Update agent settings
+     *
+     * @param projectId - Project Id
+     * @param definitionId - Robot definition Id
+     * @param model - Payload
+     * @description - Renamed from robotDefUpdateAgentSettings
+     */
+    updateAgentSettings(projectId: string, definitionId: string, model: any): Promise<any>;
+    /**
+     * Get commands fora robot definition
+     *
+     * @param projectId - Project Id
+     * @param definitionId - Robot definition Id
+     * @description - Renamed from robotDefGetCommands
+     */
+    getCommands(projectId: string, definitionId: string): Promise<any>;
+    /**
+     *
+     * Update commands fora robot definition
+     *
+     * @param projectId - Project Id
+     * @param definitionId - Robot definition Id
+     * @param model - Payload
+     * @description - Renamed from robotDefUpdateCommands
+     */
+    updateCommands(projectId: string, definitionId: string, model: any): Promise<any>;
+    /**
+     * Get command V2 for a robot definition
+     *
+     * @param projectId - Project Id
+     * @param definitionId - Robot definition Id
+     * @description - Renamed from robotDefGetCommandsV2
+     */
+    getCommandsV2(projectId: string, definitionId: string): Promise<any>;
+    /**
+     * Update command V2 for a robot definition
+     *
+     * @param projectId - Project Id
+     * @param definitionId - Robot definition Id
+     * @param model - Payload
+     * @description - Renamed from robotDefUpdateCommandsV2
+     */
+    updateCommandsV2(projectId: string, definitionId: string, model: any): Promise<any>;
+    /**
+     * Get command actions for a robot definition
+     *
+     * @param projectId - Project Id
+     * @param definitionId - Robot definition Id
+     * @description - Renamed from robotDefGetCommandActions
+     */
+    getCommandActions(projectId: string, definitionId: string): Promise<any>;
+    /**
+     * Get buttons for a robot definition
+     *
+     * @param projectId - Project Id
+     * @param definitionId - Robot definition Id
+     * @description - Renamed from robotDefGetButtons
+     */
+    getButtons(projectId: string, definitionId: string): Promise<any>;
+    /**
+     * Update buttons for a robot definition
+     *
+     * @param projectId - Project Id
+     * @param definitionId - Robot definition Id
+     * @param model - Payload
+     * @description - Renamed from robotDefUpdateButtons
+     */
+    updateButtons(projectId: string, definitionId: string, model: any): Promise<any>;
+    /**
+     * Get triggers for a robot definition
+     *
+     * @param projectId - Project Id
+     * @param definitionId - Robot definition Id
+     * @description - Renamed from robotDefGetTriggers
+     */
+    getTriggers(projectId: string, definitionId: string): Promise<any>;
+    /**
+     * Update triggers for a robot definition
+     *
+     * @param projectId - Project Id
+     * @param definitionId - Robot definition Id
+     * @param model - Payload
+     * @description - Renamed from robotDefUpdateTriggers
+     */
+    updateTriggers(projectId: string, definitionId: string, model: any): Promise<any>;
+    /**
+     * Get gamepads for a robot definition
+     *
+     * @param projectId - Project Id
+     * @param definitionId - Robot definition Id
+     * @description - Renamed from robotDefGetGamepads
+     */
+    getGamepads(projectId: string, definitionId: string): Promise<any>;
+    /**
+     * Update gamepads for a robot definition
+     *
+     * @param projectId - Project Id
+     * @param definitionId - Robot definition Id
+     * @param model - \payload
+     * @description - Renamed from robotDefUpdateGamepads
+     */
+    updateGamepads(projectId: string, definitionId: string, model: any): Promise<any>;
+}

package/esm/services/ProjectService.d.ts

@@ -0,0 +1,110 @@
+import { RocosError } from '../models/RocosError';
+import { BaseServiceAbstract } from './BaseServiceAbstract';
+import { IBaseService } from '../models/IBaseService';
+import { IOperation } from '../models/IOperation';
+import { IProject } from '../models/IProject';
+import { IRocosSDKConfig } from '../models/IRocosSDKConfig';
+import { ProjectUser } from '../models';
+export declare class ProjectService extends BaseServiceAbstract implements IBaseService {
+    constructor(config: IRocosSDKConfig);
+    protected getError(e: Error): RocosError;
+    getStatus(): boolean;
+    /**
+     * Create a new project.
+     *
+     * @param project - Project payload {@link IProject}
+     */
+    create(project: IProject): Promise<any>;
+    /**
+     * Get projects list by current account info
+     */
+    list(): Promise<any>;
+    /**
+     * Update project information.
+     *
+     * @param projectId - Project Id
+     * @param project - Project payload {@link IProject}
+     */
+    update(projectId: string, project: IProject): Promise<any>;
+    /**
+     * Get project information by project id.
+     *
+     * @param projectId - Project Id
+     */
+    info(projectId: string): Promise<IProject>;
+    /**
+     * Delete project by account id and project id.
+     *
+     * @param accountId - Account Id
+     * @param projectId - Project Id
+     */
+    delete(accountId: string, projectId: string): Promise<any>;
+    /**
+     * Get projects under account by using the account id.
+     *
+     * @param accountId - Account Id
+     */
+    projectsUnderAccount(accountId: string): Promise<IProject[]>;
+    /**
+     * Create a project under a specified account
+     *
+     * @param accountId - Account Id
+     * @param project - Project payload {@link IProject}
+     */
+    createProjectUnderAccount(accountId: string, project: IProject): Promise<any>;
+    /**
+     * Get project pre-configured templates
+     */
+    templates(): Promise<any>;
+    /**
+     * Create project by template.
+     *
+     * @param templateId - Template Id, From back-end responses
+     * @param body - Optional parameters
+     */
+    createProjectByTemplate(templateId: string, body?: any): Promise<any>;
+    /**
+     * Operations related functions
+     */
+    /**
+     * Create a new project.
+     *
+     * @param projectId - Project Id
+     * @param operation - Operation payload {@link IOperation}
+     */
+    createOperation(projectId: string, operation: IOperation): Promise<any>;
+    /**
+     * Get operations list by project id
+     *
+     * @param projectId - Project Id
+     */
+    getOperationsList(projectId: string): Promise<any>;
+    /**
+     * Get operation by project Id and operation Id.
+     *
+     * @param projectId - Project Id
+     * @param operationId - Operation Id
+     */
+    getOperation(projectId: string, operationId: string): Promise<any>;
+    /**
+     * Delete operations for project.
+     *
+     * @param projectId - Project Id
+     * @param operationIds - Operation Ids
+     */
+    deleteOperationsForProject(projectId: string, operationIds: string[]): Promise<any>;
+    /**
+     * Update operation.
+     *
+     * @param projectId - Project Id
+     * @param operationId - Operation Id
+     * @param operation - Operation payload {@link IOperation}
+     */
+    updateOperation(projectId: string, operationId: string, operation: IOperation): Promise<any>;
+    /**
+     * List users for a project
+     * @param projectId - Project Id
+     * @returns Returns list of users for a given project
+     */
+    listUsers(projectId: string): Promise<ProjectUser[]>;
+}

package/esm/services/RTPWebRTCService.d.ts

@@ -0,0 +1,102 @@
+import { IBaseService, IRocosSDKConfig, RocosError } from '../models';
+import { Observable } from 'rxjs';
+import { BaseServiceAbstract } from './BaseServiceAbstract';
+export declare enum WebRTCEventType {
+    LoadingTURNConfigs = "loading-turn-configs",
+    Disconnected = "disconnected",
+    DataChannelOpen = "data-channel-open",
+    CreatingOffer = "creating-offer",
+    AddingRemoteTrack = "adding-remote-track",
+    ICEConnectionStateChange = "ice-connection-state-change",
+    SendingOffer = "sending-offer",
+    FailedGettingTURNConfig = "failed-getting-turn-config",
+    GotTURNConfig = "got-turn-config",
+    FailedGettingAnswer = "failed-getting-answer",
+    GotAnswer = "got-answer",
+    DataChannelMessage = "data-channel-message"
+}
+interface EventMetadata {
+    [WebRTCEventType.ICEConnectionStateChange]: {
+        state: RTCIceConnectionState;
+    };
+    [WebRTCEventType.DataChannelMessage]: {
+        label: string;
+        data: string;
+    };
+}
+interface Event<T extends WebRTCEventType> {
+    type: T;
+    metadata: T extends keyof EventMetadata ? EventMetadata[T] : undefined;
+}
+export type WebRTCEvent = {
+    [K in keyof typeof WebRTCEventType]: Event<(typeof WebRTCEventType)[K]>;
+}[keyof typeof WebRTCEventType];
+export interface PeerConnectionParams {
+    projectId: string;
+    callsign: string;
+    logLevel?: 'trace';
+}
+interface InternalPeerConnectionParams extends PeerConnectionParams {
+    endpoint: {
+        host: string;
+        port: number;
+        insecure: boolean;
+    };
+    token: string;
+}
+export declare class RTPWebRTCService extends BaseServiceAbstract implements IBaseService {
+    constructor(config: IRocosSDKConfig);
+    getStatus(): boolean;
+    protected getError(e: Error): RocosError;
+    /** Create a new peer connection with a robot
+     *
+     * To connect, call `connect` on the returned connection
+     *
+     * If `logLevel` is set to trace, the connection will emit all messages as events
+     */
+    createPeerConnection(params: PeerConnectionParams): WebRTCConnection;
+}
+export declare class WebRTCConnection {
+    private pc?;
+    private sendChannel?;
+    private readonly endpoint;
+    private readonly token;
+    private readonly projectId;
+    private readonly callsign;
+    private readonly logLevel?;
+    private errorsSubject$;
+    private streamsSubject$;
+    private eventsSubject$;
+    readonly errors$: Observable<Error>;
+    readonly events$: Observable<WebRTCEvent>;
+    readonly streams$: Observable<MediaStream[]>;
+    constructor(params: InternalPeerConnectionParams);
+    get peerConnectionAvailable(): boolean;
+    /** Connect to the robot
+     *
+     * This will create a new peer connection, and send an offer to the robot.
+     * If a connection already exists, it will be disconnected first
+     *
+     * @throws {Error} if the offer fails
+     * @returns {Promise<void>} resolves when the connection is established
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect from the robot
+     */
+    disconnect(): void;
+    /**
+     * Subscribe to a video or audio topic
+     *
+     * This will send a message to the robot to start streaming the requested topic.
+     *
+     * Any data received will be sent to the streams emitted by `streams$`
+     */
+    subscribeToTopic(topic: string, type: 'video' | 'audio'): void;
+    private sendOffer;
+    private loadConfig;
+    private createPeerConnection;
+    private getEndpoint;
+    private log;
+}
+export {};

package/esm/services/RTPWebRTCService.js

@@ -0,0 +1,227 @@
+import { RocosError, errorCodes } from '../models';
+import { Subject, scan, shareReplay } from 'rxjs';
+import { BaseServiceAbstract } from './BaseServiceAbstract';
+import { splitRobotTopic } from '../helpers/splitRobotTopic';
+export var WebRTCEventType;
+(function (WebRTCEventType) {
+    WebRTCEventType["LoadingTURNConfigs"] = "loading-turn-configs";
+    WebRTCEventType["Disconnected"] = "disconnected";
+    WebRTCEventType["DataChannelOpen"] = "data-channel-open";
+    WebRTCEventType["CreatingOffer"] = "creating-offer";
+    WebRTCEventType["AddingRemoteTrack"] = "adding-remote-track";
+    WebRTCEventType["ICEConnectionStateChange"] = "ice-connection-state-change";
+    WebRTCEventType["SendingOffer"] = "sending-offer";
+    WebRTCEventType["FailedGettingTURNConfig"] = "failed-getting-turn-config";
+    WebRTCEventType["GotTURNConfig"] = "got-turn-config";
+    WebRTCEventType["FailedGettingAnswer"] = "failed-getting-answer";
+    WebRTCEventType["GotAnswer"] = "got-answer";
+    WebRTCEventType["DataChannelMessage"] = "data-channel-message";
+})(WebRTCEventType || (WebRTCEventType = {}));
+export class RTPWebRTCService extends BaseServiceAbstract {
+    constructor(config) {
+        super(config);
+    }
+    getStatus() {
+        return true;
+    }
+    getError(e) {
+        return new RocosError(e, errorCodes.WEBRTC_SERVICE_ERROR);
+    }
+    /** Create a new peer connection with a robot
+     *
+     * To connect, call `connect` on the returned connection
+     *
+     * If `logLevel` is set to trace, the connection will emit all messages as events
+     */
+    createPeerConnection(params) {
+        const isInsecure = this.config.insecure ?? false;
+        const port = this.config.port ?? (isInsecure ? 80 : 443);
+        return new WebRTCConnection({
+            endpoint: {
+                host: this.config.url,
+                port,
+                insecure: isInsecure,
+            },
+            token: this.config.token,
+            projectId: params.projectId,
+            callsign: params.callsign,
+            logLevel: params.logLevel,
+        });
+    }
+}
+export class WebRTCConnection {
+    constructor(params) {
+        this.errorsSubject$ = new Subject();
+        this.streamsSubject$ = new Subject();
+        this.eventsSubject$ = new Subject();
+        this.errors$ = this.errorsSubject$.asObservable();
+        this.events$ = this.eventsSubject$.asObservable();
+        this.streams$ = this.streamsSubject$.pipe(scan((streams, stream) => [...streams, stream].filter((i) => i.active), []), shareReplay(1));
+        this.endpoint = params.endpoint;
+        this.token = params.token;
+        this.projectId = params.projectId;
+        this.callsign = params.callsign;
+        this.logLevel = params.logLevel;
+    }
+    get peerConnectionAvailable() {
+        return !!this.pc;
+    }
+    /** Connect to the robot
+     *
+     * This will create a new peer connection, and send an offer to the robot.
+     * If a connection already exists, it will be disconnected first
+     *
+     * @throws {Error} if the offer fails
+     * @returns {Promise<void>} resolves when the connection is established
+     */
+    async connect() {
+        if (this.peerConnectionAvailable)
+            this.disconnect(); // disconnect any lingering connections
+        const config = await this.loadConfig();
+        const pc = this.createPeerConnection(config);
+        this.pc = pc;
+        // Creating data channel, must be done before creating the offer
+        const sendChannel = pc.createDataChannel('submanager');
+        sendChannel.onclose = () => this.log(WebRTCEventType.Disconnected);
+        sendChannel.onopen = () => {
+            this.log(WebRTCEventType.DataChannelOpen);
+        };
+        sendChannel.onmessage = (e) => {
+            this.log(WebRTCEventType.DataChannelMessage, {
+                label: sendChannel.label,
+                data: e.data,
+            });
+        };
+        // Offer to receive 1 audio, and 1 video track
+        pc.addTransceiver('video', { direction: 'recvonly' });
+        pc.addTransceiver('audio', { direction: 'recvonly' });
+        this.log(WebRTCEventType.CreatingOffer);
+        this.sendChannel = sendChannel;
+        await pc.createOffer().then((d) => pc.setLocalDescription(d));
+    }
+    /**
+     * Disconnect from the robot
+     */
+    disconnect() {
+        this.sendChannel?.close();
+        this.pc?.close();
+        this.pc = undefined;
+        this.sendChannel = undefined;
+    }
+    /**
+     * Subscribe to a video or audio topic
+     *
+     * This will send a message to the robot to start streaming the requested topic.
+     *
+     * Any data received will be sent to the streams emitted by `streams$`
+     */
+    subscribeToTopic(topic, type) {
+        if (!this.sendChannel) {
+            throw new Error(`Failed to start ${type}, no data channel available`);
+        }
+        if (!topic || topic.split('/').length < 1) {
+            throw new Error('Invalid Topic Provided');
+        }
+        const { component, topic: path } = splitRobotTopic(topic);
+        this.sendChannel.send(JSON.stringify({
+            projectId: this.projectId,
+            callsign: this.callsign,
+            component,
+            topic: path,
+            token: this.token,
+            logLevel: this.logLevel,
+            type,
+            mode: 'subscribe',
+        }));
+    }
+    async sendOffer(sdp) {
+        return fetch(this.getEndpoint('sdp'), {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${this.token}`,
+            },
+            body: JSON.stringify({
+                sdp,
+            }),
+        })
+            .then((res) => res.json())
+            .catch((err) => {
+            this.log(WebRTCEventType.FailedGettingAnswer);
+            throw new Error(err);
+        })
+            .then((res) => {
+            this.log(WebRTCEventType.GotAnswer);
+            return res;
+        });
+    }
+    async loadConfig() {
+        this.log(WebRTCEventType.LoadingTURNConfigs);
+        return fetch(this.getEndpoint('/sdp/configs'), {
+            method: 'GET',
+            headers: {
+                Authorization: `Bearer ${this.token}`,
+            },
+        })
+            .then((res) => res.json())
+            .catch((err) => {
+            this.log(WebRTCEventType.FailedGettingTURNConfig);
+            throw new Error(err);
+        })
+            .then((res) => {
+            this.log(WebRTCEventType.GotTURNConfig);
+            return res;
+        });
+    }
+    createPeerConnection(config) {
+        const pc = new RTCPeerConnection(config);
+        this.pc = pc;
+        pc.ontrack = (event) => {
+            if (!document) {
+                this.errorsSubject$.next(new Error('No browser - operation not supported'));
+            }
+            for (const stream of event.streams) {
+                this.streamsSubject$.next(stream);
+            }
+            this.log(WebRTCEventType.AddingRemoteTrack);
+        };
+        pc.oniceconnectionstatechange = () => {
+            this.log(WebRTCEventType.ICEConnectionStateChange, {
+                state: pc.iceConnectionState,
+            });
+            if (pc.iceConnectionState === 'failed') {
+                this.errorsSubject$.next(new Error('ICE Connection Failed'));
+            }
+        };
+        pc.onicecandidate = async (event) => {
+            if (event.candidate === null) {
+                const sdp = btoa(JSON.stringify(pc.localDescription));
+                this.log(WebRTCEventType.SendingOffer);
+                const { answer } = await this.sendOffer(sdp);
+                this.log(WebRTCEventType.GotAnswer);
+                try {
+                    await pc.setRemoteDescription(new RTCSessionDescription(JSON.parse(atob(answer))));
+                }
+                catch (e) {
+                    this.log(WebRTCEventType.FailedGettingAnswer);
+                    console.error('Failed to get answer', e);
+                    this.errorsSubject$.next(new Error('Failed to get answer'));
+                }
+            }
+        };
+        return pc;
+    }
+    getEndpoint(path) {
+        const { host, port, insecure } = this.endpoint;
+        const protocol = insecure ? 'http' : 'https';
+        const base = new URL(`${protocol}://${host}:${port}`);
+        if (path)
+            base.pathname = path;
+        return base.toString();
+    }
+    log(type, metadata) {
+        this.eventsSubject$.next({
+            type,
+            metadata,
+        });
+    }
+}

package/esm/services/RTPWebRTCService.spec.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @jest-environment jsdom
+ */
+export {};