@dronedeploy/rocos-js-sdk 3.0.1-alpha.1 → 3.0.1-alpha.14

package/cjs/services/ProjectService.d.ts

@@ -0,0 +1,106 @@
+import { IBaseService, IOperation, IProject, IProjectInfo, IRocosSDKConfig, ProjectUser, RocosError } from '../models';
+import { BaseServiceAbstract } from './BaseServiceAbstract';
+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<IProjectInfo[]>;
+    /**
+     * 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<IProjectInfo>;
+    /**
+     * 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<IProjectInfo[]>;
+    /**
+     * 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[]>;
+    getProjectByLinkedProjectId(linkedProjectId: string): Promise<IProject>;
+}

package/cjs/services/ProjectService.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectService = void 0;
+const api_1 = require("../constants/api");
+const models_1 = require("../models");
+const BaseServiceAbstract_1 = require("./BaseServiceAbstract");
+const RocosLogger_1 = require("../logger/RocosLogger");
+const formatServiceUrl_1 = require("../helpers/formatServiceUrl");
+class ProjectService extends BaseServiceAbstract_1.BaseServiceAbstract {
+    constructor(config) {
+        super(config);
+        this.logger = RocosLogger_1.RocosLogger.getInstance(`ProjectService(${this.config.url})`);
+    }
+    getError(e) {
+        return new models_1.RocosError(e, models_1.errorCodes.PROJECT_SERVICE_ERROR);
+    }
+    getStatus() {
+        return true;
+    }
+    /**
+     * Create a new project.
+     *
+     * @param project - Project payload {@link IProject}
+     */
+    // TODO: map the response object
+    async create(project) {
+        return this.callPost((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_PROJECT_URL, { url: this.config.url }, this.config.insecure), project, 'Failed to create project.');
+    }
+    /**
+     * Get projects list by current account info
+     */
+    // TODO: map the response object
+    async list() {
+        return this.callGet((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_PROJECT_URL, { url: this.config.url }, this.config.insecure), 'Failed to get project list.');
+    }
+    /**
+     * Update project information.
+     *
+     * @param projectId - Project Id
+     * @param project - Project payload {@link IProject}
+     */
+    // TODO: map the response object
+    async update(projectId, project) {
+        return this.callPut((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_PROJECT_ID_URL, { url: this.config.url, projectId }, this.config.insecure), project, `Failed to update project for ${projectId}.`);
+    }
+    /**
+     * Get project information by project id.
+     *
+     * @param projectId - Project Id
+     */
+    // TODO: map the response object
+    async info(projectId) {
+        return this.callGet((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_PROJECT_ID_URL, { url: this.config.url, projectId }, this.config.insecure), `Failed to get project info for ${projectId}.`);
+    }
+    /**
+     * Delete project by account id and project id.
+     *
+     * @param accountId - Account Id
+     * @param projectId - Project Id
+     */
+    // TODO: map the response object
+    async delete(accountId, projectId) {
+        return this.callDelete((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_ACCOUNT_PROJECT_ID_URL, { url: this.config.url, accountId, projectId }, this.config.insecure), `Failed to delete project for ${accountId}, projectId ${projectId}.`);
+    }
+    /**
+     * Get projects under account by using the account id.
+     *
+     * @param accountId - Account Id
+     */
+    async projectsUnderAccount(accountId) {
+        return this.callGet((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_ACCOUNT_PROJECT_URL, { url: this.config.url, accountId }, this.config.insecure), `Failed to get account projects for ${accountId}.`);
+    }
+    /**
+     * Create a project under a specified account
+     *
+     * @param accountId - Account Id
+     * @param project - Project payload {@link IProject}
+     */
+    // TODO: map the response object
+    async createProjectUnderAccount(accountId, project) {
+        return this.callPost((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_ACCOUNT_PROJECT_URL, { url: this.config.url, accountId }, this.config.insecure), project, `Failed to create account project for ${accountId}.`);
+    }
+    /**
+     * Get project pre-configured templates
+     */
+    // TODO: map the response object
+    async templates() {
+        return this.callGet((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_TEMPLATE_PROVISION_URL, { url: this.config.url }, this.config.insecure), 'Failed to get project templates.');
+    }
+    /**
+     * Create project by template.
+     *
+     * @param templateId - Template Id, From back-end responses
+     * @param body - Optional parameters
+     */
+    // TODO: map the request model
+    // TODO: map the response object
+    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+    async createProjectByTemplate(templateId, body) {
+        return this.callPost((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_TEMPLATE_PROVISION_ID_URL, { url: this.config.url, templateId }, this.config.insecure), body, `Failed to create project template for ${templateId}.`);
+    }
+    /**
+     * Operations related functions
+     */
+    /**
+     * Create a new project.
+     *
+     * @param projectId - Project Id
+     * @param operation - Operation payload {@link IOperation}
+     */
+    // TODO: map the response object
+    async createOperation(projectId, operation) {
+        return this.callPost((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_PROJECT_OPERATION_URL, { url: this.config.url, projectId }, this.config.insecure), operation, `Failed to create project operation for ${projectId}.`);
+    }
+    /**
+     * Get operations list by project id
+     *
+     * @param projectId - Project Id
+     */
+    // TODO: map the response object
+    async getOperationsList(projectId) {
+        return this.callGet((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_PROJECT_OPERATION_URL, { url: this.config.url, projectId }, this.config.insecure), `Failed to get project operations for ${projectId}.`);
+    }
+    /**
+     * Get operation by project Id and operation Id.
+     *
+     * @param projectId - Project Id
+     * @param operationId - Operation Id
+     */
+    // TODO: map the response object
+    async getOperation(projectId, operationId) {
+        return this.callGet((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_PROJECT_OPERATION_ID_URL, { url: this.config.url, projectId, operationId }, this.config.insecure), `Failed to get project operation for ${projectId}, operationId ${operationId}.`);
+    }
+    /**
+     * Delete operations for project.
+     *
+     * @param projectId - Project Id
+     * @param operationIds - Operation Ids
+     */
+    // TODO: map the response object
+    async deleteOperationsForProject(projectId, operationIds) {
+        return this.callDelete((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_PROJECT_OPERATION_URL, { url: this.config.url, projectId }, this.config.insecure), `Failed to delete project operations for ${projectId}.`, operationIds);
+    }
+    /**
+     * Update operation.
+     *
+     * @param projectId - Project Id
+     * @param operationId - Operation Id
+     * @param operation - Operation payload {@link IOperation}
+     */
+    // TODO: map the response object
+    async updateOperation(projectId, operationId, operation) {
+        return this.callPut((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_PROJECT_OPERATION_ID_URL, { url: this.config.url, projectId, operationId }, this.config.insecure), operation, `Failed to update project operation for ${projectId}, operationId ${operationId}.`);
+    }
+    /**
+     * List users for a project
+     * @param projectId - Project Id
+     * @returns Returns list of users for a given project
+     */
+    async listUsers(projectId) {
+        return this.callGet((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_PROJECT_USERS_URL, { url: this.config.url, projectId }, this.config.insecure), 'Failed to get project users list.');
+    }
+    async getProjectByLinkedProjectId(linkedProjectId) {
+        return this.callGet((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_LINKED_PROJECT_URL, { url: this.config.url, linkedProjectId }, this.config.insecure), `Failed to get project info for linked project ID: ${linkedProjectId}.`);
+    }
+}
+exports.ProjectService = ProjectService;

package/cjs/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): Promise<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/cjs/services/RTPWebRTCService.js

@@ -0,0 +1,234 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebRTCConnection = exports.RTPWebRTCService = exports.WebRTCEventType = void 0;
+const models_1 = require("../models");
+const rxjs_1 = require("rxjs");
+const BaseServiceAbstract_1 = require("./BaseServiceAbstract");
+const RocosStore_1 = require("../store/RocosStore");
+const splitRobotTopic_1 = require("../helpers/splitRobotTopic");
+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 || (exports.WebRTCEventType = WebRTCEventType = {}));
+class RTPWebRTCService extends BaseServiceAbstract_1.BaseServiceAbstract {
+    constructor(config) {
+        super(config);
+    }
+    getStatus() {
+        return true;
+    }
+    getError(e) {
+        return new models_1.RocosError(e, models_1.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
+     */
+    async createPeerConnection(params) {
+        const isInsecure = this.config.insecure ?? false;
+        const port = this.config.port ?? (isInsecure ? 80 : 443);
+        const token = (await RocosStore_1.RocosStore.getSDKInstance(this.config).getAuthService().getToken()).value;
+        return new WebRTCConnection({
+            endpoint: {
+                host: this.config.url,
+                port,
+                insecure: isInsecure,
+            },
+            token,
+            projectId: params.projectId,
+            callsign: params.callsign,
+            logLevel: params.logLevel,
+        });
+    }
+}
+exports.RTPWebRTCService = RTPWebRTCService;
+class WebRTCConnection {
+    constructor(params) {
+        this.errorsSubject$ = new rxjs_1.Subject();
+        this.streamsSubject$ = new rxjs_1.Subject();
+        this.eventsSubject$ = new rxjs_1.Subject();
+        this.errors$ = this.errorsSubject$.asObservable();
+        this.events$ = this.eventsSubject$.asObservable();
+        this.streams$ = this.streamsSubject$.pipe((0, rxjs_1.scan)((streams, stream) => [...streams, stream].filter((i) => i.active), []), (0, rxjs_1.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 } = (0, splitRobotTopic_1.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,
+        });
+    }
+}
+exports.WebRTCConnection = WebRTCConnection;