import { readFileSync, writeFileSync } from 'fs'
import { APIEvent, Service, Characteristic } from 'homebridge'
import type {
API,
DynamicPlatformPlugin,
Logger,
PlatformAccessory,
PlatformConfig,
} from 'homebridge'
import { PLATFORM_NAME, PLUGIN_NAME } from './settings'
import { LgAirConditionerPlatformAccessory } from './platformAccessory'
import ThinqApi from './thinq/api'
import ThinqAuth, { ThinqAuthConfig } from './thinq/auth'
import { ThinqConfig, PartialThinqConfig } from './thinq/thinqConfig'
const AUTH_REFRESH_INTERVAL = 10 * 60 * 1000 // 10 minutes
export type HomebridgeLgThinqPlatformConfig = {
remove_offline_devices_on_boot?: boolean
} & ThinqAuthConfig
/**
* HomebridgePlatform
* This class is the main constructor for your plugin, this is where you should
* parse the user config and discover/register accessories with Homebridge.
*/
export class HomebridgeLgThinqPlatform implements DynamicPlatformPlugin {
public readonly Service: typeof Service = this.api.hap.Service
public readonly Characteristic: typeof Characteristic =
this.api.hap.Characteristic
// this is used to track restored cached accessories
public readonly accessories: PlatformAccessory[] = []
public thinqAuth: ThinqAuth | undefined
public thinqApi: ThinqApi | undefined
private didFinishLaunching: Promise<void>
private handleFinishedLaunching?: () => void
constructor(
public readonly log: Logger,
public readonly config: PlatformConfig & HomebridgeLgThinqPlatformConfig,
public readonly api: API,
) {
this.didFinishLaunching = new Promise((resolve) => {
// Store the resolver locally.
// Steps that depend on this can `await didFinishLaunching`.
// When Homebridge is finishes launching, this will be called to resolve.
this.handleFinishedLaunching = resolve
})
this.log.debug('Finished initializing platform:', this.config.name)
this.initialize()
// When this event is fired it means Homebridge has restored all cached accessories from disk.
// Dynamic Platform plugins should only register new accessories after this event was fired,
// in order to ensure they weren't added to homebridge already. This event can also be used
// to start discovery of new accessories.
this.api.on(APIEvent.DID_FINISH_LAUNCHING, () => {
this.log.debug('Executed didFinishLaunching callback')
if (this.handleFinishedLaunching) {
this.handleFinishedLaunching()
}
})
}
/**
* This function is invoked when homebridge restores cached accessories from disk at startup.
* It should be used to setup event handlers for characteristics and update respective values.
*/
configureAccessory(accessory: PlatformAccessory) {
this.log.debug('Restoring accessory from cache:', accessory.displayName)
// add the restored accessory to the accessories cache so we can track if it has already been registered
this.accessories.push(accessory)
}
async initialize() {
try {
const thinqConfig = await this.initializeThinqConfig()
this.thinqAuth = ThinqAuth.fromConfig(this.log, thinqConfig, this.config)
this.thinqApi = new ThinqApi(thinqConfig, this.thinqAuth)
await this.inititializeAuth()
this.startRefreshTokenInterval()
this.discoverDevicesWhenReady()
} catch (error) {
this.log.error('Error initializing platform', `${error}`)
this.log.debug('Full error', error)
}
}
async initializeThinqConfig() {
const partialThinqConfig: PartialThinqConfig = {
// If a user installs via the homebridge UI, these values
// may not be guaranteed
countryCode: this.config.country_code || 'US',
languageCode: this.config.language_code || 'en-US',
}
const gatewayUri = await ThinqApi.getGatewayUri(partialThinqConfig)
const thinqConfig: ThinqConfig = {
apiBaseUri: gatewayUri.result.thinq2Uri,
accessTokenUri: `https://${partialThinqConfig.countryCode.toLowerCase()}.lgeapi.com/oauth/1.0/oauth2/token`,
redirectUri: `https://kr.m.lgaccount.com/login/iabClose`,
authorizationUri: `${gatewayUri.result.empSpxUri}/login/signIn`,
countryCode: partialThinqConfig.countryCode,
languageCode: partialThinqConfig.languageCode,
}
return thinqConfig
}
async inititializeAuth() {
this.updateAndReplaceConfig()
const redirectedUrl = this.config.auth_redirected_url as unknown
if (this.thinqAuth?.getIsLoggedIn()) {
this.log.info('Already logged into ThinQ')
await this.refreshAuth()
} else if (typeof redirectedUrl === 'string' && redirectedUrl !== '') {
this.log.info('Initiating auth with provided redirect URL')
try {
await this.thinqAuth!.processLoginResult(redirectedUrl)
this.updateAndReplaceConfig()
} catch (error) {
this.log.error('Error setting refresh token', error)
throw error
}
} else {
this.log.debug(
'Redirected URL not stored in config and no existing auth state. Skipping initializeAuth().',
)
throw new Error('Auth not ready yet, please log in.')
}
}
private startRefreshTokenInterval() {
setInterval(() => this.refreshAuth(), AUTH_REFRESH_INTERVAL)
}
private async refreshAuth() {
this.log.debug('refreshAuth()')
try {
await this.thinqAuth!.initiateRefreshToken()
this.updateAndReplaceConfig()
} catch (error) {
if (
error instanceof Object &&
// @ts-expect-error TS2339 from upgrade to Typescript 4.5, proven to work on-device regardless
error.body instanceof Object &&
// @ts-expect-error TS2339 from upgrade to Typescript 4.5, proven to work on-device regardless
error.body.error instanceof Object &&
// @ts-expect-error TS2339 from upgrade to Typescript 4.5, proven to work on-device regardless
error.body.error.code === 'LG.OAUTH.EC.4001'
) {
this.log.error(
'Login credentials have expired!\n\n' +
'Please re-configure the plugin:\n' +
' 1. Login again\n' +
' 2. Update the "redirected URL" in the config\n' +
' 3. Restart Homebridge\n',
)
this.thinqAuth?.clearStoredToken()
this.updateAndReplaceConfig()
} else {
this.log.error('Failed to refresh token', `${error}`)
}
}
}
private async discoverDevicesWhenReady() {
await this.didFinishLaunching
// run the method to discover / register your devices as accessories
try {
await this.discoverDevices()
} catch (error) {
const errorString = `${error}`
this.log.error('Error discovering devices', `${error}`)
if (errorString.includes('status code 400')) {
this.log.error(
'This can sometimes indicate the LG App has new agreements you must accept. If so:\n' +
' 1. Open the native LG App and sign in as usual\n' +
' 2. If an agreement pops up, review and accept it if appropriate\n' +
' 3. Restart Homebridge\n' +
'If there are no agreements to accept, try restarting Homebridge.\n' +
"If that still doesn't work, delete the config for this accessory and restart Homebridge to initiate a full reset.",
)
}
}
}
/**
* This is an example method showing how to register discovered accessories.
* Accessories must only be registered once, previously created accessories
* must not be registered again to prevent "duplicate UUID" errors.
*/
async discoverDevices() {
if (!this.thinqAuth?.getIsLoggedIn()) {
this.log.info('Not logged in; skipping discoverDevices()')
return
}
const dashboardResponse = await this.thinqApi!.getDashboard()
this.log.debug('dashboardResponse', dashboardResponse)
this.log.info(
`Discover found ${dashboardResponse.result.item.length} total devices`,
)
const devices = dashboardResponse.result.item.filter((item) => {
if (typeof item !== 'object') {
this.log.debug('Item is not an object, ignoring')
return false
}
if (item.deviceType !== 401) {
// Air Conditioners have a 401 device type
this.log.debug(`deviceType is ${item.deviceType}, ignoring`)
return false
}
if (item.platformType !== 'thinq2') {
this.log.error(
`"${item.alias}" (model ${item.modelName}) uses the ${item.platformType} platform, which is not supported. ` +
`Please see https://github.com/sman591/homebridge-lg-thinq-ac/issues/4 for updates.`,
)
return false
}
return true
})
// Keep a running list of all accessories we register or know were already registered
const matchedAccessories: PlatformAccessory[] = []
// loop over the discovered devices and register each one if it has not already been registered
for (const device of devices) {
// generate a unique id for the accessory this should be generated from
// something globally unique, but constant, for example, the device serial
// number or MAC address
const uuid = this.api.hap.uuid.generate(device.deviceId)
const matchingAccessories = this.accessories.filter(
(accessory) => accessory.UUID === uuid,
)
if (matchingAccessories.length > 0) {
this.log.info('Existing accessory:', device.alias)
// check that the device has not already been registered by checking the
// cached devices we stored in the `configureAccessory` method above
for (const accessory of matchingAccessories) {
accessory.context.device = device
matchedAccessories.push(accessory)
new LgAirConditionerPlatformAccessory(this, accessory)
}
} else if (!device.online) {
this.log.info(
`Accessory "${device.alias}" is offline and will not be added.`,
)
} else {
this.log.info('Registering new accessory:', device.alias)
// create a new accessory
const accessory = new this.api.platformAccessory(device.alias, uuid)
// store a copy of the device object in the `accessory.context`
// the `context` property can be used to store any data about the accessory you may need
accessory.context.device = device
// create the accessory handler
// this is imported from `platformAccessory.ts`
new LgAirConditionerPlatformAccessory(this, accessory)
// link the accessory to your platform
this.api.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, [
accessory,
])
// push into accessory cache
this.accessories.push(accessory)
matchedAccessories.push(accessory)
}
}
// Unregister offline accessories if desired (set by config)
if (this.config.remove_offline_devices_on_boot) {
this.log.info('Attempting to remove offline devices from HomeKit...')
// Only remove once when config is enabled
this.config.remove_offline_devices_on_boot = false
this.updateAndReplaceConfig()
let wasADeviceRemoved = false
this.accessories.forEach((accessory) => {
const deviceContext = accessory.context?.device
if (deviceContext?.online === false) {
this.log.info(
`Removing offline device "${accessory.displayName}" from HomeKit. If you need this device again, please restart Homebridge.`,
)
// @ts-expect-error This is a hack
const jsInstance = accessory.jsInstance as
| LgAirConditionerPlatformAccessory
| undefined
if (
jsInstance &&
jsInstance instanceof LgAirConditionerPlatformAccessory
) {
jsInstance?.unregisterAccessory()
wasADeviceRemoved = true
} else {
this.log.warn(
`Device "${accessory.displayName}" is offline, but could not be removed. Please file a bug with homebridge-lg-thinq-ac.`,
)
}
}
})
if (!wasADeviceRemoved) {
this.log.warn(
'remove_offline_devices_on_boot was attempted but no offline devices were found',
)
}
}
// Unregister accessories that weren't matched from the API response.
// This helps clean up devices which:
// - You no longer have connected to your account
// - Were mistakenly registered in an older version of this plugin but aren't actually supported
this.accessories.forEach((accessory) => {
const didMatchAccessory = matchedAccessories.some(
(matchedAccessory) => matchedAccessory.UUID === accessory.UUID,
)
if (!didMatchAccessory) {
this.log.info(
'Un-registering unknown accessory:',
accessory.displayName,
)
this.api.unregisterPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, [
accessory,
])
}
})
}
getRefreshIntervalMinutes() {
const fallbackDefault = 1
try {
const parsedValue = parseFloat(this.config.refresh_interval)
if (parsedValue > 0.1 && parsedValue < 100000) {
return parsedValue
}
} catch (error) {
this.log.error('Failed to parse refresh_interval from config', error)
}
this.log.debug('Using fallback refresh interval')
return fallbackDefault
}
updateAndReplaceConfig() {
const configPath = this.api.user.configPath()
const configString = readFileSync(configPath).toString()
try {
const config = JSON.parse(configString)
// this.log.debug('config', config) DO NOT COMMIT THIS -- it could accidentally leak into GitHub issue reports
const platforms = config.platforms.filter(
(platform: Record<string, string>) =>
platform.platform === 'LgThinqAirConditioner',
)
const authConfig = this.thinqAuth!.serializeToConfig()
const generalConfig = {
remove_offline_devices_on_boot:
this.config.remove_offline_devices_on_boot || false,
}
const platformConfig: Required<HomebridgeLgThinqPlatformConfig> = {
...authConfig,
...generalConfig,
}
for (const platform of platforms) {
Object.assign(platform, platformConfig)
}
writeFileSync(configPath, JSON.stringify(config))
} catch (error) {
this.log.error('Failed to store updated config', `${error}`)
this.log.debug('Full error:', error)
}
}
}
