ring-client-api 9.22.1 → 9.25.0-beta.1

package/lib/api/ring-camera.js

@@ -18,8 +18,8 @@ const camera_utils_1 = require("@homebridge/camera-utils");
 const util_1 = require("./util");
 const sip_session_1 = require("./sip-session");
 const subscribed_1 = require("./subscribed");
-const snapshotRefreshDelay = 500, maxSnapshotRefreshSeconds = 35, // needs to be 30+ because battery cam can't take snapshot while recording
-maxSnapshotRefreshAttempts = (maxSnapshotRefreshSeconds * 1000) / snapshotRefreshDelay, fullDayMs = 24 * 60 * 60 * 1000;
+const live_call_1 = require("./live-call");
+const maxSnapshotRefreshSeconds = 15, fullDayMs = 24 * 60 * 60 * 1000;
 function parseBatteryLife(batteryLife) {
     if (batteryLife === null || batteryLife === undefined) {
         return null;
@@ -66,37 +66,36 @@ function getSearchQueryString(options) {
 }
 exports.getSearchQueryString = getSearchQueryString;
 class RingCamera extends subscribed_1.Subscribed {
-    constructor(initialData, isDoorbot, restClient, avoidSnapshotBatteryDrain) {
+    constructor(initialData, isDoorbot, restClient, avoidSnapshotBatteryDrain, treatKnockAsDing) {
         super();
         this.initialData = initialData;
         this.isDoorbot = isDoorbot;
         this.restClient = restClient;
         this.avoidSnapshotBatteryDrain = avoidSnapshotBatteryDrain;
-        this.id = this.initialData.id;
-        this.deviceType = this.initialData.kind;
-        this.model = ring_types_1.RingCameraModel[this.initialData.kind] || 'Unknown Model';
-        this.onData = new rxjs_1.BehaviorSubject(this.initialData);
-        this.hasLight = this.initialData.led_status !== undefined;
-        this.hasSiren = this.initialData.siren_status !== undefined;
-        this.hasBattery = (0, ring_types_1.isBatteryCameraKind)(this.deviceType) ||
-            (typeof this.initialData.battery_life === 'string' &&
-                this.batteryLevel !== null &&
-                this.batteryLevel < 100 &&
-                this.batteryLevel >= 0);
+        this.treatKnockAsDing = treatKnockAsDing;
         this.onRequestUpdate = new rxjs_1.Subject();
         this.onRequestActiveDings = new rxjs_1.Subject();
         this.onNewDing = new rxjs_1.Subject();
         this.onActiveDings = new rxjs_1.BehaviorSubject([]);
-        this.onDoorbellPressed = this.onNewDing.pipe((0, operators_1.filter)((ding) => ding.kind === 'ding'), (0, operators_1.share)());
+        this.onDoorbellPressed = this.onNewDing.pipe((0, operators_1.filter)((ding) => ding.kind === 'ding' ||
+            (this.treatKnockAsDing && ding.kind === 'door_activity')), (0, operators_1.share)());
         this.onMotionDetected = this.onActiveDings.pipe((0, operators_1.map)((dings) => dings.some((ding) => ding.motion || ding.kind === 'motion')), (0, operators_1.distinctUntilChanged)(), (0, operators_1.publishReplay)(1), (0, operators_1.refCount)());
         this.onMotionStarted = this.onMotionDetected.pipe((0, operators_1.filter)((currentlyDetected) => currentlyDetected), (0, operators_1.mapTo)(null), // no value needed, event is what matters
         (0, operators_1.share)());
+        this.expiredDingIds = [];
+        this.lastSnapshotTimestamp = 0;
+        this.lastSnapshotTimestampLocal = 0;
+        this.fetchingSnapshot = false;
+        this.id = this.initialData.id;
+        this.deviceType = this.initialData.kind;
+        this.model = ring_types_1.RingCameraModel[this.initialData.kind] || 'Unknown Model';
+        this.onData = new rxjs_1.BehaviorSubject(this.initialData);
+        this.hasLight = this.initialData.led_status !== undefined;
+        this.hasSiren = this.initialData.siren_status !== undefined;
         this.onBatteryLevel = this.onData.pipe((0, operators_1.map)(getBatteryLevel), (0, operators_1.distinctUntilChanged)());
         this.onInHomeDoorbellStatus = this.onData.pipe((0, operators_1.map)(({ settings: { chime_settings } }) => {
             return Boolean(chime_settings === null || chime_settings === void 0 ? void 0 : chime_settings.enable);
         }), (0, operators_1.distinctUntilChanged)());
-        this.expiredDingIds = [];
-        this.lastSnapshotTimestampLocal = 0;
         if (!initialData.subscribed) {
             this.subscribeToDingEvents().catch((e) => {
                 (0, util_1.logError)('Failed to subscribe ' + initialData.description + ' to ding events');
@@ -128,6 +127,15 @@ class RingCamera extends subscribed_1.Subscribed {
     get batteryLevel() {
         return getBatteryLevel(this.data);
     }
+    get hasBattery() {
+        if (this.batteryLevel === null) {
+            return false;
+        }
+        return ((0, ring_types_1.isBatteryCameraKind)(this.deviceType) ||
+            (typeof this.initialData.battery_life === 'string' &&
+                this.batteryLevel < 100 &&
+                this.batteryLevel >= 0));
+    }
     get hasLowBattery() {
         return this.data.alerts.battery === 'low';
     }
@@ -224,6 +232,25 @@ class RingCamera extends subscribed_1.Subscribed {
             return response.device_health;
         });
     }
+    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);
+        });
+    }
     startVideoOnDemand() {
         return this.restClient
             .request({
@@ -309,34 +336,14 @@ class RingCamera extends subscribed_1.Subscribed {
     get snapshotsAreBlocked() {
         return this.data.settings.motion_detection_enabled === false;
     }
-    getSnapshotTimestamp() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { timestamps, responseTimestamp } = yield this.restClient.request({
-                url: (0, rest_client_1.clientApi)('snapshots/timestamps'),
-                method: 'POST',
-                json: {
-                    doorbot_ids: [this.id],
-                },
-            }), deviceTimestamp = timestamps[0], timestamp = deviceTimestamp ? deviceTimestamp.timestamp : 0, timestampAge = Math.abs(responseTimestamp - timestamp);
-            this.lastSnapshotTimestampLocal = timestamp ? Date.now() - timestampAge : 0;
-            return {
-                timestamp,
-                inLifeTime: this.isTimestampInLifeTime(timestampAge),
-            };
-        });
-    }
     get snapshotLifeTime() {
         return this.avoidSnapshotBatteryDrain && this.operatingOnBattery
             ? 600 * 1000 // battery cams only refresh timestamp every 10 minutes
-            : 10 * 1000; // snapshot updates will be forced.  Limit to 10 lifetime
+            : 10 * 1000; // snapshot updates will be forced.  Limit to 10s lifetime
     }
     get currentTimestampAge() {
         return Date.now() - this.lastSnapshotTimestampLocal;
     }
-    get currentTimestampExpiresIn() {
-        // Gets 0 if stale snapshot is used because snapshot timestamp refused to update (recording in progress on battery cam)
-        return Math.max(this.lastSnapshotTimestampLocal - Date.now() + this.snapshotLifeTime, 0);
-    }
     get hasSnapshotWithinLifetime() {
         return this.isTimestampInLifeTime(this.currentTimestampAge);
     }
@@ -344,79 +351,73 @@ class RingCamera extends subscribed_1.Subscribed {
         if (this.snapshotsAreBlocked) {
             throw new Error(`Motion detection is disabled for ${this.name}, which prevents snapshots from this camera.  This can be caused by Modes settings or by turning off the Record Motion setting.`);
         }
+        if (this.isOffline) {
+            throw new Error(`Cannot fetch snapshot for ${this.name} because it is offline`);
+        }
     }
-    requestSnapshotUpdate() {
-        return this.restClient.request({
-            method: 'PUT',
-            url: (0, rest_client_1.clientApi)('snapshots/update_all'),
-            json: {
-                doorbot_ids: [this.id],
-                refresh: true,
-            },
-        });
-    }
-    refreshSnapshot() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.hasSnapshotWithinLifetime) {
-                (0, util_1.logDebug)(`Snapshot for ${this.name} is still within its life time (${this.currentTimestampAge / 1000}s old)`);
-                return true;
-            }
-            this.checkIfSnapshotsAreBlocked();
-            if (!this.avoidSnapshotBatteryDrain || !this.operatingOnBattery) {
-                // tell the camera to update snapshot immediately.
-                // avoidSnapshotBatteryDrain is best if you have a battery cam that you request snapshots for frequently.  This can lead to battery drain if snapshot updates are forced.
-                yield this.requestSnapshotUpdate();
-            }
-            for (let i = 0; i < maxSnapshotRefreshAttempts; i++) {
-                this.checkIfSnapshotsAreBlocked();
-                const { timestamp, inLifeTime } = yield this.getSnapshotTimestamp();
-                if (!timestamp && this.isOffline) {
-                    throw new Error(`No snapshot available and device ${this.name} is offline`);
-                }
-                if (inLifeTime) {
-                    return false;
-                }
-                yield (0, util_1.delay)(snapshotRefreshDelay);
-            }
-            const extraMessageForBatteryCam = this.operatingOnBattery
-                ? '.  This is normal behavior since this camera is unable to capture snapshots while streaming'
-                : '';
-            throw new Error(`Snapshot for ${this.name} (${this.deviceType} - ${this.model}) failed to refresh after ${maxSnapshotRefreshAttempts} attempts${extraMessageForBatteryCam}`);
-        });
+    shouldUseExistingSnapshotPromise() {
+        if (this.fetchingSnapshot) {
+            return true;
+        }
+        if (this.hasSnapshotWithinLifetime) {
+            (0, util_1.logDebug)(`Snapshot for ${this.name} is still within its life time (${this.currentTimestampAge / 1000}s old)`);
+            return true;
+        }
+        if (!this.avoidSnapshotBatteryDrain || !this.operatingOnBattery) {
+            // tell the camera to update snapshot immediately.
+            // avoidSnapshotBatteryDrain is best if you have a battery cam that you request snapshots for frequently.  This can lead to battery drain if snapshot updates are forced.
+            return false;
+        }
     }
     getSnapshot() {
         return __awaiter(this, void 0, void 0, function* () {
-            this.refreshSnapshotInProgress =
-                this.refreshSnapshotInProgress ||
-                    this.refreshSnapshot().catch((e) => {
-                        (0, util_1.logError)(e.message);
-                        throw e;
-                    });
-            try {
-                const useLastSnapshot = yield this.refreshSnapshotInProgress;
-                this.refreshSnapshotInProgress = undefined;
-                if (useLastSnapshot && this.lastSnapshotPromise) {
-                    return this.lastSnapshotPromise;
-                }
-            }
-            catch (e) {
-                this.refreshSnapshotInProgress = undefined;
-                throw e;
+            if (this.lastSnapshotPromise && this.shouldUseExistingSnapshotPromise()) {
+                return this.lastSnapshotPromise;
             }
-            this.lastSnapshotPromise = this.restClient.request({
-                url: (0, rest_client_1.clientApi)(`snapshots/image/${this.id}`),
-                responseType: 'buffer',
-            });
+            this.checkIfSnapshotsAreBlocked();
+            this.lastSnapshotPromise = Promise.race([
+                this.getNextSnapshot({
+                    afterMs: this.lastSnapshotTimestamp,
+                    force: true,
+                }),
+                (0, util_1.delay)(maxSnapshotRefreshSeconds * 1000).then(() => {
+                    const extraMessageForBatteryCam = this.operatingOnBattery
+                        ? '.  This is normal behavior since this camera is unable to capture snapshots while streaming'
+                        : '';
+                    throw new Error(`Snapshot for ${this.name} (${this.deviceType} - ${this.model}) failed to refresh after ${maxSnapshotRefreshSeconds} seconds${extraMessageForBatteryCam}`);
+                }),
+            ]);
             try {
                 yield this.lastSnapshotPromise;
             }
-            catch (_) {
+            catch (e) {
                 // snapshot request failed, don't use it again
                 this.lastSnapshotPromise = undefined;
+                throw e;
             }
+            this.fetchingSnapshot = false;
             return this.lastSnapshotPromise;
         });
     }
+    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`,
+                responseType: 'buffer',
+                searchParams: {
+                    'after-ms': afterMs,
+                    'max-wait-ms': maxWaitMs,
+                    extras: force ? 'force' : undefined,
+                },
+                headers: {
+                    accept: 'image/jpeg',
+                },
+            }), { responseTimestamp, timeMillis } = response, timestampAge = Math.abs(responseTimestamp - timeMillis);
+            this.lastSnapshotTimestamp = timeMillis;
+            this.lastSnapshotTimestampLocal = Date.now() - timestampAge;
+            return response;
+        });
+    }
     getSipOptions() {
         return __awaiter(this, void 0, void 0, function* () {
             const activeDings = this.onActiveDings.getValue(), existingDing = activeDings
@@ -458,10 +459,11 @@ class RingCamera extends subscribed_1.Subscribed {
     }
     recordToFile(outputPath, duration = 30) {
         return __awaiter(this, void 0, void 0, function* () {
-            const sipSession = yield this.streamVideo({
+            const liveCall = yield this.startLiveCall();
+            yield liveCall.startTranscoding({
                 output: ['-t', duration.toString(), outputPath],
             });
-            yield (0, rxjs_1.firstValueFrom)(sipSession.onCallEnded);
+            yield (0, rxjs_1.firstValueFrom)(liveCall.onCallEnded);
         });
     }
     streamVideo(ffmpegOptions) {

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

@@ -5,7 +5,7 @@ export declare class RingChime {
     private initialData;
     private restClient;
     id: number;
-    deviceType: "chime" | "chime_pro" | "chime_v2" | "chime_pro_v2";
+    deviceType: import("./ring-types").ChimeKind;
     model: string;
     onData: BehaviorSubject<ChimeData>;
     onRequestUpdate: Subject<unknown>;

package/lib/api/ring-chime.js

@@ -23,11 +23,11 @@ class RingChime {
     constructor(initialData, restClient) {
         this.initialData = initialData;
         this.restClient = restClient;
+        this.onRequestUpdate = new rxjs_1.Subject();
         this.id = this.initialData.id;
         this.deviceType = this.initialData.kind;
         this.model = ring_types_1.ChimeModel[this.deviceType] || 'Chime';
         this.onData = new rxjs_1.BehaviorSubject(this.initialData);
-        this.onRequestUpdate = new rxjs_1.Subject();
     }
     updateData(update) {
         this.onData.next(update);

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

@@ -10,6 +10,7 @@ export declare enum RingDeviceType {
     TemperatureSensor = "sensor.temperature",
     WaterSensor = "sensor.water",
     TiltSensor = "sensor.tilt",
+    GlassbreakSensor = "sensor.glassbreak",
     RangeExtender = "range-extender.zwave",
     ZigbeeAdapter = "adapter.zigbee",
     AccessCodeVault = "access-code.vault",
@@ -67,6 +68,7 @@ export declare enum RingCameraKind {
     doorbell_portal = "doorbell_portal",
     doorbell_scallop = "doorbell_scallop",
     doorbell_scallop_lite = "doorbell_scallop_lite",
+    doorbell_graham_cracker = "doorbell_graham_cracker",
     lpd_v1 = "lpd_v1",
     lpd_v2 = "lpd_v2",
     jbox_v1 = "jbox_v1",
@@ -214,7 +216,7 @@ export interface BeamBridge {
     role: string;
     updated_at: string;
 }
-declare type ChimeKind = 'chime' | 'chime_pro' | 'chime_v2' | 'chime_pro_v2';
+export declare type ChimeKind = 'chime' | 'chime_pro' | 'chime_v2' | 'chime_pro_v2';
 export declare const ChimeModel: {
     readonly [P in ChimeKind]: string;
 };
@@ -686,9 +688,20 @@ export interface ActiveDing {
     sip_token: string;
     sip_ding_id: string;
 }
-export interface SnapshotTimestamp {
-    timestamp: number;
-    doorbot_id: number;
+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;

package/lib/api/ring-types.js

@@ -14,6 +14,7 @@ var RingDeviceType;
     RingDeviceType["TemperatureSensor"] = "sensor.temperature";
     RingDeviceType["WaterSensor"] = "sensor.water";
     RingDeviceType["TiltSensor"] = "sensor.tilt";
+    RingDeviceType["GlassbreakSensor"] = "sensor.glassbreak";
     RingDeviceType["RangeExtender"] = "range-extender.zwave";
     RingDeviceType["ZigbeeAdapter"] = "adapter.zigbee";
     RingDeviceType["AccessCodeVault"] = "access-code.vault";
@@ -75,6 +76,7 @@ var RingCameraKind;
     RingCameraKind["doorbell_portal"] = "doorbell_portal";
     RingCameraKind["doorbell_scallop"] = "doorbell_scallop";
     RingCameraKind["doorbell_scallop_lite"] = "doorbell_scallop_lite";
+    RingCameraKind["doorbell_graham_cracker"] = "doorbell_graham_cracker";
     RingCameraKind["lpd_v1"] = "lpd_v1";
     RingCameraKind["lpd_v2"] = "lpd_v2";
     RingCameraKind["jbox_v1"] = "jbox_v1";
@@ -93,7 +95,7 @@ var RingCameraKind;
     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))/);
+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);
 }
@@ -107,6 +109,7 @@ exports.RingCameraModel = {
     doorbell_portal: 'Door View Cam',
     doorbell_scallop: 'Doorbell 3 Plus',
     doorbell_scallop_lite: 'Doorbell 3',
+    doorbell_graham_cracker: 'Doorbell Wired',
     lpd_v1: 'Doorbell Pro',
     lpd_v2: 'Doorbell Pro',
     jbox_v1: 'Doorbell Elite',

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

@@ -1,5 +1,6 @@
 /// <reference types="node" />
 import { RtpSplitter, SrtpOptions } from '@homebridge/camera-utils';
+import { DingKind } from './ring-types';
 export interface RtpStreamOptions extends SrtpOptions {
     port: number;
     rtcpPort: number;
@@ -27,3 +28,28 @@ export declare function sendStunBindingRequest({ rtpDescription, rtpSplitter, rt
     type: 'video' | 'audio';
 }): void;
 export declare function createStunResponder(rtpSplitter: RtpSplitter): void;
+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,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createStunResponder = exports.sendStunBindingRequest = exports.isStunMessage = void 0;
+exports.parseLiveCallSession = exports.createStunResponder = exports.sendStunBindingRequest = exports.isStunMessage = void 0;
 const util_1 = require("./util");
 const stun = require('stun');
 const stunMagicCookie = 0x2112a442; // https://tools.ietf.org/html/rfc5389#section-6
@@ -54,3 +54,8 @@ function createStunResponder(rtpSplitter) {
     });
 }
 exports.createStunResponder = createStunResponder;
+function parseLiveCallSession(sessionId) {
+    const encodedSession = sessionId.split('.')[1], buff = new Buffer(encodedSession, 'base64'), text = buff.toString('ascii');
+    return JSON.parse(text);
+}
+exports.parseLiveCallSession = parseLiveCallSession;

package/lib/api/sip-session.d.ts

@@ -27,6 +27,10 @@ export declare class SipSession extends Subscribed {
     constructor(sipOptions: SipOptions, rtpOptions: RtpOptions, audioSplitter: RtpSplitter, audioRtcpSplitter: RtpSplitter, videoSplitter: RtpSplitter, videoRtcpSplitter: RtpSplitter, tlsPort: number, camera: RingCamera);
     createSipCall(sipOptions: SipOptions): SipCall;
     start(ffmpegOptions?: FfmpegOptions): Promise<RtpDescription>;
+    prepareTranscoder(transcodeVideoStream: boolean, ffmpegInputOptions: SpawnInput[] | undefined, remoteRtpOptions: RtpOptions, audioPort: number, videoPort: number, sdpInput: string): {
+        ffmpegInputArguments: SpawnInput[];
+        inputSdpLines: string[];
+    };
     private startTranscoder;
     reservePort(bufferPorts?: number): Promise<number>;
     requestKeyFrame(): Promise<void>;

package/lib/api/sip-session.js

@@ -32,8 +32,8 @@ class SipSession extends subscribed_1.Subscribed {
         this.hasStarted = false;
         this.hasCallEnded = false;
         this.onCallEndedSubject = new rxjs_1.ReplaySubject(1);
-        this.sipCall = this.createSipCall(this.sipOptions);
         this.onCallEnded = this.onCallEndedSubject.asObservable();
+        this.sipCall = this.createSipCall(this.sipOptions);
     }
     createSipCall(sipOptions) {
         if (this.sipCall) {
@@ -114,31 +114,17 @@ class SipSession extends subscribed_1.Subscribed {
             }
         });
     }
-    startTranscoder(ffmpegOptions, remoteRtpOptions, audioPort, videoPort) {
-        const transcodeVideoStream = ffmpegOptions.video !== false, ffmpegArgs = [
+    prepareTranscoder(transcodeVideoStream, ffmpegInputOptions, remoteRtpOptions, audioPort, videoPort, sdpInput) {
+        const ffmpegInputArguments = [
             '-hide_banner',
             '-protocol_whitelist',
             'pipe,udp,rtp,file,crypto',
             '-f',
             'sdp',
-            ...(ffmpegOptions.input || []),
+            ...(ffmpegInputOptions || []),
             '-i',
-            'pipe:',
-            ...(ffmpegOptions.audio || ['-acodec', 'aac']),
-            ...(transcodeVideoStream
-                ? ffmpegOptions.video || ['-vcodec', 'copy']
-                : []),
-            ...(ffmpegOptions.output || []),
-        ], ff = new camera_utils_1.FfmpegProcess({
-            ffmpegArgs,
-            ffmpegPath: (0, ffmpeg_1.getFfmpegPath)(),
-            exitCallback: () => this.callEnded(true),
-            logLabel: `From Ring (${this.camera.name})`,
-            logger: {
-                error: util_1.logError,
-                info: util_1.logDebug,
-            },
-        }), inputSdpLines = [
+            sdpInput,
+        ], inputSdpLines = [
             'v=0',
             'o=105202070 3747 461 IN IP4 127.0.0.1',
             's=Talk',
@@ -167,8 +153,6 @@ class SipSession extends subscribed_1.Subscribed {
                 };
             });
         }
-        this.onCallEnded.subscribe(() => ff.stop());
-        ff.writeStdin(inputSdpLines.filter((x) => Boolean(x)).join('\n'));
         this.audioSplitter.addMessageHandler(({ isRtpMessage, message }) => {
             if ((0, rtp_utils_1.isStunMessage)(message)) {
                 return null;
@@ -177,6 +161,26 @@ class SipSession extends subscribed_1.Subscribed {
                 port: isRtpMessage ? audioPort : audioPort + 1,
             };
         });
+        return {
+            ffmpegInputArguments,
+            inputSdpLines,
+        };
+    }
+    startTranscoder(ffmpegOptions, remoteRtpOptions, audioPort, videoPort) {
+        const transcodeVideoStream = ffmpegOptions.video !== false, { ffmpegInputArguments, inputSdpLines } = this.prepareTranscoder(transcodeVideoStream, ffmpegOptions.input, remoteRtpOptions, audioPort, videoPort, 'pipe:'), ff = new camera_utils_1.FfmpegProcess({
+            ffmpegArgs: ffmpegInputArguments.concat(...(ffmpegOptions.audio || ['-acodec', 'aac']), ...(transcodeVideoStream
+                ? ffmpegOptions.video || ['-vcodec', 'copy']
+                : []), ...(ffmpegOptions.output || [])),
+            ffmpegPath: (0, ffmpeg_1.getFfmpegPath)(),
+            exitCallback: () => this.callEnded(true),
+            logLabel: `From Ring (${this.camera.name})`,
+            logger: {
+                error: util_1.logError,
+                info: util_1.logDebug,
+            },
+        });
+        this.onCallEnded.subscribe(() => ff.stop());
+        ff.writeStdin(inputSdpLines.filter((x) => Boolean(x)).join('\n'));
     }
     reservePort(bufferPorts = 0) {
         return __awaiter(this, void 0, void 0, function* () {

package/lib/api/sip.d.ts

@@ -19,6 +19,7 @@ export function create(options: any, callback: any): {
     isFlowUri: (uri: any) => boolean;
     hostname: () => any;
     destroy: () => void;
+    makeResponse: typeof makeResponse;
 };
 export function start(options: any, callback: any): void;
 export function parseAOR(data: any): any;

package/lib/api/sip.js

@@ -1300,6 +1300,7 @@ exports.create = function (options, callback) {
             transaction.destroy();
             transport.destroy();
         },
+        makeResponse,
     };
 };
 exports.start = function (options, callback) {

package/lib/api/util.js

@@ -8,14 +8,17 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.randomString = exports.randomInteger = exports.mapAsync = exports.stringify = exports.requestInput = exports.getHardwareId = exports.generateUuid = exports.enableDebug = exports.useLogger = exports.logError = exports.logInfo = exports.logDebug = exports.delay = void 0;
-const debug = require("debug");
+const debug_1 = __importDefault(require("debug"));
 const colors_1 = require("colors");
 const readline_1 = require("readline");
 const uuid_1 = require("uuid");
 const systeminformation_1 = require("systeminformation");
-const debugLogger = debug('ring'), uuidNamespace = 'e53ffdc0-e91d-4ce1-bec2-df939d94739c';
+const debugLogger = (0, debug_1.default)('ring'), uuidNamespace = 'e53ffdc0-e91d-4ce1-bec2-df939d94739c';
 let logger = {
     logInfo(message) {
         debugLogger(message);