ring-client-api 10.0.0-beta.5 → 10.0.0-beta.8

package/CHANGELOG.md

@@ -2,6 +2,45 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+## [10.0.0-beta.8](https://github.com/dgreif/ring/compare/v10.0.0-beta.7...v10.0.0-beta.8) (2022-05-07)
+
+
+### Bug Fixes
+
+* remove unnecessary dependencies ([0acf3c3](https://github.com/dgreif/ring/commit/0acf3c35ce2b62d98e3e50ba8489996400efb4e3))
+
+## [10.0.0-beta.7](https://github.com/dgreif/ring/compare/v10.0.0-beta.6...v10.0.0-beta.7) (2022-05-07)
+
+
+### ⚠ BREAKING CHANGES
+
+* The `sendDoorbellMotionNotificationsToTv` and `sendCameraMotionNotificationsToTv` options have been removed.  These options were originally inteded as a workaround for the fact that tvOS would only automatically start streaming for doorbell presses and not for motion events.  tvOS 15 now supports this features as an option in the UI, so we no longer need this option at the plugin level.
+
+### Features
+
+* add `cocoa_floodlight` ([c7a7e9c](https://github.com/dgreif/ring/commit/c7a7e9cabf45ec6579a7d9a1033fa01930923243)), closes [#893](https://github.com/dgreif/ring/issues/893)
+* **api:** simple webrtc session ([bac7a49](https://github.com/dgreif/ring/commit/bac7a49178bb5a22914e53fda91c0fdd522b4a74))
+
+
+### Bug Fixes
+
+* **homebridge:** add `name` option to schema so that it won't be removed by config-ui ([af6755a](https://github.com/dgreif/ring/commit/af6755aa09cf4aaad0963499ad0d1afd0beeab96)), closes [#870](https://github.com/dgreif/ring/issues/870)
+* include device name when setting push token ([2466a25](https://github.com/dgreif/ring/commit/2466a2519341771d8c79557b5a61c339f31eddf6)), closes [#920](https://github.com/dgreif/ring/issues/920)
+* npm audit fix ([c1fe605](https://github.com/dgreif/ring/commit/c1fe6051e46dac92b00bb2fd1202746fd576b15a))
+* remove doorbell press simulation options ([e1d1225](https://github.com/dgreif/ring/commit/e1d12257b2acbdafdc6995a53d9052822c8a3460))
+
+## [10.0.0-beta.6](https://github.com/dgreif/ring/compare/v10.0.0-beta.5...v10.0.0-beta.6) (2022-05-06)
+
+
+### Features
+
+* **api:** allow custom peer connections for streaming ([3e9e784](https://github.com/dgreif/ring/commit/3e9e78458afe2849a8c414a6b50eec8718bf77cc))
+
+
+### Bug Fixes
+
+* update dependencies ([4b25595](https://github.com/dgreif/ring/commit/4b255950bcfbf94486192d55cfc90d966cd79d24))
+
 ## [10.0.0-beta.5](https://github.com/dgreif/ring/compare/v10.0.0-beta.4...v10.0.0-beta.5) (2022-04-10)
 
 

package/lib/api/api.js

@@ -112,9 +112,7 @@ class RingApi extends subscribed_1.Subscribed {
                         method: 'PATCH',
                         json: {
                             device: {
-                                metadata: {
-                                    pn_service: 'fcm',
-                                },
+                                metadata: Object.assign(Object.assign({}, this.restClient.baseSessionMetadata), { pn_service: 'fcm' }),
                                 os: 'android',
                                 push_notification_token: token,
                             },

package/lib/api/rest-client.d.ts

@@ -35,6 +35,10 @@ export declare class RingRestClient {
         oldRefreshToken?: string | undefined;
         newRefreshToken: string;
     }>;
+    readonly baseSessionMetadata: {
+        api_version: number;
+        device_model: string;
+    };
     constructor(authOptions: (EmailAuth | RefreshTokenAuth) & SessionOptions);
     private getGrantData;
     getAuth(twoFactorAuthCode?: string): Promise<AuthTokenResponse>;
@@ -44,6 +48,7 @@ export declare class RingRestClient {
     private refreshSession;
     request<T = void>(options: RequestOptions & {
         url: string;
+        allowNoResponse?: boolean;
     }): Promise<T & ExtendedResponse>;
     getCurrentAuth(): Promise<AuthTokenResponse>;
     clearTimeouts(): void;

package/lib/api/rest-client.js

@@ -55,7 +55,7 @@ function requestWithRetry(requestOptions) {
             return data;
         }
         catch (e) {
-            if (!e.response) {
+            if (!e.response && !requestOptions.allowNoResponse) {
                 (0, util_1.logError)(`Failed to reach Ring server at ${requestOptions.url}.  ${e.message}.  Trying again in 5 seconds...`);
                 if (e.message.includes('NGHTTP2_ENHANCE_YOUR_CALM')) {
                     (0, util_1.logError)(`There is a known issue with your current NodeJS version (${process.version}).  Please see https://github.com/dgreif/ring/wiki/NGHTTP2_ENHANCE_YOUR_CALM-Error for details`);
@@ -70,11 +70,16 @@ function requestWithRetry(requestOptions) {
 }
 class RingRestClient {
     constructor(authOptions) {
+        var _a;
         this.authOptions = authOptions;
         this.timeouts = [];
         this.sessionPromise = undefined;
         this.using2fa = false;
         this.onRefreshTokenUpdated = new rxjs_1.ReplaySubject(1);
+        this.baseSessionMetadata = {
+            api_version: apiVersion,
+            device_model: (_a = this.authOptions.controlCenterDisplayName) !== null && _a !== void 0 ? _a : 'ring-client-api',
+        };
         this.refreshToken =
             'refreshToken' in this.authOptions
                 ? this.authOptions.refreshToken
@@ -184,17 +189,13 @@ class RingRestClient {
         });
     }
     fetchNewSession(authToken) {
-        var _a;
         return __awaiter(this, void 0, void 0, function* () {
             return requestWithRetry({
                 url: clientApi('session'),
                 json: {
                     device: {
                         hardware_id: yield this.hardwareIdPromise,
-                        metadata: {
-                            api_version: apiVersion,
-                            device_model: (_a = this.authOptions.controlCenterDisplayName) !== null && _a !== void 0 ? _a : 'ring-client-api',
-                        },
+                        metadata: this.baseSessionMetadata,
                         os: 'android', // can use android, ios, ring-site, windows for sure
                     },
                 },

package/lib/api/ring-camera.d.ts

@@ -4,8 +4,9 @@ import { RingRestClient } from './rest-client';
 import { BehaviorSubject, Subject } from 'rxjs';
 import { DeepPartial } from './util';
 import { Subscribed } from './subscribed';
-import { FfmpegOptions, LiveCall } from './live-call';
-import { LiveCallRingEdge } from './live-call-ring-edge';
+import { FfmpegOptions, StreamingSession } from './streaming/streaming-session';
+import { StreamingConnectionOptions } from './streaming/streaming-connection-base';
+import { SimpleWebRtcSession } from './streaming/simple-webrtc-session';
 export declare function getBatteryLevel(data: Pick<CameraData, 'battery_life' | 'battery_life_2'> & {
     health?: Partial<CameraData['health']>;
 }): number | null;
@@ -55,7 +56,8 @@ export declare class RingCamera extends Subscribed {
     getDeviceSettings(): Promise<CameraDeviceSettingsData & import("./rest-client").ExtendedResponse>;
     setInHomeDoorbell(enable: boolean): Promise<boolean>;
     getHealth(): Promise<CameraHealth>;
-    startLiveCall(): Promise<LiveCall | LiveCallRingEdge>;
+    private createStreamingConnection;
+    startLiveCall(options?: StreamingConnectionOptions): Promise<StreamingSession>;
     private removeDingById;
     processPushNotification(notification: PushNotification): void;
     getEvents(options?: CameraEventOptions): Promise<CameraEventResponse & import("./rest-client").ExtendedResponse>;
@@ -93,7 +95,14 @@ export declare class RingCamera extends Subscribed {
     }): Promise<Buffer & import("./rest-client").ExtendedResponse>;
     getSnapshotByUuid(uuid: string): Promise<Buffer & import("./rest-client").ExtendedResponse>;
     recordToFile(outputPath: string, duration?: number): Promise<void>;
-    streamVideo(ffmpegOptions: FfmpegOptions): Promise<LiveCall | LiveCallRingEdge>;
+    streamVideo(ffmpegOptions: FfmpegOptions): Promise<StreamingSession>;
+    /**
+     * Returns a SimpleWebRtcSession, which can be initiated with an sdp offer.
+     * This session has no backplane for trickle ICE, and is designed for use in a
+     * browser setting.  Note, cameras with Ring Edge enabled will stream with the speaker
+     * enabled as soon as the stream starts, which can drain the battery more quickly.
+     */
+    createSimpleWebRtcSession(): SimpleWebRtcSession;
     subscribeToDingEvents(): Promise<void & import("./rest-client").ExtendedResponse>;
     unsubscribeFromDingEvents(): Promise<void & import("./rest-client").ExtendedResponse>;
     subscribeToMotionEvents(): Promise<void & import("./rest-client").ExtendedResponse>;

package/lib/api/ring-camera.js

@@ -16,8 +16,10 @@ const rxjs_1 = require("rxjs");
 const operators_1 = require("rxjs/operators");
 const util_1 = require("./util");
 const subscribed_1 = require("./subscribed");
-const live_call_1 = require("./live-call");
-const live_call_ring_edge_1 = require("./live-call-ring-edge");
+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;
 function parseBatteryLife(batteryLife) {
     if (batteryLife === null || batteryLife === undefined) {
@@ -229,11 +231,11 @@ class RingCamera extends subscribed_1.Subscribed {
             return response.device_health;
         });
     }
-    startLiveCall() {
+    createStreamingConnection(options) {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.isRingEdgeEnabled) {
                 const auth = yield this.restClient.getCurrentAuth();
-                return new live_call_ring_edge_1.LiveCallRingEdge(auth.access_token, this);
+                return new ring_edge_connection_1.RingEdgeConnection(auth.access_token, this, options);
             }
             const liveCall = yield this.restClient
                 .request({
@@ -249,7 +251,13 @@ class RingCamera extends subscribed_1.Subscribed {
                 }
                 throw e;
             });
-            return new live_call_1.LiveCall(liveCall.data.session_id, this);
+            return new webrtc_connection_1.WebrtcConnection(liveCall.data.session_id, this, options);
+        });
+    }
+    startLiveCall(options = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const connection = yield this.createStreamingConnection(options);
+            return new streaming_session_1.StreamingSession(this, connection);
         });
     }
     removeDingById(idToRemove) {
@@ -409,6 +417,15 @@ class RingCamera extends subscribed_1.Subscribed {
             return liveCall;
         });
     }
+    /**
+     * Returns a SimpleWebRtcSession, which can be initiated with an sdp offer.
+     * This session has no backplane for trickle ICE, and is designed for use in a
+     * browser setting.  Note, cameras with Ring Edge enabled will stream with the speaker
+     * enabled as soon as the stream starts, which can drain the battery more quickly.
+     */
+    createSimpleWebRtcSession() {
+        return new simple_webrtc_session_1.SimpleWebRtcSession(this, this.restClient);
+    }
     subscribeToDingEvents() {
         return this.restClient.request({
             method: 'POST',

package/lib/api/ring-types.d.ts

@@ -85,6 +85,7 @@ export declare enum RingCameraKind {
     floodlight_pro = "floodlight_pro",
     cocoa_camera = "cocoa_camera",
     cocoa_doorbell = "cocoa_doorbell",
+    cocoa_floodlight = "cocoa_floodlight",
     stickup_cam_mini = "stickup_cam_mini"
 }
 export declare const RingCameraModel: {

package/lib/api/ring-types.js

@@ -93,6 +93,7 @@ var RingCameraKind;
     RingCameraKind["floodlight_pro"] = "floodlight_pro";
     RingCameraKind["cocoa_camera"] = "cocoa_camera";
     RingCameraKind["cocoa_doorbell"] = "cocoa_doorbell";
+    RingCameraKind["cocoa_floodlight"] = "cocoa_floodlight";
     RingCameraKind["stickup_cam_mini"] = "stickup_cam_mini";
 })(RingCameraKind = exports.RingCameraKind || (exports.RingCameraKind = {}));
 exports.RingCameraModel = {
@@ -121,6 +122,7 @@ exports.RingCameraModel = {
     floodlight_pro: 'Floodlight Pro',
     cocoa_camera: 'Stick Up Cam',
     cocoa_doorbell: 'Doorbell Gen 2',
+    cocoa_floodlight: 'Floodlight Cam Plus',
     stickup_cam_mini: 'Indoor Cam',
 };
 exports.allAlarmStates = [

package/lib/api/{peer-connection.d.ts → streaming/peer-connection.d.ts}

@@ -1,7 +1,24 @@
-import { MediaStreamTrack, RTCIceCandidate, RTCPeerConnection, RtcpPacket, RtpPacket } from '@koush/werift';
-import { ReplaySubject, Subject } from 'rxjs';
-export declare class PeerConnection {
-    pc: RTCPeerConnection;
+import { ConnectionState, MediaStreamTrack, RTCIceCandidate, RtcpPacket, RtpPacket } from '@koush/werift';
+import { Observable, ReplaySubject, Subject } from 'rxjs';
+export interface BasicPeerConnection {
+    createOffer(): Promise<{
+        sdp: string;
+    }>;
+    createAnswer(offer: {
+        type: 'offer';
+        sdp: string;
+    }): Promise<RTCSessionDescriptionInit>;
+    acceptAnswer(answer: {
+        type: 'answer';
+        sdp: string;
+    }): Promise<void>;
+    addIceCandidate(candidate: RTCIceCandidate): Promise<void>;
+    onIceCandidate: Observable<RTCIceCandidate>;
+    onConnectionState: Observable<ConnectionState>;
+    close(): void;
+}
+export declare class WeriftPeerConnection implements BasicPeerConnection {
+    private pc;
     onAudioRtp: Subject<RtpPacket>;
     onAudioRtcp: Subject<RtcpPacket>;
     onVideoRtp: Subject<RtpPacket>;

package/lib/api/{peer-connection.js → streaming/peer-connection.js}

@@ -9,10 +9,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PeerConnection = void 0;
+exports.WeriftPeerConnection = void 0;
 const werift_1 = require("@koush/werift");
 const rxjs_1 = require("rxjs");
-const util_1 = require("./util");
+const util_1 = require("../util");
 const debug = false, ringIceServers = [
     'stun:stun.kinesisvideo.us-east-1.amazonaws.com:443',
     'stun:stun.kinesisvideo.us-east-2.amazonaws.com:443',
@@ -23,7 +23,7 @@ const debug = false, ringIceServers = [
     'stun:stun3.l.google.com:19302',
     'stun:stun4.l.google.com:19302',
 ];
-class PeerConnection {
+class WeriftPeerConnection {
     constructor() {
         this.onAudioRtp = new rxjs_1.Subject();
         this.onAudioRtcp = new rxjs_1.Subject();
@@ -131,4 +131,4 @@ class PeerConnection {
         this.pc.close().catch(util_1.logError);
     }
 }
-exports.PeerConnection = PeerConnection;
+exports.WeriftPeerConnection = WeriftPeerConnection;

package/lib/api/streaming/ring-edge-connection.d.ts

@@ -0,0 +1,65 @@
+import { RingCamera } from '../ring-camera';
+import { StreamingConnectionBase, StreamingConnectionOptions } from './streaming-connection-base';
+interface SessionBody {
+    doorbot_id: number;
+    session_id: string;
+}
+interface AnswerMessage {
+    method: 'sdp';
+    body: {
+        sdp: string;
+        type: 'answer';
+    } & SessionBody;
+}
+interface IceCandidateMessage {
+    method: 'ice';
+    body: {
+        ice: string;
+        mlineindex: number;
+    } & SessionBody;
+}
+interface SessionCreatedMessage {
+    method: 'session_created';
+    body: SessionBody;
+}
+interface SessionStartedMessage {
+    method: 'session_started';
+    body: SessionBody;
+}
+interface PongMessage {
+    method: 'pong';
+    body: SessionBody;
+}
+interface NotificationMessage {
+    method: 'notification';
+    body: {
+        is_ok: boolean;
+        text: string;
+    } & SessionBody;
+}
+declare enum CloseReasonCode {
+    NormalClose = 0,
+    AuthenticationFailed = 5,
+    Timeout = 6
+}
+interface CloseMessage {
+    method: 'close';
+    body: {
+        reason: {
+            code: CloseReasonCode;
+            text: string;
+        };
+    } & SessionBody;
+}
+declare 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 {};

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

@@ -0,0 +1,155 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+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 operators_1 = require("rxjs/operators");
+const streaming_connection_base_1 = require("./streaming-connection-base");
+// 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-aabb123',
+                '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
+        this.onCallAnswered
+            .pipe((0, operators_1.switchMap)(() => (0, rxjs_1.interval)(5000)))
+            .subscribe(() => {
+            if (!this.sessionId) {
+                return;
+            }
+            this.sendSessionMessage('ping');
+        }), this.pc.onIceCandidate.subscribe((iceCandidate) => __awaiter(this, void 0, void 0, function* () {
+            yield (0, rxjs_1.firstValueFrom)(this.onOfferSent);
+            this.sendMessage({
+                method: 'ice',
+                body: {
+                    doorbot_id: camera.id,
+                    ice: iceCandidate.candidate,
+                    mlineindex: 0,
+                },
+            });
+            // HACK: send ice candidate with both mline indexes to convince ring edge to connect both audio and video
+            // Without this, only audio will connect unless you connect from the network of the Ring Edge router
+            this.sendMessage({
+                method: 'ice',
+                body: {
+                    doorbot_id: camera.id,
+                    ice: iceCandidate.candidate,
+                    mlineindex: 1,
+                },
+            });
+        })));
+    }
+    initiateCall() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { sdp } = yield this.pc.createOffer();
+            this.sendMessage({
+                method: 'live_view',
+                body: {
+                    doorbot_id: this.camera.id,
+                    stream_options: { audio_enabled: true, video_enabled: true },
+                    sdp: sdp.replace('\na=group:BUNDLE 0 1', ''),
+                },
+            });
+            this.onOfferSent.next();
+        });
+    }
+    handleMessage(message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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':
+                    yield this.pc.acceptAnswer(message.body);
+                    this.onCallAnswered.next(message.body.sdp);
+                    return;
+                case 'ice':
+                    yield this.pc.addIceCandidate({
+                        candidate: message.body.ice,
+                        sdpMLineIndex: message.body.mlineindex,
+                    });
+                    return;
+                case 'pong':
+                    return;
+                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 message = {
+            method,
+            body: Object.assign(Object.assign({}, body), { doorbot_id: this.camera.id, session_id: this.sessionId }),
+        };
+        if (this.sessionId) {
+            // Send immediately if we already have a session id
+            // This is needed to send `close` before closing the websocket
+            this.sendMessage(message);
+        }
+        else {
+            (0, rxjs_1.firstValueFrom)(this.onSessionId)
+                .then(() => this.sendMessage(message))
+                .catch((e) => (0, util_1.logError)(e));
+        }
+    }
+}
+exports.RingEdgeConnection = RingEdgeConnection;

package/lib/api/streaming/simple-webrtc-session.d.ts

@@ -0,0 +1,11 @@
+import { RingCamera } from '../ring-camera';
+import { RingRestClient } from '../rest-client';
+export declare class SimpleWebRtcSession {
+    private readonly camera;
+    private restClient;
+    readonly sessionId: string;
+    constructor(camera: RingCamera, restClient: RingRestClient);
+    start(sdp: string): Promise<string>;
+    end(): Promise<any>;
+    activateCameraSpeaker(): Promise<void>;
+}

package/lib/api/streaming/simple-webrtc-session.js

@@ -0,0 +1,63 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SimpleWebRtcSession = void 0;
+const util_1 = require("../util");
+function liveViewUrl(path) {
+    return `https://api.ring.com/integrations/v1/liveview/${path}`;
+}
+class SimpleWebRtcSession {
+    constructor(camera, restClient) {
+        this.camera = camera;
+        this.restClient = restClient;
+        this.sessionId = (0, util_1.generateUuid)();
+    }
+    start(sdp) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.restClient.request({
+                method: 'POST',
+                url: liveViewUrl('start'),
+                json: {
+                    session_id: this.sessionId,
+                    device_id: this.camera.id,
+                    sdp,
+                    protocol: 'webrtc',
+                },
+            });
+            return response.sdp;
+        });
+    }
+    end() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resp = yield this.restClient.request({
+                method: 'POST',
+                url: liveViewUrl('end'),
+                json: {
+                    session_id: this.sessionId,
+                },
+            });
+            return resp;
+        });
+    }
+    activateCameraSpeaker() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.restClient.request({
+                method: 'PATCH',
+                url: liveViewUrl('options'),
+                json: {
+                    session_id: this.sessionId,
+                    actions: ['turn_off_stealth_mode'],
+                },
+            });
+        });
+    }
+}
+exports.SimpleWebRtcSession = SimpleWebRtcSession;

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

@@ -0,0 +1,30 @@
+import { BasicPeerConnection } from './peer-connection';
+import { Subscribed } from '../subscribed';
+import { WebSocket } from 'ws';
+import { RtpPacket } from '@koush/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 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;
+    private activated;
+    activate(): Promise<void>;
+    activateCameraSpeaker(): Promise<void>;
+    protected sendMessage(message: Record<any, any>): void;
+    sendAudioPacket(rtp: RtpPacket): void;
+    protected callEnded(): void;
+    stop(): void;
+}