@ray-js/lock-sdk 1.2.1-beta.0 → 1.2.1-beta.10

package/lib/api/gesture.d.ts

@@ -4,8 +4,10 @@ export interface GestureStatus {
     [k: string]: any;
 }
 export declare const getGestureStatusApi: (devId: string) => Promise<GestureStatus>;
-export declare const setGestureStatusApi: (params: {
-    devId: string;
+export interface UpdateGestureStatusParams {
     password: string;
     open: boolean;
+}
+export declare const setGestureStatusApi: (params: UpdateGestureStatusParams & {
+    devId: string;
 }) => Promise<boolean>;

package/lib/api/video.d.ts

@@ -37,4 +37,20 @@ export interface getAlbumDateListResult {
     dateList: string[];
 }
 export declare const getAlbumDateList: (devId: string) => Promise<getAlbumDateListResult>;
+interface GetDeviceCurrentMeidaConfigResult {
+    audioAttributes: {
+        callMode: Array<1 | 2>;
+        hardwareCapability: Array<1 | 2>;
+    };
+    maxZoomInTimes: number;
+    skill: string;
+    vedioClarity: number;
+    vedioClaritys: number[];
+}
+export declare const getDeviceCurrentMeidaConfig: (devId: string) => Promise<GetDeviceCurrentMeidaConfigResult>;
+interface GetVideoResolutionMarkResult {
+    capability: number[];
+    cloudCapability: string[];
+}
+export declare const getVideoResolutionMark: (devId: string) => Promise<GetVideoResolutionMarkResult>;
 export {};

package/lib/api/video.js

@@ -60,3 +60,23 @@ export const getAlbumDateList = (devId) => {
         },
     });
 };
+export const getDeviceCurrentMeidaConfig = (devId) => {
+    return requestApi({
+        logName: "getDeviceCurrentMeidaConfig",
+        api: "m.ipc.device.ability.get",
+        version: "1.0",
+        data: {
+            devId,
+        },
+    });
+};
+export const getVideoResolutionMark = (devId) => {
+    return requestApi({
+        logName: "getVideoResolutionMark",
+        api: `${THING}.m.device.lock.capability.cloud.get`,
+        version: "1.0",
+        data: {
+            devId,
+        },
+    });
+};

package/lib/entries/main/exports/capability.d.ts

@@ -1,8 +1,6 @@
 import type { ProductCommunicationType } from "../../../constant";
 export declare function hasCapability(capability: ProductCommunicationType): boolean;
 export declare function isBlePureDevice(): boolean;
-export declare function isShareThead(): boolean;
-export declare function isActiveThread(): Promise<boolean>;
 export declare function getDeviceAdvancedAbilities(): Promise<import("../../..").DeviceAdvancedAbility>;
 export declare function getDeviceAdvancedAbilitiesSync(): import("../../..").DeviceAdvancedAbility | undefined;
 export declare function getDeviceCapabilities(): import("../../..").CapabilityInfo | null;

package/lib/entries/main/exports/capability.js

@@ -1,17 +1,11 @@
 import { resolveRuntimeFromExportThis } from "../bootstrap/resolve-runtime-from-export-this";
-import { hasCapabilityForRuntime, isBlePureDeviceForRuntime, isShareTheadForRuntime, isActiveThreadForRuntime, getDeviceAdvancedAbilitiesForRuntime, getDeviceAdvancedAbilitiesSyncForRuntime, getDeviceCapabilitiesForRuntime, } from "../../../feature/misc/capability";
+import { hasCapabilityForRuntime, isBlePureDeviceForRuntime, getDeviceAdvancedAbilitiesForRuntime, getDeviceAdvancedAbilitiesSyncForRuntime, getDeviceCapabilitiesForRuntime, } from "../../../feature/misc/capability";
 export function hasCapability(capability) {
     return hasCapabilityForRuntime(resolveRuntimeFromExportThis(this), capability);
 }
 export function isBlePureDevice() {
     return isBlePureDeviceForRuntime(resolveRuntimeFromExportThis(this));
 }
-export function isShareThead() {
-    return isShareTheadForRuntime(resolveRuntimeFromExportThis(this));
-}
-export async function isActiveThread() {
-    return isActiveThreadForRuntime(resolveRuntimeFromExportThis(this));
-}
 export async function getDeviceAdvancedAbilities() {
     return getDeviceAdvancedAbilitiesForRuntime(resolveRuntimeFromExportThis(this));
 }

package/lib/entries/main/exports/fit-sdk/device.d.ts

@@ -24,4 +24,3 @@ interface RemoveFitBleKeyParams {
 export declare function removeFitBleKey(params: RemoveFitBleKeyParams): Promise<unknown>;
 export declare function renameFitBleKey(params: RenameFitBleKeyParams): Promise<unknown>;
 export declare function getFitUsers(): Promise<FitUserItem[]>;
-export declare function setFitSetting(dpCode: string, value: string | number | boolean): Promise<void>;

package/lib/entries/main/exports/fit-sdk/device.js

@@ -6,7 +6,6 @@ import { offFitAddUnlockMethodForRuntime, onFitAddUnlockMethodForRuntime, } from
 import { getFitUnlockMethodListForRuntime } from "../../../../feature/fit/method/list";
 import { syncOpenModeRiseForRuntime } from "../../../../feature/fit/sync";
 import { getFitBleKeyListForRuntime, addFitBleKeyForRuntime, createFitPermanentBleKeyForRuntime, createFitTemporaryBleKeyForRuntime, updateFitTemporaryBleKeyForRuntime, removeFitBleKeyForRuntime, renameFitBleKeyForRuntime, } from "../../../../feature/fit/ble-key";
-import { setFitSettingForRuntime } from "../../../../feature/fit/setting";
 import { getFitUsersForRuntime, } from "../../../../feature/fit/users";
 export function fitAddPassword(params) {
     return fitAddPasswordForRuntime(resolveRuntimeFromExportThis(this), params);
@@ -59,6 +58,3 @@ export function renameFitBleKey(params) {
 export function getFitUsers() {
     return getFitUsersForRuntime(resolveRuntimeFromExportThis(this));
 }
-export function setFitSetting(dpCode, value) {
-    return setFitSettingForRuntime(resolveRuntimeFromExportThis(this), dpCode, value);
-}

package/lib/entries/main/exports/fit-sdk/temp.d.ts

@@ -1,25 +1,13 @@
 import { type FitOnlinePasswordItem, type FitOfflinePasswordItem } from "../../../../feature/fit/password-list";
 import { type AddFitTempPwdParams, type RemoveFitTempPwdParams, type RenameFitTempPwdParams, type RenameFitOfflineTempPwdParams, type RevokeFitOfflineTempPwdParams, type FitOfflineClearCodeResult, type ResendFitTempPwdParams, type UpdateFitTempPwdParams } from "../../../../feature/fit/temp-password";
 import { type ClearFitInvalidPwdParams, type GetFitInvalidPwdListParams } from "../../../../feature/fit/invalid-password";
-import { type FitOfflineOnceResult } from "../../../../feature/password/temporary/offline-create";
+import { type FitOfflineOnceResult, type FitOfflineLimitParams } from "../../../../feature/password/temporary/offline-create";
 import type { LimitOfflinePwdItem, OfflinePwdAvailableResult } from "../../../../api/temp";
 import type { TempPasswordResult } from "../../../../interface";
-export declare function getFitPasswordList(): Promise<{
-    id: number;
-    unlockId: string;
-    unlockName: string;
-    photoUnlock: boolean;
-    userName: string;
-    lockUserId: number;
-    userType: number;
-    devLockId: string;
-    effective: import("../../../../interface").EffectiveConfig;
-}[]>;
+export declare function getFitPasswordList(): Promise<import("../../../../feature/fit/password-list").FitPasswordItem[]>;
 export declare function getFitOnlinePasswordList(): Promise<FitOnlinePasswordItem[]>;
 export declare function getFitOfflinePasswordList(): Promise<FitOfflinePasswordItem[]>;
-export declare function addFitTempPwd(params: AddFitTempPwdParams): Promise<{
-    pwdId: number;
-}>;
+export declare function addFitTempPwd(params: AddFitTempPwdParams): Promise<import("../../../../feature/fit/temp-password").AddFitTempPwdResult>;
 export declare function removeFitTempPwd(params: RemoveFitTempPwdParams): Promise<void>;
 export declare function updateFitTempPwd(params: UpdateFitTempPwdParams): Promise<void>;
 export declare function renameFitTempPwd(params: RenameFitTempPwdParams): Promise<void>;
@@ -30,10 +18,7 @@ export declare function getFitInvalidPwdList(params?: GetFitInvalidPwdListParams
 export declare function clearFitInvalidPwd(params?: ClearFitInvalidPwdParams): Promise<boolean>;
 export declare function getFitDynamicPassword(): Promise<TempPasswordResult>;
 export declare function getFitOfflineOncePassword(): Promise<FitOfflineOnceResult>;
-export declare function getFitOfflineLimitPassword(params: {
-    effectiveTime: number;
-    invalidTime: number;
-}): Promise<FitOfflineOnceResult>;
+export declare function getFitOfflineLimitPassword(params: FitOfflineLimitParams): Promise<FitOfflineOnceResult>;
 export declare function getFitOfflineClearAllCode(): Promise<FitOfflineOnceResult>;
 export declare function getFitOfflineRevocableList(): Promise<LimitOfflinePwdItem[]>;
 export declare function getFitOfflinePwdAvailable(pwdType: string): Promise<OfflinePwdAvailableResult>;

package/lib/entries/main/exports/gesture.d.ts

@@ -1,6 +1,4 @@
-export type { GestureStatus } from "../../../api/gesture";
+import type { UpdateGestureStatusParams } from "../../../api/gesture";
+export type { GestureStatus, UpdateGestureStatusParams, } from "../../../api/gesture";
 export declare function getGestureStatus(): Promise<import("../../../api/gesture").GestureStatus>;
-export declare function updateGestureStatus(params: {
-    password: string;
-    open: boolean;
-}): Promise<boolean>;
+export declare function updateGestureStatus(params: UpdateGestureStatusParams): Promise<boolean>;

package/lib/entries/main/exports/media.d.ts

@@ -7,7 +7,7 @@ export declare function openLocalAlbum(params?: OpenLocalAlbumParams): Promise<v
 export declare function gotoPlayback(params?: GotoPlaybackParams): Promise<void>;
 export declare function isSupportMultiCamera(): boolean;
 export declare function getCameraInfo(): import("../../../feature/media/camera").CameraDpInfo | undefined;
-export declare function queryCameraInfo(): Promise<import("../../../feature/media/camera").CameraInfo | undefined>;
+export declare function queryCameraInfo(): Promise<import("../../../feature/media/camera").CameraDpInfo | undefined>;
 export declare function switchCamera(index: number): Promise<true>;
 export declare function getMediaViewTimes(): Promise<import("../../../api/video").MediaViewTimesResult>;
 export declare function addMediaViewTimes(): Promise<import("../../../api/video").MediaViewTimesResult>;

package/lib/entries/main/exports/misc.d.ts

@@ -1,5 +1,5 @@
 import { GotoServiceParams } from "../../../feature/service/goto-service";
-import type { OpenSceneOptions } from "../../../feature/misc/types";
+import type { OpenSceneOptions, ConnectDeviceOptions } from "../../../feature/misc/types";
 export { parseDpPeriodTime } from "../../../feature/misc/dp-period";
 export { formatDpPeriodTime } from "../../../feature/misc/dp-period";
 export declare function openScene(options?: OpenSceneOptions): Promise<void>;
@@ -13,8 +13,14 @@ export interface UpdateDpPeriodTimeOption {
     offlineDp?: boolean;
 }
 export declare function updateDpPeriodTime(dpCode: string, data: UpdateDpPeriodTimeParams, option?: UpdateDpPeriodTimeOption): Promise<void>;
-export declare function connectDevice(options?: {
-    timeout?: number;
-}): Promise<true>;
+export declare function connectDevice(options?: ConnectDeviceOptions): Promise<true>;
 export declare function gotoService(params?: GotoServiceParams): Promise<void>;
 export declare function validatePwdComplexity(password: string): Promise<boolean>;
+export interface AwakeDeviceOptions {
+    timeout?: number;
+}
+export declare function awakeDevice(options?: AwakeDeviceOptions): Promise<true>;
+interface DisconnectDeviceOptions {
+    disconnetBle?: boolean;
+}
+export declare function disconnectDevice(options?: DisconnectDeviceOptions): Promise<void>;

package/lib/entries/main/exports/misc.js

@@ -2,7 +2,7 @@ import { resolveRuntimeFromExportThis } from "../bootstrap/resolve-runtime-from-
 import { openSceneForRuntime } from "../../../feature/misc/open-scene";
 import { isSupportBleControlForRuntime } from "../../../feature/misc/ble-control";
 import { getDpPeriodTimeForRuntime, updateDpPeriodTimeForRuntime, } from "../../../feature/misc/dp-period";
-import { connectDeviceForRuntime } from "../../../feature/misc/connect-device";
+import { awakeDeviceForRuntime, connectDeviceForRuntime, disconnectDeviceForRuntime, } from "../../../feature/misc/connect-device";
 import { validatePwdComplexityForRuntime } from "../../../feature/misc/validate-pwd";
 import { gotoServiceForRuntime, } from "../../../feature/service/goto-service";
 export { parseDpPeriodTime } from "../../../feature/misc/dp-period";
@@ -28,3 +28,9 @@ export async function gotoService(params) {
 export async function validatePwdComplexity(password) {
     return validatePwdComplexityForRuntime(resolveRuntimeFromExportThis(this), password);
 }
+export async function awakeDevice(options) {
+    return awakeDeviceForRuntime(resolveRuntimeFromExportThis(this), options);
+}
+export async function disconnectDevice(options) {
+    return disconnectDeviceForRuntime(resolveRuntimeFromExportThis(this), options);
+}

package/lib/entries/main/exports/notify.d.ts

@@ -1,7 +1,4 @@
+import type { UpdateVasNotifyConfigParams } from "../../../api/notify";
 export type { VasNotifyConfig, VasNotifyScene, VasNotifyPushConfig, UpdateVasNotifyConfigParams, } from "../../../api/notify";
 export declare function getVasNotifyConfig(): Promise<import("../../../api/notify").VasNotifyConfig>;
-export declare function updateVasNotifyConfig(params: {
-    key: string;
-    enable: boolean;
-    userId?: string;
-}): Promise<import("../../../api/notify").VasNotifyConfig>;
+export declare function updateVasNotifyConfig(params: UpdateVasNotifyConfigParams): Promise<import("../../../api/notify").VasNotifyConfig>;

package/lib/entries/main/exports/offline-dps.d.ts

@@ -4,5 +4,4 @@ export declare function offOfflineDpsUpdate(callback: (dps: OfflineDps) => void)
 export declare function publishOfflineDps(dps: Record<string, DpValue>): Promise<void>;
 export declare function getOfflineDps(isForce?: boolean): Promise<OfflineDps>;
 export declare function getOfflineDpCache(code: string): import("../../../interface").OfflineDpInfo | undefined;
-export declare function checkOfflineDpUpdate(dps: Record<string, DpValue>, isForce?: boolean): Promise<void>;
 export declare function isOfflineDpSyncing(code: string): boolean;

package/lib/entries/main/exports/offline-dps.js

@@ -1,5 +1,5 @@
 import { resolveRuntimeFromExportThis } from "../bootstrap/resolve-runtime-from-export-this";
-import { checkOfflineDpUpdateForRuntime, publishOfflineDpsForRuntime, getOfflineDpsForRuntime, getOfflineDpCacheForRuntime, onOfflineDpsUpdateForRuntime, offOfflineDpsUpdateForRuntime, } from "../../../feature/offline-dps";
+import { publishOfflineDpsForRuntime, getOfflineDpsForRuntime, getOfflineDpCacheForRuntime, onOfflineDpsUpdateForRuntime, offOfflineDpsUpdateForRuntime, } from "../../../feature/offline-dps";
 export function onOfflineDpsUpdate(callback) {
     onOfflineDpsUpdateForRuntime(resolveRuntimeFromExportThis(this), callback);
 }
@@ -15,9 +15,6 @@ export async function getOfflineDps(isForce) {
 export function getOfflineDpCache(code) {
     return getOfflineDpCacheForRuntime(resolveRuntimeFromExportThis(this), code);
 }
-export async function checkOfflineDpUpdate(dps, isForce) {
-    return checkOfflineDpUpdateForRuntime(resolveRuntimeFromExportThis(this), dps, isForce);
-}
 export function isOfflineDpSyncing(code) {
     const rt = resolveRuntimeFromExportThis(this);
     if (!rt.config.supportOfflineDps) {

package/lib/entries/main/exports/temporary.d.ts

@@ -5,21 +5,12 @@ export declare function createTempCustom(params: CreateCustomParams): Promise<Te
 export declare function removeTempCustom(params: RemoveCustomProps): Promise<boolean>;
 export declare function updateTempCustom(params: UpdateTempPasswordParams): Promise<boolean>;
 export declare function getTempEffectiveList(): Promise<import("../../../feature/password/temporary/types").EffectivePasswrodItem[]>;
-export declare function getTempInvalidList(params?: GetInvalidListParams): Promise<{
-    list: import("../../../feature/password/temporary/types").InvalidPasswordItem[];
-    hasMore: boolean;
-    total: number;
-}>;
+export declare function getTempInvalidList(params?: GetInvalidListParams): Promise<import("../../../feature/password/temporary/lists").GetTempInvalidListResult>;
 export declare function clearTempInvalidList(): Promise<boolean>;
 export declare function freezeTemp(params: FreezeParams): Promise<boolean>;
 export declare function unfreezeTemp(params: FreezeParams): Promise<boolean>;
 export declare function renameTemp(params: RenameParams): Promise<void>;
-export declare function saveTempOnlineUnlimited(params: CreateOnlineUnlimitedParams): Promise<{
-    type: "custom";
-    name: string;
-    pwdId: string;
-    effectiveConfig: import("../../../interface").EffectiveConfig;
-}>;
+export declare function saveTempOnlineUnlimited(params: CreateOnlineUnlimitedParams): Promise<import("../../../feature/password/temporary/wifi-online").SaveTempOnlineUnlimitedResult>;
 export declare function removeTempOnlineUnlimited(id: string): Promise<void>;
 export declare function getTempOnlineUnlimitedList(): Promise<import("../../../feature/password/temporary/wifi-online").OnlinePasswordItem[]>;
 export declare function createTempOffline(params: CreateOfflineParams): Promise<import("../../../feature/password/temporary/types").OfflineTempResult>;

package/lib/entries/main/index.d.ts

@@ -3,6 +3,7 @@ import type { LockSDKInstance, FitSDKInstance } from "./build-instance";
 export * from "./exports";
 export type { LockSDKInstance, FitSDKInstance };
 export type { LockSdkBoundExportThis } from "./bootstrap/resolve-runtime-from-export-this";
-export declare const createSDK: (options?: Omit<LockSDKOption, "preFetch">) => Promise<LockSDKInstance>;
+export type SDKOptions = Omit<LockSDKOption, "preFetch">;
+export declare const createSDK: (options?: SDKOptions) => Promise<LockSDKInstance>;
 export declare const init: (options?: LockSDKOption) => Promise<void>;
 export declare const destroy: () => void;

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

@@ -1,18 +1,7 @@
 import { type RawFitOpenModeScheduleItem } from "../../api/fit";
-import { EffectiveConfig, UnlockMethodType } from "../../interface";
+import { EffectiveConfig } from "../../interface";
 import { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
 export interface FitPasswordItem {
-    id: number;
-    unlockId: number;
-    unlockName: string;
-    type: UnlockMethodType;
-    userName: string;
-    lockUserId: number;
-    userType: number;
-    devLockId: string;
-    effective: EffectiveConfig;
-}
-export declare const getFitPasswordListForRuntime: (runtime: LockDeviceRuntime) => Promise<{
     id: number;
     unlockId: string;
     unlockName: string;
@@ -22,7 +11,8 @@ export declare const getFitPasswordListForRuntime: (runtime: LockDeviceRuntime)
     userType: number;
     devLockId: string;
     effective: EffectiveConfig;
-}[]>;
+}
+export declare const getFitPasswordListForRuntime: (runtime: LockDeviceRuntime) => Promise<FitPasswordItem[]>;
 export interface FitOnlinePasswordItem {
     id: number;
     pwdId: number;

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

@@ -15,9 +15,10 @@ export interface UpdateFitTempPwdParams {
     name: string;
     effective: EffectiveConfig;
 }
-export declare function fitAddTempPwdForRuntime(runtime: LockDeviceRuntime, params: AddFitTempPwdParams): Promise<{
+export interface AddFitTempPwdResult {
     pwdId: number;
-}>;
+}
+export declare function fitAddTempPwdForRuntime(runtime: LockDeviceRuntime, params: AddFitTempPwdParams): Promise<AddFitTempPwdResult>;
 export declare function fitRemoveTempPwdForRuntime(runtime: LockDeviceRuntime, params: RemoveFitTempPwdParams): Promise<void>;
 export declare function fitUpdateTempPwdForRuntime(runtime: LockDeviceRuntime, params: UpdateFitTempPwdParams): Promise<void>;
 export interface RenameFitTempPwdParams {

package/lib/feature/media/camera.d.ts

@@ -1,7 +1,5 @@
 import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
-import type { CameraConfig, DpMapDataType } from "../../interface";
-import { locationSelectReportMap } from "../../config/dp-map/media";
-export type CameraInfo = DpMapDataType<typeof locationSelectReportMap>;
+import type { CameraConfig } from "../../interface";
 export declare const isSupportMultiCameraForRuntime: (runtime: LockDeviceRuntime) => boolean;
 interface CameraItem {
     index: number;
@@ -12,7 +10,7 @@ export interface CameraDpInfo {
     list: CameraItem[];
 }
 export declare const getCameraInfoForRuntime: (runtime: LockDeviceRuntime) => CameraDpInfo | undefined;
-export declare const queryCameraInfoForRuntime: (runtime: LockDeviceRuntime) => Promise<CameraInfo | undefined>;
+export declare const queryCameraInfoForRuntime: (runtime: LockDeviceRuntime) => Promise<CameraDpInfo | undefined>;
 export declare const switchCameraForRuntime: (runtime: LockDeviceRuntime, index: number) => Promise<true>;
 export declare const getCameraConfigForRuntime: (runtime: LockDeviceRuntime) => CameraConfig[];
 export {};

package/lib/feature/misc/capability.d.ts

@@ -3,7 +3,7 @@ import { DeviceAdvancedAbility } from "../../interface";
 import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
 export declare const hasCapabilityForRuntime: (runtime: LockDeviceRuntime, capability: ProductCommunicationType) => boolean;
 export declare const isBlePureDeviceForRuntime: (rt: LockDeviceRuntime) => boolean;
-export declare const isShareTheadForRuntime: (rt: LockDeviceRuntime) => boolean;
+export declare const isShareThreadForRuntime: (rt: LockDeviceRuntime) => boolean;
 export declare const isActiveThreadForRuntime: (rt: LockDeviceRuntime) => Promise<boolean>;
 export declare const getDeviceAdvancedAbilitiesSyncForRuntime: (rt: LockDeviceRuntime) => DeviceAdvancedAbility | undefined;
 export declare const getDeviceAdvancedAbilitiesForRuntime: (rt: LockDeviceRuntime) => Promise<DeviceAdvancedAbility>;

package/lib/feature/misc/capability.js

@@ -3,10 +3,13 @@ import { CommunicationType, ProductCommunicationType } from "../../constant";
 import { checkShowMatterMutilpleShare } from "../../platform/device";
 import { ipc } from "../../platform";
 import { getWithLocalCache } from "../storage/swr-cache";
+import { getVideoResolutionMark } from "../../api/video";
+import dpCodes from "../../config/dp-code";
+import { hasDpForRuntime } from "../dp/has-dp";
 export const hasCapabilityForRuntime = (runtime, capability) => runtime.config.communication.includes(capability);
 export const isBlePureDeviceForRuntime = (rt) => hasCapabilityForRuntime(rt, ProductCommunicationType.BLUETOOTH) &&
     rt.config.communication.length === 1;
-export const isShareTheadForRuntime = (rt) => {
+export const isShareThreadForRuntime = (rt) => {
     const hasThread = hasCapabilityForRuntime(rt, ProductCommunicationType.THREAD);
     return (hasThread &&
         !rt.config.devInfo.meta?.["threadWithBLE"] &&
@@ -68,7 +71,7 @@ export const getDeviceAdvancedAbilitiesForRuntime = async (rt) => {
         return rt.cache.deviceAdvanceAbilityCache;
     }
     const devId = rt.config.devInfo.devId;
-    const [productAbilitiesRes, deviceAdvancedAbilityRes, tttList] = await Promise.allSettled([
+    const [productAbilitiesRes, deviceAdvancedAbilityRes, tttList, videoMarkRes] = await Promise.allSettled([
         getWithLocalCache(rt, "productAbilities", () => getProductAbilities(devId, [
             "tyabi4ucx5",
             "tyabis9tpe",
@@ -79,10 +82,23 @@ export const getDeviceAdvancedAbilitiesForRuntime = async (rt) => {
         ])),
         getWithLocalCache(rt, "deviceAdvancedAbility", () => getDeviceAdvancedAbility(devId)),
         ipc.getTTTAbilityKeyList("isSupportedVRMode"),
+        hasDpForRuntime(rt, dpCodes.initiativeMessage)
+            ? getWithLocalCache(rt, "videoResolutionMark", () => getVideoResolutionMark(devId))
+            : Promise.resolve({
+                capability: [],
+                cloudCapability: [],
+            }),
     ]);
     const productAbilities = productAbilitiesRes.status === "fulfilled" ? productAbilitiesRes.value : [];
     const tttAbList = tttList.status === "fulfilled" ? tttList.value.abilityList : [];
+    const videoMark = videoMarkRes.status === "fulfilled"
+        ? videoMarkRes.value
+        : { capability: [], cloudCapability: [] };
     const deviceAdvanceAbilityCache = {
+        videoConfig: {
+            isLowResolution: videoMark?.cloudCapability?.includes("tyabig3wt9"),
+            isHighResolution: videoMark?.cloudCapability?.includes("tyabixkep7"),
+        },
         cloudStorage: {
             support: false,
         },
@@ -91,6 +107,7 @@ export const getDeviceAdvancedAbilitiesForRuntime = async (rt) => {
             defaultMode: "VR",
             modes: [],
             coverMode: "VR",
+            options: {},
         },
         ai: {
             support: false,
@@ -151,6 +168,24 @@ export const getDeviceAdvancedAbilitiesForRuntime = async (rt) => {
                                     deviceAdvanceAbilityCache.vr.modes?.[0]?.mode;
                             }
                             deviceAdvanceAbilityCache.vr.coverMode = data.photo_cover_format;
+                            if (data.configs) {
+                                let options;
+                                try {
+                                    options = JSON.parse(data.configs);
+                                }
+                                catch (e) {
+                                }
+                                if (options.zoomIn) {
+                                    deviceAdvanceAbilityCache.vr.options.zoomIn =
+                                        Number(options.zoomIn?.value) > 0
+                                            ? Number(options.zoomIn?.value)
+                                            : undefined;
+                                    deviceAdvanceAbilityCache.vr.options.radialEmphasis =
+                                        Number(options.radialEmphasis?.value) > 0
+                                            ? Number(options.radialEmphasis?.value)
+                                            : undefined;
+                                }
+                            }
                         }
                         break;
                     }

package/lib/feature/misc/connect-device.d.ts

@@ -1,2 +1,8 @@
 import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
 export declare function connectDeviceForRuntime(rt: LockDeviceRuntime, timeout?: number): Promise<true>;
+export declare const awakeDeviceForRuntime: (runtime: LockDeviceRuntime, options?: {
+    timeout?: number;
+}) => Promise<true>;
+export declare const disconnectDeviceForRuntime: (rt: LockDeviceRuntime, options?: {
+    disconnetBle?: boolean;
+}) => Promise<void>;

package/lib/feature/misc/connect-device.js

@@ -1,5 +1,5 @@
 import dpCodes from "../../config/dp-code";
-import { connectBLEDevice, getBLEOnlineState, onBleChange, onOnlineChange, offBleChange, offOnlineChange, yuChannelSyncSingleSync, } from "../../platform/device";
+import { connectBLEDevice, getBLEOnlineState, onBleChange, onOnlineChange, offBleChange, offOnlineChange, yuChannelSyncSingleSync, disconnectBLEDevice, } from "../../platform/device";
 import { DPCHANGE } from "../../utils/constant";
 import emitter from "../../utils/event";
 import { getError } from "../../utils/errors";
@@ -8,70 +8,8 @@ import { getDpValueForRuntime } from "../dp/get-dp-value";
 import { getDeviceStatusForRuntime } from "../state/device-status";
 import { isSupportBleControlForRuntime } from "./ble-control";
 import { sdkLog } from "../../utils/sdk-log";
+import { hasDpForRuntime } from "../dp/has-dp";
 const { wirelessAwake } = dpCodes;
-const awakeDevice = async (devId, timeout) => {
-    const startedAt = Date.now();
-    sdkLog("info", "connectDevice", "awakeStart", {
-        devId,
-        data: { timeout: timeout || 15000 },
-    });
-    return new Promise((resolve, reject) => {
-        const handleChangeDp = (dpCodesArg) => {
-            if (dpCodesArg[wirelessAwake] === true) {
-                sdkLog("info", "connectDevice", "awakeReportSuccess", {
-                    devId,
-                    duration: Date.now() - startedAt,
-                });
-                resolve(true);
-                emitter.off(DPCHANGE, handleChangeDp);
-                clearTimeout(timer);
-            }
-        };
-        emitter.on(DPCHANGE, handleChangeDp);
-        const timer = setTimeout(() => {
-            emitter.off(DPCHANGE, handleChangeDp);
-            const error = getError(1002);
-            sdkLog("warn", "connectDevice", "awakeTimeout", {
-                devId,
-                duration: Date.now() - startedAt,
-                error,
-            });
-            reject(error);
-        }, timeout || 15000);
-        const run = async () => {
-            try {
-                ipc.wakeUpDoorBell(devId);
-                ipc.wakeUpDoorBell(devId);
-                ipc.wakeUpDoorBell(devId);
-                const connected = await ipc.isConnected(devId);
-                if (connected.isConnected) {
-                    sdkLog("info", "connectDevice", "awakeAlreadyConnected", {
-                        devId,
-                        duration: Date.now() - startedAt,
-                    });
-                    return resolve(true);
-                }
-                const connecting = await ipc.isConnecting(devId);
-                if (!connecting.isConnecting) {
-                    sdkLog("info", "connectDevice", "awakeIpcConnectStart", { devId });
-                    await ipc.connect(devId);
-                }
-                else {
-                    sdkLog("debug", "connectDevice", "awakeIpcConnecting", { devId });
-                }
-            }
-            catch (error) {
-                sdkLog("error", "connectDevice", "awakeFail", {
-                    devId,
-                    duration: Date.now() - startedAt,
-                    error,
-                });
-                reject(error);
-            }
-        };
-        run();
-    });
-};
 const connectBle = async (devId, timeout) => {
     const startedAt = Date.now();
     sdkLog("info", "connectDevice", "bleConnectStart", { devId });
@@ -147,7 +85,7 @@ export async function connectDeviceForRuntime(rt, timeout) {
     const cfg = rt.config;
     const devId = cfg.devInfo.devId;
     const deviceStatus = getDeviceStatusForRuntime(rt);
-    const hasWirelessAwakeDp = !!cfg.dpSchema[wirelessAwake];
+    const hasWirelessAwakeDp = hasDpForRuntime(rt, wirelessAwake) && !cfg.notSupportWake;
     const startedAt = Date.now();
     sdkLog("info", "connectDevice", "start", {
         devId,
@@ -160,7 +98,7 @@ export async function connectDeviceForRuntime(rt, timeout) {
     });
     if (deviceStatus.connectEnable && hasWirelessAwakeDp) {
         if (cfg.devInfo.isCloudOnline && !getDpValueForRuntime(rt, wirelessAwake)) {
-            const result = await awakeDevice(devId, timeout);
+            const result = await awakeDeviceForRuntime(rt, { timeout });
             sdkLog("info", "connectDevice", "success", {
                 devId,
                 duration: Date.now() - startedAt,
@@ -205,3 +143,102 @@ export async function connectDeviceForRuntime(rt, timeout) {
     });
     throw error;
 }
+export const awakeDeviceForRuntime = (runtime, options) => {
+    const cfg = runtime.config;
+    const devId = cfg.devInfo.devId;
+    const timeout = options?.timeout || 15000;
+    const startedAt = Date.now();
+    const hasWirelessAwake = hasDpForRuntime(runtime, wirelessAwake) && !cfg.notSupportWake;
+    sdkLog("info", "connectDevice", "awakeStart", {
+        devId,
+        data: { timeout, hasWirelessAwake },
+    });
+    return new Promise((resolve, reject) => {
+        const handleChangeDp = (dpCodesArg) => {
+            if (dpCodesArg[wirelessAwake] === true) {
+                sdkLog("info", "connectDevice", "awakeReportSuccess", {
+                    devId,
+                    duration: Date.now() - startedAt,
+                });
+                resolve(true);
+                emitter.off(DPCHANGE, handleChangeDp);
+                clearTimeout(timer);
+            }
+        };
+        hasWirelessAwake && emitter.on(DPCHANGE, handleChangeDp);
+        const timer = setTimeout(() => {
+            emitter.off(DPCHANGE, handleChangeDp);
+            const error = getError(1002);
+            sdkLog("warn", "connectDevice", "awakeTimeout", {
+                devId,
+                duration: Date.now() - startedAt,
+                error,
+            });
+            reject(error);
+        }, timeout);
+        const run = async () => {
+            try {
+                ipc.wakeUpDoorBell(devId);
+                ipc.wakeUpDoorBell(devId);
+                ipc.wakeUpDoorBell(devId);
+                const connected = await ipc.isConnected(devId);
+                if (connected.isConnected) {
+                    sdkLog("info", "connectDevice", "awakeAlreadyConnected", {
+                        devId,
+                        duration: Date.now() - startedAt,
+                    });
+                    clearTimeout(timer);
+                    return resolve(true);
+                }
+                const connecting = await ipc.isConnecting(devId);
+                if (!connecting.isConnecting) {
+                    sdkLog("info", "connectDevice", "awakeIpcConnectStart", { devId });
+                    await ipc.connect(devId);
+                    if (!hasWirelessAwake) {
+                        clearTimeout(timer);
+                        return resolve(true);
+                    }
+                }
+                else {
+                    sdkLog("debug", "connectDevice", "awakeIpcConnecting", { devId });
+                }
+            }
+            catch (error) {
+                sdkLog("error", "connectDevice", "awakeFail", {
+                    devId,
+                    duration: Date.now() - startedAt,
+                    error,
+                });
+                reject(error);
+            }
+        };
+        run();
+    });
+};
+export const disconnectDeviceForRuntime = async (rt, options) => {
+    const cfg = rt.config;
+    const devId = cfg.devInfo.devId;
+    const startedAt = Date.now();
+    sdkLog("info", "disconnectDevice", "start", {
+        devId,
+    });
+    try {
+        const deviceStatus = getDeviceStatusForRuntime(rt);
+        await ipc.disConnect(devId);
+        if (deviceStatus.onlineTypes.includes("ble") && !!options?.disconnetBle) {
+            await disconnectBLEDevice(devId);
+        }
+        sdkLog("info", "disconnectDevice", "success", {
+            devId,
+            duration: Date.now() - startedAt,
+        });
+    }
+    catch (e) {
+        sdkLog("error", "disconnectDevice", "Fail", {
+            devId,
+            duration: Date.now() - startedAt,
+            error: e,
+        });
+        throw e;
+    }
+};

package/lib/feature/misc/types.d.ts

@@ -1,5 +1,8 @@
 export type ExecutorRange = "unlock" | "lock";
 export type Ability = "backHome" | "alarm" | "geographyArrive" | "geographyLeave" | "bleGeofence" | "siriUnlock" | "siriLock";
+export interface ConnectDeviceOptions {
+    timeout?: number;
+}
 export interface OpenSceneOptions {
     themeColor?: string;
     executorRange?: Array<ExecutorRange>;

package/lib/feature/misc/update-config.js

@@ -1,9 +1,16 @@
+import { updateDeviceStatus } from "../state/device-status";
 export function updateConfigForRuntime(runtime, options) {
     const cfg = runtime.config;
+    let needUpdateDeviceStatus = false;
+    if (typeof options?.notSupportWake === "boolean" &&
+        cfg.notSupportWake !== options.notSupportWake) {
+        needUpdateDeviceStatus = true;
+    }
     Object.keys(options).forEach((key) => {
         const value = options[key];
         if (value !== undefined) {
             cfg[key] = value;
         }
     });
+    needUpdateDeviceStatus && updateDeviceStatus(runtime);
 }

package/lib/feature/password/temporary/lists.d.ts

@@ -1,11 +1,12 @@
 import type { LockDeviceRuntime } from "../../../runtime/LockDeviceRuntime";
 import type { EffectivePasswrodItem, GetInvalidListParams, InvalidPasswordItem } from "./types";
 export declare function getTempEffectiveListForRuntime(rt: LockDeviceRuntime): Promise<EffectivePasswrodItem[]>;
-export declare function getTempInvalidListForRuntime(rt: LockDeviceRuntime, params?: GetInvalidListParams): Promise<{
+export interface GetTempInvalidListResult {
     list: InvalidPasswordItem[];
     hasMore: boolean;
     total: number;
-}>;
+}
+export declare function getTempInvalidListForRuntime(rt: LockDeviceRuntime, params?: GetInvalidListParams): Promise<GetTempInvalidListResult>;
 export declare function clearTempInvalidListForRuntime(rt: LockDeviceRuntime): Promise<boolean>;
 export interface LimitTempItem {
     id: string;

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

@@ -10,10 +10,11 @@ export interface FitOfflineOnceResult {
     gmtExpired: number;
 }
 export declare function createFitOfflineOnceForRuntime(rt: LockDeviceRuntime): Promise<FitOfflineOnceResult>;
-export declare function createFitOfflineLimitForRuntime(rt: LockDeviceRuntime, params: {
+export interface FitOfflineLimitParams {
     effectiveTime: number;
     invalidTime: number;
-}): Promise<FitOfflineOnceResult>;
+}
+export declare function createFitOfflineLimitForRuntime(rt: LockDeviceRuntime, params: FitOfflineLimitParams): Promise<FitOfflineOnceResult>;
 export declare function createFitOfflineClearAllForRuntime(rt: LockDeviceRuntime): Promise<FitOfflineOnceResult>;
 export declare function getFitOfflineRevocableListForRuntime(rt: LockDeviceRuntime): Promise<LimitOfflinePwdItem[]>;
 export declare function getFitOfflinePwdAvailableForRuntime(rt: LockDeviceRuntime, pwdType: string): Promise<OfflinePwdAvailableResult>;

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

@@ -1,12 +1,13 @@
 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<{
+export interface SaveTempOnlineUnlimitedResult {
     type: "custom";
     name: string;
     pwdId: string;
     effectiveConfig: EffectiveConfig;
-}>;
+}
+export declare function saveTempOnlineUnlimitedForRuntime(rt: LockDeviceRuntime, params: CreateOnlineUnlimitedParams): Promise<SaveTempOnlineUnlimitedResult>;
 export declare function removeTempOnlineUnlimitedForRuntime(rt: LockDeviceRuntime, id: string): Promise<void>;
 export interface OnlinePasswordItem {
     status: "effective" | "synchronizing" | "expired" | "disabled" | "invalid";

package/lib/feature/state/init-state.js

@@ -14,10 +14,11 @@ import syncT0 from "./sync/t0";
 import { getDeviceStatusForRuntime, updateOnlineType } from "./device-status";
 import { handleDpChange } from "./dp-change";
 import { fetchDeviceProperties } from "./remote-permissions";
-import { ipc, yuChannelSyncSingleSync, } from "../../platform";
+import { ipc, yuChannelSyncSingleSync } from "../../platform";
 import { sdkLog } from "../../utils/sdk-log";
 import { ProductCommunicationType, RotateType } from "../../constant";
 import { isHarmony } from "../../utils";
+import { getError } from "../../utils/errors";
 export const initState = async (runtime) => {
     const { devInfo: { dps, devId, yuNetState }, dpSchema, } = runtime.config;
     const startedAt = Date.now();
@@ -41,7 +42,7 @@ export const initState = async (runtime) => {
                 isSupportVideo,
             },
         });
-        const [, , , advanceAbilities, isActiveThread, rotateInfo, deviceSkill, ipcConfig,] = await Promise.allSettled([
+        const [, userInfoResult, , advanceAbilities, isActiveThread, rotateInfo, deviceSkill, ipcConfig,] = await Promise.allSettled([
             updateOnlineType(runtime),
             getCurrentUserForRuntime(runtime),
             fetchDeviceProperties(runtime),
@@ -71,6 +72,43 @@ export const initState = async (runtime) => {
                     },
                 }),
         ]);
+        if (userInfoResult.status === "rejected") {
+            throw userInfoResult.reason;
+        }
+        if (advanceAbilities.status === "fulfilled") {
+            const abilities = advanceAbilities.value;
+            sdkLog("debug", "initState", "advancedAbilitiesFetched", {
+                devId,
+                data: {
+                    yuChannelSupport: abilities.yuChannel.support,
+                    yuChannelValue: abilities.yuChannel.value,
+                },
+            });
+            if (isSupportVideo &&
+                !abilities.videoConfig.isHighResolution &&
+                !abilities.videoConfig.isLowResolution) {
+                throw getError(1107);
+            }
+            if (abilities.yuChannel.support) {
+                if (abilities.yuChannel.value === 1) {
+                    sdkLog("debug", "initState", "yuChannelSync", {
+                        devId,
+                        data: { reason: "abilityEnabled" },
+                    });
+                    yuChannelSyncSingleSync(devId);
+                }
+                else if (yuNetState === 1) {
+                    sdkLog("debug", "initState", "yuChannelSync", {
+                        devId,
+                        data: { reason: "yuNetState" },
+                    });
+                    yuChannelSyncSingleSync(devId);
+                }
+            }
+        }
+        else {
+            throw getError(1108);
+        }
         if (isSupportVideo) {
             const isSEI = runtime.config.capabilities?.rotateType === RotateType.SEI;
             if (rotateInfo.status === "fulfilled") {
@@ -85,14 +123,11 @@ export const initState = async (runtime) => {
             }
             if (ipcConfig.status === "fulfilled" &&
                 ipcConfig.value?.audioAttributes?.hardwareCapability?.includes(2)) {
-                if (isHarmony()) {
-                    runtime.config.supportTalk = true;
-                    runtime.config.isTwoWayTalk =
-                        ipcConfig.value?.audioAttributes?.callMode?.includes(2);
-                }
-                else {
+                runtime.config.supportTalk = true;
+                runtime.config.isTwoWayTalk =
+                    ipcConfig.value?.audioAttributes?.callMode?.[0] === 2;
+                if (!isHarmony()) {
                     try {
-                        runtime.config.supportTalk = true;
                         const modeRes = await ipc.getCurrentSupportedTalkMode(devId);
                         runtime.config.isTwoWayTalk = modeRes.talkbackMode === 2;
                         sdkLog("info", "initState", "supportTalk", {
@@ -128,32 +163,6 @@ export const initState = async (runtime) => {
                 videoAngle: runtime.config.videoAngle,
             },
         });
-        if (advanceAbilities.status === "fulfilled") {
-            const abilities = advanceAbilities.value;
-            sdkLog("debug", "initState", "advancedAbilitiesFetched", {
-                devId,
-                data: {
-                    yuChannelSupport: abilities.yuChannel.support,
-                    yuChannelValue: abilities.yuChannel.value,
-                },
-            });
-            if (abilities.yuChannel.support) {
-                if (abilities.yuChannel.value === 1) {
-                    sdkLog("debug", "initState", "yuChannelSync", {
-                        devId,
-                        data: { reason: "abilityEnabled" },
-                    });
-                    yuChannelSyncSingleSync(devId);
-                }
-                else if (yuNetState === 1) {
-                    sdkLog("debug", "initState", "yuChannelSync", {
-                        devId,
-                        data: { reason: "yuNetState" },
-                    });
-                    yuChannelSyncSingleSync(devId);
-                }
-            }
-        }
         syncRemoteSerectKey(runtime);
         checkOfflineDpUpdateForRuntime(runtime, {}, true).then(() => {
             sdkLog("debug", "initState", "offlineDpCheckDone", { devId });
@@ -163,8 +172,10 @@ export const initState = async (runtime) => {
         });
         setTimeout(() => {
             sdkLog("debug", "initState", "scheduledSyncUnlock", { devId });
-            syncT0(runtime);
-            autoSyncUnlockMethod(runtime);
+            if (getDeviceStatusForRuntime(runtime).type === "online") {
+                syncT0(runtime);
+                autoSyncUnlockMethod(runtime);
+            }
         }, 2000);
         setTimeout(() => {
             sdkLog("debug", "initState", "scheduledSyncTempAndUsers", { devId });

package/lib/feature/state/internal/share-thread-local.js

@@ -1,4 +1,4 @@
-import { isShareTheadForRuntime } from "../../misc/capability";
+import { isShareThreadForRuntime } from "../../misc/capability";
 export function isShareThreadRuntimeLocal(rt) {
-    return isShareTheadForRuntime(rt);
+    return isShareThreadForRuntime(rt);
 }

package/lib/feature/unlock/method/add-flow.js

@@ -1,7 +1,7 @@
 import dpUtils from "@ray-js/tuya-dp-transform";
 import { createUnlockMethod } from "../../../api/lock";
 import { parallelOnlyForRuntime } from "../../utils";
-import { formatCloudUnlockId, sleep } from "../../../utils";
+import { sleep } from "../../../utils";
 import { getError } from "../../../utils/errors";
 import { publishDpsForRuntime } from "../../dp/publish-dps";
 import emitter from "../../../utils/event";
@@ -207,7 +207,7 @@ const handleAddReport = async (dps) => {
                         const res = await createUnlockMethod({
                             devId: cfg.devInfo.devId,
                             userId: addUnlockMethodData.userId,
-                            unlockId: formatCloudUnlockId(addUnlockMethodData.unlockDpId, result.unlockId),
+                            unlockId: `${addUnlockMethodData.unlockDpId}-${result.unlockId}`,
                             unlockName: "",
                             unlockAttr: 0,
                         });

package/lib/feature/unlock/method/add-password.js

@@ -1,7 +1,7 @@
 import dpUtils from "@ray-js/tuya-dp-transform";
 import { createUnlockMethod } from "../../../api/lock";
 import { encrypt } from "../../../platform/device";
-import { formatCloudUnlockId, sleep } from "../../../utils";
+import { sleep } from "../../../utils";
 import { getError, handleCloudError } from "../../../utils/errors";
 import { publishDpsForRuntime } from "../../dp/publish-dps";
 import { getUnlockMethodBase } from "./internal/base";
@@ -76,7 +76,7 @@ export async function addPasswordForRuntime(rt, params) {
         const result = await createUnlockMethod({
             devId: devId,
             userId: params.userId,
-            unlockId: formatCloudUnlockId(dpId, res.unlockId),
+            unlockId: `${dpId}-${res.unlockId}`,
             unlockName: params.name,
             unlockDetail: aesPwd,
             ...specialInfo,

package/lib/feature/unlock/method/update-remove.js

@@ -26,7 +26,7 @@ export async function updateUnlockMethodForRuntime(rt, params) {
     await editUnlockMethod({
         devId: cfg.devInfo.devId,
         opModeId: params.id,
-        unlockName: params.name,
+        unlockName: params.name || detail.unlockName,
         ...specialInfo,
     });
     sdkLog("info", "unlockMethod", "updateSuccess", {

package/lib/interface.d.ts

@@ -359,6 +359,10 @@ export interface AlbumMessage extends MediaInfo {
 }
 export type VRModeType = "original" | "VR" | "horizontal" | "vertical";
 export interface DeviceAdvancedAbility {
+    videoConfig: {
+        isLowResolution: boolean;
+        isHighResolution: boolean;
+    };
     cloudStorage: {
         support: boolean;
     };
@@ -370,6 +374,10 @@ export interface DeviceAdvancedAbility {
             value: number;
         }>;
         defaultMode: VRModeType;
+        options: {
+            zoomIn?: number;
+            radialEmphasis?: number;
+        };
     };
     ai: {
         support: boolean;

package/lib/platform/device.d.ts

@@ -173,6 +173,7 @@ 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 declare const disconnectBLEDevice: (deviceId: string) => Promise<void>;
 export interface BLEFileTransferParams {
     deviceId: string;
     fileId: number;

package/lib/platform/device.js

@@ -365,6 +365,15 @@ export const connectBLEDevice = (deviceId) => {
         });
     });
 };
+export const disconnectBLEDevice = (deviceId) => {
+    return new Promise((resolve, reject) => {
+        ty.device.disconnectBLEDevice({
+            deviceId,
+            success: () => resolve(),
+            fail: reject,
+        });
+    });
+};
 export const postBLEFileTransfer = (params) => {
     return new Promise((resolve, reject) => {
         const device = ty.device;
@@ -450,10 +459,10 @@ export const offAppShow = (cb) => {
     ty.offAppShow(cb);
 };
 export const onAppHide = (cb) => {
-    ty.onAppShow(cb);
+    ty.onAppHide(cb);
 };
 export const offAppHide = (cb) => {
-    ty.offAppShow(cb);
+    ty.offAppHide(cb);
 };
 export const trackEvent = (event, data) => {
     ty.event({

package/lib/platform/ipc.d.ts

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

package/lib/platform/ipc.js

@@ -18,6 +18,11 @@ const connect = (deviceId) => {
         ty.ipc.connect({ deviceId, success: resolve, fail: reject });
     });
 };
+const disConnect = (deviceId) => {
+    return new Promise((resolve, reject) => {
+        ty.ipc.disConnect({ deviceId, success: resolve, fail: reject });
+    });
+};
 const getCurrentSupportedTalkMode = (deviceId) => {
     if (ty.ipc.getCurrentSupportedTalkMode) {
         return new Promise((resolve, reject) => {
@@ -47,6 +52,7 @@ export default {
     wakeUpDoorBell,
     isConnected,
     isConnecting,
+    disConnect,
     connect,
     getCurrentSupportedTalkMode,
     getTTTAbilityKeyList,

package/lib/utils/errors.js

@@ -106,6 +106,8 @@ const errors = {
     1104: "Failed to switch cameras",
     1105: "Camera switching is not supported",
     1106: "No validity configuration data",
+    1107: "Invalid device, please re-authorize",
+    1108: "Failed to get configuration",
 };
 export const getError = (code, ...places) => {
     if (errors[code]) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ray-js/lock-sdk",
-  "version": "1.2.1-beta.0",
+  "version": "1.2.1-beta.10",
   "files": [
     "lib",
     "LICENSE.md"