@boozilla/homebridge-shome 1.0.0

package/src/platform.ts

@@ -0,0 +1,113 @@
+import { API, Characteristic, DynamicPlatformPlugin, Logger, PlatformAccessory, PlatformConfig, Service } from 'homebridge';
+import { PLATFORM_NAME, PLUGIN_NAME } from './settings.js';
+import { ShomeClient, MainDevice, SubDevice } from './shomeClient.js';
+import { LightAccessory } from './accessories/lightAccessory.js';
+import { VentilatorAccessory } from './accessories/ventilatorAccessory.js';
+import { HeaterAccessory } from './accessories/heaterAccessory.js';
+import { DoorlockAccessory } from './accessories/doorlockAccessory.js';
+
+const CONTROLLABLE_MULTI_DEVICE_TYPES = ['LIGHT', 'HEATER', 'VENTILATOR'];
+const SPECIAL_CONTROLLABLE_TYPES = ['DOORLOCK'];
+
+export class ShomePlatform implements DynamicPlatformPlugin {
+  public readonly Service: typeof Service;
+  public readonly Characteristic: typeof Characteristic;
+  public readonly accessories: PlatformAccessory[] = [];
+  public readonly shomeClient: ShomeClient;
+
+  constructor(
+    public readonly log: Logger,
+    public readonly config: PlatformConfig,
+    public readonly api: API,
+  ) {
+    this.Service = this.api.hap.Service;
+    this.Characteristic = this.api.hap.Characteristic;
+
+    this.shomeClient = new ShomeClient(
+      this.log,
+      this.config.username,
+      this.config.password,
+      this.config.deviceId,
+    );
+
+    this.api.on('didFinishLaunching', () => {
+      this.discoverDevices();
+    });
+  }
+
+  configureAccessory(accessory: PlatformAccessory) {
+    this.accessories.push(accessory);
+  }
+
+  async discoverDevices() {
+    const devices = await this.shomeClient.getDeviceList();
+    const foundAccessories: PlatformAccessory[] = [];
+
+    for (const device of devices) {
+      if (CONTROLLABLE_MULTI_DEVICE_TYPES.includes(device.thngModelTypeName)) {
+        const deviceInfoList = await this.shomeClient.getDeviceInfo(device.thngId, device.thngModelTypeName);
+
+        if (deviceInfoList) {
+          for (const subDevice of deviceInfoList) {
+            const uuid = this.api.hap.uuid.generate(`${device.thngId}-${subDevice.deviceId}`);
+            const accessory = this.setupAccessory(device, subDevice, uuid);
+            foundAccessories.push(accessory);
+          }
+        }
+      } else if (SPECIAL_CONTROLLABLE_TYPES.includes(device.thngModelTypeName)) {
+        const uuid = this.api.hap.uuid.generate(device.thngId);
+        const accessory = this.setupAccessory(device, null, uuid);
+        foundAccessories.push(accessory);
+      } else {
+        this.log.info(`Ignoring device: ${device.nickname} (Type: ${device.thngModelTypeName})`);
+      }
+    }
+
+    const accessoriesToRemove = this.accessories.filter(cachedAccessory =>
+      !foundAccessories.some(foundAccessory => foundAccessory.UUID === cachedAccessory.UUID),
+    );
+    if (accessoriesToRemove.length > 0) {
+      this.log.info('Removing stale accessories:', accessoriesToRemove.map(a => a.displayName));
+      this.api.unregisterPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, accessoriesToRemove);
+    }
+  }
+
+  setupAccessory(mainDevice: MainDevice, subDevice: SubDevice | null, uuid: string): PlatformAccessory {
+    const displayName = subDevice ? subDevice.nickname : mainDevice.nickname;
+    const existingAccessory = this.accessories.find(accessory => accessory.UUID === uuid);
+
+    if (existingAccessory) {
+      this.log.info('Restoring existing accessory from cache:', displayName);
+      existingAccessory.context.device = mainDevice;
+      existingAccessory.context.subDevice = subDevice;
+      this.createAccessory(existingAccessory);
+      return existingAccessory;
+    } else {
+      this.log.info('Adding new accessory:', displayName);
+      const accessory = new this.api.platformAccessory(displayName, uuid);
+      accessory.context.device = mainDevice;
+      accessory.context.subDevice = subDevice;
+      this.createAccessory(accessory);
+      this.api.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, [accessory]);
+      return accessory;
+    }
+  }
+
+  createAccessory(accessory: PlatformAccessory) {
+    const device = accessory.context.device;
+    switch (device.thngModelTypeName) {
+    case 'LIGHT':
+      new LightAccessory(this, accessory);
+      break;
+    case 'VENTILATOR':
+      new VentilatorAccessory(this, accessory);
+      break;
+    case 'HEATER':
+      new HeaterAccessory(this, accessory);
+      break;
+    case 'DOORLOCK':
+      new DoorlockAccessory(this, accessory);
+      break;
+    }
+  }
+}

package/src/settings.ts

@@ -0,0 +1,9 @@
+/**
+ * This is the name of the platform that users will use to register the plugin in the Homebridge config.json
+ */
+export const PLATFORM_NAME = 'sHome';
+
+/**
+ * This must match the name of your plugin as defined the package.json
+ */
+export const PLUGIN_NAME = 'homebridge-shome';

package/src/shomeClient.ts

@@ -0,0 +1,196 @@
+import axios from 'axios';
+import CryptoJS from 'crypto-js';
+import { Logger } from 'homebridge';
+
+const BASE_URL = 'https://shome-api.samsung-ihp.com';
+const APP_REGST_ID = '6110736314d9eef6baf393f3e43a5342f9ccde6ef300d878385acd9264cf14d5';
+const CHINA_APP_REGST_ID = 'SHOME==6110736314d9eef6baf393f3e43a5342f9ccde6ef300d878385acd9264cf14d5';
+const LANGUAGE = 'KOR';
+
+// Define and export interfaces for device types
+export interface MainDevice {
+  thngId: string;
+  thngModelTypeName: string;
+  nickname: string;
+  [key: string]: unknown;
+}
+
+export interface SubDevice {
+  deviceId: string;
+  nickname: string;
+  [key: string]: unknown;
+}
+
+export class ShomeClient {
+  private cachedAccessToken: string | null = null;
+  private ihdId: string | null = null;
+  private tokenExpiry: number = 0;
+
+  constructor(
+    private readonly log: Logger,
+    private readonly username: string,
+    private readonly password: string,
+    private readonly deviceId: string,
+  ) {
+  }
+
+  async login(): Promise<string | null> {
+    if (!this.isTokenExpired()) {
+      return this.cachedAccessToken;
+    }
+
+    try {
+      const createDate = this.getDateTime();
+      const hashedPassword = this.sha512(this.password);
+      const hashData = this.sha512(`IHRESTAPI${this.username}${hashedPassword}${this.deviceId}` +
+        `${APP_REGST_ID}${CHINA_APP_REGST_ID}${LANGUAGE}${createDate}`);
+
+      const response = await axios.put(`${BASE_URL}/v18/users/login`, null, {
+        params: {
+          appRegstId: APP_REGST_ID,
+          chinaAppRegstId: CHINA_APP_REGST_ID,
+          createDate: createDate,
+          hashData: hashData,
+          language: LANGUAGE,
+          mobileDeviceIdno: this.deviceId,
+          password: hashedPassword,
+          userId: this.username,
+        },
+      });
+
+      if (response.data && response.data.accessToken) {
+        this.cachedAccessToken = response.data.accessToken;
+        this.ihdId = response.data.ihdId;
+
+        // Decode token to find expiry
+        const payload = JSON.parse(Buffer.from(this.cachedAccessToken!.split('.')[1], 'base64').toString());
+        this.tokenExpiry = payload.exp * 1000;
+
+        this.log.info('Successfully logged in to sHome API.');
+        return this.cachedAccessToken;
+      } else {
+        this.log.error('Login failed: Invalid credentials or API error.');
+        return null;
+      }
+    } catch (error) {
+      this.log.error(`Login error: ${error}`);
+      return null;
+    }
+  }
+
+  async getDeviceList(): Promise<MainDevice[]> {
+    const token = await this.login();
+    if (!token || !this.ihdId) {
+      return [];
+    }
+
+    try {
+      const createDate = this.getDateTime();
+      const hashData = this.sha512(`IHRESTAPI${this.ihdId}${createDate}`);
+
+      const response = await axios.get(`${BASE_URL}/v16/settings/${this.ihdId}/devices/`, {
+        params: { createDate, hashData },
+        headers: { 'Authorization': `Bearer ${token}` },
+      });
+
+      return response.data.deviceList || [];
+    } catch (error) {
+      this.log.error(`Error getting device list: ${error}`);
+      return [];
+    }
+  }
+
+  async getDeviceInfo(thingId: string, type: string): Promise<SubDevice[] | null> {
+    const token = await this.login();
+    if (!token) {
+      return null;
+    }
+
+    try {
+      const createDate = this.getDateTime();
+      const hashData = this.sha512(`IHRESTAPI${thingId}${createDate}`);
+      const typePath = type.toLowerCase().replace(/_/g, '');
+
+      const response = await axios.get(`${BASE_URL}/v18/settings/${typePath}/${thingId}`, {
+        params: { createDate, hashData },
+        headers: { 'Authorization': `Bearer ${token}` },
+      });
+
+      return response.data.deviceInfoList || null;
+    } catch (error) {
+      this.log.error(`Error getting device info for ${thingId}: ${error}`);
+      return null;
+    }
+  }
+
+  async setDevice(thingId: string, deviceId: string, type: string, controlType: string, state: string): Promise<boolean> {
+    const token = await this.login();
+    if (!token) {
+      return false;
+    }
+
+    try {
+      const createDate = this.getDateTime();
+      const hashData = this.sha512(`IHRESTAPI${thingId}${deviceId}${state}${createDate}`);
+      const typePath = type.toLowerCase().replace(/_/g, '');
+      const controlPath = controlType.toLowerCase().replace(/_/g, '-');
+
+      await axios.put(`${BASE_URL}/v18/settings/${typePath}/${thingId}/${deviceId}/${controlPath}`, null, {
+        params: {
+          createDate,
+          [controlType === 'WINDSPEED' ? 'mode' : 'state']: state,
+          hashData,
+        },
+        headers: { 'Authorization': `Bearer ${token}` },
+      });
+
+      this.log.info(`Set ${type} [${thingId}/${deviceId}] to ${state}`);
+      return true;
+    } catch (error) {
+      this.log.error(`Error setting device ${thingId}: ${error}`);
+      return false;
+    }
+  }
+
+  async unlockDoorlock(thingId: string): Promise<boolean> {
+    const token = await this.login();
+    if (!token) {
+      return false;
+    }
+
+    try {
+      const createDate = this.getDateTime();
+      const hashData = this.sha512(`IHRESTAPI${thingId}${createDate}`);
+
+      await axios.put(`${BASE_URL}/v16/settings/doorlocks/${thingId}/open-mode`, null, {
+        params: {
+          createDate,
+          pin: '',
+          hashData,
+        },
+        headers: { 'Authorization': `Bearer ${token}` },
+      });
+
+      this.log.info(`Unlocked doorlock [${thingId}]`);
+      return true;
+    } catch (error) {
+      this.log.error(`Error unlocking doorlock ${thingId}: ${error}`);
+      return false;
+    }
+  }
+
+  private sha512(input: string): string {
+    return CryptoJS.SHA512(input).toString();
+  }
+
+  private isTokenExpired(): boolean {
+    return !this.cachedAccessToken || Date.now() >= this.tokenExpiry;
+  }
+
+  private getDateTime(): string {
+    const now = new Date();
+    const pad = (num: number) => num.toString().padStart(2, '0');
+    return `${now.getUTCFullYear()}${pad(now.getUTCMonth() + 1)}${pad(now.getUTCDate())}` +
+      `${pad(now.getUTCHours())}${pad(now.getUTCMinutes())}${pad(now.getUTCSeconds())}`;
+  }
+}

package/tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": [
+      "DOM",
+      "ES2022"
+    ],
+    "rootDir": "src",
+    "module": "nodenext",
+    "moduleResolution": "nodenext",
+    "strict": true,
+    "declaration": true,
+    "outDir": "dist",
+    "sourceMap": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": [
+    "eslint.config.js",
+    "homebridge-ui",
+    "src"
+  ]
+}