mirror of
https://github.com/tsightler/ring-mqtt.git
synced 2025-09-27 13:12:09 +08:00
472 lines
22 KiB
JavaScript
472 lines
22 KiB
JavaScript
import { RingApi, RingDeviceType, RingCamera, RingChime, RingIntercom } from 'ring-client-api'
|
|
import chalk from 'chalk'
|
|
import utils from './utils.js'
|
|
import go2rtc from './go2rtc.js'
|
|
import BaseStation from '../devices/base-station.js'
|
|
import Beam from '../devices/beam.js'
|
|
import BeamOutdoorPlug from '../devices/beam-outdoor-plug.js'
|
|
import BinarySensor from '../devices/binary-sensor.js'
|
|
import Bridge from '../devices/bridge.js'
|
|
import Camera from '../devices/camera.js'
|
|
import CoAlarm from '../devices/co-alarm.js'
|
|
import Chime from '../devices/chime.js'
|
|
import Fan from '../devices/fan.js'
|
|
import FloodFreezeSensor from '../devices/flood-freeze-sensor.js'
|
|
import Intercom from '../devices/intercom.js'
|
|
import Keypad from '../devices/keypad.js'
|
|
import Lock from '../devices/lock.js'
|
|
import ModesPanel from '../devices/modes-panel.js'
|
|
import MultiLevelSwitch from '../devices/multi-level-switch.js'
|
|
import PanicButton from '../devices/panic-button.js'
|
|
import RangeExtender from '../devices/range-extender.js'
|
|
import SecurityPanel from '../devices/security-panel.js'
|
|
import Siren from '../devices/siren.js'
|
|
import SmokeAlarm from '../devices/smoke-alarm.js'
|
|
import SmokeCoListener from '../devices/smoke-co-listener.js'
|
|
import Switch from '../devices/switch.js'
|
|
import TemperatureSensor from '../devices/temperature-sensor.js'
|
|
import Thermostat from '../devices/thermostat.js'
|
|
import Valve from '../devices/valve.js'
|
|
import debugModule from 'debug'
|
|
const debug = debugModule('ring-mqtt')
|
|
|
|
export default new class RingMqtt {
|
|
constructor() {
|
|
this.locations = new Array()
|
|
this.devices = new Array()
|
|
this.client = false
|
|
this.mqttConnected = false
|
|
this.republishCount = 6 // Republish config/state this many times after startup or HA start/restart
|
|
this.refreshToken = undefined
|
|
|
|
// Configure event listeners
|
|
utils.event.on('mqtt_state', async (state) => {
|
|
if (state === 'connected') {
|
|
this.mqttConnected = true
|
|
if (this.locations.length > 0) {
|
|
debug('MQTT connection re-established, republishing Ring locations...')
|
|
this.publishLocations()
|
|
} else {
|
|
debug('MQTT connection established, processing Ring locations...')
|
|
await this.initRingData()
|
|
this.publishLocations()
|
|
}
|
|
} else {
|
|
this.mqttConnected = false
|
|
}
|
|
})
|
|
|
|
utils.event.on('ha_status', async (topic, message) => {
|
|
debug('Home Assistant state topic '+topic+' received message: '+message)
|
|
if (message === 'online') {
|
|
// Republish devices and state if restart of HA is detected
|
|
if (this.republishCount > 0) {
|
|
debug('Home Assistant restart detected during existing republish cycle')
|
|
debug('Resetting device config/state republish count')
|
|
this.republishCount = 6
|
|
} else {
|
|
debug('Home Assistant restart detected, resending device config/state in 15 seconds')
|
|
await utils.sleep(15)
|
|
this.republishCount = 6
|
|
this.publishLocations()
|
|
}
|
|
}
|
|
})
|
|
|
|
// Check for invalid refreshToken after connection was successfully made
|
|
// This usually indicates a Ring service outage impacting authentication
|
|
setInterval(() => {
|
|
if (this.client && !this.client.restClient.refreshToken) {
|
|
debug(chalk.yellow('Possible Ring service outage detected, forcing use of refresh token from latest state'))
|
|
this.client.restClient.refreshToken = this.refreshToken
|
|
this.client.restClient._authPromise = undefined
|
|
}
|
|
}, 60000)
|
|
}
|
|
|
|
async init(state, generatedToken) {
|
|
if (generatedToken) {
|
|
this.refreshToken = generatedToken
|
|
state.updateToken(generatedToken)
|
|
} else {
|
|
this.refreshToken = state.data.ring_token
|
|
}
|
|
|
|
if (this.client) {
|
|
try {
|
|
debug('A new refresh token was generated, attempting to re-establish connection to Ring API')
|
|
this.client.restClient.refreshToken = this.refreshToken
|
|
this.client.restClient._authPromise = undefined
|
|
await utils.sleep(2)
|
|
await this.client.getProfile()
|
|
debug(`Successfully re-established connection to Ring API using generated refresh token`)
|
|
} catch (error) {
|
|
debug(chalk.yellowBright(error.message))
|
|
debug(chalk.yellowBright(`Failed to re-establish connection to Ring API using generated refresh token`))
|
|
}
|
|
} else {
|
|
const ringAuth = {
|
|
refreshToken: this.refreshToken,
|
|
systemId: state.data.systemId,
|
|
controlCenterDisplayName: `${process.env.RUNMODE === 'addon' ? 'ring-mqtt-addon' : 'ring-mqtt'}-${state.data.systemId.slice(-5)}`,
|
|
...utils.config().enable_cameras ? { cameraStatusPollingSeconds: 20 } : {},
|
|
...utils.config().enable_modes ? { locationModePollingSeconds: 20 } : {},
|
|
...!(utils.config().location_ids === undefined || utils.config().location_ids == 0) ? { locationIds: utils.config().location_ids } : {}
|
|
}
|
|
|
|
try {
|
|
debug(`Attempting connection to Ring API using ${generatedToken ? 'generated' : 'saved'} refresh token...`)
|
|
this.client = new RingApi(ringAuth)
|
|
await utils.sleep(2)
|
|
await this.client.getProfile()
|
|
utils.event.emit('ring_api_state', 'connected')
|
|
debug(`Successfully established connection to Ring API using ${generatedToken ? 'generated' : 'saved'} token`)
|
|
|
|
// Subscribe to token update events and save new tokens to state file
|
|
this.client.onRefreshTokenUpdated.subscribe(({ newRefreshToken, oldRefreshToken }) => {
|
|
if (!oldRefreshToken) {
|
|
return
|
|
}
|
|
debug('Received updated refresh token')
|
|
this.refreshToken = newRefreshToken
|
|
state.updateToken(newRefreshToken)
|
|
})
|
|
} catch(error) {
|
|
this.client = false
|
|
debug(chalk.yellowBright(error.message))
|
|
debug(chalk.yellowBright(`Failed to establish connection to Ring API using ${generatedToken ? 'generated' : 'saved'} refresh token`))
|
|
}
|
|
}
|
|
|
|
return this.client
|
|
}
|
|
|
|
// Update all Ring location/device data
|
|
async initRingData() {
|
|
// Small delay here makes debug output more readable
|
|
await utils.sleep(2)
|
|
|
|
// Get all Ring locations
|
|
const locations = await this.client.getLocations()
|
|
|
|
debug(chalk.green('-'.repeat(90)))
|
|
debug(chalk.white('This account has access to the following locations:'))
|
|
locations.map(function(location) {
|
|
debug(' '+chalk.green(location.name)+chalk.cyan(` (${location.id})`))
|
|
})
|
|
debug(' '.repeat(90))
|
|
debug(chalk.yellowBright('IMPORTANT: ')+chalk.white('If any alarm or smart lighting hubs for a location are in any state other '))
|
|
debug(chalk.white(' than *ONLINE*, including *OFFLINE* or *CELL BACKUP*, device discovery will '))
|
|
debug(chalk.white(' hang and no devices will be published until the hub returns to *ONLINE* state. '))
|
|
debug(' '.repeat(90))
|
|
debug(chalk.white(' If desired, the "location_ids" config option can be used to restrict '))
|
|
debug(chalk.white(' discovery to specific locations. See the documentation for details. '))
|
|
debug(chalk.green('-'.repeat(90)))
|
|
debug(chalk.white('Starting Device Discovery...'))
|
|
|
|
// Loop through each location and update stored locations/devices
|
|
for (const location of locations) {
|
|
let cameras = new Array()
|
|
let chimes = new Array()
|
|
let intercoms = new Array()
|
|
let events = new Array()
|
|
const unsupportedDevices = new Array()
|
|
|
|
debug(' '.repeat(90))
|
|
|
|
// If new location, set custom properties and add to location list
|
|
if (this.locations.find(l => l.locationId == location.locationId)) {
|
|
debug(chalk.white('Existing location: ')+chalk.green(location.name)+chalk.cyan(` (${location.id})`))
|
|
} else {
|
|
debug(chalk.white('New location: ')+chalk.green(location.name)+chalk.cyan(` (${location.id})`))
|
|
location.isSubscribed = false
|
|
location.isConnected = false
|
|
this.locations.push(location)
|
|
}
|
|
|
|
// Get all location devices and, if camera support is enabled, cameras, chimes and intercoms
|
|
let suppressInterval = 0
|
|
const logInterval = setInterval(() => {
|
|
// Only output every 300 seconds after first log
|
|
if (suppressInterval % 30 === 0 && location.offlineAssets.length > 0) {
|
|
debug(`Location ${chalk.green(location.name)} is waiting for the following hubs to be fully online:`)
|
|
location.offlineAssets.forEach(offlineAssetUuid => {
|
|
const asset = location.assets && location.assets.find(asset => asset.uuid === offlineAssetUuid);
|
|
let assetName = asset.kind.startsWith('base_station')
|
|
? 'Alarm Base Station'
|
|
: asset.kind.startsWith('beams_bridge')
|
|
? 'Smart Lighting Bridge'
|
|
: asset.kind
|
|
if (asset) {
|
|
debug(` ${assetName} ${chalk.cyan('('+asset.uuid+')')} status: ${chalk.red(asset.status)}`)
|
|
}
|
|
})
|
|
}
|
|
suppressInterval++
|
|
}, 10000)
|
|
|
|
let devices
|
|
try {
|
|
devices = await location.getDevices();
|
|
} finally {
|
|
clearInterval(logInterval);
|
|
}
|
|
|
|
if (utils.config().enable_cameras) {
|
|
cameras = location.cameras
|
|
chimes = location.chimes
|
|
intercoms = location.intercoms
|
|
}
|
|
|
|
if (cameras.length > 0) {
|
|
const cameraIds = (cameras.map(camera => camera.id)).join('%2C')
|
|
try {
|
|
const response = await location.restClient.request({
|
|
method: 'GET',
|
|
url: `https://api.ring.com/evm/v2/history/devices?source_ids=${cameraIds}&capabilities=offline_event&limit=100`
|
|
})
|
|
if (Array.isArray(response?.items) && response.items?.length > 0) {
|
|
events = response.items
|
|
}
|
|
} catch (err) {
|
|
debug(err)
|
|
debug('Failed to retrieve camera event history from Ring API')
|
|
}
|
|
}
|
|
|
|
const allDevices = [...devices, ...cameras, ...chimes, ...intercoms]
|
|
|
|
// Add modes panel, if configured and the location supports it
|
|
if (utils.config().enable_modes && (await location.supportsLocationModeSwitching())) {
|
|
allDevices.push({
|
|
deviceType: 'location.mode',
|
|
location: location,
|
|
id: location.locationId + '_mode',
|
|
onData: location.onLocationMode,
|
|
data: {
|
|
device_id: location.locationId + '_mode',
|
|
location_id: location.locationId
|
|
}
|
|
})
|
|
}
|
|
|
|
// Update Ring devices for location
|
|
for (const device of allDevices) {
|
|
const deviceId = (device instanceof RingCamera || device instanceof RingChime || device instanceof RingIntercom) ? device.data.device_id : device.id
|
|
let foundMessage = ' New device: '
|
|
let ringDevice = this.devices.find(d => d.deviceId === deviceId && d.locationId === location.locationId)
|
|
if (ringDevice) {
|
|
foundMessage = ' Existing device: '
|
|
} else {
|
|
ringDevice = await this.getDevice(device, allDevices, events)
|
|
switch (ringDevice) {
|
|
case 'not-supported':
|
|
// Save unsupported device type for log output later
|
|
unsupportedDevices.push(device.deviceType)
|
|
// fall through
|
|
case 'ignore':
|
|
ringDevice=false
|
|
break
|
|
default:
|
|
this.devices.push(ringDevice)
|
|
}
|
|
}
|
|
|
|
if (ringDevice && !ringDevice.hasOwnProperty('parentDevice')) {
|
|
debug(chalk.white(foundMessage)+chalk.green(`${ringDevice.deviceData.name}`)+chalk.cyan(' ('+ringDevice.deviceId+')'))
|
|
if (ringDevice?.childDevices) {
|
|
const indent = ' '.repeat(foundMessage.length-4)
|
|
debug(chalk.white(`${indent}│ `)+chalk.gray(ringDevice.device.deviceType))
|
|
let keys = Object.keys(ringDevice.childDevices).length
|
|
Object.keys(ringDevice.childDevices).forEach(key => {
|
|
debug(chalk.white(`${indent}${(keys > 1) ? '├─: ' : '└─: '}`)+chalk.green(`${ringDevice.childDevices[key].name}`)+chalk.cyan(` (${ringDevice.childDevices[key].id})`))
|
|
debug(chalk.white(`${indent}${(keys > 1) ? '│ ' : ' '}`)+chalk.gray(ringDevice.childDevices[key].deviceType))
|
|
keys--
|
|
})
|
|
} else {
|
|
const indent = ' '.repeat(foundMessage.length)
|
|
debug(chalk.gray(`${indent}${ringDevice.device.deviceType}`))
|
|
}
|
|
}
|
|
}
|
|
// Output any unsupported devices to debug with warning
|
|
unsupportedDevices.forEach(deviceType => {
|
|
debug(chalk.yellow(` Unsupported device: ${deviceType}`))
|
|
})
|
|
await utils.sleep(2)
|
|
}
|
|
await utils.sleep(2)
|
|
debug(' '.repeat(90))
|
|
debug(chalk.white('Device Discovery Complete!'))
|
|
const cameras = await this.devices.filter(d => d.device instanceof RingCamera)
|
|
if (cameras.length > 0 && !go2rtc.started) {
|
|
await go2rtc.init(cameras)
|
|
} else {
|
|
debug(chalk.green('-'.repeat(90)))
|
|
}
|
|
await utils.sleep(3)
|
|
}
|
|
|
|
// Return supported device
|
|
async getDevice(device, allDevices, events) {
|
|
const deviceInfo = {
|
|
device: device,
|
|
...allDevices.filter(d => d.data.parentZid === device.id).length
|
|
? { childDevices: allDevices.filter(d => d.data.parentZid === device.id) } : {},
|
|
...(device.data && device.data.hasOwnProperty('parentZid'))
|
|
? { parentDevice: allDevices.find(d => d.id === device.data.parentZid) } : {}
|
|
}
|
|
if (device instanceof RingCamera) {
|
|
return new Camera(deviceInfo, events.filter(event => event.source_id === device.id.toString()))
|
|
} else if (device instanceof RingChime) {
|
|
return new Chime(deviceInfo)
|
|
} else if (device instanceof RingIntercom) {
|
|
return new Intercom(deviceInfo)
|
|
} else if (/^lock($|\.)/.test(device.deviceType)) {
|
|
return new Lock(deviceInfo)
|
|
}
|
|
switch (device.deviceType) {
|
|
case RingDeviceType.ContactSensor:
|
|
case RingDeviceType.RetrofitZone:
|
|
case RingDeviceType.TiltSensor:
|
|
case RingDeviceType.GlassbreakSensor:
|
|
case RingDeviceType.MotionSensor:
|
|
case RingDeviceType.Sensor:
|
|
deviceInfo.securityPanel = allDevices.find(device =>
|
|
device.deviceType === RingDeviceType.SecurityPanel
|
|
)
|
|
return new BinarySensor(deviceInfo)
|
|
case RingDeviceType.FloodFreezeSensor:
|
|
return new FloodFreezeSensor(deviceInfo)
|
|
case RingDeviceType.SecurityPanel:
|
|
deviceInfo.bypassCapableDevices = allDevices.filter(device =>
|
|
device.deviceType === RingDeviceType.ContactSensor ||
|
|
device.deviceType === RingDeviceType.RetrofitZone ||
|
|
device.deviceType === RingDeviceType.MotionSensor ||
|
|
device.deviceType === RingDeviceType.TiltSensor ||
|
|
device.deviceType === RingDeviceType.GlassbreakSensor
|
|
)
|
|
return new SecurityPanel(deviceInfo)
|
|
case RingDeviceType.SmokeAlarm:
|
|
return new SmokeAlarm(deviceInfo)
|
|
case RingDeviceType.CoAlarm:
|
|
return new CoAlarm(deviceInfo)
|
|
case RingDeviceType.SmokeCoListener:
|
|
return new SmokeCoListener(deviceInfo)
|
|
case RingDeviceType.BeamsMotionSensor:
|
|
case RingDeviceType.BeamsMultiLevelSwitch:
|
|
case RingDeviceType.BeamsTransformerSwitch:
|
|
case RingDeviceType.BeamsLightGroupSwitch:
|
|
return new Beam(deviceInfo)
|
|
case RingDeviceType.BeamsDevice:
|
|
return new BeamOutdoorPlug(deviceInfo)
|
|
case RingDeviceType.MultiLevelSwitch:
|
|
return device.categoryId === 17 ? new Fan(deviceInfo) : new MultiLevelSwitch(deviceInfo)
|
|
case RingDeviceType.Switch:
|
|
return new Switch(deviceInfo)
|
|
case RingDeviceType.Keypad:
|
|
return new Keypad(deviceInfo)
|
|
case RingDeviceType.BaseStation:
|
|
return new BaseStation(deviceInfo)
|
|
case RingDeviceType.RangeExtender:
|
|
return new RangeExtender(deviceInfo)
|
|
case RingDeviceType.RingNetAdapter:
|
|
// For some reason some locations have devices of type "ringnet" that are not real
|
|
// so this filters devices with hidden tag to try to elimnate these phantom devices
|
|
return device.tags?.includes('hidden') ? 'ignore' : new Bridge(deviceInfo)
|
|
case 'location.mode':
|
|
return new ModesPanel(deviceInfo)
|
|
case 'siren':
|
|
case 'siren.outdoor-strobe':
|
|
return new Siren(deviceInfo)
|
|
case RingDeviceType.Thermostat:
|
|
return new Thermostat(deviceInfo)
|
|
case RingDeviceType.TemperatureSensor:
|
|
if (deviceInfo.hasOwnProperty('parentDevice') && deviceInfo.parentDevice.deviceType === RingDeviceType.Thermostat) {
|
|
return 'ignore'
|
|
} else {
|
|
return new TemperatureSensor(deviceInfo)
|
|
}
|
|
case RingDeviceType.WaterValve:
|
|
return new Valve(deviceInfo)
|
|
case 'security-remote':
|
|
return new PanicButton(deviceInfo)
|
|
case RingDeviceType.BeamsSwitch:
|
|
case 'access-code':
|
|
case 'access-code.vault':
|
|
case 'adapter.sidewalk':
|
|
case 'adapter.zigbee':
|
|
case 'adapter.zwave':
|
|
case 'thermostat-operating-status':
|
|
return "ignore"
|
|
}
|
|
return "not-supported"
|
|
}
|
|
|
|
// Loop through each location and publish supported devices
|
|
async publishLocations() {
|
|
// For each location get existing alarm & camera devices
|
|
this.locations.forEach(async location => {
|
|
const devices = await this.devices.filter(d => d.locationId == location.locationId)
|
|
// If location has devices publish them
|
|
if (devices && devices.length) {
|
|
if (location.hasHubs && !location.isSubscribed) {
|
|
// Location has an alarm or smart bridge so subscribe to websocket connection monitor
|
|
location.isSubscribed = true
|
|
location.onConnected.subscribe(async connected => {
|
|
if (connected) {
|
|
// Only publish if previous state was actually disconnected
|
|
if (!location.isConnected) {
|
|
location.isConnected = true
|
|
debug(`Websocket for location id ${location.locationId} is connected`)
|
|
this.publishDevices(location)
|
|
}
|
|
} else {
|
|
// Wait 30 seconds before setting devices offline in case disconnect is transient
|
|
// Keeps from creating "unknown" state for sensors if connection error is short lived
|
|
await utils.sleep(30)
|
|
if (!location.onConnected._value) {
|
|
location.isConnected = false
|
|
debug(`Websocket for location id ${location.locationId} is disconnected`)
|
|
this.devices.forEach(device => {
|
|
if (device.locationId == location.locationId && !device.camera) {
|
|
device.offline()
|
|
}
|
|
})
|
|
}
|
|
}
|
|
})
|
|
} else {
|
|
this.publishDevices(location)
|
|
}
|
|
} else {
|
|
debug(`No devices found for location ID ${location.id}`)
|
|
}
|
|
})
|
|
}
|
|
|
|
// Publish devices/cameras for given location
|
|
async publishDevices(location) {
|
|
this.republishCount = (this.republishCount < 1) ? 1 : this.republishCount
|
|
while (this.republishCount > 0 && this.mqttConnected) {
|
|
try {
|
|
const devices = await this.devices.filter(d => d.locationId == location.locationId)
|
|
if (devices && devices.length) {
|
|
devices.forEach(device => {
|
|
// Provide location websocket connection state to device
|
|
device.publish(location.onConnected._value)
|
|
})
|
|
}
|
|
} catch (error) {
|
|
debug(error)
|
|
}
|
|
await utils.sleep(30)
|
|
this.republishCount--
|
|
}
|
|
}
|
|
|
|
async go2rtcShutdown() {
|
|
await go2rtc.shutdown()
|
|
}
|
|
}
|