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

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

@@ -0,0 +1,130 @@
+import { hasCapabilityForRuntime } from "../misc/capability";
+import { hasDpForRuntime } from "../dp/has-dp";
+import dpCodes from "../../config/dp-code";
+import { ProductCommunicationType } from "../../constant";
+import { getDeviceStatusChangeEvent } from "./device-status-events";
+import { getDeviceInfo, getDeviceOnlineType, isYuDeviceOnlineSync, } from "../../platform/device";
+import { equels, getCapabilities, isOnlineByType } from "../../utils";
+import emitter from "../../utils/event";
+import { syncDeleteUsersWithRuntime } from "../user/sync-user";
+import { getDpPeriodTimeForRuntime } from "../misc/dp-period";
+import { isSupportBleControlForRuntime } from "../misc/ble-control";
+import { getDpValueForRuntime } from "../dp/get-dp-value";
+import { readIsSleepForRuntime } from "./internal/read-is-sleep";
+import { isShareThreadRuntimeLocal } from "./internal/share-thread-local";
+export const updateOnlineType = async (runtime) => {
+    const [devInfo, onlineType] = await Promise.all([
+        getDeviceInfo(runtime.config.devInfo.devId),
+        getDeviceOnlineType(runtime.config.devInfo.devId),
+    ]);
+    runtime.config.onlineType = onlineType;
+    runtime.config.devInfo = devInfo;
+    runtime.config.communication = getCapabilities(devInfo.capability).map((item) => item.id);
+    updateDeviceStatus(runtime);
+};
+export const getDeviceStatusForRuntime = (runtime) => {
+    const { onlineType, devInfo: { isCloudOnline, isOnline, wifiEnableState, isMatter }, } = runtime.config;
+    const supportWifi = hasCapabilityForRuntime(runtime, ProductCommunicationType.WIFI);
+    const supportBle = hasCapabilityForRuntime(runtime, ProductCommunicationType.BLUETOOTH);
+    const supportThread = hasCapabilityForRuntime(runtime, 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 = hasDpForRuntime(runtime, dpCodes.wirelessAwake);
+    const wirelessAwake = getDpValueForRuntime(runtime, dpCodes.wirelessAwake);
+    status.connectEnable = isSupportBleControlForRuntime(runtime) && !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 (supportThread && supportBle) {
+        const isShareThread = isShareThreadRuntimeLocal(runtime);
+        if (isShareThread && isOnline) {
+            if (!status.onlineTypes.includes("local")) {
+                status.onlineTypes = ["local"];
+            }
+        }
+    }
+    if (supportBle) {
+        if (runtime.cache.deviceAdvanceAbilityCache?.yuChannel.support) {
+            if (isYuDeviceOnlineSync(runtime.config.devInfo.devId)) {
+                status.onlineTypes.push("yuChannel");
+            }
+        }
+    }
+    if (status.onlineTypes.length === 0 && isOnline) {
+        status.onlineTypes.push("unknown");
+    }
+    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 (readIsSleepForRuntime(runtime)) {
+            status.type = "sleep";
+        }
+    }
+    if (status.type === "sleep") {
+        if (getDpValueForRuntime(runtime, dpCodes.dormantSwitch) ||
+            getDpValueForRuntime(runtime, dpCodes.onlineSwitch)) {
+            status.sleepPeriod = getDpPeriodTimeForRuntime(runtime, dpCodes.dormantTimeSet);
+        }
+    }
+    return status;
+};
+export const updateDeviceStatus = (runtime) => {
+    const status = getDeviceStatusForRuntime(runtime);
+    if (!equels(runtime.deviceStatus, status)) {
+        runtime.deviceStatus = status;
+        emitter.emit(getDeviceStatusChangeEvent(runtime), status);
+    }
+    if (status.type === "online") {
+        void syncDeleteUsersWithRuntime(runtime);
+    }
+};

package/lib/feature/state/dp-change.d.ts

@@ -0,0 +1,3 @@
+import type { DpData } from "../../interface";
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export declare const handleDpChange: (runtime: LockDeviceRuntime, dps: DpData, notEmit?: boolean) => void;

package/lib/feature/state/dp-change.js

@@ -0,0 +1,44 @@
+import dpCodes, { latLogDpCodes } from "../../config/dp-code";
+import { parseCapabilities } from "../../utils/parse";
+import { DPCHANGE } from "../../utils/constant";
+import emitter from "../../utils/event";
+import { checkOfflineDpUpdateForRuntime } from "../offline-dps";
+import { readIsSleepForRuntime } from "./internal/read-is-sleep";
+import { getLogsRefreshEvent } from "../log/log";
+import { getSleepStatusEvent } from "../misc/sleep";
+import { handleBleSyncRequestReport } from "../password/sync-temp";
+export const handleDpChange = (runtime, dps, notEmit) => {
+    let refleshLogsEnabled = false;
+    const dpData = Object.keys(dps).reduce((acc, key) => {
+        const code = runtime.config.codesById[key];
+        if (code) {
+            acc[code] = dps[key];
+            if (!refleshLogsEnabled && latLogDpCodes.some((c) => c === code)) {
+                refleshLogsEnabled = true;
+            }
+        }
+        return acc;
+    }, {});
+    if (dpData[dpCodes.deviceInfo]) {
+        runtime.config.capabilities = parseCapabilities(dpData[dpCodes.deviceInfo]);
+    }
+    Object.assign(runtime.cache.dpState, dpData);
+    if (!notEmit) {
+        emitter.emit(DPCHANGE, dpData);
+        if (typeof dpData[dpCodes.linkMode] !== "undefined") {
+            emitter.emit(getSleepStatusEvent(runtime), {
+                sleep: readIsSleepForRuntime(runtime),
+            });
+        }
+        if (refleshLogsEnabled) {
+            clearTimeout(runtime.infra.logRefreshTimer);
+            runtime.infra.logRefreshTimer = setTimeout(() => {
+                emitter.emit(getLogsRefreshEvent(runtime), dpData);
+            }, 2000);
+        }
+        void checkOfflineDpUpdateForRuntime(runtime, dpData);
+        if (typeof dpData[dpCodes.bleSyncRequest] !== "undefined") {
+            void handleBleSyncRequestReport(runtime, dpData[dpCodes.bleSyncRequest]);
+        }
+    }
+};

package/lib/feature/state/init-state.d.ts

@@ -0,0 +1,2 @@
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export declare const initState: (runtime: LockDeviceRuntime) => Promise<void>;

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

@@ -0,0 +1,167 @@
+import dpCodes from "../../config/dp-code";
+import { getDeviceSkill, getIPCConfig, getRotateInfo } from "../../api/video";
+import { getDataWithPreFetchForRuntime } from "../utils";
+import { getDeviceAdvancedAbilitiesForRuntime } from "../misc/capability";
+import { getCurrentUserForRuntime } from "../user/current-user";
+import { checkOfflineDpUpdateForRuntime } from "../offline-dps";
+import { autoSyncTemp } from "../password/sync-temp";
+import { autoSyncUnlockMethod } from "../unlock/sync/unlock-method";
+import { syncDeleteUsersWithRuntime } from "../user/sync-user";
+import syncRemoteSerectKey from "./sync/remote-serect-key";
+import { syncOfflineDps } from "./sync/offline-dps";
+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 { sdkLog } from "../../utils/sdk-log";
+import { RotateType } from "../../constant";
+export const initState = async (runtime) => {
+    const { devInfo: { dps, devId, yuNetState }, dpSchema, } = runtime.config;
+    const startedAt = Date.now();
+    sdkLog("info", "initState", "start", {
+        devId,
+        data: {
+            preFetch: runtime.config.preFetch,
+            dpCount: Object.keys(dps ?? {}).length,
+        },
+    });
+    try {
+        handleDpChange(runtime, dps, true);
+        const isSupportVideo = !!dpSchema[dpCodes.initiativeMessage];
+        runtime.deviceStatus = getDeviceStatusForRuntime(runtime);
+        sdkLog("debug", "initState", "baseStateReady", {
+            devId,
+            data: {
+                statusType: runtime.deviceStatus.type,
+                onlineTypes: runtime.deviceStatus.onlineTypes,
+                isSupportVideo,
+            },
+        });
+        const [, , rotateInfo, deviceSkill, ipcConfig] = await Promise.allSettled([
+            updateOnlineType(runtime),
+            getCurrentUserForRuntime(runtime),
+            isSupportVideo
+                ? getDataWithPreFetchForRuntime(runtime, "getRotate", () => getRotateInfo(devId))
+                : Promise.resolve({
+                    angle: 0,
+                    actualAngle: 0,
+                }),
+            isSupportVideo
+                ? getDeviceSkill(devId)
+                : Promise.resolve({
+                    devId,
+                    json: { videos: [{ width: 0, height: 0 }] },
+                }),
+            isSupportVideo
+                ? getIPCConfig(devId)
+                : Promise.resolve({
+                    audioAttributes: {
+                        hardwareCapability: [],
+                        callMode: [],
+                    },
+                }),
+        ]);
+        if (isSupportVideo) {
+            const isSEI = runtime.config.capabilities?.rotateType === RotateType.SEI;
+            if (rotateInfo.status === "fulfilled") {
+                runtime.config.imageAngle = isSEI ? 0 : rotateInfo.value.angle;
+                runtime.config.videoAngle = isSEI ? 0 : rotateInfo.value.actualAngle;
+            }
+            if (deviceSkill.status === "fulfilled") {
+                runtime.config.mediaWidth =
+                    deviceSkill.value?.json?.videos?.[0]?.width ?? 0;
+                runtime.config.mediaHeight =
+                    deviceSkill.value?.json?.videos?.[0]?.height ?? 0;
+            }
+            if (ipcConfig.status === "fulfilled" &&
+                ipcConfig.value?.audioAttributes?.hardwareCapability?.includes(2)) {
+                try {
+                    const modeRes = await ipc.getCurrentSupportedTalkMode(devId);
+                    runtime.config.supportTalk = true;
+                    runtime.config.isTwoWayTalk = modeRes.talkbackMode === 2;
+                    sdkLog("info", "initState", "supportTalk", {
+                        devId,
+                        duration: Date.now() - startedAt,
+                        data: {
+                            mode: modeRes.talkbackMode,
+                        },
+                    });
+                }
+                catch (e) {
+                    sdkLog("error", "initState", "supportTalk", {
+                        devId,
+                        duration: Date.now() - startedAt,
+                        data: {},
+                    });
+                }
+            }
+            if (!isSEI &&
+                (runtime.config.imageAngle === 90 || runtime.config.imageAngle === 270)) {
+                const temp = runtime.config.mediaWidth;
+                runtime.config.mediaWidth = runtime.config.mediaHeight;
+                runtime.config.mediaHeight = temp;
+            }
+        }
+        await fetchDeviceProperties(runtime);
+        sdkLog("info", "initState", "ready", {
+            devId,
+            duration: Date.now() - startedAt,
+            data: {
+                onlineType: runtime.config.onlineType,
+                imageAngle: runtime.config.imageAngle,
+                videoAngle: runtime.config.videoAngle,
+            },
+        });
+        getDeviceAdvancedAbilitiesForRuntime(runtime).then((abilities) => {
+            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 });
+            setTimeout(() => {
+                syncOfflineDps(runtime);
+            }, 3000);
+        });
+        setTimeout(() => {
+            sdkLog("debug", "initState", "scheduledSyncUnlock", { devId });
+            syncT0(runtime);
+            autoSyncUnlockMethod(runtime);
+        }, 2000);
+        setTimeout(() => {
+            sdkLog("debug", "initState", "scheduledSyncTempAndUsers", { devId });
+            autoSyncTemp(runtime);
+            syncDeleteUsersWithRuntime(runtime);
+        }, 3000);
+    }
+    catch (error) {
+        sdkLog("error", "initState", "fail", {
+            devId,
+            duration: Date.now() - startedAt,
+            error,
+        });
+        throw error;
+    }
+};

package/lib/feature/state/internal/read-is-sleep.d.ts

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

package/lib/feature/state/internal/read-is-sleep.js

@@ -0,0 +1,9 @@
+import { hasDpForRuntime } from "../../dp/has-dp";
+import dpCodes from "../../../config/dp-code";
+export function readIsSleepForRuntime(rt) {
+    if (!hasDpForRuntime(rt, dpCodes.linkMode)) {
+        return false;
+    }
+    const linkMode = rt.cache.dpState[dpCodes.linkMode];
+    return linkMode === "sleep" || linkMode === "lock_sleep";
+}

package/lib/feature/state/internal/share-thread-local.d.ts

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

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

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

package/lib/feature/state/platform-routing.d.ts

@@ -0,0 +1,3 @@
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export declare const addEvents: (runtime: LockDeviceRuntime) => void;
+export declare const removeEvents: () => void;

package/lib/feature/state/platform-routing.js

@@ -0,0 +1,155 @@
+import { offBleChange, offDeviceInfoUpdated, offDpDataChange, offMqttMessage, offOnlineChange, offResetMemberName, offResetMemberRole, onAppHide, onAppShow, onBleChange, onDeviceInfoUpdated, onDpDataChange, onMqttMessage, onOnlineChange, onResetMemberName, onResetMemberRole, registerBleStatus, registerDevice, registerMQTTDeviceListener, registerMQTTProtocolListener, } from "../../platform/device";
+import { getRuntimeByDevId, listRegisteredRuntimes, } from "../../runtime/registry";
+import emitter from "../../utils/event";
+import { getWiFiSignalChangeEvent } from "../misc/signal";
+import { autoSyncTemp } from "../password/sync-temp";
+import syncT0 from "./sync/t0";
+import syncRemoteSerectKey from "./sync/remote-serect-key";
+import { syncOfflineDps } from "./sync/offline-dps";
+import { updateDeviceStatus, updateOnlineType } from "./device-status";
+import { handleDpChange } from "./dp-change";
+import { getCurrentUserForRuntime } from "../user/current-user";
+import { syncDeleteUsersWithRuntime } from "../user/sync-user";
+import { fetchDeviceProperties } from "./remote-permissions";
+import { checkOfflineDpUpdateForRuntime } from "../offline-dps";
+import { sdkLog } from "../../utils/sdk-log";
+const subscribedDevIds = new Set();
+let globalPlatformListenersInstalled = false;
+let mqttProtocolListenerRegistered = false;
+const globalHandleDeviceDpsChange = ({ dps, deviceId, }) => {
+    try {
+        const rt = getRuntimeByDevId(deviceId);
+        if (!rt) {
+            return;
+        }
+        handleDpChange(rt, dps);
+        updateDeviceStatus(rt);
+    }
+    catch (e) {
+        sdkLog("error", "platform", "dpDataChangeError", { error: e });
+    }
+};
+const globalHandleDeviceInfoChange = async ({ dps, deviceId, }) => {
+    const rt = getRuntimeByDevId(deviceId);
+    if (!rt) {
+        return;
+    }
+    if (dps) {
+        handleDpChange(rt, dps);
+    }
+    await updateOnlineType(rt);
+    updateDeviceStatus(rt);
+};
+const globalUpdateAllOnlineTypes = async (data) => {
+    if (!data?.deviceId) {
+        return;
+    }
+    const rt = getRuntimeByDevId(data.deviceId);
+    if (rt) {
+        await updateOnlineType(rt);
+        if (data.online) {
+            void syncRemoteSerectKey(rt);
+            autoSyncTemp(rt);
+            void syncT0(rt);
+            void syncOfflineDps(rt);
+        }
+    }
+};
+const globalHandleMqttMessage = ({ deviceId, messageData, protocol }) => {
+    const rt = getRuntimeByDevId(deviceId);
+    if (!rt) {
+        return;
+    }
+    switch (+protocol) {
+        case 23: {
+            if (messageData?.data?.signal || messageData?.data?.signal === 0) {
+                const signal = messageData.data.signal;
+                let signalText = "bad";
+                if (signal > -50) {
+                    signalText = "good";
+                }
+                else if (signal <= -50 && signal > -65) {
+                    signalText = "normal";
+                }
+                else if (signal <= -65 && signal > -75) {
+                    signalText = "weak";
+                }
+                emitter.emit(getWiFiSignalChangeEvent(rt), {
+                    signal,
+                    level: signalText,
+                    devId: deviceId,
+                });
+            }
+            break;
+        }
+    }
+};
+const globalHandleBleChange = ({ deviceId, status }) => {
+    const rt = getRuntimeByDevId(deviceId);
+    sdkLog("debug", "platform", "bleChange", {
+        devId: deviceId,
+        data: { status, registered: !!rt },
+    });
+    if (!rt || status !== "CONNECTED") {
+        return;
+    }
+};
+const globalHandleAppShow = () => {
+    for (const rt of listRegisteredRuntimes()) {
+        void getCurrentUserForRuntime(rt, true);
+        void fetchDeviceProperties(rt);
+        void checkOfflineDpUpdateForRuntime(rt, {}, true);
+        setTimeout(() => {
+            void syncDeleteUsersWithRuntime(rt);
+        }, 1000);
+    }
+};
+const globalHandleAppHide = () => { };
+const globalHandleResetMemberName = ({ memberId }) => {
+};
+const globalHandleResetMemberRole = ({ memberId }) => {
+};
+export const addEvents = (runtime) => {
+    if (!globalPlatformListenersInstalled) {
+        globalPlatformListenersInstalled = true;
+        onMqttMessage(globalHandleMqttMessage);
+        onDpDataChange(globalHandleDeviceDpsChange);
+        onDeviceInfoUpdated(globalHandleDeviceInfoChange);
+        onOnlineChange(globalUpdateAllOnlineTypes);
+        onBleChange(globalHandleBleChange);
+        onAppShow(globalHandleAppShow);
+        onAppHide(globalHandleAppHide);
+        onResetMemberName(globalHandleResetMemberName);
+        onResetMemberRole(globalHandleResetMemberRole);
+    }
+    if (runtime.infra.eventsRegistered) {
+        return;
+    }
+    runtime.infra.eventsRegistered = true;
+    subscribedDevIds.add(runtime.devId);
+    registerDevice([...subscribedDevIds]);
+    registerBleStatus(runtime.devId);
+    registerMQTTDeviceListener(runtime.devId);
+    if (!mqttProtocolListenerRegistered) {
+        registerMQTTProtocolListener(23);
+        mqttProtocolListenerRegistered = true;
+    }
+};
+export const removeEvents = () => {
+    if (!globalPlatformListenersInstalled) {
+        return;
+    }
+    globalPlatformListenersInstalled = false;
+    mqttProtocolListenerRegistered = false;
+    offDpDataChange(globalHandleDeviceDpsChange);
+    offDeviceInfoUpdated(globalHandleDeviceInfoChange);
+    offOnlineChange(globalUpdateAllOnlineTypes);
+    offBleChange(globalHandleBleChange);
+    offMqttMessage(globalHandleMqttMessage);
+    offResetMemberName(globalHandleResetMemberName);
+    offResetMemberRole(globalHandleResetMemberRole);
+    subscribedDevIds.clear();
+    for (const rt of listRegisteredRuntimes()) {
+        rt.infra.eventsRegistered = false;
+    }
+};

package/lib/feature/state/remote-permissions.d.ts

@@ -0,0 +1,4 @@
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+import { RemotePermissionType } from "../../constant";
+export declare const permissions: RemotePermissionType[];
+export declare function fetchDeviceProperties(runtime: LockDeviceRuntime, isForce?: boolean): Promise<void>;

package/lib/feature/state/remote-permissions.js

@@ -0,0 +1,30 @@
+import { getDeviceProperties } from "../../api/setting";
+import { getDataWithPreFetchForRuntime } from "../utils";
+import { RemotePermissionType } from "../../constant";
+export const permissions = [
+    RemotePermissionType.ADMINS_ONLY,
+    RemotePermissionType.EVERY_ONE,
+    RemotePermissionType.NO_ONE,
+];
+var DeviceProperties;
+(function (DeviceProperties) {
+    DeviceProperties["REMOTE_UNLOCK_AUTH"] = "REMOTE_UNLOCK_AUTH";
+    DeviceProperties["UNLOCK_PHONE_REMOTE"] = "UNLOCK_PHONE_REMOTE";
+})(DeviceProperties || (DeviceProperties = {}));
+const propsList = [
+    DeviceProperties.REMOTE_UNLOCK_AUTH,
+    DeviceProperties.UNLOCK_PHONE_REMOTE,
+];
+export async function fetchDeviceProperties(runtime, isForce) {
+    let result = null;
+    if (isForce) {
+        result = await getDeviceProperties(runtime.config.devInfo.devId, propsList);
+    }
+    else {
+        result = await getDataWithPreFetchForRuntime(runtime, "getDeviceProperties", () => getDeviceProperties(runtime.config.devInfo.devId, propsList));
+    }
+    runtime.config.remoteOpenEnabled =
+        result[DeviceProperties.UNLOCK_PHONE_REMOTE] === "true";
+    runtime.config.remoteOpenPermission =
+        permissions[+result[DeviceProperties.REMOTE_UNLOCK_AUTH] || 0];
+}

package/lib/feature/state/sync/offline-dps.d.ts

@@ -0,0 +1,2 @@
+import type { LockDeviceRuntime } from "../../../runtime/LockDeviceRuntime";
+export declare const syncOfflineDps: (runtime: LockDeviceRuntime) => Promise<void>;

package/lib/feature/state/sync/offline-dps.js

@@ -0,0 +1,71 @@
+import { getOfflineDpsForRuntime } from "../../offline-dps";
+import { isUseNearChannelForRuntime } from "../../misc/is-use-near-channel-for-runtime";
+import { publishDpsOnlyWithRuntime } from "../../dp/publish-dps";
+import { clearOfflineDpData } from "../../../api";
+import { sdkLog } from "../../../utils/sdk-log";
+export const syncOfflineDps = async (runtime) => {
+    const rt = runtime;
+    if (!rt.config.supportOfflineDps) {
+        sdkLog("debug", "syncOfflineDps", "skipped", {
+            devId: rt.devId,
+            data: { reason: "disabled" },
+        });
+        return;
+    }
+    const useNear = isUseNearChannelForRuntime(rt);
+    if (!useNear) {
+        sdkLog("debug", "syncOfflineDps", "skipped", {
+            devId: rt.devId,
+            data: { reason: "notNearChannel" },
+        });
+        return;
+    }
+    const startedAt = Date.now();
+    sdkLog("info", "syncOfflineDps", "start", { devId: rt.devId });
+    const offlineDps = await getOfflineDpsForRuntime(rt);
+    try {
+        const codes = Object.keys(offlineDps);
+        if (codes.length) {
+            const hasTask = codes.some((code) => offlineDps[code].pushStatus === false);
+            sdkLog("debug", "syncOfflineDps", "cacheLoaded", {
+                devId: rt.devId,
+                data: { count: codes.length, hasTask },
+            });
+            if (hasTask) {
+                await clearOfflineDpData(rt.config.devInfo.devId);
+                const dpData = codes.reduce((acc, code) => {
+                    acc[code] = offlineDps[code].value;
+                    return acc;
+                }, {});
+                await publishDpsOnlyWithRuntime(rt, dpData);
+                sdkLog("info", "syncOfflineDps", "success", {
+                    devId: rt.devId,
+                    duration: Date.now() - startedAt,
+                    data: { count: codes.length },
+                });
+            }
+            else {
+                sdkLog("debug", "syncOfflineDps", "skipped", {
+                    devId: rt.devId,
+                    duration: Date.now() - startedAt,
+                    data: { reason: "noPendingTask", count: codes.length },
+                });
+            }
+        }
+        else {
+            sdkLog("debug", "syncOfflineDps", "skipped", {
+                devId: rt.devId,
+                duration: Date.now() - startedAt,
+                data: { reason: "emptyCache" },
+            });
+        }
+    }
+    catch (error) {
+        console.warn(error);
+        sdkLog("warn", "syncOfflineDps", "fail", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            error,
+        });
+    }
+};

package/lib/feature/state/sync/remote-serect-key.d.ts

@@ -0,0 +1,3 @@
+import type { LockDeviceRuntime } from "../../../runtime/LockDeviceRuntime";
+declare const syncRemoteSerectKey: (runtime: LockDeviceRuntime, force?: boolean) => Promise<void>;
+export default syncRemoteSerectKey;