ring-client-api 10.0.0-beta.3 → 10.0.0-beta.6

package/lib/api/ring-types.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isWebSocketSupportedAsset = exports.disabledLocationModes = exports.DispatchSignalType = exports.DoorbellType = exports.ChimeModel = exports.deviceTypesWithVolume = exports.allAlarmStates = exports.RingCameraModel = exports.isBatteryCameraKind = exports.RingCameraKind = exports.RingDeviceCategory = exports.RingDeviceType = void 0;
+exports.isWebSocketSupportedAsset = exports.disabledLocationModes = exports.DispatchSignalType = exports.PushNotificationAction = exports.NotificationDetectionType = exports.DoorbellType = exports.ChimeModel = exports.deviceTypesWithVolume = exports.allAlarmStates = exports.RingCameraModel = exports.RingCameraKind = exports.RingDeviceCategory = exports.RingDeviceType = void 0;
 // eslint-disable-next-line no-shadow
 var RingDeviceType;
 (function (RingDeviceType) {
@@ -95,12 +95,6 @@ var RingCameraKind;
     RingCameraKind["cocoa_doorbell"] = "cocoa_doorbell";
     RingCameraKind["stickup_cam_mini"] = "stickup_cam_mini";
 })(RingCameraKind = exports.RingCameraKind || (exports.RingCameraKind = {}));
-// RegExp taken from ring.com app
-const isWiredCameraRegExp = new RegExp(/(^(lpd|jbox|stickup_cam_elite|stickup_cam_mini|hp_cam|spotlightw|floodlight|doorbell_graham_cracker))/);
-function isBatteryCameraKind(kind) {
-    return !kind.match(isWiredCameraRegExp);
-}
-exports.isBatteryCameraKind = isBatteryCameraKind;
 exports.RingCameraModel = {
     doorbot: 'Doorbell',
     doorbell: 'Doorbell',
@@ -158,6 +152,23 @@ var DoorbellType;
     DoorbellType[DoorbellType["None"] = 2] = "None";
 })(DoorbellType = exports.DoorbellType || (exports.DoorbellType = {}));
 // eslint-disable-next-line no-shadow
+var NotificationDetectionType;
+(function (NotificationDetectionType) {
+    // Note, this list may not be complete
+    NotificationDetectionType["Human"] = "human";
+    NotificationDetectionType["Loitering"] = "loitering";
+    NotificationDetectionType["Motion"] = "motion";
+    NotificationDetectionType["OtherMotion"] = "other_motion";
+    NotificationDetectionType["NotAvailable"] = "null";
+    NotificationDetectionType["StreamBroken"] = "stream_broken";
+})(NotificationDetectionType = exports.NotificationDetectionType || (exports.NotificationDetectionType = {}));
+// eslint-disable-next-line no-shadow
+var PushNotificationAction;
+(function (PushNotificationAction) {
+    PushNotificationAction["Ding"] = "com.ring.push.HANDLE_NEW_DING";
+    PushNotificationAction["Motion"] = "com.ring.push.HANDLE_NEW_motion";
+})(PushNotificationAction = exports.PushNotificationAction || (exports.PushNotificationAction = {}));
+// eslint-disable-next-line no-shadow
 var DispatchSignalType;
 (function (DispatchSignalType) {
     DispatchSignalType["Burglar"] = "user-verified-burglar-xa";

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,12 +9,21 @@ 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 debug = false;
-class PeerConnection {
+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',
+    'stun:stun.kinesisvideo.us-west-2.amazonaws.com:443',
+    'stun:stun.l.google.com:19302',
+    'stun:stun1.l.google.com:19302',
+    'stun:stun2.l.google.com:19302',
+    'stun:stun3.l.google.com:19302',
+    'stun:stun4.l.google.com:19302',
+];
+class WeriftPeerConnection {
     constructor() {
         this.onAudioRtp = new rxjs_1.Subject();
         this.onAudioRtcp = new rxjs_1.Subject();
@@ -43,10 +52,12 @@ class PeerConnection {
                             { type: 'nack', parameter: 'pli' },
                             { type: 'goog-remb' },
                         ],
-                        parameters: 'packetization-mode=1;profile-level-id=42801F;level-asymmetry-allowed=1',
+                        parameters: 'packetization-mode=1;profile-level-id=640029;level-asymmetry-allowed=1',
                     }),
                 ],
             },
+            iceServers: ringIceServers.map((server) => ({ urls: server })),
+            iceTransportPolicy: 'all',
         })), audioTransceiver = pc.addTransceiver(this.returnAudioTrack, {
             direction: 'sendrecv',
         }), videoTransceiver = pc.addTransceiver('video', {
@@ -120,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/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;