homebridge-ring 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/README.md

@@ -59,8 +59,6 @@ Only include an optional parameter if you actually need it.  Default behavior wi
   "hideDoorbellSwitch": true,
   "hideCameraLight": true,
   "hideCameraMotionSensor": true,
-  "sendCameraMotionNotificationsToTv": true,
-  "sendDoorbellMotionNotificationsToTv": true,
   "hideCameraSirenSwitch": true,
   "hideInHomeDoorbellSwitch": true,
   "hideAlarmSirenSwitch": true,
@@ -82,8 +80,6 @@ Option | Default | Explanation
 `hideDoorbellSwitch` | `false` | If you have a Ring video doorbell, you will see a Programmable Switch associated with it.  This switch can be used to perform actions on when the doorbell is pressed using "Single Press" actions.  If you do not care to perform actions when the doorbell is pressed, you can hide the Programmable Switch by setting this option to `true`. You will still be able to receive _notifications_ from the doorbell even if the Programmable Switch is hidden (notifications can be configured in the settings for the doorbell camera in the Home app)
 `hideCameraLight` | `false` | If `true`, hides the light for Ring cameras in HomeKit.
 `hideCameraMotionSensor` | `false` | If `true`, hides the motion sensor for Ring cameras in HomeKit.
-`sendCameraMotionNotificationsToTv` | `false` | If `true`, creates a 'Doorbell' accessory triggered by non-doorbell camera motion alerts for tvOS 14 notification support.
-`sendDoorbellMotionNotificationsToTv` | `false` | If `true`, motion events on doorbell cameras will trigger a doorbell press event for tvOS 14 notification support.
 `hideCameraSirenSwitch` | `false` | If `true`, hides the siren switch for Ring cameras in HomeKit.
 `hideInHomeDoorbellSwitch` | `false` | If `true`, hides the switch for in-home doorbells in HomeKit.
 `hideAlarmSirenSwitch` | `false` | If you have a Ring Alarm, you will see both the alarm and a "Siren" switch in HomeKit.  The siren switch can sometimes get triggered by Siri commands by accident, which is loud and annoying.  Set this option to `true` to hide the siren switch.
@@ -105,7 +101,6 @@ Option | Default | Explanation
     * Shows a live feed from the camera if you click on it.  The feed supports video and 2-way audio, but requires that you have `ffmpeg` with `libfdk_aac` installed.  A pre-built `ffmpeg` will be automatically installed on most platforms using `ffmpeg-for-homebridge`.  See the [FFmpeg wiki](https://github.com/dgreif/ring/wiki/FFmpeg) for details.
   * Motion Sensor
     * Can be hidden with `hideCameraMotionSensor`
-    * Can trigger doorbell events with `sendCameraMotionNotificationsToTv` and `sendDoorbellMotionNotificationsToTv` for tvOS 14 notifications
   * Light (if camera is equipped)
   * Siren Switch (if camera is equipped)
     * Can be hidden with `hideCameraSirenSwitch`
@@ -121,6 +116,8 @@ HomeKit with a snapshot from the camera
 
 If you are having issues with your cameras in the Home app, please see the [Camera Troubleshooting Wiki](https://github.com/dgreif/ring/wiki/Camera-Troubleshooting)
 
+Note: Although homebridge has support for HomeKit Secure Video (HKSV), I will not be adding it to this plugin.  Please see [this issue](https://github.com/dgreif/ring/issues/860#issuecomment-1021584211) for more details.
+
 ### Supported Devices via Ring Alarm and Ring Smart Lighting Hubs
   * Security Panel
     * This is a software device that represents the alarm for a Ring location

package/config.schema.json

@@ -86,14 +86,6 @@
         "type": "boolean",
         "description": "Causes snapshots for battery cameras to be fetched at a minimum 10 minute interval to avoid draining the battery.  This is useful if have the Home app open constantly, causing frequent snapshot requests."
       },
-      "sendCameraMotionNotificationsToTv": {
-        "title": "Create a 'Doorbell' accessory triggered by non-doorbell camera motion alerts for tvOS 14 notification support",
-        "type": "boolean"
-      },
-      "sendDoorbellMotionNotificationsToTv": {
-        "title": "Motion events on doorbell cameras will trigger a doorbell press event for tvOS 14 notification support.",
-        "type": "boolean"
-      },
       "beamDurationSeconds": {
         "title": "Ring Smart Lighting Timer",
         "type": "integer",
@@ -140,6 +132,10 @@
         "items": {
           "type": "string"
         }
+      },
+      "name": {
+        "title": "Name",
+        "type": "string"
       }
     },
     "required": ["refreshToken"]
@@ -167,8 +163,6 @@
         "showPanicButtons",
         "nightModeBypassFor",
         "avoidSnapshotBatteryDrain",
-        "sendCameraMotionNotificationsToTv",
-        "sendDoorbellMotionNotificationsToTv",
         "beamDurationSeconds",
         "debug",
         "cameraStatusPollingSeconds",

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>;
+}