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

package/lib/feature/voice-file/voice-file.js

@@ -0,0 +1,203 @@
+import { Base64 } from "js-base64";
+import dpUtils from "@ray-js/tuya-dp-transform";
+import dpCodes from "../../config/dp-code";
+import { getVoiceFileDownloadUrlApi, getVoiceFileListApi, } from "../../api/voice-file";
+import { offBLEBigDataChannelProgressEvent, onBLEBigDataChannelProgressEvent, postBLEFileTransfer, } from "../../platform/device";
+import emitter from "../../utils/event";
+import { bleVoiceData } from "../../config/dp-map/ble-voice-data";
+import { hasDpForRuntime } from "../dp/has-dp";
+import { getError } from "../../utils/errors";
+import { getDeviceStatusForRuntime } from "../state/device-status";
+import { sdkLog } from "../../utils/sdk-log";
+const VOICE_FILE_PROGRESS_EVENT = "voice_file_progress";
+const VOICE_FILE_ALREADY_EXISTS_CODE = "205158";
+const activeTransfers = new Map();
+let bridgeRegistered = false;
+let progressListenerCount = 0;
+function getVoiceFileProgressEvent(runtime) {
+    return `${VOICE_FILE_PROGRESS_EVENT}_${runtime.devId}`;
+}
+function normalizeProgress(progress) {
+    const value = Number(progress);
+    if (!Number.isFinite(value)) {
+        return 0;
+    }
+    return Math.max(0, Math.min(100, Math.trunc(value)));
+}
+const handleNativeProgress = (data) => {
+    const deviceId = data.deviceId;
+    if (!deviceId) {
+        return;
+    }
+    const target = activeTransfers.get(deviceId);
+    emitter.emit(`${VOICE_FILE_PROGRESS_EVENT}_${deviceId}`, {
+        deviceId,
+        fileType: target?.fileType,
+        fileKey: target?.fileKey,
+        version: target?.version,
+        progress: normalizeProgress(data.progress),
+    });
+};
+function ensureProgressBridge() {
+    if (!bridgeRegistered) {
+        onBLEBigDataChannelProgressEvent(handleNativeProgress);
+        bridgeRegistered = true;
+    }
+}
+function cleanupProgressBridge() {
+    if (bridgeRegistered &&
+        progressListenerCount <= 0 &&
+        activeTransfers.size === 0) {
+        offBLEBigDataChannelProgressEvent(handleNativeProgress);
+        bridgeRegistered = false;
+    }
+}
+export function parseVoiceFileStatus(raw) {
+    if (typeof raw !== "string" || raw.length < 14) {
+        return {
+            fileType: 0,
+            version: "0.0.0",
+            status: 0,
+        };
+    }
+    const res = dpUtils.parse(raw, bleVoiceData);
+    return {
+        fileType: res.type,
+        version: `${res.major}.${res.minor}.${res.patch}`,
+        status: res.status,
+    };
+}
+export function voiceFileVersionToNumber(version = "0") {
+    const hex = version.split(".").reduce((acc, part) => {
+        return acc + Number(part).toString(16).padStart(2, "0");
+    }, "");
+    return parseInt(`0x${hex.padStart(8, "0")}`, 16);
+}
+export async function getVoiceFileListForRuntime(runtime) {
+    const startedAt = Date.now();
+    sdkLog("info", "voiceFile", "getListStart", {
+        devId: runtime.devId,
+    });
+    if (!hasDpForRuntime(runtime, dpCodes.voiceData)) {
+        const error = getError(1014);
+        sdkLog("warn", "voiceFile", "getListUnsupported", {
+            devId: runtime.devId,
+            error,
+        });
+        throw error;
+    }
+    const list = await getVoiceFileListApi(runtime.devId);
+    const result = list.map((item) => ({
+        fileType: item.fileType,
+        fileKey: item.fileKey,
+        version: item.version,
+        status: item.fileStatus,
+    }));
+    sdkLog("info", "voiceFile", "getListSuccess", {
+        devId: runtime.devId,
+        duration: Date.now() - startedAt,
+        data: { count: result.length },
+    });
+    return result;
+}
+export function getCurrentVoiceFileForRuntime(runtime) {
+    return parseVoiceFileStatus(runtime.cache.dpState[dpCodes.voiceData]);
+}
+export function onVoiceFileProgressForRuntime(runtime, callback) {
+    progressListenerCount += 1;
+    ensureProgressBridge();
+    emitter.on(getVoiceFileProgressEvent(runtime), callback);
+}
+export function offVoiceFileProgressForRuntime(runtime, callback) {
+    progressListenerCount = Math.max(0, progressListenerCount - 1);
+    emitter.off(getVoiceFileProgressEvent(runtime), callback);
+    cleanupProgressBridge();
+}
+function isVoiceFileAlreadyExistsError(error) {
+    const data = error;
+    const values = [data?.code, data?.errorCode, data?.innerError?.errorCode];
+    return values.some((value) => String(value ?? "").includes(VOICE_FILE_ALREADY_EXISTS_CODE));
+}
+export async function sendVoiceFileForRuntime(runtime, file) {
+    const devId = runtime.devId;
+    const startedAt = Date.now();
+    sdkLog("info", "voiceFile", "sendStart", {
+        devId,
+        data: {
+            fileType: file.fileType,
+            version: file.version,
+            status: file.status,
+        },
+    });
+    if (!hasDpForRuntime(runtime, dpCodes.voiceData)) {
+        const error = getError(1014);
+        sdkLog("warn", "voiceFile", "sendUnsupported", {
+            devId,
+            error,
+        });
+        throw error;
+    }
+    const isOnline = getDeviceStatusForRuntime(runtime).type === "online";
+    if (!isOnline) {
+        const error = getError(1001);
+        sdkLog("warn", "voiceFile", "sendOffline", {
+            devId,
+            error,
+        });
+        throw error;
+    }
+    activeTransfers.set(devId, file);
+    ensureProgressBridge();
+    try {
+        sdkLog("info", "voiceFile", "downloadUrlStart", {
+            devId,
+            data: { fileType: file.fileType },
+        });
+        const res = await getVoiceFileDownloadUrlApi({
+            devId,
+            fileKey: file.fileKey,
+        });
+        const filePath = Base64.decode(res.url);
+        sdkLog("info", "voiceFile", "bleTransferStart", {
+            devId,
+            data: {
+                fileType: file.fileType,
+                versionNumber: voiceFileVersionToNumber(file.version),
+            },
+        });
+        const result = await postBLEFileTransfer({
+            deviceId: devId,
+            fileId: Number(file.fileType),
+            fileIdentifier: file.fileKey,
+            fileVersion: voiceFileVersionToNumber(file.version),
+            filePath,
+        });
+        sdkLog("info", "voiceFile", "sendSuccess", {
+            devId,
+            duration: Date.now() - startedAt,
+            data: { fileType: file.fileType, result: result.result },
+        });
+        return true;
+    }
+    catch (error) {
+        if (isVoiceFileAlreadyExistsError(error)) {
+            sdkLog("info", "voiceFile", "sendAlreadyExists", {
+                devId,
+                duration: Date.now() - startedAt,
+                data: { fileType: file.fileType },
+            });
+            return true;
+        }
+        sdkLog("error", "voiceFile", "sendFail", {
+            devId,
+            duration: Date.now() - startedAt,
+            data: { fileType: file.fileType },
+            error,
+        });
+        throw error;
+    }
+    finally {
+        activeTransfers.delete(devId);
+        cleanupProgressBridge();
+    }
+}

package/lib/feature/voip/voip.d.ts

@@ -0,0 +1,3 @@
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export declare const getVoipAuthForRuntime: (rt: LockDeviceRuntime) => Promise<import("../../api/voip").VoipAuth>;
+export declare const saveVoipAuthForRuntime: (rt: LockDeviceRuntime, userId: string) => Promise<boolean>;

package/lib/feature/voip/voip.js

@@ -0,0 +1,3 @@
+import { getVoipAuthApi, saveVoipAuthApi } from "../../api/voip";
+export const getVoipAuthForRuntime = (rt) => getVoipAuthApi(rt.config.devInfo.devId);
+export const saveVoipAuthForRuntime = (rt, userId) => saveVoipAuthApi(rt.config.devInfo.devId, userId);

package/lib/fit.d.ts

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

package/lib/fit.js

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

package/lib/index.d.ts

@@ -1,23 +1,4 @@
-import { hasCapability, hasDp, updateConfig } from "./config";
-import { LockSDKOption } from "./interface";
-import { getCurrentUser, getDeviceStatus, onDeviceStatusChange, offDeviceStatusChange, getCurrentUserSync, getMediaRotate } from "./state";
-import { syncUnlockMethod } from "./sync/unlock-method";
-import syncDeleteUsers from "./sync/user";
-import { publishDps } from "./utils/publishDps";
-import { publishOfflineDps, getOfflineDps, isOfflineDpSyncing, onOfflineDpsUpdate, offOfflineDpsUpdate, getOfflineDpCache } from "./offline-dps";
-export * from "./user";
-export * from "./unlock-method";
-export * from "./temporary";
-export * from "./open";
-export * from "./log";
-export * from "./signal";
-export * from "./sleep";
+export * from "./entries/main/index";
 export * from "./interface";
 export * from "./constant";
-export * from "./other";
-export * from "./media";
-export * from "./linkage";
-export * from "./capability";
-export declare const init: (options?: LockSDKOption) => Promise<void>;
-export declare const destroy: () => void;
-export { getCurrentUser, getMediaRotate, getCurrentUserSync, syncUnlockMethod, syncDeleteUsers, getDeviceStatus, onDeviceStatusChange, offDeviceStatusChange, updateConfig, hasCapability, hasDp, publishDps, publishOfflineDps, getOfflineDps, isOfflineDpSyncing, onOfflineDpsUpdate, offOfflineDpsUpdate, getOfflineDpCache, };
+export type { SDKLogConfig, SDKLogEntry, SDKLogLevel, SDKLogSink, } from "./utils/sdk-log";

package/lib/index.js

@@ -1,76 +1,3 @@
-import config, { hasCapability, hasDp, updateConfig } from "./config";
-import dpCodes from "./config/dp-code";
-import { addEvents, clearState, initState, removeEvents, getCurrentUser, getDeviceStatus, onDeviceStatusChange, offDeviceStatusChange, getCurrentUserSync, getMediaRotate, } from "./state";
-import { getCapabilities } from "./utils";
-import { getDeviceInfo, getLaunchOptionsSync, trackEvent, } from "./utils/device";
-import { syncUnlockMethod } from "./sync/unlock-method";
-import syncDeleteUsers from "./sync/user";
-import { publishDps } from "./utils/publishDps";
-import { publishOfflineDps, getOfflineDps, isOfflineDpSyncing, onOfflineDpsUpdate, offOfflineDpsUpdate, getOfflineDpCache, } from "./offline-dps";
-export * from "./user";
-export * from "./unlock-method";
-export * from "./temporary";
-export * from "./open";
-export * from "./log";
-export * from "./signal";
-export * from "./sleep";
+export * from "./entries/main/index";
 export * from "./interface";
 export * from "./constant";
-export * from "./other";
-export * from "./media";
-export * from "./linkage";
-export * from "./capability";
-export const init = async (options) => {
-    let { devInfo, deviceId } = options || {};
-    if (!devInfo && !deviceId) {
-        const { query } = getLaunchOptionsSync();
-        deviceId = query.deviceId;
-        if (!deviceId) {
-            throw new Error("deviceId is required in lock sdk");
-        }
-    }
-    if (deviceId && (!devInfo || devInfo.devId !== deviceId)) {
-        devInfo = await getDeviceInfo(deviceId);
-    }
-    let dpSchema = {};
-    const codesById = {};
-    const idsByCode = {};
-    if (devInfo.schema) {
-        dpSchema = devInfo.schema.reduce((acc, cur) => {
-            acc[cur.code] = cur;
-            codesById[cur.id] = cur.code;
-            idsByCode[cur.code] = cur.id;
-            return acc;
-        }, {});
-    }
-    else if (devInfo.dpSchema) {
-        dpSchema = devInfo.dpSchema;
-        Object.keys(dpSchema).forEach((key) => {
-            const item = dpSchema[key];
-            codesById[item.id] = item.code;
-            idsByCode[item.code] = item.id;
-        });
-    }
-    config.strictMode = options?.strictMode ?? true;
-    config.passwordDigitalBase = options?.passwordDigitalBase ?? 10;
-    config.passwordSupportZero = options?.passwordSupportZero ?? true;
-    config.supportMultipleFace = options?.supportMultipleFace ?? false;
-    config.supportOfflineDps = options?.supportOfflineDps ?? false;
-    config.devInfo = devInfo;
-    config.dpSchema = dpSchema;
-    config.codesById = codesById;
-    config.idsByCode = idsByCode;
-    config.supportBigData = !!dpSchema[dpCodes.synchMethodW];
-    config.preFetch = options?.preFetch ?? false;
-    config.communication = getCapabilities(devInfo.capability).map((item) => item.id);
-    addEvents();
-    trackEvent("t$y_UztB3Lj9Qns375R0r7dA0L5Kr2VytH3J".replace("$", ""), {
-        pid: devInfo.productId,
-    });
-    await initState();
-};
-export const destroy = () => {
-    clearState();
-    removeEvents();
-};
-export { getCurrentUser, getMediaRotate, getCurrentUserSync, syncUnlockMethod, syncDeleteUsers, getDeviceStatus, onDeviceStatusChange, offDeviceStatusChange, updateConfig, hasCapability, hasDp, publishDps, publishOfflineDps, getOfflineDps, isOfflineDpSyncing, onOfflineDpsUpdate, offOfflineDpsUpdate, getOfflineDpCache, };

package/lib/interface.d.ts

@@ -1,4 +1,5 @@
 import { CommunicationType, LocalOperateCategory, LocalOperateUserType, ModuleType, RotateType, UserType, VedioStreamType, VedioType, VoiceType } from "./constant";
+import type { SDKLogLevel, SDKLogSink } from "./utils/sdk-log";
 export type ParamType<T> = T extends (param: infer K) => any ? K : never;
 export type DpValue = string | boolean | number;
 export type DpData = Record<string, DpValue>;
@@ -11,6 +12,9 @@ export interface LockSDKOption {
     supportMultipleFace?: boolean;
     supportOfflineDps?: boolean;
     preFetch?: boolean;
+    logLevel?: SDKLogLevel;
+    logger?: SDKLogSink;
+    logToConsole?: boolean;
 }
 export interface ErrorData {
     errorCode: number;
@@ -44,6 +48,7 @@ export interface DeviceInfo {
     dpsTime: Record<string, string>;
     parentId?: string;
     isMatter?: boolean;
+    yuNetState?: number;
 }
 export interface DpSchema {
     type: "raw" | "obj";
@@ -81,6 +86,9 @@ export interface CurrentUser {
     admin: boolean;
     offlineUnlock: boolean;
     permanent: boolean;
+    expireTime?: number;
+    effectiveTime?: number;
+    expireDay?: number;
 }
 export interface UnlockMethodBaseInfo {
     unlockId: number;
@@ -126,6 +134,7 @@ export interface UserInfo {
     userContact: string;
     userType: UserType;
     isAccountUser: boolean;
+    isFamilyUser: boolean;
 }
 type MapItem = {
     readonly name: string;
@@ -171,7 +180,6 @@ export interface EffectiveConfig {
     effectiveTime?: number;
     expiredTime?: number;
 }
-export type RemotePermission = "everyOne" | "adminsOnly" | "noOne";
 export interface UnBindUnlockMethod {
     dpId: number;
     dpCode: string;
@@ -189,7 +197,7 @@ export interface DeviceStatus {
     type: "offline" | "online" | "sleep";
     connectEnable: boolean;
     onlineType: "local" | "cloud" | "ble" | "none" | "unknown";
-    onlineTypes: Array<"local" | "cloud" | "ble" | "localMatter" | "unknown">;
+    onlineTypes: Array<"local" | "cloud" | "ble" | "localMatter" | "yuChannel" | "unknown">;
     sleepPeriod?: {
         start: number;
         end: number;
@@ -247,13 +255,15 @@ export interface MediaInfo {
     mediaBucket: string;
     mediaKey: string;
 }
-export type LogType = "alarm_record" | "close_record" | "unlock_record" | "operation" | "local_operation" | "dev_bind";
+export type LogType = "alarm_record" | "close_record" | "unlock_record" | "operation" | "local_operation";
 export type CloseValue = "UNDEFINED" | "VOICE_REMOTE" | "APP_REMOTE" | "AUTO" | "LOCAL_MANUAL" | "FITTINGS" | "APP" | "GEO_FENCE";
+export type OperationType = "dev_bind" | "member_schedule_update" | "unlock_add" | "unlock_del" | "temp_pwd_create" | "temp_pwd_del" | "temp_pwd_meta_update" | "temp_pwd_name_update" | "offline_pwd_achieve" | "offline_pwd_clear_achieve" | "offline_pwd_clear_single_achieve" | "offline_pwd_name_update" | "arming_switch" | "unlock_switch" | "automatic_lock" | "auto_lock_time" | "verify_lock_switch" | "do_not_disturb" | "special_control" | "special_function" | "beep_volume" | "remote_unlock_setting" | "remote_voice_pwd_setting";
 export interface LogData {
     logId: string;
     time: number;
     currentUser: boolean;
     type: LogType;
+    operationType?: OperationType;
     userId: string;
     dpId: number;
     dpCode: string;
@@ -272,6 +282,28 @@ export interface LogData {
         source: number;
         type: number;
     };
+    tempPwdInfo?: {
+        name: string;
+        originName?: string;
+        effectiveConfig?: EffectiveConfig;
+    };
+    clearInfo?: {
+        name: string;
+        originName?: string;
+        effectiveConfig?: EffectiveConfig;
+        targetName?: string;
+    };
+    unlockInfo?: {
+        userName: string;
+        userId: string;
+        unlockName: string;
+        type: UnlockMethodType;
+    };
+    userEffectiveInfo?: {
+        userName: string;
+        permanent: boolean;
+        effectiveConfig?: EffectiveConfig;
+    };
 }
 export type TemporaryPasswordType = "custom" | "once" | "limit" | "clear" | "clearOne";
 export interface TempPasswordResult {
@@ -302,10 +334,20 @@ export interface AlbumMessage extends MediaInfo {
     type: number;
     createTime: number;
 }
+export type VRModeType = "original" | "VR" | "horizontal" | "vertical";
 export interface DeviceAdvancedAbility {
     cloudStorage: {
         support: boolean;
     };
+    vr: {
+        support: boolean;
+        coverMode: VRModeType;
+        modes: Array<{
+            mode: VRModeType;
+            value: number;
+        }>;
+        defaultMode: VRModeType;
+    };
     ai: {
         support: boolean;
         config: Record<string, any>;
@@ -316,7 +358,9 @@ export interface DeviceAdvancedAbility {
     };
     wechatVoip: {
         support: boolean;
-        config: Record<string, any>;
+        isPublice: boolean;
+        appId?: string;
+        modeId?: string;
     };
     voip: {
         support: boolean;
@@ -326,6 +370,10 @@ export interface DeviceAdvancedAbility {
         support: boolean;
         config: Record<string, any>;
     };
+    yuChannel: {
+        support: boolean;
+        value: 1 | 2;
+    };
 }
 export interface OfflineDpInfo {
     value: DpValue;
@@ -339,4 +387,26 @@ export interface UnlockGuide {
     picUrl: string;
     expireTime: number;
 }
+export interface SharedUserInfo {
+    id: string;
+    name: string;
+    effectiveType: "once" | "permanent" | "limit";
+    effectiveConfig: EffectiveConfig;
+    account: string;
+    countryCode: string;
+    offlineUnlock: boolean;
+    lockUserId: number;
+    userExist: boolean;
+}
+export interface AIReportPopup {
+    reportId: string;
+    yearMonth: number;
+}
+export interface CameraConfig {
+    isVR: boolean;
+    width: number;
+    height: number;
+    rotate: number;
+    localtion: number;
+}
 export {};

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

@@ -23,7 +23,7 @@ export declare const onOnlineChange: (func: ParamType<typeof ty.device.onDeviceO
 export declare const offOnlineChange: (func: ParamType<typeof ty.device.offDeviceOnlineStatusUpdate>) => void;
 export declare const onBleChange: (func: ParamType<typeof ty.device.onBLEConnectStatusChange>) => void;
 export declare const offBleChange: (func: ParamType<typeof ty.device.offBLEConnectStatusChange>) => void;
-export declare const getSystemInfo: () => {
+export declare const getSystemInfoSync: () => {
     is24Hour: boolean;
     system: string;
     brand: string;
@@ -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 {};