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

package/lib/feature/media/media.js

@@ -4,6 +4,7 @@ import dpCodes from "../../config/dp-code";
 import { RotateType, VedioType } from "../../constant";
 import { isSupportShortLink } from "../../platform";
 import { getError } from "../../utils/errors";
+import { getMediaViewTimes, setMediaViewTimes, getAlbumDateList, } from "../../api/video";
 export const getMediaUrlForRuntime = async (runtime, params) => {
     const devId = runtime.config.devInfo.devId;
     if ("mediaPath" in params && "mediaBucket" in params) {
@@ -52,6 +53,27 @@ export const openLocalAlbumForRuntime = async (runtime, params) => {
     }
     return Promise.reject(getError(1013));
 };
+export const gotoPlaybackForRuntime = async (runtime, params) => {
+    const link = await isSupportShortLink("camera_playbacks_panel");
+    if (!link) {
+        return Promise.reject(getError(1013));
+    }
+    const tabs = params?.tabs && params.tabs.length ? params.tabs : ["local"];
+    let url = `tuyaSmart://${link}?extra_camera_uuid=${runtime.devId}&devId=${runtime.devId}&bizType=doorLock&defaultShowTabs=true&theme=1&tabs=${JSON.stringify(tabs)}`;
+    if (params?.isLowPower) {
+        url += `&isLowPowerDevice=true`;
+    }
+    if (params?.rotate !== undefined) {
+        url += `&rotate=${params.rotate}`;
+    }
+    return new Promise((resolve, reject) => {
+        ty.router({
+            url,
+            success: () => resolve(),
+            fail: (e) => reject(e),
+        });
+    });
+};
 export const getMediaInfoForRuntime = (runtime) => {
     const isSEI = runtime.config.capabilities?.rotateType === RotateType.SEI;
     return {
@@ -64,3 +86,12 @@ export const getMediaInfoForRuntime = (runtime) => {
         isTwoWayTalk: runtime.config.isTwoWayTalk,
     };
 };
+export const getMediaViewTimesForRuntime = (runtime) => {
+    return getMediaViewTimes(runtime.config.devInfo.devId);
+};
+export const setMediaViewTimesForRuntime = (runtime) => {
+    return setMediaViewTimes(runtime.config.devInfo.devId);
+};
+export const getAlbumDateListForRuntime = (runtime) => {
+    return getAlbumDateList(runtime.config.devInfo.devId);
+};

package/lib/feature/misc/capability.js

@@ -34,23 +34,52 @@ export const isActiveThreadForRuntime = async (rt) => {
     }
     return false;
 };
+const allModes = [
+    {
+        mode: "VR",
+        value: 1,
+    },
+    {
+        mode: "original",
+        value: 0,
+    },
+    {
+        mode: "vertical",
+        value: 3,
+    },
+    {
+        mode: "horizontal",
+        value: 2,
+    },
+];
 export const getDeviceAdvancedAbilitiesForRuntime = async (rt) => {
     if (rt.cache.deviceAdvanceAbilityCache) {
         return rt.cache.deviceAdvanceAbilityCache;
     }
-    const [productAbilities, deviceAdvancedAbility] = await Promise.all([
+    const [productAbilitiesRes, deviceAdvancedAbilityRes] = await Promise.allSettled([
         getProductAbilities(rt.config.devInfo.devId, [
             "tyabi4ucx5",
             "tyabis9tpe",
             "tyabiwxrn9",
             "tyabipd4hh",
             "tyabin4u5v",
+            "visual_door_lock_cloud_store",
         ]),
         getDeviceAdvancedAbility(rt.config.devInfo.devId),
     ]);
+    const productAbilities = productAbilitiesRes.status === "fulfilled" ? productAbilitiesRes.value : [];
+    const deviceAdvancedAbility = deviceAdvancedAbilityRes.status === "fulfilled"
+        ? deviceAdvancedAbilityRes.value
+        : undefined;
     const deviceAdvanceAbilityCache = {
         cloudStorage: {
-            support: deviceAdvancedAbility.types.includes(0),
+            support: deviceAdvancedAbility?.types?.includes(0) ?? false,
+        },
+        vr: {
+            support: false,
+            defaultMode: "VR",
+            modes: [],
+            coverMode: "VR",
         },
         ai: {
             support: false,
@@ -61,12 +90,12 @@ export const getDeviceAdvancedAbilitiesForRuntime = async (rt) => {
             config: {},
         },
         voip: {
-            support: deviceAdvancedAbility.types.includes(1),
+            support: false,
             config: {},
         },
         wechatVoip: {
             support: false,
-            config: {},
+            isPublice: true,
         },
         unlockGuide: {
             support: false,
@@ -80,8 +109,11 @@ export const getDeviceAdvancedAbilitiesForRuntime = async (rt) => {
     productAbilities.forEach((item) => {
         try {
             if (item.isOpen) {
-                const data = JSON.parse(item.extConfig);
+                const data = item.extConfig ? JSON.parse(item.extConfig) : {};
                 switch (item.abilityCode) {
+                    case "visual_door_lock_cloud_store":
+                        deviceAdvanceAbilityCache.cloudStorage.support = true;
+                        break;
                     case "tyabi4ucx5": {
                         deviceAdvanceAbilityCache.ai.config = data;
                         const dataReport = data?.ai_data_report ?? false;
@@ -95,6 +127,37 @@ export const getDeviceAdvancedAbilitiesForRuntime = async (rt) => {
                                 petRecognition ||
                                 voice ||
                                 message;
+                        deviceAdvanceAbilityCache.vr.support = !!data?.lock_VR;
+                        if (deviceAdvanceAbilityCache.vr.support) {
+                            const modeMap = {
+                                original: {
+                                    mode: "original",
+                                    value: 0,
+                                },
+                                VR: {
+                                    mode: "VR",
+                                    value: 1,
+                                },
+                                horizontal: {
+                                    mode: "horizontal",
+                                    value: 2,
+                                },
+                                vertical: {
+                                    mode: "vertical",
+                                    value: 3,
+                                },
+                            };
+                            deviceAdvanceAbilityCache.vr.modes = allModes.filter((item) => {
+                                return data?.modes?.includes(item.mode);
+                            });
+                            deviceAdvanceAbilityCache.vr.defaultMode = data.default_mode;
+                            const exist = deviceAdvanceAbilityCache.vr.modes.find((x) => x.mode === deviceAdvanceAbilityCache.vr.defaultMode);
+                            if (!exist) {
+                                deviceAdvanceAbilityCache.vr.defaultMode =
+                                    deviceAdvanceAbilityCache.vr.modes?.[0].mode;
+                            }
+                            deviceAdvanceAbilityCache.vr.coverMode = data.photo_cover_format;
+                        }
                         break;
                     }
                     case "tyabis9tpe": {
@@ -104,8 +167,16 @@ export const getDeviceAdvancedAbilitiesForRuntime = async (rt) => {
                     }
                     case "tyabiwxrn9": {
                         deviceAdvanceAbilityCache.wechatVoip.support =
+                            deviceAdvancedAbility?.types?.includes(1) ?? false;
+                        deviceAdvanceAbilityCache.wechatVoip.isPublice =
+                            data?.WechatType === "0";
+                        if (!deviceAdvanceAbilityCache.wechatVoip.isPublice) {
+                            deviceAdvanceAbilityCache.wechatVoip.appId =
+                                data["WechatMPAppid"];
+                            deviceAdvanceAbilityCache.wechatVoip.modeId = data["WechatMPMid"];
+                        }
+                        deviceAdvanceAbilityCache.voip.support =
                             !!data?.voipType?.includes("0");
-                        deviceAdvanceAbilityCache.wechatVoip.config = data;
                         break;
                     }
                     case "tyabipd4hh": {

package/lib/feature/notify/notify.d.ts

@@ -0,0 +1,4 @@
+import { type UpdateVasNotifyConfigParams } from "../../api/notify";
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export declare const getVasNotifyConfigForRuntime: (rt: LockDeviceRuntime) => Promise<import("../../api/notify").VasNotifyConfig>;
+export declare const updateVasNotifyConfigForRuntime: (rt: LockDeviceRuntime, params: UpdateVasNotifyConfigParams) => Promise<import("../../api/notify").VasNotifyConfig>;

package/lib/feature/notify/notify.js

@@ -0,0 +1,3 @@
+import { getVasNotifyConfigApi, updateVasNotifyConfigApi, } from "../../api/notify";
+export const getVasNotifyConfigForRuntime = (rt) => getVasNotifyConfigApi(rt.config.devInfo.devId);
+export const updateVasNotifyConfigForRuntime = (rt, params) => updateVasNotifyConfigApi(rt.config.devInfo.devId, params);

package/lib/feature/password/temporary/custom-dp.js

@@ -52,67 +52,72 @@ export const createTempCustomForRuntime = parallelOnlyForRuntime(async function
             throw handleCloudError(error);
         }
     }
-    await isValidPassword(baseData);
-    const { tyNum, name: createdName } = await createTemporaryPassword({
-        ...baseData,
-        sn: 0,
-        availTime: 0,
-        symbolic: false,
-        dpTunnel: 2,
-    });
-    if (!tyNum) {
-        const error = getError(1043);
-        sdkLog("warn", "tempPassword", "createCustomMissingCloudNo", {
+    try {
+        await isValidPassword(baseData);
+        const { tyNum, name: createdName } = await createTemporaryPassword({
+            ...baseData,
+            sn: 0,
+            availTime: 0,
+            symbolic: false,
+            dpTunnel: 2,
+        });
+        if (!tyNum) {
+            const error = getError(1043);
+            sdkLog("warn", "tempPassword", "createCustomMissingCloudNo", {
+                devId: rt.devId,
+                duration: Date.now() - startedAt,
+                error,
+            });
+            throw error;
+        }
+        const targetDpCode = cfg.supportBigData
+            ? dpCodes.tempPwdCreateW
+            : dpCodes.tempPwdCreate;
+        const dpPayload = dpUtils.format({
+            cloudNo: tyNum,
+            valid: true,
+            validConfig,
+            validNum: 0,
+            pwdLength: params.password.length,
+            pwd: params.password.split("").map(Number),
+        }, (cfg.supportBigData ? addTempPwdBigDpMap : addTempPwdDpMap));
+        const result = await publishDpsForRuntime(rt, {
+            [targetDpCode]: dpPayload,
+        }, {
+            checkReport: (dpsIn) => {
+                const dpDataRow = dpsIn;
+                const reportData = dpDataRow[targetDpCode];
+                if (reportData) {
+                    const data = dpUtils.parse(dpDataRow[targetDpCode], (cfg.supportBigData
+                        ? reportAddTempPwdDBigpMap
+                        : reportAddTempPwdDpMap));
+                    if (data.cloudNo === tyNum) {
+                        return data;
+                    }
+                }
+                return false;
+            },
+        });
+        if (result.status === 0) {
+            sdkLog("info", "tempPassword", "createCustomSuccess", {
+                devId: rt.devId,
+                duration: Date.now() - startedAt,
+                data: { route: "nearDp" },
+            });
+            return buildTempCustomCreateResult(createdName, params.password, result.unlockBindingId, effective);
+        }
+        const error = getError(result.status === 2 ? 1041 : 1042);
+        sdkLog("warn", "tempPassword", "createCustomDpFail", {
             devId: rt.devId,
             duration: Date.now() - startedAt,
+            data: { status: result.status },
             error,
         });
         throw error;
     }
-    const targetDpCode = cfg.supportBigData
-        ? dpCodes.tempPwdCreateW
-        : dpCodes.tempPwdCreate;
-    const dpPayload = dpUtils.format({
-        cloudNo: tyNum,
-        valid: true,
-        validConfig,
-        validNum: 0,
-        pwdLength: params.password.length,
-        pwd: params.password.split("").map(Number),
-    }, (cfg.supportBigData ? addTempPwdBigDpMap : addTempPwdDpMap));
-    const result = await publishDpsForRuntime(rt, {
-        [targetDpCode]: dpPayload,
-    }, {
-        checkReport: (dpsIn) => {
-            const dpDataRow = dpsIn;
-            const reportData = dpDataRow[targetDpCode];
-            if (reportData) {
-                const data = dpUtils.parse(dpDataRow[targetDpCode], (cfg.supportBigData
-                    ? reportAddTempPwdDBigpMap
-                    : reportAddTempPwdDpMap));
-                if (data.cloudNo === tyNum) {
-                    return data;
-                }
-            }
-            return false;
-        },
-    });
-    if (result.status === 0) {
-        sdkLog("info", "tempPassword", "createCustomSuccess", {
-            devId: rt.devId,
-            duration: Date.now() - startedAt,
-            data: { route: "nearDp" },
-        });
-        return buildTempCustomCreateResult(createdName, params.password, result.unlockBindingId, effective);
+    catch (er) {
+        throw handleCloudError(er);
     }
-    const error = getError(result.status === 2 ? 1041 : 1042);
-    sdkLog("warn", "tempPassword", "createCustomDpFail", {
-        devId: rt.devId,
-        duration: Date.now() - startedAt,
-        data: { status: result.status },
-        error,
-    });
-    throw error;
 });
 export async function removeTempCustomForRuntime(rt, params) {
     const cfg = rt.config;

package/lib/feature/screen/bind-watch.d.ts

@@ -0,0 +1,18 @@
+import { type BindingResult } from "../../api/screen";
+import type { ErrorData } from "../../interface";
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export interface BindLockToScreenEvent {
+    lockDevId: string;
+    success: boolean;
+    data?: BindingResult;
+    error?: ErrorData;
+}
+export type BindLockToScreenListener = (event: BindLockToScreenEvent) => void;
+export declare function emitBindResult(runtime: LockDeviceRuntime, event: BindLockToScreenEvent): void;
+export declare function onBindLockToScreenForRuntime(runtime: LockDeviceRuntime, listener: BindLockToScreenListener): void;
+export declare function offBindLockToScreenForRuntime(runtime: LockDeviceRuntime, listener: BindLockToScreenListener): void;
+export declare function watchBindResult(runtime: LockDeviceRuntime, params: {
+    lockDevId: string;
+    sessionId: string;
+}): Promise<void>;
+export declare function isWatchingBind(runtime: LockDeviceRuntime, sessionId: string): boolean;

package/lib/feature/screen/bind-watch.js

@@ -0,0 +1,92 @@
+import { getBindingResultApi } from "../../api/screen";
+import emitter from "../../utils/event";
+import { getError } from "../../utils/errors";
+import { sdkLog } from "../../utils/sdk-log";
+import { handleScreenCloudError } from "./error";
+const POLL_INTERVAL_MS = 2_000;
+const BIND_POLL_TIMEOUT_MS = 30_000;
+const delay = (ms) => new Promise((resolve) => {
+    setTimeout(resolve, ms);
+});
+function bindResultEventName(runtime) {
+    return `screen_bind_result_${runtime.devId}`;
+}
+export function emitBindResult(runtime, event) {
+    emitter.emit(bindResultEventName(runtime), event);
+}
+const watchKey = (runtime, sessionId) => `${runtime.devId}:${sessionId}`;
+const inflight = new Map();
+export function onBindLockToScreenForRuntime(runtime, listener) {
+    emitter.on(bindResultEventName(runtime), listener);
+}
+export function offBindLockToScreenForRuntime(runtime, listener) {
+    emitter.off(bindResultEventName(runtime), listener);
+}
+async function pollBindResult(runtime, lockDevId, sessionId) {
+    const accessoryDevId = runtime.devId;
+    const startedAt = Date.now();
+    const deadline = startedAt + BIND_POLL_TIMEOUT_MS;
+    while (Date.now() < deadline) {
+        await delay(POLL_INTERVAL_MS);
+        let result;
+        try {
+            result = await getBindingResultApi({ accessoryDevId, sessionId });
+        }
+        catch (e) {
+            const error = handleScreenCloudError(e);
+            sdkLog("error", "screen", "bindResultPollError", {
+                devId: accessoryDevId,
+                duration: Date.now() - startedAt,
+                data: { lockDevId },
+                error: e,
+            });
+            emitBindResult(runtime, { lockDevId, success: false, error });
+            return;
+        }
+        if (result.status === "binding") {
+            continue;
+        }
+        if (result.status === "bound") {
+            sdkLog("info", "screen", "bindResultSettled", {
+                devId: accessoryDevId,
+                duration: Date.now() - startedAt,
+                data: { lockDevId, status: result.status, lanStatus: result.lanStatus },
+            });
+            emitBindResult(runtime, { lockDevId, success: true, data: result });
+            return;
+        }
+        sdkLog("info", "screen", "bindResultSettled", {
+            devId: accessoryDevId,
+            duration: Date.now() - startedAt,
+            data: { lockDevId, status: result.status, lanStatus: result.lanStatus },
+        });
+        emitBindResult(runtime, {
+            lockDevId,
+            success: false,
+            data: result,
+            error: getError(1103),
+        });
+        return;
+    }
+    sdkLog("warn", "screen", "bindResultTimeout", {
+        devId: accessoryDevId,
+        duration: Date.now() - startedAt,
+        data: { lockDevId },
+    });
+    emitBindResult(runtime, { lockDevId, success: false, error: getError(1002) });
+}
+export function watchBindResult(runtime, params) {
+    const key = watchKey(runtime, params.sessionId);
+    const existing = inflight.get(key);
+    if (existing) {
+        return existing;
+    }
+    const task = pollBindResult(runtime, params.lockDevId, params.sessionId).finally(() => {
+        inflight.delete(key);
+    });
+    inflight.set(key, task);
+    return task;
+}
+export function isWatchingBind(runtime, sessionId) {
+    return inflight.has(watchKey(runtime, sessionId));
+}

package/lib/feature/screen/bind.d.ts

@@ -1,4 +1,4 @@
-import { type BindingResult, type UnbindingResult } from "../../api/screen";
+import { type AddBindingResult, type UnbindingResult } from "../../api/screen";
 import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
-export declare function bindLockForRuntime(runtime: LockDeviceRuntime, lockDevId: string): Promise<BindingResult>;
+export declare function bindLockForRuntime(runtime: LockDeviceRuntime, lockDevId: string): Promise<AddBindingResult>;
 export declare function unbindLockForRuntime(runtime: LockDeviceRuntime, relationId: string): Promise<UnbindingResult>;

package/lib/feature/screen/bind.js

@@ -1,11 +1,11 @@
-import { addBindingApi, deleteBindingApi, getBindingResultApi, getUnbindingResultApi, } from "../../api/screen";
+import { addBindingApi, deleteBindingApi, getUnbindingResultApi, } from "../../api/screen";
 import { getDeviceInfo } from "../../platform/device";
 import { getError } from "../../utils/errors";
 import { sdkLog } from "../../utils/sdk-log";
 import { getDeviceStatusForRuntime } from "../state/device-status";
 import { handleScreenCloudError } from "./error";
+import { watchBindResult } from "./bind-watch";
 const POLL_INTERVAL_MS = 2_000;
-const BIND_POLL_TIMEOUT_MS = 25_000;
 const UNBIND_POLL_TIMEOUT_MS = 20_000;
 const delay = (ms) => new Promise((resolve) => {
     setTimeout(resolve, ms);
@@ -42,48 +42,18 @@ export async function bindLockForRuntime(runtime, lockDevId) {
             });
             sdkLog("info", "screen", "bindAddSuccess", {
                 devId: accessoryDevId,
+                duration: Date.now() - startedAt,
                 data: { lockDevId, relationId: sessionData.relationId },
             });
         }
         catch (e) {
             throw handleScreenCloudError(e);
         }
-        const deadline = Date.now() + BIND_POLL_TIMEOUT_MS;
-        let last;
-        while (Date.now() < deadline) {
-            await delay(POLL_INTERVAL_MS);
-            try {
-                last = await getBindingResultApi({
-                    accessoryDevId,
-                    sessionId: sessionData.sessionId,
-                });
-            }
-            catch (e) {
-                throw handleScreenCloudError(e);
-            }
-            if (last.status !== "binding") {
-                sdkLog("info", "screen", "bindSettled", {
-                    devId: accessoryDevId,
-                    duration: Date.now() - startedAt,
-                    data: {
-                        lockDevId,
-                        relationId: sessionData.relationId,
-                        status: last.status,
-                        lanStatus: last.lanStatus,
-                    },
-                });
-                if (last.status === "failed") {
-                    throw getError(1103);
-                }
-                return last;
-            }
-        }
-        sdkLog("warn", "screen", "bindTimeout", {
-            devId: accessoryDevId,
-            duration: Date.now() - startedAt,
-            data: { lockDevId, relationId: sessionData.relationId },
-        });
-        throw getError(1002);
+        void watchBindResult(runtime, {
+            lockDevId,
+            sessionId: sessionData.sessionId,
+        }).catch(() => { });
+        return sessionData;
     }
     catch (error) {
         sdkLog("error", "screen", "bindFail", {

package/lib/feature/screen/list.js

@@ -1,6 +1,7 @@
 import { getBoundLockListApi, getBindableLockListApi, } from "../../api/screen";
 import { getDeviceInfo } from "../../platform/device";
 import { sdkLog } from "../../utils/sdk-log";
+import { isWatchingBind, watchBindResult } from "./bind-watch";
 async function resolveLockDeviceInfo(accessoryDevId, lockDevId) {
     try {
         const info = await getDeviceInfo(lockDevId);
@@ -52,5 +53,17 @@ export async function getBindableLockListForRuntime(runtime) {
         duration: Date.now() - startedAt,
         data: { count: items.length, canBindMore: result?.canBindMore },
     });
+    for (const item of items) {
+        if (item.bindStatus !== "binding" || !item.sessionId) {
+            continue;
+        }
+        if (isWatchingBind(runtime, item.sessionId)) {
+            continue;
+        }
+        void watchBindResult(runtime, {
+            lockDevId: item.lockDevId,
+            sessionId: item.sessionId,
+        }).catch(() => { });
+    }
     return { ...result, items };
 }

package/lib/feature/service/goto-service.d.ts

@@ -1,5 +1,6 @@
 import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
 export interface GotoServiceParams {
-    tab?: "cloudStorage" | "AI";
+    tab?: "cloudStorage" | "AI" | "voip";
+    showGift?: boolean;
 }
 export declare function gotoServiceForRuntime(rt: LockDeviceRuntime, params?: GotoServiceParams): Promise<unknown>;

package/lib/feature/service/goto-service.js

@@ -4,8 +4,14 @@ export function gotoServiceForRuntime(rt, params) {
     if (params?.tab === "AI") {
         type = 3;
     }
+    else if (params?.tab === "voip") {
+        type = 1;
+    }
     return new Promise((resolve, reject) => {
-        const url = `godzilla://tyawqoyej4wi3pqebb?deviceId=${rt.config.devInfo.devId}&commodityType=${type}`;
+        let url = `godzilla://tyawqoyej4wi3pqebb?deviceId=${rt.config.devInfo.devId}&commodityType=${type}`;
+        if (params?.showGift) {
+            url += `&showGift=true`;
+        }
         navigateToMiniProgram({
             position: "bottom",
             shortLink: url,

package/lib/feature/service/value-added.d.ts

@@ -0,0 +1,4 @@
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export declare const getCloudServiceStatusForRuntime: (rt: LockDeviceRuntime) => Promise<import("../../api/service").CloudServiceStatus>;
+export declare const getServicePopupListForRuntime: (rt: LockDeviceRuntime) => Promise<import("../../api/service").ServiceBenefitPopupItem[]>;
+export declare const claimServiceForRuntime: (rt: LockDeviceRuntime, batchId: string) => Promise<import("../../api/service").ClaimResultItem[]>;

package/lib/feature/service/value-added.js

@@ -0,0 +1,4 @@
+import { getCloudServiceStatusApi, getServicePopupListApi, claimServiceApi, } from "../../api/service";
+export const getCloudServiceStatusForRuntime = (rt) => getCloudServiceStatusApi(rt.config.devInfo.devId);
+export const getServicePopupListForRuntime = (rt) => getServicePopupListApi(rt.config.devInfo.devId);
+export const claimServiceForRuntime = (rt, batchId) => claimServiceApi(rt.config.devInfo.devId, batchId);

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

@@ -16,6 +16,7 @@ import { fetchDeviceProperties } from "./remote-permissions";
 import { ipc, yuChannelSyncSingleSync } from "../../platform";
 import { sdkLog } from "../../utils/sdk-log";
 import { RotateType } from "../../constant";
+import { isHarmony } from "../../utils";
 export const initState = async (runtime) => {
     const { devInfo: { dps, devId, yuNetState }, dpSchema, } = runtime.config;
     const startedAt = Date.now();
@@ -38,9 +39,10 @@ export const initState = async (runtime) => {
                 isSupportVideo,
             },
         });
-        const [, , rotateInfo, deviceSkill, ipcConfig] = await Promise.allSettled([
+        const [, , , rotateInfo, deviceSkill, ipcConfig] = await Promise.allSettled([
             updateOnlineType(runtime),
             getCurrentUserForRuntime(runtime),
+            fetchDeviceProperties(runtime),
             isSupportVideo
                 ? getDataWithPreFetchForRuntime(runtime, "getRotate", () => getRotateInfo(devId))
                 : Promise.resolve({
@@ -76,24 +78,31 @@ export const initState = async (runtime) => {
             }
             if (ipcConfig.status === "fulfilled" &&
                 ipcConfig.value?.audioAttributes?.hardwareCapability?.includes(2)) {
-                try {
-                    const modeRes = await ipc.getCurrentSupportedTalkMode(devId);
+                if (isHarmony()) {
                     runtime.config.supportTalk = true;
-                    runtime.config.isTwoWayTalk = modeRes.talkbackMode === 2;
-                    sdkLog("info", "initState", "supportTalk", {
-                        devId,
-                        duration: Date.now() - startedAt,
-                        data: {
-                            mode: modeRes.talkbackMode,
-                        },
-                    });
+                    runtime.config.isTwoWayTalk =
+                        ipcConfig.value?.audioAttributes?.callMode?.includes(2);
                 }
-                catch (e) {
-                    sdkLog("error", "initState", "supportTalk", {
-                        devId,
-                        duration: Date.now() - startedAt,
-                        data: {},
-                    });
+                else {
+                    try {
+                        runtime.config.supportTalk = true;
+                        const modeRes = await ipc.getCurrentSupportedTalkMode(devId);
+                        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,
+                            error: e,
+                        });
+                    }
                 }
             }
             if (!isSEI &&
@@ -103,7 +112,6 @@ export const initState = async (runtime) => {
                 runtime.config.mediaHeight = temp;
             }
         }
-        await fetchDeviceProperties(runtime);
         sdkLog("info", "initState", "ready", {
             devId,
             duration: Date.now() - startedAt,