ring-client-api 11.8.1 → 12.0.0-beta.1

package/lib/ring-camera.d.ts

@@ -4,8 +4,8 @@ import { RingRestClient } from './rest-client';
 import { BehaviorSubject, Subject } from 'rxjs';
 import { DeepPartial } from './util';
 import { Subscribed } from './subscribed';
+import { StreamingConnectionOptions } from './streaming/webrtc-connection';
 import { FfmpegOptions, StreamingSession } from './streaming/streaming-session';
-import { StreamingConnectionOptions } from './streaming/streaming-connection-base';
 import { SimpleWebRtcSession } from './streaming/simple-webrtc-session';
 export type AnyCameraData = CameraData | OnvifCameraData;
 export declare function getBatteryLevel(data: Pick<CameraData, 'battery_life' | 'battery_life_2'> & {

package/lib/ring-camera.js

@@ -8,7 +8,6 @@ const operators_1 = require("rxjs/operators");
 const util_1 = require("./util");
 const subscribed_1 = require("./subscribed");
 const webrtc_connection_1 = require("./streaming/webrtc-connection");
-const ring_edge_connection_1 = require("./streaming/ring-edge-connection");
 const streaming_session_1 = require("./streaming/streaming-session");
 const simple_webrtc_session_1 = require("./streaming/simple-webrtc-session");
 const maxSnapshotRefreshSeconds = 15, fullDayMs = 24 * 60 * 60 * 1000;
@@ -239,24 +238,15 @@ class RingCamera extends subscribed_1.Subscribed {
         return response.device_health;
     }
     async createStreamingConnection(options) {
-        if (this.isRingEdgeEnabled) {
-            const auth = await this.restClient.getCurrentAuth();
-            return new ring_edge_connection_1.RingEdgeConnection(auth.access_token, this, options);
-        }
-        const liveCall = await this.restClient
+        const response = await this.restClient
             .request({
             method: 'POST',
-            url: this.doorbotUrl('live_call'),
+            url: (0, rest_client_1.appApi)('clap/ticket/request/signalsocket'),
         })
             .catch((e) => {
-            if (e.response?.statusCode === 403) {
-                const errorMessage = `Camera ${this.name} returned 403 when starting a live stream.  This usually indicates that live streaming is blocked by Modes settings.  Check your Ring app and verify that you are able to stream from this camera with the current Modes settings.`;
-                (0, util_1.logError)(errorMessage);
-                throw new Error(errorMessage);
-            }
             throw e;
         });
-        return new webrtc_connection_1.WebrtcConnection(liveCall.data.session_id, this, options);
+        return new webrtc_connection_1.WebrtcConnection(response.ticket, this, options);
     }
     async startLiveCall(options = {}) {
         const connection = await this.createStreamingConnection(options);

package/lib/ring-types.d.ts

@@ -919,20 +919,9 @@ export interface PushNotificationLowBattery {
     action: PushNotificationAction.LowBattery;
 }
 export type PushNotification = PushNotificationDing | PushNotificationAlarm | PushNotificationLowBattery;
-export interface LiveCallResponse {
-    ding_id: string;
-    ding_kind: DingKind;
-    device_id: number;
-    device_kind: RingCameraKind;
-    device_description: string;
-    state: DingState;
-    protocol: 'ring_media_server' | unknown;
-    now: number;
-    video_jitter_buffer_ms: number;
-    audio_jitter_buffer_ms: number;
-    data: {
-        session_id: string;
-    };
+export interface SocketTicketResponse {
+    ticket: string;
+    responseTimestampe: number;
 }
 export interface AuthTokenResponse {
     access_token: string;

package/lib/streaming/peer-connection.d.ts

@@ -5,10 +5,6 @@ export interface BasicPeerConnection {
     createOffer(): Promise<{
         sdp: string;
     }>;
-    createAnswer(offer: {
-        type: 'offer';
-        sdp: string;
-    }): Promise<RTCSessionDescriptionInit>;
     acceptAnswer(answer: {
         type: 'answer';
         sdp: string;
@@ -31,10 +27,6 @@ export declare class WeriftPeerConnection extends Subscribed implements BasicPee
     private onRequestKeyFrame;
     constructor();
     createOffer(): Promise<import("werift").RTCSessionDescription>;
-    createAnswer(offer: {
-        type: 'offer';
-        sdp: string;
-    }): Promise<import("werift").RTCSessionDescription>;
     acceptAnswer(answer: {
         type: 'answer';
         sdp: string;

package/lib/streaming/peer-connection.js

@@ -116,12 +116,6 @@ class WeriftPeerConnection extends subscribed_1.Subscribed {
         await this.pc.setLocalDescription(offer);
         return offer;
     }
-    async createAnswer(offer) {
-        await this.pc.setRemoteDescription(offer);
-        const answer = await this.pc.createAnswer();
-        await this.pc.setLocalDescription(answer);
-        return answer;
-    }
     async acceptAnswer(answer) {
         await this.pc.setRemoteDescription(answer);
     }

package/lib/streaming/{ring-edge-connection.d.ts → streaming-messages.d.ts}

@@ -1,5 +1,3 @@
-import { RingCamera } from '../ring-camera';
-import { StreamingConnectionBase, StreamingConnectionOptions } from './streaming-connection-base';
 interface SessionBody {
     doorbot_id: number;
     session_id: string;
@@ -51,15 +49,5 @@ interface CloseMessage {
         };
     } & SessionBody;
 }
-type IncomingMessage = AnswerMessage | IceCandidateMessage | SessionCreatedMessage | SessionStartedMessage | PongMessage | CloseMessage | NotificationMessage;
-export declare class RingEdgeConnection extends StreamingConnectionBase {
-    private camera;
-    private readonly onSessionId;
-    private readonly onOfferSent;
-    constructor(authToken: string, camera: RingCamera, options: StreamingConnectionOptions);
-    private initiateCall;
-    private sessionId;
-    protected handleMessage(message: IncomingMessage): Promise<void>;
-    protected sendSessionMessage(method: string, body?: Record<any, any>): void;
-}
+export type IncomingMessage = AnswerMessage | IceCandidateMessage | SessionCreatedMessage | SessionStartedMessage | PongMessage | CloseMessage | NotificationMessage;
 export {};

package/lib/streaming/streaming-messages.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// eslint-disable-next-line no-shadow
+var CloseReasonCode;
+(function (CloseReasonCode) {
+    CloseReasonCode[CloseReasonCode["NormalClose"] = 0] = "NormalClose";
+    // reason: { code: 5, text: '[rsl-apps/webrtc-liveview-server/Session.cpp:429] [Auth] [0xd540]: [rsl-apps/session-manager/Manager.cpp:227] [AppAuth] Unauthorized: invalid or expired token' }
+    // reason: { code: 5, text: 'Authentication failed: -1' }
+    // reason: { code: 5, text: 'Sessions with the provided ID not found' }
+    CloseReasonCode[CloseReasonCode["AuthenticationFailed"] = 5] = "AuthenticationFailed";
+    // reason: { code: 6, text: 'Timeout waiting for ping' }
+    CloseReasonCode[CloseReasonCode["Timeout"] = 6] = "Timeout";
+})(CloseReasonCode || (CloseReasonCode = {}));

package/lib/streaming/streaming-session.d.ts

@@ -1,6 +1,5 @@
 import { RtpPacket } from 'werift';
 import { ReplaySubject, Subject } from 'rxjs';
-import { RingEdgeConnection } from './ring-edge-connection';
 import { WebrtcConnection } from './webrtc-connection';
 import { RingCamera } from '../ring-camera';
 import { Subscribed } from '../subscribed';
@@ -21,7 +20,7 @@ export declare class StreamingSession extends Subscribed {
     private readonly audioSplitter;
     private readonly videoSplitter;
     private readonly returnAudioSplitter;
-    constructor(camera: RingCamera, connection: RingEdgeConnection | WebrtcConnection);
+    constructor(camera: RingCamera, connection: WebrtcConnection);
     private bindToConnection;
     /**
      * @deprecated

package/lib/streaming/webrtc-connection.d.ts

@@ -1,23 +1,38 @@
+import { ReplaySubject, Subject } from 'rxjs';
 import { RingCamera } from '../ring-camera';
-import { StreamingConnectionBase, StreamingConnectionOptions } from './streaming-connection-base';
-interface InitializationMessage {
-    method: 'initialization';
-    text: 'Done';
+import { BasicPeerConnection } from './peer-connection';
+import { Subscribed } from '../subscribed';
+import { RtpPacket } from 'werift';
+export interface StreamingConnectionOptions {
+    createPeerConnection?: () => BasicPeerConnection;
 }
-interface OfferMessage {
-    method: 'sdp';
-    sdp: string;
-    type: 'offer';
-}
-interface IceCandidateMessage {
-    method: 'ice';
-    ice: string;
-    mlineindex: number;
-}
-export declare class WebrtcConnection extends StreamingConnectionBase {
+export declare class WebrtcConnection extends Subscribed {
+    private camera;
+    private readonly onSessionId;
+    private readonly onOfferSent;
+    private readonly dialogId;
+    readonly onCallAnswered: ReplaySubject<string>;
+    readonly onCallEnded: ReplaySubject<void>;
+    readonly onError: ReplaySubject<void>;
+    readonly onMessage: ReplaySubject<{
+        method: string;
+    }>;
+    readonly onWsOpen: import("rxjs").Observable<unknown>;
+    readonly onAudioRtp: Subject<RtpPacket>;
+    readonly onVideoRtp: Subject<RtpPacket>;
+    private readonly pc;
+    private readonly ws;
+    constructor(ticket: string, camera: RingCamera, options: StreamingConnectionOptions);
+    private initiateCall;
     private sessionId;
-    constructor(sessionId: string, camera: RingCamera, options: StreamingConnectionOptions);
-    protected handleMessage(message: InitializationMessage | OfferMessage | IceCandidateMessage): Promise<void>;
-    protected sendSessionMessage(method: string, body?: Record<any, any>): void;
+    private handleMessage;
+    private sendSessionMessage;
+    private sendMessage;
+    sendAudioPacket(rtp: RtpPacket): void;
+    private activate;
+    activateCameraSpeaker(): void;
+    private hasEnded;
+    private callEnded;
+    stop(): void;
+    requestKeyFrame(): void;
 }
-export {};

package/lib/streaming/webrtc-connection.js

@@ -2,48 +2,244 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WebrtcConnection = void 0;
 const ws_1 = require("ws");
-const streaming_connection_base_1 = require("./streaming-connection-base");
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
 const util_1 = require("../util");
-function parseLiveCallSession(sessionId) {
-    const encodedSession = sessionId.split('.')[1], text = (0, util_1.fromBase64)(encodedSession);
-    return JSON.parse(text);
-}
-class WebrtcConnection extends streaming_connection_base_1.StreamingConnectionBase {
-    constructor(sessionId, camera, options) {
-        const liveCallSession = parseLiveCallSession(sessionId);
-        super(new ws_1.WebSocket(`wss://${liveCallSession.rms_fqdn}:${liveCallSession.webrtc_port}/`, {
+const peer_connection_1 = require("./peer-connection");
+const subscribed_1 = require("../subscribed");
+class WebrtcConnection extends subscribed_1.Subscribed {
+    constructor(ticket, camera, options) {
+        super();
+        this.camera = camera;
+        this.onSessionId = new rxjs_1.ReplaySubject(1);
+        this.onOfferSent = new rxjs_1.ReplaySubject(1);
+        this.dialogId = (0, util_1.generateUuid)();
+        this.onCallAnswered = new rxjs_1.ReplaySubject(1);
+        this.onCallEnded = new rxjs_1.ReplaySubject(1);
+        this.onError = new rxjs_1.ReplaySubject(1);
+        this.onMessage = new rxjs_1.ReplaySubject();
+        this.sessionId = null;
+        this.hasEnded = false;
+        this.ws = new ws_1.WebSocket(`wss://api.prod.signalling.ring.devices.a2z.com:443/ws?api_version=4.0&auth_type=ring_solutions&client_id=ring_site-${(0, util_1.generateUuid)()}&token=${ticket}`, {
             headers: {
-                API_VERSION: '3.1',
-                API_TOKEN: sessionId,
-                CLIENT_INFO: 'Ring/3.49.0;Platform/Android;OS/7.0;Density/2.0;Device/samsung-SM-T710;Locale/en-US;TimeZone/GMT-07:00',
+                // This must exist or the socket will close immediately but content does not seem to matter
+                'User-Agent': 'android:com.ringapp',
             },
-        }), options);
-        this.sessionId = sessionId;
-        this.addSubscriptions(this.onWsOpen.subscribe(() => {
-            (0, util_1.logDebug)(`WebSocket connected for ${camera.name}`);
+        });
+        if (options.createPeerConnection) {
+            // we were passed a custom peer connection factory
+            this.pc = options.createPeerConnection();
+            // passing rtp packets is not supported for custom peer connections
+            this.onAudioRtp = new rxjs_1.Subject();
+            this.onVideoRtp = new rxjs_1.Subject();
+        }
+        else {
+            // no custom peer connection factory, use the werift and pass along rtp packets
+            const pc = new peer_connection_1.WeriftPeerConnection();
+            this.pc = pc;
+            this.onAudioRtp = pc.onAudioRtp;
+            this.onVideoRtp = pc.onVideoRtp;
+        }
+        this.onWsOpen = (0, rxjs_1.fromEvent)(this.ws, 'open');
+        const onMessage = (0, rxjs_1.fromEvent)(this.ws, 'message'), onError = (0, rxjs_1.fromEvent)(this.ws, 'error'), onClose = (0, rxjs_1.fromEvent)(this.ws, 'close');
+        this.addSubscriptions(onMessage
+            .pipe((0, operators_1.concatMap)((event) => {
+            const message = JSON.parse(event.data);
+            this.onMessage.next(message);
+            return this.handleMessage(message).catch((e) => {
+                if (e instanceof Error &&
+                    e.message.includes('negotiate codecs failed')) {
+                    e = new Error('Failed to negotiate codecs.  This is a known issue with Ring cameras.  Please see https://github.com/dgreif/ring/wiki/Streaming-Legacy-Mode');
+                }
+                this.onError.next(e);
+                throw e;
+            });
+        }))
+            .subscribe(), onError.subscribe((e) => {
+            (0, util_1.logError)(e);
+            this.callEnded();
+        }), onClose.subscribe(() => {
+            this.callEnded();
+        }), this.pc.onConnectionState.subscribe((state) => {
+            if (state === 'failed') {
+                (0, util_1.logError)('Stream connection failed');
+                this.callEnded();
+            }
+            if (state === 'closed') {
+                (0, util_1.logDebug)('Stream connection closed');
+                this.callEnded();
+            }
+        }), this.onError.subscribe((e) => {
+            (0, util_1.logError)(e);
+            this.callEnded();
+        }), this.onWsOpen.subscribe(() => {
+            const connectionType = camera.isRingEdgeEnabled ? 'Ring Edge' : 'Cloud';
+            (0, util_1.logDebug)(`WebSocket connected for ${camera.name} (${connectionType})`);
+            this.initiateCall().catch((e) => {
+                (0, util_1.logError)(e);
+                this.callEnded();
+            });
+        }), 
+        // The ring-edge session needs a ping every 5 seconds to keep the connection alive
+        (0, rxjs_1.interval)(5000).subscribe(() => {
+            this.sendSessionMessage('ping');
+        }), this.pc.onIceCandidate.subscribe(async (iceCandidate) => {
+            await (0, rxjs_1.firstValueFrom)(this.onOfferSent);
+            this.sendMessage({
+                method: 'ice',
+                dialog_id: this.dialogId,
+                body: {
+                    doorbot_id: camera.id,
+                    ice: iceCandidate.candidate,
+                    mlineindex: iceCandidate.sdpMLineIndex,
+                },
+            });
         }));
     }
+    async initiateCall() {
+        const { sdp } = await this.pc.createOffer();
+        this.sendMessage({
+            method: 'live_view',
+            dialog_id: this.dialogId,
+            body: {
+                doorbot_id: this.camera.id,
+                stream_options: { audio_enabled: true, video_enabled: true },
+                sdp,
+            },
+        });
+        this.onOfferSent.next();
+    }
     async handleMessage(message) {
+        if (message.body.doorbot_id !== this.camera.id) {
+            // ignore messages for other cameras
+            return;
+        }
+        if (['session_created', 'session_started'].includes(message.method) &&
+            'session_id' in message.body &&
+            !this.sessionId) {
+            this.sessionId = message.body.session_id;
+            this.onSessionId.next(this.sessionId);
+        }
+        if (message.body.session_id && message.body.session_id !== this.sessionId) {
+            // ignore messages for other sessions
+            return;
+        }
         switch (message.method) {
+            case 'session_created':
+            case 'session_started':
+                // session already stored above
+                return;
             case 'sdp':
-                const answer = await this.pc.createAnswer(message);
-                this.sendSessionMessage('sdp', answer);
-                this.onCallAnswered.next(message.sdp);
+                await this.pc.acceptAnswer(message.body);
+                this.onCallAnswered.next(message.body.sdp);
                 this.activate();
                 return;
             case 'ice':
                 await this.pc.addIceCandidate({
-                    candidate: message.ice,
-                    sdpMLineIndex: message.mlineindex,
+                    candidate: message.body.ice,
+                    sdpMLineIndex: message.body.mlineindex,
                 });
                 return;
+            case 'pong':
+                return;
+            case 'notification':
+                const { text } = message.body;
+                if (text === 'PeerConnectionState::kConnecting' ||
+                    text === 'PeerConnectionState::kConnected' ||
+                    text === 'camera_connected') {
+                    return;
+                }
+                break;
+            case 'close':
+                (0, util_1.logError)('Video stream closed');
+                (0, util_1.logError)(message.body);
+                this.callEnded();
+                return;
         }
+        (0, util_1.logError)('UNKNOWN MESSAGE');
+        (0, util_1.logError)(message);
     }
     sendSessionMessage(method, body = {}) {
-        this.sendMessage({
-            ...body,
-            method,
+        const sendSessionMessage = (sessionId) => {
+            const message = {
+                method,
+                dialog_id: this.dialogId,
+                body: {
+                    ...body,
+                    doorbot_id: this.camera.id,
+                    session_id: sessionId,
+                },
+            };
+            this.sendMessage(message);
+        };
+        if (this.sessionId) {
+            // Send immediately if we already have a session id
+            // This is needed to send `close` before closing the websocket
+            sendSessionMessage(this.sessionId);
+        }
+        else {
+            // Otherwise wait for the session id to be set and then send the message
+            this.addSubscriptions(this.onSessionId.pipe((0, operators_1.take)(1)).subscribe(sendSessionMessage));
+        }
+    }
+    sendMessage(message) {
+        if (this.hasEnded) {
+            return;
+        }
+        this.ws.send(JSON.stringify(message));
+    }
+    sendAudioPacket(rtp) {
+        if (this.hasEnded) {
+            return;
+        }
+        if (this.pc instanceof peer_connection_1.WeriftPeerConnection) {
+            this.pc.returnAudioTrack.writeRtp(rtp);
+        }
+        else {
+            throw new Error('Cannot send audio packets to a custom peer connection implementation');
+        }
+    }
+    activate() {
+        (0, util_1.logInfo)('Activating Session');
+        // the activate_session message is required to keep the stream alive longer than 70 seconds
+        this.sendSessionMessage('activate_session');
+        this.sendSessionMessage('stream_options', {
+            audio_enabled: true,
+            video_enabled: true,
         });
     }
+    activateCameraSpeaker() {
+        // Fire and forget this call so that callers don't get hung up waiting for answer (which might not happen)
+        this.addSubscriptions(this.onCallAnswered.pipe((0, operators_1.take)(1)).subscribe(() => {
+            this.sendSessionMessage('camera_options', {
+                stealth_mode: false,
+            });
+        }));
+    }
+    callEnded() {
+        if (this.hasEnded) {
+            return;
+        }
+        try {
+            this.sendMessage({
+                reason: { code: 0, text: '' },
+                method: 'close',
+            });
+            this.ws.close();
+        }
+        catch (_) {
+            // ignore any errors since we are stopping the call
+        }
+        this.hasEnded = true;
+        this.unsubscribe();
+        this.onCallEnded.next();
+        this.pc.close();
+    }
+    stop() {
+        this.callEnded();
+    }
+    requestKeyFrame() {
+        this.pc.requestKeyFrame?.();
+    }
 }
 exports.WebrtcConnection = WebrtcConnection;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ring-client-api",
-  "version": "11.8.1",
+  "version": "12.0.0-beta.1",
   "description": "Unofficial API for Ring doorbells, cameras, security alarm system and smart lighting",
   "main": "lib/index.js",
   "exports": {
@@ -31,10 +31,13 @@
     "socket.io-client": "^2.5.0",
     "systeminformation": "^5.18.10",
     "uuid": "^9.0.0",
-    "webcrypto-core": "^1.7.7",
     "werift": "0.18.5",
     "ws": "^8.13.0"
   },
+  "overrides": {
+    "webcrypto-core": "^1.7.7",
+    "pvtsutils": "1.3.2"
+  },
   "devDependencies": {
     "@types/debug": "4.1.8",
     "@types/jest": "29.5.3",
@@ -49,7 +52,7 @@
     "typescript": "5.1.6"
   },
   "engines": {
-    "node": "^16 || ^18 || ^20"
+    "node": "^18 || ^20"
   },
   "repository": {
     "type": "git",

package/lib/streaming/ring-edge-connection.js

@@ -1,147 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RingEdgeConnection = void 0;
-const ws_1 = require("ws");
-const rxjs_1 = require("rxjs");
-const util_1 = require("../util");
-const streaming_connection_base_1 = require("./streaming-connection-base");
-const crypto_1 = __importDefault(require("crypto"));
-// eslint-disable-next-line no-shadow
-var CloseReasonCode;
-(function (CloseReasonCode) {
-    CloseReasonCode[CloseReasonCode["NormalClose"] = 0] = "NormalClose";
-    // reason: { code: 5, text: '[rsl-apps/webrtc-liveview-server/Session.cpp:429] [Auth] [0xd540]: [rsl-apps/session-manager/Manager.cpp:227] [AppAuth] Unauthorized: invalid or expired token' }
-    // reason: { code: 5, text: 'Authentication failed: -1' }
-    // reason: { code: 5, text: 'Sessions with the provided ID not found' }
-    CloseReasonCode[CloseReasonCode["AuthenticationFailed"] = 5] = "AuthenticationFailed";
-    // reason: { code: 6, text: 'Timeout waiting for ping' }
-    CloseReasonCode[CloseReasonCode["Timeout"] = 6] = "Timeout";
-})(CloseReasonCode || (CloseReasonCode = {}));
-class RingEdgeConnection extends streaming_connection_base_1.StreamingConnectionBase {
-    constructor(authToken, camera, options) {
-        super(new ws_1.WebSocket('wss://api.prod.signalling.ring.devices.a2z.com:443/ws', {
-            headers: {
-                Authorization: `Bearer ${authToken}`,
-                'X-Sig-API-Version': '4.0',
-                'X-Sig-Client-ID': `ring_android-${crypto_1.default
-                    .randomBytes(4)
-                    .toString('hex')}`,
-                'X-Sig-Client-Info': 'Ring/3.49.0;Platform/Android;OS/7.0;Density/2.0;Device/samsung-SM-T710;Locale/en-US;TimeZone/GMT-07:00',
-                'X-Sig-Auth-Type': 'ring_oauth',
-            },
-        }), options);
-        this.camera = camera;
-        this.onSessionId = new rxjs_1.ReplaySubject(1);
-        this.onOfferSent = new rxjs_1.ReplaySubject(1);
-        this.sessionId = null;
-        this.addSubscriptions(this.onWsOpen.subscribe(() => {
-            (0, util_1.logDebug)(`WebSocket connected for ${camera.name} (Ring Edge)`);
-            this.initiateCall().catch((e) => {
-                (0, util_1.logError)(e);
-                this.callEnded();
-            });
-        }), 
-        // The ring-edge session needs a ping every 5 seconds to keep the connection alive
-        (0, rxjs_1.interval)(5000).subscribe(() => {
-            this.sendSessionMessage('ping');
-        }), this.pc.onIceCandidate.subscribe(async (iceCandidate) => {
-            await (0, rxjs_1.firstValueFrom)(this.onOfferSent);
-            this.sendMessage({
-                method: 'ice',
-                body: {
-                    doorbot_id: camera.id,
-                    ice: iceCandidate.candidate,
-                    mlineindex: iceCandidate.sdpMLineIndex,
-                },
-            });
-        }));
-    }
-    async initiateCall() {
-        const { sdp } = await this.pc.createOffer();
-        this.sendMessage({
-            method: 'live_view',
-            body: {
-                doorbot_id: this.camera.id,
-                stream_options: { audio_enabled: true, video_enabled: true },
-                sdp,
-            },
-        });
-        this.onOfferSent.next();
-    }
-    async handleMessage(message) {
-        if (message.body.doorbot_id !== this.camera.id) {
-            // ignore messages for other cameras
-            return;
-        }
-        if (['session_created', 'session_started'].includes(message.method) &&
-            'session_id' in message.body &&
-            !this.sessionId) {
-            this.sessionId = message.body.session_id;
-            this.onSessionId.next(this.sessionId);
-        }
-        if (message.body.session_id && message.body.session_id !== this.sessionId) {
-            // ignore messages for other sessions
-            return;
-        }
-        switch (message.method) {
-            case 'session_created':
-            case 'session_started':
-                // session already stored above
-                return;
-            case 'sdp':
-                await this.pc.acceptAnswer(message.body);
-                this.onCallAnswered.next(message.body.sdp);
-                this.activate();
-                return;
-            case 'ice':
-                await this.pc.addIceCandidate({
-                    candidate: message.body.ice,
-                    sdpMLineIndex: message.body.mlineindex,
-                });
-                return;
-            case 'pong':
-                return;
-            case 'notification':
-                const { text } = message.body;
-                if (text === 'PeerConnectionState::kConnecting' ||
-                    text === 'PeerConnectionState::kConnected') {
-                    return;
-                }
-                break;
-            case 'close':
-                (0, util_1.logError)('Video stream closed');
-                (0, util_1.logError)(message.body);
-                this.callEnded();
-                return;
-        }
-        (0, util_1.logError)('UNKNOWN MESSAGE');
-        (0, util_1.logError)(message);
-    }
-    sendSessionMessage(method, body = {}) {
-        const sendSessionMessage = () => {
-            const message = {
-                method,
-                body: {
-                    ...body,
-                    doorbot_id: this.camera.id,
-                    session_id: this.sessionId,
-                },
-            };
-            this.sendMessage(message);
-        };
-        if (this.sessionId) {
-            // Send immediately if we already have a session id
-            // This is needed to send `close` before closing the websocket
-            sendSessionMessage();
-        }
-        else {
-            (0, rxjs_1.firstValueFrom)(this.onSessionId)
-                .then(sendSessionMessage)
-                .catch((e) => (0, util_1.logError)(e));
-        }
-    }
-}
-exports.RingEdgeConnection = RingEdgeConnection;

package/lib/streaming/streaming-connection-base.d.ts

@@ -1,35 +0,0 @@
-import { BasicPeerConnection } from './peer-connection';
-import { Subscribed } from '../subscribed';
-import { WebSocket } from 'ws';
-import { RtpPacket } from 'werift';
-import { ReplaySubject, Subject } from 'rxjs';
-export interface StreamingConnectionOptions {
-    createPeerConnection?: () => BasicPeerConnection;
-}
-export declare abstract class StreamingConnectionBase extends Subscribed {
-    protected ws: WebSocket;
-    protected options: StreamingConnectionOptions;
-    readonly onCallAnswered: ReplaySubject<string>;
-    readonly onCallEnded: ReplaySubject<void>;
-    readonly onError: ReplaySubject<void>;
-    readonly onMessage: ReplaySubject<{
-        method: string;
-    }>;
-    readonly onWsOpen: import("rxjs").Observable<unknown>;
-    protected readonly pc: BasicPeerConnection;
-    readonly onAudioRtp: Subject<RtpPacket>;
-    readonly onVideoRtp: Subject<RtpPacket>;
-    constructor(ws: WebSocket, options?: StreamingConnectionOptions);
-    protected abstract handleMessage(message: {
-        method: string;
-    }): Promise<void>;
-    protected abstract sendSessionMessage(method: string, body?: Record<any, any>): void;
-    protected activate(): void;
-    activateCameraSpeaker(): void;
-    protected sendMessage(message: Record<any, any>): void;
-    sendAudioPacket(rtp: RtpPacket): void;
-    private hasEnded;
-    protected callEnded(): void;
-    stop(): void;
-    requestKeyFrame(): void;
-}

package/lib/streaming/streaming-connection-base.js

@@ -1,131 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StreamingConnectionBase = void 0;
-const peer_connection_1 = require("./peer-connection");
-const subscribed_1 = require("../subscribed");
-const rxjs_1 = require("rxjs");
-const operators_1 = require("rxjs/operators");
-const util_1 = require("../util");
-class StreamingConnectionBase extends subscribed_1.Subscribed {
-    constructor(ws, options = {}) {
-        super();
-        this.ws = ws;
-        this.options = options;
-        this.onCallAnswered = new rxjs_1.ReplaySubject(1);
-        this.onCallEnded = new rxjs_1.ReplaySubject(1);
-        this.onError = new rxjs_1.ReplaySubject(1);
-        this.onMessage = new rxjs_1.ReplaySubject();
-        this.hasEnded = false;
-        if (options.createPeerConnection) {
-            // we were passed a custom peer connection factory
-            this.pc = options.createPeerConnection();
-            // passing rtp packets is not supported for custom peer connections
-            this.onAudioRtp = new rxjs_1.Subject();
-            this.onVideoRtp = new rxjs_1.Subject();
-        }
-        else {
-            // no custom peer connection factory, use the werift and pass along rtp packets
-            const pc = new peer_connection_1.WeriftPeerConnection();
-            this.pc = pc;
-            this.onAudioRtp = pc.onAudioRtp;
-            this.onVideoRtp = pc.onVideoRtp;
-        }
-        this.onWsOpen = (0, rxjs_1.fromEvent)(this.ws, 'open');
-        const onMessage = (0, rxjs_1.fromEvent)(this.ws, 'message'), onError = (0, rxjs_1.fromEvent)(this.ws, 'error'), onClose = (0, rxjs_1.fromEvent)(this.ws, 'close');
-        this.addSubscriptions(onMessage
-            .pipe((0, operators_1.concatMap)((event) => {
-            const message = JSON.parse(event.data);
-            this.onMessage.next(message);
-            return this.handleMessage(message).catch((e) => {
-                if (e instanceof Error &&
-                    e.message.includes('negotiate codecs failed')) {
-                    e = new Error('Failed to negotiate codecs.  This is a known issue with Ring cameras.  Please see https://github.com/dgreif/ring/wiki/Streaming-Legacy-Mode');
-                }
-                this.onError.next(e);
-                throw e;
-            });
-        }))
-            .subscribe(), onError.subscribe((e) => {
-            (0, util_1.logError)(e);
-            this.callEnded();
-        }), onClose.subscribe(() => {
-            this.callEnded();
-        }), this.pc.onConnectionState.subscribe((state) => {
-            if (state === 'failed') {
-                (0, util_1.logError)('Stream connection failed');
-                this.callEnded();
-            }
-            if (state === 'closed') {
-                (0, util_1.logDebug)('Stream connection closed');
-                this.callEnded();
-            }
-        }), this.onError.subscribe((e) => {
-            (0, util_1.logError)(e);
-            this.callEnded();
-        }));
-    }
-    activate() {
-        (0, util_1.logInfo)('Activating Session');
-        // the activate_session message is required to keep the stream alive longer than 70 seconds
-        this.sendSessionMessage('activate_session');
-        this.sendSessionMessage('stream_options', {
-            audio_enabled: true,
-            video_enabled: true,
-        });
-    }
-    activateCameraSpeaker() {
-        // Fire and forget this call so that callers don't get hung up waiting for answer (which might not happen)
-        (0, rxjs_1.firstValueFrom)(this.onCallAnswered)
-            .then(() => {
-            this.sendSessionMessage('camera_options', {
-                stealth_mode: false,
-            });
-        })
-            .catch((e) => {
-            (0, util_1.logError)(e);
-        });
-    }
-    sendMessage(message) {
-        if (this.hasEnded) {
-            return;
-        }
-        this.ws.send(JSON.stringify(message));
-    }
-    sendAudioPacket(rtp) {
-        if (this.hasEnded) {
-            return;
-        }
-        if (this.pc instanceof peer_connection_1.WeriftPeerConnection) {
-            this.pc.returnAudioTrack.writeRtp(rtp);
-        }
-        else {
-            throw new Error('Cannot send audio packets to a custom peer connection implementation');
-        }
-    }
-    callEnded() {
-        if (this.hasEnded) {
-            return;
-        }
-        try {
-            this.sendMessage({
-                reason: { code: 0, text: '' },
-                method: 'close',
-            });
-            this.ws.close();
-        }
-        catch (_) {
-            // ignore any errors since we are stopping the call
-        }
-        this.hasEnded = true;
-        this.unsubscribe();
-        this.onCallEnded.next();
-        this.pc.close();
-    }
-    stop() {
-        this.callEnded();
-    }
-    requestKeyFrame() {
-        this.pc.requestKeyFrame?.();
-    }
-}
-exports.StreamingConnectionBase = StreamingConnectionBase;