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

package/lib/feature/fit/temp-password.d.ts

@@ -0,0 +1,27 @@
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+import { EffectiveConfig } from "../../interface";
+export interface AddFitTempPwdParams {
+    lockDevId: string;
+    type: "once" | "limit";
+    password: string;
+    name?: string;
+    effective: EffectiveConfig;
+}
+export interface RemoveFitTempPwdParams {
+    id: number;
+}
+export interface UpdateFitTempPwdParams {
+    id: number;
+    name: string;
+    effective: EffectiveConfig;
+}
+export declare function fitAddTempPwdForRuntime(runtime: LockDeviceRuntime, params: AddFitTempPwdParams): Promise<{
+    pwdId: number;
+}>;
+export declare function fitRemoveTempPwdForRuntime(runtime: LockDeviceRuntime, params: RemoveFitTempPwdParams): Promise<void>;
+export declare function fitUpdateTempPwdForRuntime(runtime: LockDeviceRuntime, params: UpdateFitTempPwdParams): Promise<void>;
+export interface RenameFitTempPwdParams {
+    id: number;
+    name: string;
+}
+export declare const fitRenameTempPwdForRuntime: (runtime: LockDeviceRuntime, params: RenameFitTempPwdParams) => Promise<void>;

package/lib/feature/fit/temp-password.js

@@ -0,0 +1,428 @@
+import dpUtils from "@ray-js/tuya-dp-transform";
+import dpCodes from "../../config/dp-code";
+import { fitAddTempPwd, fitReportAddTempPwd, fitRemoveTempPwd, fitReportRemoveTempPwd, fitUpdateTempPwd, fitReportUpdateTempPwd, fitBlePswCreate, fitBlePswDelete, fitBlePswCreateReport, fitBlePswDeleteReport, fitBlePswUpdate, fitBlePswUpdateReport, } from "../../config/dp-map/temp-pwd-fit";
+import { publishDpsForRuntime } from "../dp/publish-dps";
+import { resolveSlaveId } from "./resolve-slave-id";
+import { getError } from "../../utils/errors";
+import { sdkLog } from "../../utils/sdk-log";
+import { addFitOnlineTempPwd, addFitOnlineTempPwdCloud, getFitPasswordList, removeFitOnlineTempPwd, renameFitOnlineTempPwd, updateFitOnlineTempPwd, } from "../../api/fit";
+import { decrypt, encrypt } from "../../platform";
+import { formatPasswordToList, formatWeek, getAppUser, parseWeek, sleep, transformEffectiveConfigToValidConfig, validateEffectiveConfig, } from "../../utils";
+import { hasDpForRuntime } from "../dp/has-dp";
+export async function fitAddTempPwdForRuntime(runtime, params) {
+    const startedAt = Date.now();
+    sdkLog("info", "fitTempPassword", "addStart", {
+        devId: runtime.devId,
+        data: {
+            type: params.type,
+            hasLockDevId: typeof params.lockDevId === "string",
+            credentialProvided: typeof params.password === "string" && params.password.length > 0,
+        },
+    });
+    if (params.name && params.name.length > 20) {
+        throw getError(1031);
+    }
+    validateEffectiveConfig(params.effective);
+    if (!hasDpForRuntime(runtime, dpCodes.tempPwdCreate) &&
+        !hasDpForRuntime(runtime, dpCodes.bleKeyCreate)) {
+        throw getError(1045);
+    }
+    const passwordEncrypted = await encrypt(runtime.config.devInfo.devId, params.password);
+    const slaveId = await resolveSlaveId(runtime, params.lockDevId);
+    const countryCode = getAppUser()?.phoneCode || "86";
+    const schedule = [
+        {
+            allDay: params.effective.repeat !== "week",
+            effectiveTime: params.effective?.effectiveTime ?? 0,
+            invalidTime: params.effective?.expiredTime ?? 0,
+            workingDay: formatWeek(params.effective?.weeks ?? [0, 0, 0, 0, 0, 0, 0]),
+        },
+    ];
+    const validConfig = transformEffectiveConfigToValidConfig(params.effective);
+    const pwdList = formatPasswordToList(params.password);
+    if (hasDpForRuntime(runtime, dpCodes.tempPwdCreate)) {
+        const payload = dpUtils.format({
+            slaveId,
+            type: params.type === "once" ? 1 : 0,
+            validConfig,
+            validNum: params.type === "once" ? 1 : 0,
+            pwdLength: params.password.length ?? 0,
+            pwd: pwdList,
+        }, fitAddTempPwd);
+        const res = await publishDpsForRuntime(runtime, { [dpCodes.tempPwdCreate]: payload }, {
+            checkReport: (dps) => checkFitTempPwdReport(dps, dpCodes.tempPwdCreate, fitReportAddTempPwd),
+        });
+        try {
+            if (res.status === 0x00) {
+                const result = await addFitOnlineTempPwd({
+                    fittingId: runtime.devId,
+                    devIdList: [params.lockDevId],
+                    password: passwordEncrypted,
+                    effectiveTime: params.effective.effectiveDate,
+                    invalidTime: params.effective.expiredDate,
+                    sn: res.unlockId,
+                    schedule,
+                    countryCode,
+                    availTime: params.type === "once" ? 0x01 : 0x00,
+                    name: params.name,
+                });
+                sdkLog("info", "fitTempPassword", "addSuccess", {
+                    devId: runtime.devId,
+                    duration: Date.now() - startedAt,
+                    data: { type: params.type },
+                });
+                return result;
+            }
+            else {
+                switch (res.status) {
+                    case 0x02:
+                        throw getError(1041);
+                }
+                throw getError(1042);
+            }
+        }
+        catch (error) {
+            sdkLog("error", "fitTempPassword", "addFail", {
+                devId: runtime.devId,
+                duration: Date.now() - startedAt,
+                data: { type: params.type },
+                error,
+            });
+            throw error;
+        }
+    }
+    else {
+        try {
+            const result = await addFitOnlineTempPwdCloud({
+                fittingId: runtime.devId,
+                devIdList: [params.lockDevId],
+                password: passwordEncrypted,
+                effectiveTime: params.effective.effectiveDate,
+                invalidTime: params.effective.expiredDate,
+                sn: -1,
+                schedule,
+                countryCode,
+                availTime: params.type === "once" ? 0x01 : 0x00,
+                name: params.name,
+            });
+            const payload = dpUtils.format({
+                slaveId,
+                msgId: result.msgId,
+                type: params.type === "once" ? 0x00 : 0x01,
+                validConfig,
+                validNum: params.type === "once" ? 0x01 : 0x00,
+                pwdLength: params.password.length ?? 0,
+                pwd: pwdList,
+            }, fitBlePswCreate);
+            const res = await publishDpsForRuntime(runtime, { [dpCodes.blePswCreate]: payload }, {
+                checkReport: (dps) => {
+                    if (dps[dpCodes.blePswCreate]) {
+                        return {
+                            status: parseInt(dps[dpCodes.blePswCreate].slice(-2), 16),
+                        };
+                    }
+                    return false;
+                },
+            });
+            if (res.status === 0x00) {
+                sdkLog("info", "fitTempPassword", "addSuccess", {
+                    devId: runtime.devId,
+                    duration: Date.now() - startedAt,
+                    data: { type: params.type, strategy: "cloud_first" },
+                });
+                return {
+                    pwdId: result.msgId,
+                };
+            }
+            else {
+                switch (res.status) {
+                    case 0x02:
+                        throw getError(1041);
+                }
+                throw getError(1042);
+            }
+        }
+        catch (error) {
+            sdkLog("error", "fitTempPassword", "addFail", {
+                devId: runtime.devId,
+                duration: Date.now() - startedAt,
+                data: { type: params.type, strategy: "cloud_first" },
+                error,
+            });
+            throw error;
+        }
+    }
+}
+export async function fitRemoveTempPwdForRuntime(runtime, params) {
+    const startedAt = Date.now();
+    sdkLog("info", "fitTempPassword", "removeStart", {
+        devId: runtime.devId,
+        data: { id: params.id },
+    });
+    const supportDeleteDp = hasDpForRuntime(runtime, dpCodes.tempPwdDel);
+    const supportBleDeleteDp = hasDpForRuntime(runtime, dpCodes.blePswDelete);
+    try {
+        if (!supportDeleteDp && !supportBleDeleteDp) {
+            throw getError(1045);
+        }
+        const list = await getFitPasswordList(runtime.devId);
+        const exist = list.find((item) => item.unlockBindingId === params.id);
+        if (!exist) {
+            throw getError(1040);
+        }
+        if (supportDeleteDp) {
+            const payload = dpUtils.format({ slaveId: parseInt(exist.devUnlockId, 16), unlockId: exist.sn }, fitRemoveTempPwd);
+            const res = await publishDpsForRuntime(runtime, { [dpCodes.tempPwdDel]: payload }, {
+                checkReport: (dps) => checkFitTempPwdReport(dps, dpCodes.tempPwdDel, fitReportRemoveTempPwd),
+            });
+            sdkLog("info", "fitTempPassword", "removeReport", {
+                devId: runtime.devId,
+                data: { id: params.id, status: res.status, strategy: "device_first" },
+            });
+            if (res.status === 0x00 || res.status === 0x02) {
+                await removeFitOnlineTempPwd(runtime.devId, exist.pwdId);
+            }
+            else {
+                throw getError(1028);
+            }
+        }
+        else {
+            let { sn } = exist;
+            if (sn < 1) {
+                const { effectiveTime = 0, workingDay = 0, allDay, invalidTime = 0, } = exist.scheduleDetails?.[0] ?? {};
+                const repeat = allDay ? "none" : "week";
+                const password = await decrypt(runtime.config.devInfo.devId, exist.passWord ?? "");
+                const payload = dpUtils.format({
+                    slaveId: parseInt(exist.devUnlockId, 16),
+                    msgId: exist.msgId,
+                    type: exist.opModeSubType === 0 ? 1 : 0,
+                    validConfig: transformEffectiveConfigToValidConfig({
+                        effectiveDate: exist.effectiveTime,
+                        expiredDate: exist.invalidTime,
+                        repeat: repeat,
+                        weeks: parseWeek(workingDay),
+                        effectiveTime,
+                        expiredTime: invalidTime,
+                    }),
+                    validNum: exist.opModeSubType === 0 ? 0 : 1,
+                    pwdLength: password.length,
+                    pwd: formatPasswordToList(password),
+                }, fitBlePswCreate);
+                const res = await publishDpsForRuntime(runtime, { [dpCodes.blePswCreate]: payload }, {
+                    checkReport: (dps) => checkFitTempPwdReport(dps, dpCodes.blePswCreate, fitBlePswCreateReport),
+                });
+                sdkLog("info", "fitTempPassword", "removeSyncReport", {
+                    devId: runtime.devId,
+                    data: { id: params.id, status: res.status },
+                });
+                if (res.status === 0) {
+                    sn = res.unlockId;
+                }
+                else {
+                    await sleep(100);
+                    sdkLog("info", "fitTempPassword", "removeSuccess", {
+                        devId: runtime.devId,
+                        duration: Date.now() - startedAt,
+                        data: { id: params.id, strategy: "cloud_first_sync_skipped" },
+                    });
+                    return;
+                }
+            }
+            const payload = dpUtils.format({
+                slaveId: parseInt(exist.devUnlockId, 16),
+                msgId: exist.msgId,
+                type: exist.opModeSubType === 0 ? 1 : 0,
+                unlockId: sn,
+            }, fitBlePswDelete);
+            const res = await publishDpsForRuntime(runtime, {
+                [dpCodes.blePswDelete]: payload,
+            }, {
+                checkReport: (dps) => checkFitTempPwdReport(dps, dpCodes.blePswDelete, fitBlePswDeleteReport),
+            });
+            sdkLog("info", "fitTempPassword", "removeReport", {
+                devId: runtime.devId,
+                data: { id: params.id, status: res.status, strategy: "cloud_first" },
+            });
+            if (res.status === 0x00 || res.status === 0x03) {
+                await sleep(100);
+                sdkLog("info", "fitTempPassword", "removeSuccess", {
+                    devId: runtime.devId,
+                    duration: Date.now() - startedAt,
+                    data: { id: params.id, strategy: "cloud_first" },
+                });
+                return;
+            }
+            else {
+                switch (res.status) {
+                    case 0x02:
+                        throw getError(1091);
+                }
+                throw getError(1028);
+            }
+        }
+        sdkLog("info", "fitTempPassword", "removeSuccess", {
+            devId: runtime.devId,
+            duration: Date.now() - startedAt,
+            data: { id: params.id, strategy: "device_first" },
+        });
+    }
+    catch (error) {
+        sdkLog("error", "fitTempPassword", "removeFail", {
+            devId: runtime.devId,
+            duration: Date.now() - startedAt,
+            data: { id: params.id },
+            error,
+        });
+        throw error;
+    }
+}
+export async function fitUpdateTempPwdForRuntime(runtime, params) {
+    const startedAt = Date.now();
+    sdkLog("info", "fitTempPassword", "updateStart", {
+        devId: runtime.devId,
+        data: { id: params.id, hasName: typeof params.name === "string" },
+    });
+    const supportUpdateDp = hasDpForRuntime(runtime, dpCodes.tempPwdEdit);
+    const supportBleUpdateDp = hasDpForRuntime(runtime, dpCodes.blePswUpdate);
+    try {
+        if (!supportUpdateDp && !supportBleUpdateDp) {
+            throw getError(1045);
+        }
+        const list = await getFitPasswordList(runtime.devId);
+        const exist = list.find((item) => item.unlockBindingId === params.id);
+        if (!exist) {
+            throw getError(1040);
+        }
+        if (!params.name || !params.name.trim()) {
+            throw getError(1054);
+        }
+        if (params.name.trim().length > 20) {
+            throw getError(1031);
+        }
+        validateEffectiveConfig(params.effective);
+        const schedule = [
+            {
+                allDay: params.effective.repeat !== "week",
+                effectiveTime: params.effective?.effectiveTime ?? 0,
+                invalidTime: params.effective?.expiredTime ?? 0,
+                workingDay: formatWeek(params.effective?.weeks ?? [0, 0, 0, 0, 0, 0, 0]),
+            },
+        ];
+        if (supportUpdateDp) {
+            const payload = dpUtils.format({
+                slaveId: parseInt(exist.devUnlockId, 16),
+                unlockId: exist.sn,
+                type: exist.opModeSubType === 0 ? 1 : 0,
+                validConfig: transformEffectiveConfigToValidConfig(params.effective),
+                validNum: exist.opModeSubType === 0 ? 0 : 1,
+                pwdLength: 0,
+                pwd: [],
+            }, fitUpdateTempPwd);
+            const res = await publishDpsForRuntime(runtime, { [dpCodes.tempPwdEdit]: payload }, {
+                checkReport: (dps) => checkFitTempPwdReport(dps, dpCodes.tempPwdEdit, fitReportUpdateTempPwd),
+            });
+            sdkLog("info", "fitTempPassword", "updateReport", {
+                devId: runtime.devId,
+                data: { id: params.id, status: res.status, strategy: "device_first" },
+            });
+            if (res.status === 0x00) {
+                await updateFitOnlineTempPwd(runtime.devId, {
+                    pwdId: exist.unlockBindingId,
+                    name: params.name,
+                    effectiveTime: params.effective.effectiveDate,
+                    invalidTime: params.effective.expiredDate,
+                    sn: exist.sn,
+                    schedule,
+                });
+            }
+            else {
+                throw getError(1028);
+            }
+        }
+        else {
+            await updateFitOnlineTempPwd(runtime.devId, {
+                pwdId: exist.unlockBindingId,
+                name: params.name,
+                effectiveTime: params.effective.effectiveDate,
+                invalidTime: params.effective.expiredDate,
+                availTime: exist.opModeSubType === 0 ? 0 : 1,
+                sn: exist.sn,
+                schedule,
+            });
+            const payload = dpUtils.format({
+                slaveId: parseInt(exist.devUnlockId, 16),
+                msgId: exist.msgId,
+                type: exist.opModeSubType === 0 ? 1 : 0,
+                unlockId: exist.sn,
+                validConfig: transformEffectiveConfigToValidConfig(params.effective),
+                validNum: exist.opModeSubType === 0 ? 0 : 1,
+                pwdLength: 0,
+                pwd: [],
+            }, fitBlePswUpdate);
+            const res = await publishDpsForRuntime(runtime, { [dpCodes.blePswUpdate]: payload }, {
+                checkReport: (dps) => checkFitTempPwdReport(dps, dpCodes.blePswUpdate, fitBlePswUpdateReport),
+            });
+            sdkLog("info", "fitTempPassword", "updateReport", {
+                devId: runtime.devId,
+                data: { id: params.id, status: res.status, strategy: "cloud_first" },
+            });
+            if (res.status !== 0x00) {
+                switch (res.status) {
+                    case 0x02:
+                        throw getError(1091);
+                    case 0x03:
+                        throw getError(1092);
+                }
+                throw getError(1082);
+            }
+        }
+        sdkLog("info", "fitTempPassword", "updateSuccess", {
+            devId: runtime.devId,
+            duration: Date.now() - startedAt,
+            data: {
+                id: params.id,
+                strategy: supportUpdateDp ? "device_first" : "cloud_first",
+            },
+        });
+    }
+    catch (error) {
+        sdkLog("error", "fitTempPassword", "updateFail", {
+            devId: runtime.devId,
+            duration: Date.now() - startedAt,
+            data: { id: params.id },
+            error,
+        });
+        throw error;
+    }
+}
+function checkFitTempPwdReport(dps, dpCode, reportMap) {
+    const raw = dps[dpCode];
+    if (typeof raw !== "string") {
+        return false;
+    }
+    return dpUtils.parse(raw, reportMap);
+}
+export const fitRenameTempPwdForRuntime = async (runtime, params) => {
+    const startedAt = Date.now();
+    sdkLog("info", "fitTempPassword", "renameStart", {
+        devId: runtime.devId,
+        data: { id: params.id, hasName: typeof params.name === "string" },
+    });
+    try {
+        await renameFitOnlineTempPwd(runtime.devId, params.id, params.name);
+        sdkLog("info", "fitTempPassword", "renameSuccess", {
+            devId: runtime.devId,
+            duration: Date.now() - startedAt,
+            data: { id: params.id },
+        });
+    }
+    catch (error) {
+        sdkLog("error", "fitTempPassword", "renameFail", {
+            devId: runtime.devId,
+            duration: Date.now() - startedAt,
+            data: { id: params.id },
+            error,
+        });
+        throw error;
+    }
+};

package/lib/feature/fit/users.d.ts

@@ -0,0 +1,12 @@
+import type { UserType } from "../../constant";
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export interface FitUserItem {
+    userId: string;
+    lockUserId: number;
+    avatarUrl: string;
+    nickName: string;
+    userType: UserType;
+    userContact: string;
+    phase: number;
+}
+export declare function getFitUsersForRuntime(runtime: LockDeviceRuntime): Promise<FitUserItem[]>;

package/lib/feature/fit/users.js

@@ -0,0 +1,25 @@
+import { getFitUserListApi } from "../../api/fit";
+import { sdkLog } from "../../utils/sdk-log";
+const pickFitUserItem = (raw) => ({
+    userId: raw.userId,
+    lockUserId: raw.lockUserId,
+    avatarUrl: raw.avatarUrl,
+    nickName: raw.nickName,
+    userType: raw.userType,
+    userContact: raw.userContact,
+    phase: raw.phase,
+});
+export async function getFitUsersForRuntime(runtime) {
+    const startedAt = Date.now();
+    sdkLog("info", "fit", "getUsersStart", {
+        devId: runtime.devId,
+    });
+    const list = await getFitUserListApi(runtime.devId);
+    const result = Array.isArray(list) ? list.map(pickFitUserItem) : [];
+    sdkLog("info", "fit", "getUsersSuccess", {
+        devId: runtime.devId,
+        duration: Date.now() - startedAt,
+        data: { count: result.length },
+    });
+    return result;
+}

package/lib/feature/linkage/linkage.d.ts

@@ -0,0 +1,10 @@
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export interface RemainingInfo {
+    message: number;
+    phone: number;
+}
+export declare const getRemainingInfo: () => Promise<RemainingInfo>;
+export declare function getDoorbellServiceForRuntime(rt: LockDeviceRuntime): Promise<import("../../api/linkage").LinkageRule | undefined>;
+export declare function enableDoorbellServiceForRuntime(rt: LockDeviceRuntime): Promise<void>;
+export declare function disableDoorbellServiceForRuntime(rt: LockDeviceRuntime): Promise<void>;
+export declare function toSetDoorbellServiceForRuntime(rt: LockDeviceRuntime): Promise<void>;

package/lib/{linkage.js → feature/linkage/linkage.js}

@@ -1,8 +1,7 @@
-import { disableLinkage, enableLinkage, getLinkageList, getRemainingMessage, getRemainingPhone, saveLinkage, } from "./api/linkage";
-import config from "./config";
-import { getHomeInfo } from "./utils";
-import { createAction, editAction } from "./utils/device";
-import { getError } from "./utils/errors";
+import { disableLinkage, enableLinkage, getLinkageList, getRemainingMessage, getRemainingPhone, saveLinkage, } from "../../api/linkage";
+import { getHomeInfo } from "../../utils";
+import { createAction, editAction } from "../../platform/device";
+import { getError } from "../../utils/errors";
 const DOORBELL_RING_TYPE = "doorbell_ring";
 const TARGET_KEY = "appPushTrigger";
 const ACTION_TYPE = "kafkaSend";
@@ -19,22 +18,16 @@ export const getRemainingInfo = async () => {
         phone,
     };
 };
-export const getDoorbellService = async () => {
+export async function getDoorbellServiceForRuntime(rt) {
     const homeInfo = await getHomeInfo();
-    const list = await getLinkageList(config.devInfo.devId, homeInfo.homeId);
+    const list = await getLinkageList(rt.config.devInfo.devId, homeInfo.homeId);
     return list.find((item) => item.code === DOORBELL_RING_TYPE && item.ruleId);
-};
-const createDoorbellService = async () => {
-    const actions = await createAction({
-        createType: "remind",
-        smartType: "auto",
-    });
-    await saveDoorbellService(actions);
-};
-const saveDoorbellService = async (actions) => {
+}
+const saveDoorbellServiceForRuntime = async (rt, actions) => {
     const homeInfo = await getHomeInfo();
+    const devId = rt.config.devInfo.devId;
     saveLinkage({
-        devId: config.devInfo.devId,
+        devId,
         ownerId: homeInfo.homeId,
         name: "doorbell",
         enabled: true,
@@ -55,7 +48,7 @@ const saveDoorbellService = async (actions) => {
                 conditions: [
                     {
                         entityType: 23,
-                        entityId: config.devInfo.devId,
+                        entityId: devId,
                         entitySubIds: "",
                         iconUrl: "",
                         expr: [],
@@ -99,27 +92,34 @@ const saveDoorbellService = async (actions) => {
         ],
     }, homeInfo.homeId);
 };
-export const enableDoorbellService = async () => {
+const createDoorbellServiceForRuntime = async (rt) => {
+    const actions = await createAction({
+        createType: "remind",
+        smartType: "auto",
+    });
+    await saveDoorbellServiceForRuntime(rt, actions);
+};
+export async function enableDoorbellServiceForRuntime(rt) {
     const homeInfo = await getHomeInfo();
-    const service = await getDoorbellService();
+    const service = await getDoorbellServiceForRuntime(rt);
     if (service && service.ruleId) {
         await enableLinkage(service.ruleId, homeInfo.homeId);
     }
     else {
-        await createDoorbellService();
+        await createDoorbellServiceForRuntime(rt);
     }
-};
-export const disableDoorbellService = async () => {
+}
+export async function disableDoorbellServiceForRuntime(rt) {
     const homeInfo = await getHomeInfo();
-    const service = await getDoorbellService();
+    const service = await getDoorbellServiceForRuntime(rt);
     if (service && service.ruleId) {
         await disableLinkage(service.ruleId, homeInfo.homeId);
         return;
     }
     throw getError(1059);
-};
-export const toSetDoorbellService = async () => {
-    const service = await getDoorbellService();
+}
+export async function toSetDoorbellServiceForRuntime(rt) {
+    const service = await getDoorbellServiceForRuntime(rt);
     if (service && service.ruleId && service.ruleVO) {
         const findIndex = service.ruleVO.actions.findIndex((item) => item.actionExecutor === TARGET_KEY ||
             item.actionExecutor === ACTION_TYPE);
@@ -135,9 +135,9 @@ export const toSetDoorbellService = async () => {
                 return item;
             }),
         });
-        await saveDoorbellService(actions);
+        await saveDoorbellServiceForRuntime(rt, actions);
     }
     else {
-        await createDoorbellService();
+        await createDoorbellServiceForRuntime(rt);
     }
-};
+}

package/lib/feature/log/log.d.ts

@@ -0,0 +1,63 @@
+import { LockLogCategory } from "../../api/log";
+import { AlbumMessage, LogData, UnlockMethodType } from "../../interface";
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export type LogsRefreshListener = () => void;
+export declare function getLogsRefreshEvent(runtime: LockDeviceRuntime): string;
+export declare const unlockDp2Type: Record<string, UnlockMethodType>;
+export interface GetLatestLogsResult {
+    data: LogData[];
+    unreadCount: number;
+}
+export declare function getLatestLogsForRuntime(rt: LockDeviceRuntime): Promise<GetLatestLogsResult>;
+export declare const onLogsRefreshForRuntime: (rt: LockDeviceRuntime, cb: LogsRefreshListener) => void;
+export declare const offLogsRefreshForRuntime: (rt: LockDeviceRuntime, cb: LogsRefreshListener) => void;
+export interface GetLogsParams {
+    page?: number;
+    pageSize?: number;
+}
+export declare const openDps: ("unlock_matter_kw" | "unlock_password" | "unlock_fingerprint" | "unlock_finger_vein" | "unlock_hand" | "unlock_dynamic" | "unlock_key" | "unlock_card" | "unlock_face" | "unlock_temporary" | "unlock_offline_pd" | "unlock_phone_remote" | "unlock_voice_remote" | "lock_record" | "unlock_ble" | "unlock_eye" | "unlock_double_kit" | "unlock_double_kit_w" | "open_inside" | "lock_local_record" | "unlock_inside" | "door_opened" | "unlock_app")[];
+export interface GetLogsResult {
+    list: LogData[];
+    hasMore: boolean;
+    total: number;
+}
+export declare function getLogsForRuntime(rt: LockDeviceRuntime, params?: GetLogsParams): Promise<GetLogsResult>;
+export interface GetAlarmsParams {
+    page?: number;
+    pageSize?: number;
+}
+export interface GetAlarmsResult {
+    list: LogData[];
+    hasMore: boolean;
+    total: number;
+}
+export declare function getAlarmsForRuntime(rt: LockDeviceRuntime, params?: GetAlarmsParams): Promise<GetAlarmsResult>;
+export interface GetAlbumsParams {
+    page?: number;
+    pageSize?: number;
+    startTime?: number;
+    endTime?: number;
+}
+export interface GetAlbumsResult {
+    hasMore: boolean;
+    list: AlbumMessage[];
+    allAitypes: number[];
+    types: number[];
+    langMap: string[];
+}
+export declare function getAlbumsForRuntime(rt: LockDeviceRuntime, params?: GetAlbumsParams): Promise<GetAlbumsResult>;
+export interface GetLockLogListParams {
+    logCategories?: LockLogCategory[];
+    userIds?: string;
+    onlyShowMediaRecord?: boolean;
+    startTime?: number;
+    endTime?: number;
+    lastRowKey?: string;
+    limit: number;
+}
+export interface GetLockLogListResult {
+    list: LogData[];
+    hasNext: boolean;
+    lastRowKey: string;
+}
+export declare const getLockLogListForRuntime: (rt: LockDeviceRuntime, params: GetLockLogListParams) => Promise<GetLockLogListResult>;