ring-client-api 10.0.0-beta.4 → 10.0.0-beta.7

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

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

@@ -0,0 +1,111 @@
+"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.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.activated = 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)((message) => {
+            return this.handleMessage(JSON.parse(message.data));
+        }))
+            .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();
+            }
+        }));
+    }
+    activate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.activated) {
+                return;
+            }
+            this.activated = true;
+            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.sendSessionMessage('camera_options', {
+                stealth_mode: false,
+            });
+        });
+    }
+    sendMessage(message) {
+        this.ws.send(JSON.stringify(message));
+    }
+    sendAudioPacket(rtp) {
+        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() {
+        try {
+            this.sendMessage({
+                reason: { code: 0, text: '' },
+                method: 'close',
+            });
+            this.ws.close();
+        }
+        catch (_) {
+            // ignore any errors since we are stopping the call
+        }
+        this.unsubscribe();
+        this.onCallEnded.next();
+        this.pc.close();
+    }
+    stop() {
+        this.callEnded();
+    }
+}
+exports.StreamingConnectionBase = StreamingConnectionBase;

package/lib/api/{live-call.d.ts → streaming/streaming-session.d.ts}

@@ -1,7 +1,9 @@
-import { ReplaySubject } from 'rxjs';
-import { RingCamera } from './ring-camera';
-import { Subscribed } from './subscribed';
 import { RtpPacket } from '@koush/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';
 declare type SpawnInput = string | number;
 export interface FfmpegOptions {
     input?: SpawnInput[];
@@ -9,27 +11,22 @@ export interface FfmpegOptions {
     audio?: SpawnInput[];
     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 onCallAnswered: ReplaySubject<string>;
+export declare class StreamingSession extends Subscribed {
+    private readonly camera;
+    private connection;
     readonly onCallEnded: ReplaySubject<void>;
+    readonly onVideoRtp: Subject<RtpPacket>;
+    readonly onAudioRtp: Subject<RtpPacket>;
     private readonly audioSplitter;
     private readonly videoSplitter;
-    readonly onVideoRtp: import("rxjs").Subject<RtpPacket>;
-    readonly onAudioRtp: import("rxjs").Subject<RtpPacket>;
-    constructor(sessionId: string, camera: RingCamera);
-    private handleMessage;
-    reservePort(bufferPorts?: number): Promise<number>;
-    startTranscoding(ffmpegOptions: FfmpegOptions): Promise<void>;
+    constructor(camera: RingCamera, connection: RingEdgeConnection | WebrtcConnection);
+    private bindToConnection;
     activated: boolean;
     activate(): Promise<void>;
+    cameraSpeakerActivated: boolean;
     activateCameraSpeaker(): Promise<void>;
-    private sendMessage;
+    reservePort(bufferPorts?: number): Promise<number>;
+    startTranscoding(ffmpegOptions: FfmpegOptions): Promise<void>;
     private callEnded;
     stop(): void;
     sendAudioPacket(rtp: RtpPacket): void;

package/lib/api/{live-call.js → streaming/streaming-session.js}

@@ -9,15 +9,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LiveCall = void 0;
-const ws_1 = require("ws");
+exports.StreamingSession = void 0;
+const camera_utils_1 = require("@homebridge/camera-utils");
 const rxjs_1 = require("rxjs");
-const peer_connection_1 = require("./peer-connection");
-const util_1 = require("./util");
+const ffmpeg_1 = require("../ffmpeg");
+const util_1 = require("../util");
 const operators_1 = require("rxjs/operators");
-const subscribed_1 = require("./subscribed");
-const camera_utils_1 = require("@homebridge/camera-utils");
-const ffmpeg_1 = require("./ffmpeg");
+const subscribed_1 = require("../subscribed");
 function getCleanSdp(sdp, includeVideo) {
     return sdp
         .split('\nm=')
@@ -26,62 +24,39 @@ function getCleanSdp(sdp, includeVideo) {
         .filter((section) => includeVideo || !section.startsWith('m=video'))
         .join('\n');
 }
-function parseLiveCallSession(sessionId) {
-    const encodedSession = sessionId.split('.')[1], buff = Buffer.from(encodedSession, 'base64'), text = buff.toString('ascii');
-    return JSON.parse(text);
-}
-class LiveCall extends subscribed_1.Subscribed {
-    constructor(sessionId, camera) {
+class StreamingSession extends subscribed_1.Subscribed {
+    constructor(camera, connection) {
         super();
-        this.sessionId = sessionId;
         this.camera = camera;
-        this.onCallAnswered = new rxjs_1.ReplaySubject(1);
+        this.connection = connection;
         this.onCallEnded = new rxjs_1.ReplaySubject(1);
+        this.onVideoRtp = new rxjs_1.Subject();
+        this.onAudioRtp = new rxjs_1.Subject();
         this.audioSplitter = new camera_utils_1.RtpSplitter();
         this.videoSplitter = new camera_utils_1.RtpSplitter();
         this.activated = false;
-        const liveCallSession = parseLiveCallSession(sessionId);
-        this.pc = new peer_connection_1.PeerConnection();
-        this.ws = new ws_1.WebSocket(`wss://${liveCallSession.rms_fqdn}:${liveCallSession.webrtc_port}/`, {
-            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.cameraSpeakerActivated = false;
+        this.bindToConnection(connection);
+    }
+    bindToConnection(connection) {
+        this.addSubscriptions(connection.onAudioRtp.subscribe(this.onAudioRtp), connection.onVideoRtp.subscribe(this.onVideoRtp));
+    }
+    activate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.activated) {
+                return;
+            }
+            this.activated = true;
+            yield this.connection.activate();
         });
-        this.onAudioRtp = this.pc.onAudioRtp;
-        this.onVideoRtp = this.pc.onVideoRtp;
-        this.onMessage = (0, rxjs_1.fromEvent)(this.ws, 'message');
-        this.onWsOpen = (0, rxjs_1.fromEvent)(this.ws, 'open');
-        const onError = (0, rxjs_1.fromEvent)(this.ws, 'error'), onClose = (0, rxjs_1.fromEvent)(this.ws, 'close');
-        this.addSubscriptions(this.onMessage
-            .pipe((0, operators_1.concatMap)((message) => {
-            return this.handleMessage(JSON.parse(message.data));
-        }))
-            .subscribe(), this.onWsOpen.subscribe(() => {
-            (0, util_1.logDebug)(`WebSocket connected for ${this.camera.name}`);
-        }), onError.subscribe((e) => {
-            (0, util_1.logError)(e);
-            this.callEnded();
-        }), onClose.subscribe(() => {
-            this.callEnded();
-        }));
     }
-    handleMessage(message) {
+    activateCameraSpeaker() {
         return __awaiter(this, void 0, void 0, function* () {
-            switch (message.method) {
-                case 'sdp':
-                    const answer = yield this.pc.createAnswer(message);
-                    this.sendMessage(Object.assign({ method: 'sdp' }, answer));
-                    this.onCallAnswered.next(message.sdp);
-                    return;
-                case 'ice':
-                    yield this.pc.addIceCandidate({
-                        candidate: message.ice,
-                        sdpMLineIndex: message.mlineindex,
-                    });
-                    return;
+            if (this.cameraSpeakerActivated) {
+                return;
             }
+            this.cameraSpeakerActivated = true;
+            yield this.connection.activateCameraSpeaker();
         });
     }
     reservePort(bufferPorts = 0) {
@@ -103,7 +78,7 @@ class LiveCall extends subscribed_1.Subscribed {
                 ...(ffmpegOptions.input || []),
                 '-i',
                 'pipe:',
-            ], ringSdp = yield (0, rxjs_1.firstValueFrom)(this.onCallAnswered), inputSdp = getCleanSdp(ringSdp, transcodeVideoStream)
+            ], ringSdp = yield (0, rxjs_1.firstValueFrom)(this.connection.onCallAnswered), inputSdp = getCleanSdp(ringSdp, transcodeVideoStream)
                 .replace(/m=audio \d+/, `m=audio ${audioPort}`)
                 .replace(/m=video \d+/, `m=video ${videoPort}`), ff = new camera_utils_1.FfmpegProcess({
                 ffmpegArgs: ffmpegInputArguments.concat(...(ffmpegOptions.audio || ['-acodec', 'aac']), ...(transcodeVideoStream
@@ -139,47 +114,10 @@ class LiveCall extends subscribed_1.Subscribed {
             yield this.activate();
         });
     }
-    activate() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.activated) {
-                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',
-            });
-        });
-    }
-    activateCameraSpeaker() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield (0, rxjs_1.firstValueFrom)(this.onCallAnswered);
-            this.sendMessage({
-                stealth_mode: false,
-                method: 'camera_options',
-            });
-        });
-    }
-    sendMessage(message) {
-        this.ws.send(JSON.stringify(message));
-    }
     callEnded() {
-        try {
-            this.sendMessage({
-                reason: { code: 0, text: '' },
-                method: 'close',
-            });
-            this.ws.close();
-        }
-        catch (_) {
-            // ignore any errors since we are stopping the call
-        }
         this.unsubscribe();
         this.onCallEnded.next();
-        this.pc.close();
+        this.connection.stop();
         this.audioSplitter.close();
         this.videoSplitter.close();
     }
@@ -187,7 +125,7 @@ class LiveCall extends subscribed_1.Subscribed {
         this.callEnded();
     }
     sendAudioPacket(rtp) {
-        this.pc.returnAudioTrack.writeRtp(rtp);
+        this.connection.sendAudioPacket(rtp);
     }
 }
-exports.LiveCall = LiveCall;
+exports.StreamingSession = StreamingSession;

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

@@ -0,0 +1,23 @@
+import { RingCamera } from '../ring-camera';
+import { StreamingConnectionBase, StreamingConnectionOptions } from './streaming-connection-base';
+interface InitializationMessage {
+    method: 'initialization';
+    text: 'Done';
+}
+interface OfferMessage {
+    method: 'sdp';
+    sdp: string;
+    type: 'offer';
+}
+interface IceCandidateMessage {
+    method: 'ice';
+    ice: string;
+    mlineindex: number;
+}
+export declare class WebrtcConnection extends StreamingConnectionBase {
+    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;
+}
+export {};

package/lib/api/streaming/webrtc-connection.js

@@ -0,0 +1,60 @@
+"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.WebrtcConnection = void 0;
+const ws_1 = require("ws");
+const streaming_connection_base_1 = require("./streaming-connection-base");
+const util_1 = require("../util");
+function parseLiveCallSession(sessionId) {
+    const encodedSession = sessionId.split('.')[1], buff = Buffer.from(encodedSession, 'base64'), text = buff.toString('ascii');
+    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}/`, {
+            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',
+            },
+        }), options);
+        this.sessionId = sessionId;
+        this.addSubscriptions(this.onWsOpen.subscribe(() => {
+            (0, util_1.logDebug)(`WebSocket connected for ${camera.name}`);
+        }));
+    }
+    handleMessage(message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            switch (message.method) {
+                case 'sdp':
+                    const answer = yield this.pc.createAnswer(message);
+                    this.sendSessionMessage('sdp', answer);
+                    this.onCallAnswered.next(message.sdp);
+                    this.sendSessionMessage('stream_options', {
+                        audio_enabled: true,
+                        video_enabled: true,
+                    });
+                    return;
+                case 'ice':
+                    yield this.pc.addIceCandidate({
+                        candidate: message.ice,
+                        sdpMLineIndex: message.mlineindex,
+                    });
+                    return;
+            }
+        });
+    }
+    sendSessionMessage(method, body = {}) {
+        this.sendMessage(Object.assign(Object.assign({}, body), { method }));
+    }
+}
+exports.WebrtcConnection = WebrtcConnection;

package/lib/api/util.js

@@ -18,6 +18,7 @@ const colors_1 = require("colors");
 const readline_1 = require("readline");
 const uuid_1 = require("uuid");
 const systeminformation_1 = require("systeminformation");
+const logger_1 = __importDefault(require("@eneris/push-receiver/dist/utils/logger"));
 const debugLogger = (0, debug_1.default)('ring'), uuidNamespace = 'e53ffdc0-e91d-4ce1-bec2-df939d94739d';
 let logger = {
     logInfo(message) {
@@ -120,3 +121,9 @@ function randomString(length) {
     return uuid.replace(/-/g, '').substring(0, length).toLowerCase();
 }
 exports.randomString = randomString;
+// Override push receiver logging to avoid ECONNRESET errors leaking
+function logPushReceiver(...args) {
+    logDebug('[Push Receiver]');
+    logDebug(args[0]);
+}
+logger_1.default.error = logPushReceiver;

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

@@ -0,0 +1 @@
+export {};

package/lib/test/api/ring-camera.spec.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const api_1 = require("../../api");
+describe('Ring Camera', () => {
+    describe('battery level', () => {
+        it('should handle string battery life', () => {
+            expect((0, api_1.getBatteryLevel)({
+                battery_life: '49',
+            })).toEqual(49);
+        });
+        it('should handle null battery life', () => {
+            expect((0, api_1.getBatteryLevel)({ battery_life: null })).toEqual(null);
+        });
+        it('should handle right battery only', () => {
+            expect((0, api_1.getBatteryLevel)({ battery_life: null, battery_life_2: 24 })).toEqual(24);
+        });
+        it('should handle left battery only', () => {
+            expect((0, api_1.getBatteryLevel)({ battery_life: 76, battery_life_2: null })).toEqual(76);
+        });
+        it('should handle dual batteries', () => {
+            expect((0, api_1.getBatteryLevel)({ battery_life: '92', battery_life_2: 84 })).toEqual(84);
+            expect((0, api_1.getBatteryLevel)({ battery_life: '92', battery_life_2: 100 })).toEqual(92);
+        });
+    });
+});