homebridge-ring 10.0.0-beta.1 → 10.0.0-beta.2

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 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.2](https://github.com/dgreif/ring/compare/v10.0.0-beta.1...v10.0.0-beta.2) (2022-03-26)
+
+
+### Features
+
+* support ring edge camera streaming ([b30d99f](https://github.com/dgreif/ring/commit/b30d99f9ffaa1fabc1d09b830cf8ba0e69fe84a0))
+
+
+### Bug Fixes
+
+* **api:** allow snapshot to be force-updated based on options ([fa0212a](https://github.com/dgreif/ring/commit/fa0212ab539cc268f8000c5b9ea39a00799cb8d7))
+
 ## [10.0.0-beta.1](https://github.com/dgreif/ring/compare/v10.0.0-beta.0...v10.0.0-beta.1) (2022-02-27)
 
 

package/lib/api/live-call.d.ts

@@ -10,25 +10,29 @@ export interface FfmpegOptions {
     output: SpawnInput[];
 }
 export declare class LiveCall extends Subscribed {
-    private sessionId;
     private camera;
     private readonly ws;
     private readonly onWsOpen;
     private readonly onMessage;
     private readonly pc;
+    readonly onSessionId: ReplaySubject<string>;
     readonly onCallAnswered: ReplaySubject<string>;
     readonly onCallEnded: ReplaySubject<void>;
     private readonly audioSplitter;
     private readonly videoSplitter;
     readonly onVideoRtp: import("rxjs").Subject<RtpPacket>;
     readonly onAudioRtp: import("rxjs").Subject<RtpPacket>;
-    constructor(sessionId: string, camera: RingCamera);
+    private readonly onOfferSent;
+    constructor(authToken: string, camera: RingCamera);
+    private initiateCall;
+    private sessionId;
     private handleMessage;
     reservePort(bufferPorts?: number): Promise<number>;
     startTranscoding(ffmpegOptions: FfmpegOptions): Promise<void>;
     activated: boolean;
     activate(): Promise<void>;
     activateCameraSpeaker(): Promise<void>;
+    private sendSessionMessage;
     private sendMessage;
     private callEnded;
     stop(): void;

package/lib/api/live-call.js

@@ -10,7 +10,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LiveCall = void 0;
-const rtp_utils_1 = require("./rtp-utils");
 const ws_1 = require("ws");
 const rxjs_1 = require("rxjs");
 const peer_connection_1 = require("./peer-connection");
@@ -19,6 +18,17 @@ const operators_1 = require("rxjs/operators");
 const subscribed_1 = require("./subscribed");
 const camera_utils_1 = require("@homebridge/camera-utils");
 const ffmpeg_1 = require("./ffmpeg");
+// 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 = {}));
 function getCleanSdp(sdp, includeVideo) {
     return sdp
         .split('\nm=')
@@ -28,22 +38,25 @@ function getCleanSdp(sdp, includeVideo) {
         .join('\n');
 }
 class LiveCall extends subscribed_1.Subscribed {
-    constructor(sessionId, camera) {
+    constructor(authToken, camera) {
         super();
-        this.sessionId = sessionId;
         this.camera = camera;
+        this.onSessionId = new rxjs_1.ReplaySubject(1);
         this.onCallAnswered = new rxjs_1.ReplaySubject(1);
         this.onCallEnded = new rxjs_1.ReplaySubject(1);
         this.audioSplitter = new camera_utils_1.RtpSplitter();
         this.videoSplitter = new camera_utils_1.RtpSplitter();
+        this.onOfferSent = new rxjs_1.ReplaySubject(1);
+        this.sessionId = null;
         this.activated = false;
-        const liveCallSession = (0, rtp_utils_1.parseLiveCallSession)(sessionId);
         this.pc = new peer_connection_1.PeerConnection();
-        this.ws = new ws_1.WebSocket(`wss://${liveCallSession.rms_fqdn}:${liveCallSession.webrtc_port}/`, {
+        this.ws = new ws_1.WebSocket('wss://api.prod.signalling.ring.devices.a2z.com:443/ws', {
             headers: {
-                API_VERSION: '3.1',
-                API_TOKEN: sessionId,
-                CLIENT_INFO: 'Ring/3.48.0;Platform/Android;OS/7.0;Density/2.0;Device/samsung-SM-T710;Locale/en-US;TimeZone/GMT-07:00',
+                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',
             },
         });
         this.onAudioRtp = this.pc.onAudioRtp;
@@ -57,28 +70,109 @@ class LiveCall extends subscribed_1.Subscribed {
         }))
             .subscribe(), this.onWsOpen.subscribe(() => {
             (0, util_1.logDebug)(`WebSocket connected for ${this.camera.name}`);
+            this.initiateCall().catch((e) => {
+                (0, util_1.logError)(e);
+                this.callEnded();
+            });
         }), onError.subscribe((e) => {
             (0, util_1.logError)(e);
             this.callEnded();
         }), onClose.subscribe(() => {
             this.callEnded();
+        }), 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: this.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: this.camera.id,
+                    ice: iceCandidate.candidate,
+                    mlineindex: 1,
+                },
+            });
+        })), 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();
+            }
         }));
     }
+    initiateCall() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const offer = yield this.pc.createOffer();
+            offer.sdp = offer.sdp.replace('\na=group:BUNDLE 0 1', '');
+            this.sendMessage({
+                method: 'live_view',
+                body: {
+                    doorbot_id: this.camera.id,
+                    stream_options: { audio_enabled: true, video_enabled: true },
+                    sdp: offer.sdp,
+                },
+            });
+            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':
-                    const answer = yield this.pc.createAnswer(message);
-                    this.sendMessage(Object.assign({ method: 'sdp' }, answer));
-                    this.onCallAnswered.next(message.sdp);
+                    yield this.pc.acceptAnswer(message.body);
+                    this.onCallAnswered.next(message.body.sdp);
                     return;
                 case 'ice':
                     yield this.pc.addIceCandidate({
-                        candidate: message.ice,
-                        sdpMLineIndex: message.mlineindex,
+                        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);
         });
     }
     reservePort(bufferPorts = 0) {
@@ -142,32 +236,42 @@ class LiveCall extends subscribed_1.Subscribed {
                 return;
             }
             this.activated = true;
-            yield (0, rxjs_1.firstValueFrom)(this.onCallAnswered);
-            this.sendMessage({ method: 'activate_session' });
-            this.sendMessage({
-                video_enabled: true,
-                audio_enabled: true,
-                method: 'stream_options',
-            });
+            yield (0, rxjs_1.firstValueFrom)(this.pc.onConnectionState.pipe((0, operators_1.filter)((state) => state === 'connected')));
+            (0, util_1.logInfo)('Activating Session');
+            this.sendSessionMessage('activate_session');
         });
     }
     activateCameraSpeaker() {
         return __awaiter(this, void 0, void 0, function* () {
             yield (0, rxjs_1.firstValueFrom)(this.onCallAnswered);
-            this.sendMessage({
+            this.sendSessionMessage('camera_options', {
                 stealth_mode: false,
-                method: 'camera_options',
             });
         });
     }
+    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));
+        }
+    }
     sendMessage(message) {
         this.ws.send(JSON.stringify(message));
     }
     callEnded() {
         try {
-            this.sendMessage({
-                reason: { code: 0, text: '' },
-                method: 'close',
+            this.sendSessionMessage('close', {
+                reason: { code: CloseReasonCode.NormalClose, text: '' },
             });
             this.ws.close();
         }

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

@@ -1,17 +1,20 @@
 import { MediaStreamTrack, RTCIceCandidate, RTCPeerConnection, RtcpPacket, RtpPacket } from '@koush/werift';
-import { Subject } from 'rxjs';
+import { ReplaySubject, Subject } from 'rxjs';
 export declare class PeerConnection {
     pc: RTCPeerConnection;
     onAudioRtp: Subject<RtpPacket>;
     onAudioRtcp: Subject<RtcpPacket>;
     onVideoRtp: Subject<RtpPacket>;
     onVideoRtcp: Subject<RtcpPacket>;
+    onIceCandidate: Subject<RTCIceCandidate>;
+    onConnectionState: ReplaySubject<"failed" | "closed" | "connected" | "connecting" | "new" | "disconnected">;
     returnAudioTrack: MediaStreamTrack;
     constructor();
-    createAnswer(offer: {
-        type: 'offer';
+    createOffer(): Promise<import("@koush/werift").RTCSessionDescription>;
+    acceptAnswer(answer: {
+        type: 'answer';
         sdp: string;
-    }): Promise<import("@koush/werift").RTCSessionDescription>;
+    }): Promise<void>;
     addIceCandidate(candidate: RTCIceCandidate): Promise<void>;
     close(): void;
 }

package/lib/api/peer-connection.js

@@ -20,6 +20,8 @@ class PeerConnection {
         this.onAudioRtcp = new rxjs_1.Subject();
         this.onVideoRtp = new rxjs_1.Subject();
         this.onVideoRtcp = new rxjs_1.Subject();
+        this.onIceCandidate = new rxjs_1.Subject();
+        this.onConnectionState = new rxjs_1.ReplaySubject(1);
         this.returnAudioTrack = new werift_1.MediaStreamTrack({ kind: 'audio' });
         const pc = (this.pc = new werift_1.RTCPeerConnection({
             codecs: {
@@ -41,7 +43,7 @@ class PeerConnection {
                             { type: 'nack', parameter: 'pli' },
                             { type: 'goog-remb' },
                         ],
-                        parameters: 'level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42e01f',
+                        parameters: 'profile-level-id=42801F',
                     }),
                 ],
             },
@@ -77,13 +79,30 @@ class PeerConnection {
                 setInterval(() => videoTransceiver.receiver.sendRtcpPLI(track.ssrc), 2000);
             });
         });
+        this.pc.onIceCandidate.subscribe((iceCandidate) => {
+            this.onIceCandidate.next(iceCandidate);
+        });
+        pc.iceConnectionStateChange.subscribe(() => {
+            (0, util_1.logInfo)(`iceConnectionStateChange: ${pc.iceConnectionState}`);
+            if (pc.iceConnectionState === 'closed') {
+                this.onConnectionState.next('closed');
+            }
+        });
+        pc.connectionStateChange.subscribe(() => {
+            (0, util_1.logInfo)(`connectionStateChange: ${pc.connectionState}`);
+            this.onConnectionState.next(pc.connectionState);
+        });
+    }
+    createOffer() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const offer = yield this.pc.createOffer();
+            yield this.pc.setLocalDescription(offer);
+            return offer;
+        });
     }
-    createAnswer(offer) {
+    acceptAnswer(answer) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.pc.setRemoteDescription(offer);
-            const answer = yield this.pc.createAnswer();
-            yield this.pc.setLocalDescription(answer);
-            return answer;
+            yield this.pc.setRemoteDescription(answer);
         });
     }
     addIceCandidate(candidate) {

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

@@ -42,6 +42,7 @@ export declare class RingCamera extends Subscribed {
     get isCharging(): boolean;
     get operatingOnBattery(): boolean;
     get isOffline(): boolean;
+    get isRingEdgeEnabled(): boolean;
     get hasInHomeDoorbell(): boolean;
     doorbotUrl(path?: string): string;
     deviceUrl(path?: string): string;

package/lib/api/ring-camera.js

@@ -145,6 +145,9 @@ class RingCamera extends subscribed_1.Subscribed {
     get isOffline() {
         return this.data.alerts.connection === 'offline';
     }
+    get isRingEdgeEnabled() {
+        return this.data.settings.sheila_settings.local_storage_enabled === true;
+    }
     get hasInHomeDoorbell() {
         const { chime_settings } = this.data.settings;
         return (this.isDoorbot &&
@@ -231,21 +234,8 @@ class RingCamera extends subscribed_1.Subscribed {
     }
     startLiveCall() {
         return __awaiter(this, void 0, void 0, function* () {
-            const liveCall = yield this.restClient
-                .request({
-                method: 'POST',
-                url: this.doorbotUrl('live_call'),
-            })
-                .catch((e) => {
-                var _a;
-                if (((_a = e.response) === null || _a === void 0 ? void 0 : _a.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 live_call_1.LiveCall(liveCall.data.session_id, this);
+            const auth = yield this.restClient.getCurrentAuth();
+            return new live_call_1.LiveCall(auth.access_token, this);
         });
     }
     removeDingById(idToRemove) {
@@ -362,7 +352,7 @@ class RingCamera extends subscribed_1.Subscribed {
     getNextSnapshot({ afterMs, maxWaitMs, force, }) {
         return __awaiter(this, void 0, void 0, function* () {
             const response = yield this.restClient.request({
-                url: `https://app-snaps.ring.com/snapshots/next/${this.id}?extras=force`,
+                url: `https://app-snaps.ring.com/snapshots/next/${this.id}`,
                 responseType: 'buffer',
                 searchParams: {
                     'after-ms': afterMs,

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

@@ -379,6 +379,13 @@ export interface CameraData {
         live_view_disabled?: boolean;
         motion_detection_enabled?: boolean;
         power_mode?: 'battery' | 'wired';
+        sheila_settings: {
+            cv_processing_enabled: boolean | null;
+            local_storage_enabled: boolean | null;
+        };
+        server_settings: {
+            ring_media_server_enabled: boolean;
+        };
     };
     features: {
         motions_enabled: boolean;
@@ -689,21 +696,6 @@ export interface ActiveDing {
     sip_token: string;
     sip_ding_id: string;
 }
-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 AuthTokenResponse {
     access_token: string;
     expires_in: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "homebridge-ring",
-  "version": "10.0.0-beta.1",
+  "version": "10.0.0-beta.2",
   "description": "Homebridge plugin for Ring doorbells, cameras, security alarm system and smart lighting",
   "main": "lib/homebridge/index.js",
   "bin": {

package/lib/api/rtp-utils.d.ts

@@ -1,26 +0,0 @@
-import { DingKind } from './ring-types';
-export interface LiveCallSession {
-    alexa_port: 18443;
-    app_session_token: string;
-    availability_zone: 'availability-zone';
-    custom_timer: {
-        max_sec: number;
-    };
-    ding_id: string;
-    ding_kind: DingKind;
-    doorbot_id: number;
-    exp: number;
-    ip: string;
-    port: number;
-    private_ip: string;
-    rms_fqdn: string;
-    rms_version: string;
-    rsp_port: number;
-    rtsp_port: number;
-    session_id: string;
-    sip_port: number;
-    webrtc_port: number;
-    webrtc_url: string;
-    wwr_port: number;
-}
-export declare function parseLiveCallSession(sessionId: string): LiveCallSession;

package/lib/api/rtp-utils.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseLiveCallSession = void 0;
-function parseLiveCallSession(sessionId) {
-    const encodedSession = sessionId.split('.')[1], buff = Buffer.from(encodedSession, 'base64'), text = buff.toString('ascii');
-    return JSON.parse(text);
-}
-exports.parseLiveCallSession = parseLiveCallSession;