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

package/lib/{utils → platform}/device.d.ts

@@ -172,10 +172,58 @@ export declare const navigateTo: (params: ParamType<typeof ty.navigateTo>) => vo
 export declare const checkShowMatterMutilpleShare: (deviceId: string) => Promise<unknown>;
 export declare const getBLEOnlineState: (deviceId: string) => Promise<boolean>;
 export declare const connectBLEDevice: (deviceId: string) => Promise<void>;
+export interface BLEFileTransferParams {
+    deviceId: string;
+    fileId: number;
+    fileIdentifier: string;
+    fileVersion: number;
+    filePath: string;
+}
+export interface BLEFileTransferResult {
+    result: boolean;
+}
+export declare const postBLEFileTransfer: (params: BLEFileTransferParams) => Promise<BLEFileTransferResult>;
+export interface BLEBigDataChannelProgressEvent {
+    deviceId: string;
+    progress: number;
+}
+export type BLEBigDataChannelProgressHandler = (data: BLEBigDataChannelProgressEvent) => void;
+export declare const onBLEBigDataChannelProgressEvent: (cb: BLEBigDataChannelProgressHandler) => void;
+export declare const offBLEBigDataChannelProgressEvent: (cb: BLEBigDataChannelProgressHandler) => void;
+export interface BLETransparentDataReport {
+    deviceId?: string;
+    data?: string;
+}
+export declare const getEncryptLocalKeyWithData: (params: {
+    deviceId: string;
+    keyDeviceId: string;
+}) => Promise<string>;
+export declare const subscribeBLETransparentDataReport: (deviceId: string) => any;
 export declare const publishBLETransparentData: (deviceId: string, data: string) => Promise<void>;
+export type BLETransparentDataReportHandler = (data: BLETransparentDataReport) => void;
+export declare const onBLETransparentDataReport: (cb: BLETransparentDataReportHandler) => void;
+export declare const offBLETransparentDataReport: (cb: BLETransparentDataReportHandler) => void;
 export declare const onAppShow: (cb: () => void) => void;
 export declare const offAppShow: (cb: () => void) => void;
 export declare const onAppHide: (cb: () => void) => void;
 export declare const offAppHide: (cb: () => void) => void;
 export declare const trackEvent: (event: string, data: Record<string, any>) => void;
+export declare const yuChannelSyncSingleSync: (deviceId: string) => null;
+export declare const isYuDeviceOnlineSync: (deviceId: string) => boolean;
+export declare const yuChannelSaveState: (deviceId: string, state: boolean) => Promise<void>;
+export declare const yuChannelQueryNodes: (deviceId: string) => Promise<string[]>;
+export type HomeMemberListener = (data: {
+    memberId: string;
+}) => void;
+export declare const onResetMemberName: (cb: HomeMemberListener) => void;
+export declare const offResetMemberName: (cb: HomeMemberListener) => void;
+export declare const onResetMemberRole: (cb: HomeMemberListener) => void;
+export declare const offResetMemberRole: (cb: HomeMemberListener) => void;
+export declare const getLogManager: () => ty.GetLogManagerTask;
+export declare const getAppUserInfo: () => Promise<{
+    nickName: string;
+    avatarUrl: string;
+    phoneCode: string;
+    isTemporaryUser: boolean;
+}>;
 export {};

package/lib/{utils → platform}/device.js

@@ -1,3 +1,4 @@
+import { sdkLog } from "../utils/sdk-log";
 export const getDeviceInfo = (devId) => {
     return new Promise((resolve, reject) => {
         ty.device.getDeviceInfo({
@@ -196,7 +197,7 @@ export const isSupportShortLink = async (link) => {
                 }
             },
             fail: (err) => {
-                console.warn("isSupportShortLink fail", err);
+                sdkLog("warn", "platform", "isSupportShortLinkFail", { error: err });
                 resolve("");
             },
         });
@@ -364,9 +365,63 @@ export const connectBLEDevice = (deviceId) => {
         });
     });
 };
+export const postBLEFileTransfer = (params) => {
+    return new Promise((resolve, reject) => {
+        const device = ty.device;
+        const fn = device.postBLEFileTransfer;
+        if (typeof fn !== "function") {
+            reject(new Error("BLE file transfer is not supported"));
+            return;
+        }
+        fn.call(device, {
+            ...params,
+            success: (res) => {
+                resolve(res ?? { result: true });
+            },
+            fail: reject,
+        });
+    });
+};
+export const onBLEBigDataChannelProgressEvent = (cb) => {
+    const device = ty.device;
+    const fn = device.onBLEBigDataChannelProgressEvent;
+    if (typeof fn === "function") {
+        fn.call(device, cb);
+    }
+};
+export const offBLEBigDataChannelProgressEvent = (cb) => {
+    const device = ty.device;
+    const fn = device.offBLEBigDataChannelProgressEvent;
+    if (typeof fn === "function") {
+        fn.call(device, cb);
+    }
+};
+export const getEncryptLocalKeyWithData = (params) => {
+    return new Promise((resolve, reject) => {
+        ty.device.getEncryptLocalKeyWithData({
+            ...params,
+            success: resolve,
+            fail: reject,
+        });
+    });
+};
+export const subscribeBLETransparentDataReport = (deviceId) => {
+    const device = ty.device;
+    const fn = device.subscribeBLETransparentDataReport ||
+        device.subscribeBleTransparentDataReport;
+    if (typeof fn === "function") {
+        return fn.call(device, { deviceId });
+    }
+};
 export const publishBLETransparentData = (deviceId, data) => {
     return new Promise((resolve, reject) => {
-        ty.device.publishBLETransparentData({
+        const device = ty.device;
+        const fn = device.publishBLETransparentData || device.publishBleTransparentData;
+        if (typeof fn !== "function") {
+            reject(new Error("BLE transparent publish is not supported"));
+            return;
+        }
+        fn.call(device, {
             deviceId,
             data,
             success: () => resolve(),
@@ -374,6 +429,20 @@ export const publishBLETransparentData = (deviceId, data) => {
         });
     });
 };
+export const onBLETransparentDataReport = (cb) => {
+    const device = ty.device;
+    const fn = device.onBLETransparentDataReport || device.onBleTransparentDataReport;
+    if (typeof fn === "function") {
+        fn.call(device, cb);
+    }
+};
+export const offBLETransparentDataReport = (cb) => {
+    const device = ty.device;
+    const fn = device.offBLETransparentDataReport || device.offBleTransparentDataReport;
+    if (typeof fn === "function") {
+        fn.call(device, cb);
+    }
+};
 export const onAppShow = (cb) => {
     ty.onAppShow(cb);
 };
@@ -392,3 +461,85 @@ export const trackEvent = (event, data) => {
         event: data,
     });
 };
+export const yuChannelSyncSingleSync = (deviceId) => {
+    return ty.device.yuChannelSyncSingleSync({
+        deviceId,
+    });
+};
+export const isYuDeviceOnlineSync = (deviceId) => {
+    return ty.device.isYuDeviceOnlineSync({
+        deviceId,
+    });
+};
+export const yuChannelSaveState = (deviceId, state) => {
+    return new Promise((resolve, reject) => {
+        ty.device.yuChannelSaveState({
+            deviceId,
+            state: Number(state),
+            success: () => resolve(),
+            fail: reject,
+        });
+    });
+};
+export const yuChannelQueryNodes = (deviceId) => {
+    return new Promise((resolve, reject) => {
+        ty.device.yuChannelQueryNodes({
+            deviceId,
+            success: (res) => resolve(res.result),
+            fail: reject,
+        });
+    });
+};
+export const onResetMemberName = (cb) => {
+    if (ty.home.onResetMemberNameHandler) {
+        ty.home.onResetMemberNameHandler(cb);
+    }
+    else {
+        sdkLog("warn", "platform", "homeKitUnsupported", {
+            data: { method: "onResetMemberName" },
+        });
+    }
+};
+export const offResetMemberName = (cb) => {
+    if (ty.home.offResetMemberNameHandler) {
+        ty.home.offResetMemberNameHandler(cb);
+    }
+    else {
+        sdkLog("warn", "platform", "homeKitUnsupported", {
+            data: { method: "offResetMemberName" },
+        });
+    }
+};
+export const onResetMemberRole = (cb) => {
+    if (ty.home.onResetMemberRoleHandler) {
+        ty.home.onResetMemberRoleHandler(cb);
+    }
+    else {
+        sdkLog("warn", "platform", "homeKitUnsupported", {
+            data: { method: "onResetMemberRole" },
+        });
+    }
+};
+export const offResetMemberRole = (cb) => {
+    if (ty.home.offResetMemberRoleHandler) {
+        ty.home.offResetMemberRoleHandler(cb);
+    }
+    else {
+        sdkLog("warn", "platform", "homeKitUnsupported", {
+            data: { method: "offResetMemberRole" },
+        });
+    }
+};
+export const getLogManager = () => {
+    return ty.getLogManager({
+        tag: "lock-sdk",
+    });
+};
+export const getAppUserInfo = () => {
+    return new Promise((resolve, reject) => {
+        ty.getUserInfo({
+            success: resolve,
+            fail: reject,
+        });
+    });
+};

package/lib/platform/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./device";
+export { default as ipc } from "./ipc";

package/lib/platform/index.js

@@ -0,0 +1,2 @@
+export * from "./device";
+export { default as ipc } from "./ipc";

package/lib/{utils → platform}/ipc.d.ts

@@ -7,5 +7,8 @@ declare const _default: {
         isConnecting: boolean;
     }>;
     connect: (deviceId: string) => Promise<unknown>;
+    getCurrentSupportedTalkMode: (deviceId: string) => Promise<{
+        talkbackMode: number;
+    }>;
 };
 export default _default;

package/lib/{utils → platform}/ipc.js

@@ -18,9 +18,20 @@ const connect = (deviceId) => {
         ty.ipc.connect({ deviceId, success: resolve, fail: reject });
     });
 };
+const getCurrentSupportedTalkMode = (deviceId) => {
+    return new Promise((resolve, reject) => {
+        ty.ipc.getCurrentSupportedTalkMode({
+            deviceId,
+            extendParam: {},
+            success: resolve,
+            fail: reject,
+        });
+    });
+};
 export default {
     wakeUpDoorBell,
     isConnected,
     isConnecting,
     connect,
+    getCurrentSupportedTalkMode,
 };

package/lib/platform/transport/index.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/platform/transport/index.js

@@ -0,0 +1 @@
+export {};

package/lib/runtime/LockDeviceRuntime.d.ts

@@ -0,0 +1,12 @@
+import type { DeviceStatus } from "../interface";
+import { type LockConfigState } from "./lock-config";
+import type { LockRuntimeCacheFields, LockRuntimeInfraFields, LockRuntimeSyncFlags } from "./runtime-state-types";
+export declare class LockDeviceRuntime {
+    readonly config: LockConfigState;
+    deviceStatus: DeviceStatus;
+    readonly cache: LockRuntimeCacheFields;
+    readonly sync: LockRuntimeSyncFlags;
+    readonly infra: LockRuntimeInfraFields;
+    constructor();
+    get devId(): string;
+}

package/lib/runtime/LockDeviceRuntime.js

@@ -0,0 +1,34 @@
+import { createDefaultDeviceStatus, createLockConfigState, } from "./lock-config";
+export class LockDeviceRuntime {
+    config;
+    deviceStatus;
+    cache;
+    sync;
+    infra;
+    constructor() {
+        this.config = createLockConfigState();
+        this.deviceStatus = createDefaultDeviceStatus();
+        this.cache = {
+            dpState: {},
+            currentUser: null,
+            offlineDpCache: undefined,
+            isActiveThreadCache: false,
+            deviceAdvanceAbilityCache: undefined,
+        };
+        this.sync = {
+            hasSyncedT0: false,
+            syncDeleteUsersBusy: false,
+            unlockMethodAutoSyncEnabled: true,
+            tempAutoSyncEnabled: true,
+            tempPayloadSyncing: false,
+        };
+        this.infra = {
+            eventsRegistered: false,
+            logRefreshTimer: 0,
+            tempSyncNotifyTimer: 0,
+        };
+    }
+    get devId() {
+        return this.config.devInfo.devId;
+    }
+}

package/lib/runtime/device-status/compute-device-status.d.ts

@@ -0,0 +1,25 @@
+import { ProductCommunicationType } from "../../constant";
+import type { DeviceStatus } from "../../interface";
+export type ComputeDeviceStatusConfigSlice = {
+    onlineType: number;
+    devInfo: {
+        isCloudOnline: boolean;
+        isOnline: boolean;
+        wifiEnableState?: number;
+        isMatter?: boolean;
+    };
+};
+export type ComputeDeviceStatusDeps = {
+    hasCapability: (t: ProductCommunicationType) => boolean;
+    hasDp: (code: string) => boolean;
+    getDpValue: (code: string) => unknown;
+    isSupportBleControl: () => boolean;
+    isShareThread: () => boolean;
+    readIsSleep: () => boolean;
+    registeredRuntimeCount: number;
+    getDormantPeriod: () => {
+        start: number;
+        end: number;
+    };
+};
+export declare function computeDeviceStatus(config: ComputeDeviceStatusConfigSlice, deps: ComputeDeviceStatusDeps): DeviceStatus;

package/lib/runtime/device-status/compute-device-status.js

@@ -0,0 +1,94 @@
+import dpCodes from "../../config/dp-code";
+import { ProductCommunicationType } from "../../constant";
+import { isOnlineByType } from "../../utils";
+export function computeDeviceStatus(config, deps) {
+    const { onlineType, devInfo: { isCloudOnline, isOnline, wifiEnableState, isMatter }, } = config;
+    const supportWifi = deps.hasCapability(ProductCommunicationType.WIFI);
+    const supportBle = deps.hasCapability(ProductCommunicationType.BLUETOOTH);
+    const supportThread = deps.hasCapability(ProductCommunicationType.THREAD);
+    const status = {
+        type: isOnline ? "online" : "offline",
+        connectEnable: false,
+        onlineType: "unknown",
+        onlineTypes: [],
+        isWifiActive: wifiEnableState !== 1,
+        isWifiMatter: !!isMatter && supportWifi,
+    };
+    const isMatterLocal = isOnlineByType(onlineType, 8);
+    const isBleOnline = isOnlineByType(onlineType, 2);
+    const isLocalOnline = !isCloudOnline && isOnlineByType(onlineType, 1);
+    const hasWirelessAwakeDp = deps.hasDp(dpCodes.wirelessAwake);
+    const wirelessAwake = deps.getDpValue(dpCodes.wirelessAwake);
+    status.connectEnable = deps.isSupportBleControl() && !isOnline;
+    if (supportWifi) {
+        if (!status.connectEnable) {
+            if (isCloudOnline) {
+                status.connectEnable =
+                    hasWirelessAwakeDp && wirelessAwake === false && !isBleOnline;
+            }
+        }
+    }
+    if (isOnline) {
+        if (isCloudOnline) {
+            if (hasWirelessAwakeDp) {
+                if (wirelessAwake) {
+                    status.onlineTypes.push("cloud");
+                }
+                else {
+                    status.type = "offline";
+                }
+            }
+            else {
+                status.onlineTypes.push("cloud");
+            }
+        }
+        if (isLocalOnline) {
+            status.onlineTypes.push("local");
+        }
+        if (isMatterLocal) {
+            if (!status.onlineTypes.includes("local")) {
+                status.onlineTypes.push("local");
+            }
+        }
+        if (isBleOnline) {
+            status.onlineTypes.push("ble");
+        }
+    }
+    if (status.onlineTypes.length === 0 && isOnline) {
+        status.onlineTypes.push("unknown");
+    }
+    if (supportThread && supportBle) {
+        const isShareThread = deps.isShareThread();
+        if (isShareThread && isOnline) {
+            if (!status.onlineTypes.includes("local")) {
+                status.onlineTypes = ["local"];
+            }
+        }
+    }
+    if (status.onlineTypes.includes("ble")) {
+        status.onlineType = "ble";
+    }
+    else if (status.onlineTypes.includes("cloud")) {
+        status.onlineType = "cloud";
+    }
+    else if (status.onlineTypes.includes("local")) {
+        status.onlineType = "local";
+    }
+    else {
+        status.onlineType = "unknown";
+    }
+    if (!isOnline) {
+        if (deps.readIsSleep()) {
+            status.type = "sleep";
+        }
+    }
+    if (status.type === "sleep") {
+        if (deps.getDpValue(dpCodes.dormantSwitch) ||
+            deps.getDpValue(dpCodes.onlineSwitch)) {
+            if (deps.registeredRuntimeCount === 1) {
+                status.sleepPeriod = deps.getDormantPeriod();
+            }
+        }
+    }
+    return status;
+}

package/lib/runtime/index.d.ts

@@ -0,0 +1,5 @@
+export type { LockConfigState } from "./lock-config";
+export { createDefaultDeviceStatus, createLockConfigState, } from "./lock-config";
+export { LockDeviceRuntime } from "./LockDeviceRuntime";
+export type { LockRuntimeCacheFields, LockRuntimeInfraFields, LockRuntimeSyncFlags, } from "./runtime-state-types";
+export { registerRuntime, unregisterRuntime, getRuntimeByDevId, getRegisteredRuntimeCount, clearAllRuntimes, listRegisteredRuntimes, } from "./registry";

package/lib/runtime/index.js

@@ -0,0 +1,3 @@
+export { createDefaultDeviceStatus, createLockConfigState, } from "./lock-config";
+export { LockDeviceRuntime } from "./LockDeviceRuntime";
+export { registerRuntime, unregisterRuntime, getRuntimeByDevId, getRegisteredRuntimeCount, clearAllRuntimes, listRegisteredRuntimes, } from "./registry";

package/lib/runtime/lock-config.d.ts

@@ -0,0 +1,28 @@
+import { ProductCommunicationType, RemotePermissionType } from "../constant";
+import { CapabilityInfo, DeviceInfo, DeviceStatus, DpSchema } from "../interface";
+export type LockConfigState = {
+    devInfo: DeviceInfo;
+    dpSchema: Record<string, DpSchema>;
+    codesById: Record<string, string>;
+    idsByCode: Record<string, number>;
+    remoteOpenEnabled: boolean;
+    remoteOpenPermission: RemotePermissionType;
+    capabilities: CapabilityInfo | null;
+    onlineType: number;
+    communication: ProductCommunicationType[];
+    supportBigData: boolean;
+    passwordDigitalBase: number;
+    passwordSupportZero: boolean;
+    strictMode: boolean;
+    imageAngle: number;
+    videoAngle: number;
+    mediaWidth: number;
+    mediaHeight: number;
+    supportMultipleFace: boolean;
+    supportOfflineDps: boolean;
+    preFetch: boolean;
+    supportTalk: boolean;
+    isTwoWayTalk: boolean;
+};
+export declare function createDefaultDeviceStatus(): DeviceStatus;
+export declare function createLockConfigState(): LockConfigState;

package/lib/runtime/lock-config.js

@@ -0,0 +1,37 @@
+import { RemotePermissionType } from "../constant";
+export function createDefaultDeviceStatus() {
+    return {
+        type: "offline",
+        connectEnable: false,
+        onlineType: "none",
+        onlineTypes: [],
+        isWifiActive: false,
+        isWifiMatter: false,
+    };
+}
+export function createLockConfigState() {
+    return {
+        devInfo: {},
+        dpSchema: {},
+        codesById: {},
+        idsByCode: {},
+        remoteOpenEnabled: false,
+        remoteOpenPermission: RemotePermissionType.EVERY_ONE,
+        capabilities: null,
+        onlineType: 0,
+        communication: [0],
+        supportBigData: false,
+        passwordDigitalBase: 10,
+        passwordSupportZero: true,
+        strictMode: true,
+        imageAngle: 0,
+        videoAngle: 0,
+        mediaWidth: 0,
+        mediaHeight: 0,
+        supportMultipleFace: false,
+        supportOfflineDps: false,
+        preFetch: false,
+        supportTalk: false,
+        isTwoWayTalk: false,
+    };
+}

package/lib/runtime/registry.d.ts

@@ -0,0 +1,7 @@
+import { LockDeviceRuntime } from "./LockDeviceRuntime";
+export declare function registerRuntime(runtime: LockDeviceRuntime): void;
+export declare function unregisterRuntime(devId: string): void;
+export declare function getRuntimeByDevId(devId: string): LockDeviceRuntime | undefined;
+export declare function getRegisteredRuntimeCount(): number;
+export declare function clearAllRuntimes(): void;
+export declare function listRegisteredRuntimes(): LockDeviceRuntime[];

package/lib/runtime/registry.js

@@ -0,0 +1,28 @@
+import { getError } from "../utils/errors";
+const byDevId = new Map();
+export function registerRuntime(runtime) {
+    const id = runtime.devId;
+    if (byDevId.has(id)) {
+        throw getError(1070, id);
+    }
+    byDevId.set(id, runtime);
+}
+export function unregisterRuntime(devId) {
+    const rt = byDevId.get(devId);
+    if (!rt) {
+        return;
+    }
+    byDevId.delete(devId);
+}
+export function getRuntimeByDevId(devId) {
+    return byDevId.get(devId);
+}
+export function getRegisteredRuntimeCount() {
+    return byDevId.size;
+}
+export function clearAllRuntimes() {
+    byDevId.clear();
+}
+export function listRegisteredRuntimes() {
+    return [...byDevId.values()];
+}

package/lib/runtime/runtime-state-types.d.ts

@@ -0,0 +1,20 @@
+import type { CurrentUser, DeviceAdvancedAbility, DpData, OfflineDps } from "../interface";
+export interface LockRuntimeCacheFields {
+    dpState: DpData;
+    currentUser: CurrentUser | null;
+    offlineDpCache: OfflineDps | undefined;
+    isActiveThreadCache: boolean;
+    deviceAdvanceAbilityCache: DeviceAdvancedAbility | undefined;
+}
+export interface LockRuntimeSyncFlags {
+    hasSyncedT0: boolean;
+    syncDeleteUsersBusy: boolean;
+    unlockMethodAutoSyncEnabled: boolean;
+    tempAutoSyncEnabled: boolean;
+    tempPayloadSyncing: boolean;
+}
+export interface LockRuntimeInfraFields {
+    eventsRegistered: boolean;
+    logRefreshTimer: ReturnType<typeof setTimeout> | number;
+    tempSyncNotifyTimer: ReturnType<typeof setTimeout> | number;
+}

package/lib/runtime/runtime-state-types.js

@@ -0,0 +1 @@
+export {};

package/lib/screen.d.ts

@@ -0,0 +1,4 @@
+export * from "./entries/screen/index";
+export * from "./interface";
+export * from "./constant";
+export type { SDKLogConfig, SDKLogEntry, SDKLogLevel, SDKLogSink, } from "./utils/sdk-log";

package/lib/screen.js

@@ -0,0 +1,3 @@
+export * from "./entries/screen/index";
+export * from "./interface";
+export * from "./constant";

package/lib/utils/constant.d.ts

@@ -3,6 +3,9 @@ export { THING };
 export declare const DPCHANGE = "dpChange";
 export declare const LOGCHANGE = "logChange";
 export declare const UNLOCK_METHOD_EVENT = "UMEvent";
+export declare const FIT_UNLOCK_METHOD_EVENT = "FitUMEvent";
+export declare const SLEEP_EVENT = "sleep_event";
+export declare const DEVICE_STATUS_CHANGE_EVENT = "device_status_change";
 export declare enum LoopTypes {
     NONE = 0,
     DAY = 1,

package/lib/utils/constant.js

@@ -4,6 +4,9 @@ export { THING };
 export const DPCHANGE = "dpChange";
 export const LOGCHANGE = "logChange";
 export const UNLOCK_METHOD_EVENT = "UMEvent";
+export const FIT_UNLOCK_METHOD_EVENT = "FitUMEvent";
+export const SLEEP_EVENT = "sleep_event";
+export const DEVICE_STATUS_CHANGE_EVENT = "device_status_change";
 export var LoopTypes;
 (function (LoopTypes) {
     LoopTypes[LoopTypes["NONE"] = 0] = "NONE";