@dronedeploy/rocos-js-sdk 4.4.4 → 4.4.5

package/esm/services/TargetService.js

@@ -1,4 +1,4 @@
-import { API_GRAPHS_ASSETS_UPLOAD_URL, API_GRAPHS_ASSETS_URL, API_GRAPHS_TARGETS_URL, API_GRAPHS_TARGET_UPLOAD_URL, } from '../constants/api';
+import { API_GRAPHS_ASSETS_UPLOAD_URL, API_GRAPHS_ASSETS_URL, API_GRAPHS_TARGETS_URL, API_GRAPHS_TARGET_MEDIA_URL, API_GRAPHS_TARGET_UPLOAD_URL, } from '../constants/api';
 import { RocosError, errorCodes } from '../models';
 import { BaseServiceAbstract } from './BaseServiceAbstract';
 import { RocosLogger } from '../logger/RocosLogger';
@@ -53,10 +53,10 @@ export class TargetService extends BaseServiceAbstract {
         });
     }
     async addMedia(projectId, targetId, media) {
-        await this.callPost(formatServiceUrl(API_GRAPHS_TARGETS_URL, {
+        await this.callPut(formatServiceUrl(API_GRAPHS_TARGET_MEDIA_URL, {
             url: this.config.url,
             projectId,
-            targetId,
+            targetId: encodeURIComponent(targetId),
         }, this.config.insecure), media, 'Failed to add media to a target');
     }
 }

package/esm/services/TelemetryService.d.ts

@@ -46,6 +46,6 @@ export declare class TelemetryService extends BaseStreamService<ITelemetryStream
     monitorTelemetryWithTimeout(projectId: string, callsign: string, source: string, heartbeatTimeoutMs?: number, intervalMs?: number): Observable<TelemetryMonitorStatus>;
     protected initStream(stream: ITelemetryStream): Promise<void>;
     private buildScope;
-    private createStream;
+    private buildStreamConfig;
     protected getStream(config: ITelemetryStreamConfig): ITelemetryStream;
 }

package/esm/services/TelemetryService.js

@@ -1,5 +1,5 @@
 import { BehaviorSubject, catchError, combineLatest, defer, distinctUntilChanged, from, interval, map, mergeAll, of, startWith, } from 'rxjs';
-import { CallsignStatus, CallsignsLookup, CallsignsLookupType, RocosError, SubscriberStatusEnum, TelemetryMonitorStatus, errorCodes, } from '../models';
+import { CallsignStatus, CallsignsLookup, RocosError, SubscriberStatusEnum, TelemetryMonitorStatus, errorCodes, } from '../models';
 import { filter, finalize } from 'rxjs/operators';
 import { BaseStreamService } from './BaseStreamService';
 import { IDENTIFIER_NAME_TELEMETRY } from '../constants/identifier';
@@ -52,20 +52,33 @@ export class TelemetryService extends BaseStreamService {
         // scope is used as a key to generate unique streams
         // ideally there should be just one concurrent stream opened
         const scope = this.buildScope(params, callsignsLookup);
-        const callsigns = callsignsLookup.lookupValue;
         const subscriptionParams = {
             uniqueId: getUniqueId(params.projectId, callsignsLookup, sources, scope),
-            callsigns: callsignsLookup?.lookupType === CallsignsLookupType.List ? callsignsLookup.lookupValue : [],
+            callsigns: callsignsLookup.getCallsigns(),
             sources,
         };
         // `defer` acquires the stream only when subscribed; `finalize` releases it on unsubscribe, error
-        // and complete — so acquire and release stay balanced on every path.
+        // and complete — so acquire and release stay balanced on every path. The registry refcount taken
+        // here keeps the stream alive until the finalize, so everything in between is race-free.
         return defer(() => {
-            let acquired;
-            const stream$ = this.createStream(params.projectId, callsignsLookup, sources, scope, (stream) => {
-                acquired = stream;
+            const { stream, isNew, ready, release } = this.acquireStream(IDENTIFIER_NAME_TELEMETRY, this.buildStreamConfig(params.projectId, callsignsLookup, sources, scope));
+            try {
                 stream.addSubscription(subscriptionParams);
-            }).then((stream) => {
+                if (!isNew) {
+                    stream.statusStream$.subscribe((msg) => {
+                        this.streamStatusSubject$.next({
+                            scope,
+                            status: msg,
+                        });
+                    });
+                }
+            }
+            catch (e) {
+                // finalize below is not wired up yet, so a throw here must hand the refcount back itself.
+                release();
+                throw e;
+            }
+            const messages$ = ready.then(() => {
                 if (!this.statusSubscription) {
                     this.statusSubscription = stream.statusStream$.subscribe((msg) => {
                         this.status = msg === SubscriberStatusEnum.STOPPED || msg === SubscriberStatusEnum.ALIVE;
@@ -74,9 +87,12 @@ export class TelemetryService extends BaseStreamService {
                 }
                 return from(stream.messageStream$);
             });
-            return from(stream$).pipe(mergeAll(), filter((message) => {
-                return callsigns.includes(message.callsign) && sources.includes(message.source);
-            }), finalize(() => acquired?.removeSubscription(subscriptionParams, params.terminateReceiverGroupOnUnsubscribe)));
+            return from(messages$).pipe(mergeAll(), filter((message) => {
+                return callsignsLookup.includesCallsign(message.callsign) && sources.includes(message.source);
+            }), finalize(() => {
+                void stream.removeSubscription(subscriptionParams, params.terminateReceiverGroupOnUnsubscribe);
+                release();
+            }));
         });
     }
     /**
@@ -156,8 +172,8 @@ export class TelemetryService extends BaseStreamService {
             return `${params.projectId}-default-${flattenCallsignsLookup(callsignsLookup).join()}`;
         return `${params.projectId}-default`;
     }
-    async createStream(projectId, callsignsLookup, sources, scope, onAcquire) {
-        const newStream = await this.createStreamFromConfig(IDENTIFIER_NAME_TELEMETRY, {
+    buildStreamConfig(projectId, callsignsLookup, sources, scope) {
+        return {
             url: this.config.url,
             projectId,
             callsignsLookup,
@@ -169,16 +185,7 @@ export class TelemetryService extends BaseStreamService {
             insecure: this.config.insecure,
             transport: this.config.transport,
             fetch: this.config.fetch,
-        }, onAcquire);
-        if (!newStream.isNew) {
-            newStream.stream.statusStream$.subscribe((msg) => {
-                this.streamStatusSubject$.next({
-                    scope,
-                    status: msg,
-                });
-            });
-        }
-        return newStream.stream;
+        };
     }
     getStream(config) {
         if (config.transport === 'grpc-web') {

package/esm/services/WebRTCSignallingService.js

@@ -1,4 +1,4 @@
-import { IDENTIFIER_NAME_COMMAND } from '../constants/identifier';
+import { IDENTIFIER_NAME_WEBRTC_SIGNALLING } from '../constants/identifier';
 import { RocosLogger } from '../logger/RocosLogger';
 import { RocosStore } from '../store/RocosStore';
 import { StreamRegister } from '../api/StreamRegister';
@@ -34,11 +34,9 @@ export class WebRTCSignallingService {
     }
     async createSignallingStream() {
         const scope = 'default';
-        const identifier = StreamRegister.getIdentifier(IDENTIFIER_NAME_COMMAND, scope);
-        const streamRegister = StreamRegister.getInstance();
-        let stream = streamRegister.getStream(identifier);
-        if (!stream) {
-            stream = this.getStream({
+        const identifier = StreamRegister.getIdentifier(IDENTIFIER_NAME_WEBRTC_SIGNALLING, scope);
+        const { stream, ready } = StreamRegister.getInstance().acquireStream(identifier, () => {
+            const newStream = this.getStream({
                 url: this.config.url,
                 token: this.config.token,
                 scope,
@@ -46,13 +44,13 @@ export class WebRTCSignallingService {
                 port: this.config.port,
                 insecure: this.config.insecure,
             });
-            stream.statusStream$.subscribe((msg) => {
+            newStream.statusStream$.subscribe((msg) => {
                 this.status = msg === SubscriberStatusEnum.STOPPED || msg === SubscriberStatusEnum.ALIVE;
                 this.status$.next(msg);
             });
-            streamRegister.addStream(stream);
-            await this.initStream(stream);
-        }
+            return newStream;
+        }, (newStream) => this.initStream(newStream));
+        await ready;
         return stream;
     }
     async initStream(stream) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dronedeploy/rocos-js-sdk",
-  "version": "4.4.4",
+  "version": "4.4.5",
   "description": "Javascript SDK for rocos",
   "main": "cjs/index.js",
   "module": "esm/index.js",