@ray-js/lock-sdk 1.1.3 → 1.2.0-beta.1

package/lib/feature/password/temporary/wifi-offline.d.ts

@@ -0,0 +1,5 @@
+import type { LockDeviceRuntime } from "../../../runtime/LockDeviceRuntime";
+import type { CreateOfflineParams, OfflinePasswordType, OfflineTempResult } from "./types";
+export declare function createTempOfflineForRuntime(rt: LockDeviceRuntime, params: CreateOfflineParams): Promise<OfflineTempResult>;
+export declare function getTempOfflineEffectiveListForRuntime(rt: LockDeviceRuntime, pwdTypeCode: OfflinePasswordType): Promise<import("../../../api/temp").EffectivePasswrodItem[]>;
+export declare function getTempOfflineInvalidListForRuntime(rt: LockDeviceRuntime, pwdTypeCode: OfflinePasswordType): Promise<import("../../../api/temp").EffectivePasswrodItem[]>;

package/lib/feature/password/temporary/wifi-offline.js

@@ -0,0 +1,85 @@
+import { createOfflineOnceAPI, getTempOfflineListAPI, } from "../../../api/temp";
+import { parseOfflinePasswordForRuntime } from "../../utils";
+import { getError, handleCloudError } from "../../../utils/errors";
+const offlinePasswordTypeMap = {
+    once: "1",
+    multiple: "0",
+    clear_one: "8",
+    clear_all: "9",
+};
+export async function createTempOfflineForRuntime(rt, params) {
+    const { name, effective, isOnce } = params;
+    try {
+        if (isOnce) {
+            const res = await createOfflineOnceAPI({
+                devId: rt.config.devInfo.devId,
+                pwdType: "1",
+                gmtStart: "0",
+                gmtExpired: "0",
+            });
+            return {
+                type: "once",
+                name: res.pwdName,
+                password: parseOfflinePasswordForRuntime(rt, res.pwd),
+                unlockBindingId: res.unlockBindingId,
+                pwdId: res.pwdId,
+                effectiveConfig: {
+                    effectiveDate: Number(res.gmtStart),
+                    expiredDate: Number(res.gmtExpired),
+                },
+            };
+        }
+        if (name && name.length > 20) {
+            throw getError(1031);
+        }
+        if (effective.effectiveDate >= effective.expiredDate) {
+            throw getError(1010);
+        }
+        const res = await createOfflineOnceAPI({
+            devId: rt.config.devInfo.devId,
+            pwdType: "0",
+            gmtStart: effective.effectiveDate.toString(),
+            gmtExpired: effective.expiredDate.toString(),
+        });
+        return {
+            type: "multiple",
+            name: res.pwdName,
+            password: parseOfflinePasswordForRuntime(rt, res.pwd),
+            unlockBindingId: res.unlockBindingId,
+            pwdId: res.pwdId,
+            effectiveConfig: {
+                effectiveDate: Number(res.gmtStart),
+                expiredDate: Number(res.gmtExpired),
+            },
+        };
+    }
+    catch (error) {
+        throw handleCloudError(error);
+    }
+}
+export async function getTempOfflineEffectiveListForRuntime(rt, pwdTypeCode) {
+    try {
+        const offLineValidPswList = await getTempOfflineListAPI({
+            devId: rt.config.devInfo.devId,
+            pwdType: offlinePasswordTypeMap[pwdTypeCode],
+            status: "1",
+        });
+        return offLineValidPswList;
+    }
+    catch (error) {
+        throw handleCloudError(error);
+    }
+}
+export async function getTempOfflineInvalidListForRuntime(rt, pwdTypeCode) {
+    try {
+        const offLineFailurePswList = await getTempOfflineListAPI({
+            devId: rt.config.devInfo.devId,
+            pwdType: offlinePasswordTypeMap[pwdTypeCode],
+            status: "0",
+        });
+        return offLineFailurePswList;
+    }
+    catch (error) {
+        throw handleCloudError(error);
+    }
+}

package/lib/feature/password/temporary/wifi-online.d.ts

@@ -0,0 +1,28 @@
+import type { LockDeviceRuntime } from "../../../runtime/LockDeviceRuntime";
+import type { CreateOnlineUnlimitedParams } from "./types";
+import type { EffectiveConfig } from "../../../interface";
+export declare function saveTempOnlineUnlimitedForRuntime(rt: LockDeviceRuntime, params: CreateOnlineUnlimitedParams): Promise<{
+    type: "custom";
+    name: string;
+    pwdId: string;
+    effectiveConfig: EffectiveConfig;
+}>;
+export declare function removeTempOnlineUnlimitedForRuntime(rt: LockDeviceRuntime, id: string): Promise<void>;
+export interface OnlinePasswordItem {
+    status: "effective" | "synchronizing" | "expired" | "disabled" | "invalid";
+    effectiveConfig: EffectiveConfig;
+    unlockBindingId: string;
+    failReason: number;
+    name: string;
+    phase: number;
+    opModeType: number;
+    opModeSubType: number;
+    sn: number;
+    opModeInfo?: {
+        hasClearPwd?: boolean;
+        revokedPwdName?: string;
+        revokedPwdEffectiveTime?: number;
+        revokedPwdInvalidTime?: number;
+    };
+}
+export declare function getTempOnlineUnlimitedListForRuntime(rt: LockDeviceRuntime): Promise<OnlinePasswordItem[]>;

package/lib/feature/password/temporary/wifi-online.js

@@ -0,0 +1,153 @@
+import { createOnlineUnlimited, getTempOnlineUnlimitedListAPI, removeTempOnlineUnlimitedAPI, } from "../../../api/temp";
+import { formatWeek, parseWeek, validateEffectiveConfig } from "../../../utils";
+import { LoopTypes } from "../../../utils/constant";
+import { encrypt } from "../../../platform/device";
+import { getError, handleCloudError } from "../../../utils/errors";
+import { PASSWORD_REGEX } from "./internal/password-helpers";
+import { sdkLog } from "../../../utils/sdk-log";
+const onLinePasswordStatusMap = {
+    1: "effective",
+    2: "synchronizing",
+    3: "expired",
+    4: "disabled",
+    5: "invalid",
+};
+export async function saveTempOnlineUnlimitedForRuntime(rt, params) {
+    const { password, name, effective, phone, countryCode } = params;
+    const startedAt = Date.now();
+    sdkLog("info", "tempPassword", "saveOnlineUnlimitedStart", {
+        devId: rt.devId,
+        data: {
+            hasName: typeof name === "string",
+            hasPhone: typeof phone === "string",
+            hasCountryCode: typeof countryCode === "string",
+            repeat: effective?.repeat,
+        },
+    });
+    if (!PASSWORD_REGEX.test(password)) {
+        const error = getError(1030);
+        sdkLog("warn", "tempPassword", "saveOnlineUnlimitedInvalidPassword", {
+            devId: rt.devId,
+            error,
+        });
+        throw error;
+    }
+    if (name && name.length > 20) {
+        const error = getError(1031);
+        sdkLog("warn", "tempPassword", "saveOnlineUnlimitedInvalidName", {
+            devId: rt.devId,
+            data: { nameLength: name.length },
+            error,
+        });
+        throw error;
+    }
+    validateEffectiveConfig(effective);
+    const { effectiveTime = 0, expiredTime = 1439 } = effective;
+    const aesPwd = await encrypt(rt.config.devInfo.devId, password);
+    const loopType = effective?.repeat
+        ?
+            LoopTypes[effective?.repeat?.toUpperCase()]
+        : LoopTypes.NONE;
+    const schedule = [
+        {
+            allDay: loopType === LoopTypes.NONE,
+            effectiveTime,
+            invalidTime: expiredTime,
+            workingDay: formatWeek(effective?.weeks ?? [0]),
+        },
+    ];
+    try {
+        const res = await createOnlineUnlimited({
+            devId: rt.config.devInfo.devId,
+            effectiveTime: effective.effectiveDate,
+            invalidTime: effective.expiredDate,
+            name: name,
+            password: aesPwd,
+            schedule,
+            availTime: 0,
+            phone,
+            countryCode,
+        });
+        sdkLog("info", "tempPassword", "saveOnlineUnlimitedSuccess", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+        });
+        return {
+            type: "custom",
+            name: res.name,
+            pwdId: res.pwdId,
+            effectiveConfig: effective,
+        };
+    }
+    catch (error) {
+        sdkLog("error", "tempPassword", "saveOnlineUnlimitedFail", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            error,
+        });
+        throw handleCloudError(error);
+    }
+}
+export async function removeTempOnlineUnlimitedForRuntime(rt, id) {
+    const startedAt = Date.now();
+    sdkLog("info", "tempPassword", "removeOnlineUnlimitedStart", {
+        devId: rt.devId,
+        data: { hasId: !!id },
+    });
+    try {
+        await removeTempOnlineUnlimitedAPI({
+            devId: rt.config.devInfo.devId,
+            id,
+        });
+        sdkLog("info", "tempPassword", "removeOnlineUnlimitedSuccess", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+        });
+    }
+    catch (error) {
+        sdkLog("error", "tempPassword", "removeOnlineUnlimitedFail", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            error,
+        });
+        throw handleCloudError(error);
+    }
+}
+export async function getTempOnlineUnlimitedListForRuntime(rt) {
+    const startedAt = Date.now();
+    try {
+        const pswList = await getTempOnlineUnlimitedListAPI(rt.config.devInfo.devId);
+        const newPswList = pswList?.map(({ effective, effectiveTime, invalidTime, scheduleDetails, ...rest }) => {
+            const status = onLinePasswordStatusMap[effective];
+            const effectiveConfig = {
+                effectiveDate: effectiveTime,
+                expiredDate: invalidTime,
+            };
+            if (scheduleDetails?.length) {
+                const scheduleDetail = scheduleDetails[0];
+                effectiveConfig.repeat =
+                    scheduleDetail.allDay === false ? "week" : "none";
+                if (effectiveConfig.repeat === "week") {
+                    effectiveConfig.weeks = parseWeek(scheduleDetail.workingDay);
+                    effectiveConfig.effectiveTime = scheduleDetail.effectiveTime;
+                    effectiveConfig.expiredTime = scheduleDetail.invalidTime;
+                }
+            }
+            return { ...rest, status, effectiveConfig };
+        });
+        sdkLog("debug", "tempPassword", "getOnlineUnlimitedListSuccess", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            data: { count: newPswList?.length ?? 0 },
+        });
+        return newPswList;
+    }
+    catch (error) {
+        sdkLog("error", "tempPassword", "getOnlineUnlimitedListFail", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            error,
+        });
+        throw handleCloudError(error);
+    }
+}

package/lib/feature/screen/bind.d.ts

@@ -0,0 +1,4 @@
+import { type BindingResult, type UnbindingResult } from "../../api/screen";
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export declare function bindLockForRuntime(runtime: LockDeviceRuntime, lockDevId: string): Promise<BindingResult>;
+export declare function unbindLockForRuntime(runtime: LockDeviceRuntime, relationId: string): Promise<UnbindingResult>;

package/lib/feature/screen/bind.js

@@ -0,0 +1,181 @@
+import { addBindingApi, deleteBindingApi, getBindingResultApi, getUnbindingResultApi, } from "../../api/screen";
+import { getDeviceInfo } from "../../platform/device";
+import { getError } from "../../utils/errors";
+import { sdkLog } from "../../utils/sdk-log";
+import { getDeviceStatusForRuntime } from "../state/device-status";
+import { handleScreenCloudError } from "./error";
+const POLL_INTERVAL_MS = 2_000;
+const BIND_POLL_TIMEOUT_MS = 25_000;
+const UNBIND_POLL_TIMEOUT_MS = 20_000;
+const delay = (ms) => new Promise((resolve) => {
+    setTimeout(resolve, ms);
+});
+export async function bindLockForRuntime(runtime, lockDevId) {
+    const accessoryDevId = runtime.devId;
+    const startedAt = Date.now();
+    sdkLog("info", "screen", "bindStart", {
+        devId: accessoryDevId,
+        data: { lockDevId },
+    });
+    try {
+        const deviceStatus = getDeviceStatusForRuntime(runtime);
+        if (deviceStatus.type !== "online") {
+            sdkLog("warn", "screen", "bindAccessoryOffline", {
+                devId: accessoryDevId,
+                data: { lockDevId },
+            });
+            throw getError(1001);
+        }
+        const lockInfo = await getDeviceInfo(lockDevId);
+        if (!lockInfo?.isOnline) {
+            sdkLog("warn", "screen", "bindLockOffline", {
+                devId: accessoryDevId,
+                data: { lockDevId },
+            });
+            throw getError(1001);
+        }
+        let sessionData;
+        try {
+            sessionData = await addBindingApi({
+                accessoryDevId,
+                lockDevId,
+            });
+            sdkLog("info", "screen", "bindAddSuccess", {
+                devId: accessoryDevId,
+                data: { lockDevId, relationId: sessionData.relationId },
+            });
+        }
+        catch (e) {
+            throw handleScreenCloudError(e);
+        }
+        const deadline = Date.now() + BIND_POLL_TIMEOUT_MS;
+        let last;
+        while (Date.now() < deadline) {
+            await delay(POLL_INTERVAL_MS);
+            try {
+                last = await getBindingResultApi({
+                    accessoryDevId,
+                    sessionId: sessionData.sessionId,
+                });
+            }
+            catch (e) {
+                throw handleScreenCloudError(e);
+            }
+            if (last.status !== "binding") {
+                sdkLog("info", "screen", "bindSettled", {
+                    devId: accessoryDevId,
+                    duration: Date.now() - startedAt,
+                    data: {
+                        lockDevId,
+                        relationId: sessionData.relationId,
+                        status: last.status,
+                        lanStatus: last.lanStatus,
+                    },
+                });
+                if (last.status === "failed") {
+                    throw getError(1103);
+                }
+                return last;
+            }
+        }
+        sdkLog("warn", "screen", "bindTimeout", {
+            devId: accessoryDevId,
+            duration: Date.now() - startedAt,
+            data: { lockDevId, relationId: sessionData.relationId },
+        });
+        throw getError(1002);
+    }
+    catch (error) {
+        sdkLog("error", "screen", "bindFail", {
+            devId: accessoryDevId,
+            duration: Date.now() - startedAt,
+            data: { lockDevId },
+            error,
+        });
+        throw error;
+    }
+}
+export async function unbindLockForRuntime(runtime, relationId) {
+    const accessoryDevId = runtime.devId;
+    const startedAt = Date.now();
+    sdkLog("info", "screen", "unbindStart", {
+        devId: accessoryDevId,
+        data: { relationId },
+    });
+    try {
+        const deviceStatus = getDeviceStatusForRuntime(runtime);
+        if (deviceStatus.type !== "online") {
+            sdkLog("warn", "screen", "unbindAccessoryOffline", {
+                devId: accessoryDevId,
+                data: { relationId },
+            });
+            throw getError(1001);
+        }
+        try {
+            await deleteBindingApi({ accessoryDevId, relationId });
+            sdkLog("info", "screen", "unbindDeleteSuccess", {
+                devId: accessoryDevId,
+                data: { relationId },
+            });
+        }
+        catch (e) {
+            if (e.innerError) {
+                switch (e.innerError.errorCode) {
+                    case "RELATION_NOT_FOUND":
+                    case "RELATION_CONFLICT":
+                        return {
+                            relationId,
+                            status: "unbound",
+                        };
+                    default:
+                }
+            }
+            throw handleScreenCloudError(e);
+        }
+        const deadline = Date.now() + UNBIND_POLL_TIMEOUT_MS;
+        let last;
+        while (Date.now() < deadline) {
+            await delay(POLL_INTERVAL_MS);
+            try {
+                last = await getUnbindingResultApi({ accessoryDevId, relationId });
+            }
+            catch (e) {
+                if (e.innerError) {
+                    switch (e.innerError.errorCode) {
+                        case "RELATION_NOT_FOUND":
+                        case "RELATION_CONFLICT":
+                            return {
+                                relationId,
+                                status: "unbound",
+                            };
+                        default:
+                    }
+                }
+                throw handleScreenCloudError(e);
+            }
+            if (last.status === "unbound") {
+                sdkLog("info", "screen", "unbindSettled", {
+                    devId: accessoryDevId,
+                    duration: Date.now() - startedAt,
+                    data: { relationId, status: last.status },
+                });
+                return last;
+            }
+        }
+        sdkLog("warn", "screen", "unbindTimeout", {
+            devId: accessoryDevId,
+            duration: Date.now() - startedAt,
+            data: { relationId },
+        });
+        throw getError(1002);
+    }
+    catch (error) {
+        sdkLog("error", "screen", "unbindFail", {
+            devId: accessoryDevId,
+            duration: Date.now() - startedAt,
+            data: { relationId },
+            error,
+        });
+        throw error;
+    }
+}

package/lib/feature/screen/error.d.ts

@@ -0,0 +1 @@
+export declare const handleScreenCloudError: (error: any) => any;

package/lib/feature/screen/error.js

@@ -0,0 +1,34 @@
+import { getError } from "../../utils/errors";
+export const handleScreenCloudError = (error) => {
+    if (error.innerError) {
+        switch (error.innerError.errorCode) {
+            case "USER_NOT_ADMIN_IN_GROUP":
+                return getError(1093);
+            case "USER_NOT_IN_GROUP":
+                return getError(1094);
+            case "ACCESSORY_NOT_FOUND":
+                return getError(1086);
+            case "LOCK_NOT_FOUND":
+                return getError(1095);
+            case "DEVICE_NOT_SAME_HOME":
+                return getError(1096);
+            case "ACCESSORY_OFFLINE":
+                return getError(1001);
+            case "LOCK_OFFLINE":
+                return getError(1097);
+            case "LOCK_NOT_SUPPORTED":
+                return getError(1098);
+            case "ACCESSORY_BIND_NOT_SUPPORTED":
+                return getError(1099);
+            case "BIND_LIMIT_REACHED":
+                return getError(1100);
+            case "RELATION_ALREADY_BOUND":
+                return getError(1101);
+            case "BINDING_IN_PROGRESS":
+                return getError(1102);
+            case "SESSION_INVALID":
+                return getError(1103);
+        }
+    }
+    return error;
+};

package/lib/feature/screen/event.d.ts

@@ -0,0 +1,3 @@
+import { type ScreenEventListParams } from "../../api/screen";
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export declare function getEventListForRuntime(runtime: LockDeviceRuntime, params?: ScreenEventListParams): Promise<import("../../api/screen").ScreenEventListResult>;

package/lib/feature/screen/event.js

@@ -0,0 +1,19 @@
+import { getEventListApi, } from "../../api/screen";
+import { sdkLog } from "../../utils/sdk-log";
+export async function getEventListForRuntime(runtime, params = {}) {
+    const startedAt = Date.now();
+    sdkLog("info", "screen", "getEventListStart", {
+        devId: runtime.devId,
+        data: { offset: params.offset, limit: params.limit },
+    });
+    const result = await getEventListApi({
+        accessoryDevId: runtime.devId,
+        ...params,
+    });
+    sdkLog("info", "screen", "getEventListSuccess", {
+        devId: runtime.devId,
+        duration: Date.now() - startedAt,
+        data: { count: result?.datas?.length ?? 0, totalCount: result?.totalCount },
+    });
+    return result;
+}

package/lib/feature/screen/list.d.ts

@@ -0,0 +1,13 @@
+import { type ScreenLockDeviceInfo } from "../../api/screen";
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export declare function getBoundLockListForRuntime(runtime: LockDeviceRuntime): Promise<{
+    items: (import("../../api/screen").BoundLockItem & ScreenLockDeviceInfo)[];
+    bindLimit: number;
+    boundCount: number;
+}>;
+export declare function getBindableLockListForRuntime(runtime: LockDeviceRuntime): Promise<{
+    items: (import("../../api/screen").BindableLockItem & ScreenLockDeviceInfo)[];
+    bindLimit: number;
+    boundCount: number;
+    canBindMore: boolean;
+}>;

package/lib/feature/screen/list.js

@@ -0,0 +1,56 @@
+import { getBoundLockListApi, getBindableLockListApi, } from "../../api/screen";
+import { getDeviceInfo } from "../../platform/device";
+import { sdkLog } from "../../utils/sdk-log";
+async function resolveLockDeviceInfo(accessoryDevId, lockDevId) {
+    try {
+        const info = await getDeviceInfo(lockDevId);
+        return {
+            isOnline: info.isOnline,
+            dpSchema: info.schema,
+            dps: info.dps,
+        };
+    }
+    catch (error) {
+        sdkLog("warn", "screen", "resolveLockDeviceInfoFail", {
+            devId: accessoryDevId,
+            data: { lockDevId },
+            error,
+        });
+        return {};
+    }
+}
+async function enrichItemsWithDeviceInfo(accessoryDevId, items) {
+    if (!Array.isArray(items) || items.length === 0) {
+        return [];
+    }
+    return Promise.all(items.map(async (item) => ({
+        ...item,
+        ...(await resolveLockDeviceInfo(accessoryDevId, item.lockDevId)),
+    })));
+}
+export async function getBoundLockListForRuntime(runtime) {
+    const startedAt = Date.now();
+    sdkLog("info", "screen", "getBoundListStart", { devId: runtime.devId });
+    const result = await getBoundLockListApi({ accessoryDevId: runtime.devId });
+    const items = await enrichItemsWithDeviceInfo(runtime.devId, result?.items ?? []);
+    sdkLog("info", "screen", "getBoundListSuccess", {
+        devId: runtime.devId,
+        duration: Date.now() - startedAt,
+        data: { count: items.length, boundCount: result?.boundCount },
+    });
+    return { ...result, items };
+}
+export async function getBindableLockListForRuntime(runtime) {
+    const startedAt = Date.now();
+    sdkLog("info", "screen", "getBindableListStart", { devId: runtime.devId });
+    const result = await getBindableLockListApi({
+        accessoryDevId: runtime.devId,
+    });
+    const items = await enrichItemsWithDeviceInfo(runtime.devId, result?.items ?? []);
+    sdkLog("info", "screen", "getBindableListSuccess", {
+        devId: runtime.devId,
+        duration: Date.now() - startedAt,
+        data: { count: items.length, canBindMore: result?.canBindMore },
+    });
+    return { ...result, items };
+}

package/lib/feature/service/goto-service.d.ts

@@ -0,0 +1,5 @@
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export interface GotoServiceParams {
+    tab?: "cloudStorage" | "AI";
+}
+export declare function gotoServiceForRuntime(rt: LockDeviceRuntime, params?: GotoServiceParams): Promise<unknown>;

package/lib/feature/service/goto-service.js

@@ -0,0 +1,16 @@
+import { navigateToMiniProgram } from "../../platform/device";
+export function gotoServiceForRuntime(rt, params) {
+    let type = 0;
+    if (params?.tab === "AI") {
+        type = 3;
+    }
+    return new Promise((resolve, reject) => {
+        const url = `godzilla://tyawqoyej4wi3pqebb?deviceId=${rt.config.devInfo.devId}&commodityType=${type}`;
+        navigateToMiniProgram({
+            position: "bottom",
+            shortLink: url,
+            success: resolve,
+            fail: reject,
+        });
+    });
+}

package/lib/feature/state/clear.d.ts

@@ -0,0 +1,2 @@
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export declare function clearStateForRuntime(runtime: LockDeviceRuntime): void;

package/lib/feature/state/clear.js

@@ -0,0 +1,17 @@
+import { createDefaultDeviceStatus } from "../../runtime/lock-config";
+export function clearStateForRuntime(runtime) {
+    if (runtime.infra.logRefreshTimer) {
+        clearTimeout(runtime.infra.logRefreshTimer);
+        runtime.infra.logRefreshTimer = 0;
+    }
+    runtime.cache.dpState = {};
+    runtime.cache.currentUser = null;
+    runtime.cache.offlineDpCache = undefined;
+    runtime.cache.deviceAdvanceAbilityCache = undefined;
+    runtime.cache.isActiveThreadCache = false;
+    runtime.sync.hasSyncedT0 = false;
+    runtime.sync.syncDeleteUsersBusy = false;
+    runtime.sync.unlockMethodAutoSyncEnabled = true;
+    runtime.sync.tempAutoSyncEnabled = true;
+    runtime.deviceStatus = createDefaultDeviceStatus();
+}

package/lib/feature/state/device-status-events.d.ts

@@ -0,0 +1,5 @@
+import type { DeviceStatus } from "../../interface";
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export declare function getDeviceStatusChangeEvent(runtime: LockDeviceRuntime): string;
+export declare const onDeviceStatusChangeForRuntime: (runtime: LockDeviceRuntime, callback: (status: DeviceStatus) => void) => void;
+export declare const offDeviceStatusChangeForRuntime: (runtime: LockDeviceRuntime, callback: (status: DeviceStatus) => void) => void;

package/lib/feature/state/device-status-events.js

@@ -0,0 +1,11 @@
+import { DEVICE_STATUS_CHANGE_EVENT } from "../../utils/constant";
+import emitter from "../../utils/event";
+export function getDeviceStatusChangeEvent(runtime) {
+    return `${DEVICE_STATUS_CHANGE_EVENT}_${runtime.devId}`;
+}
+export const onDeviceStatusChangeForRuntime = (runtime, callback) => {
+    emitter.on(getDeviceStatusChangeEvent(runtime), callback);
+};
+export const offDeviceStatusChangeForRuntime = (runtime, callback) => {
+    emitter.off(getDeviceStatusChangeEvent(runtime), callback);
+};

package/lib/feature/state/device-status.d.ts

@@ -0,0 +1,5 @@
+import type { DeviceStatus } from "../../interface";
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export declare const updateOnlineType: (runtime: LockDeviceRuntime) => Promise<void>;
+export declare const getDeviceStatusForRuntime: (runtime: LockDeviceRuntime) => DeviceStatus;
+export declare const updateDeviceStatus: (runtime: LockDeviceRuntime) => void;