@ray-js/ipc-player-integration 0.0.53-beta.1 → 0.0.53-beta.11

package/lib/ctx/ctx.autoClarity.test.d.ts

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

package/lib/ctx/ctx.autoClarity.test.js

@@ -0,0 +1,150 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import { act, renderHook } from '@testing-library/react-hooks';
+import { ClarityType } from '@ray-js/ray-ipc-utils/lib/interface';
+import { createUseCtx } from './ctx';
+import { useStore } from './store';
+import { PlayState } from '../interface';
+import { getCachedAutoClarity, setCachedAutoClarity, subscribeClarityChanged } from '../utils/ttt';
+jest.mock('@ray-js/ray', () => ({}));
+jest.mock('@ray-js/ray-ipc-utils/lib/interface', () => ({
+  ClarityType: {
+    SS: 'SS',
+    SD: 'SD',
+    HD: 'HD',
+    UD: 'UD',
+    SSP: 'SSP',
+    AUTO: 'AUTO',
+    AUDIO: 'AUDIO'
+  },
+  IntercomMode: {
+    OneWay: 'OneWay',
+    TwoWay: 'TwoWay'
+  }
+}));
+jest.mock('../i18n', () => ({
+  __esModule: true,
+  default: {
+    getLang: key => key
+  }
+}));
+jest.mock('./multiCameraCtx', () => ({
+  isMultiCameraTileSupported: () => false,
+  useMultiCameraCtx: () => ({})
+}));
+jest.mock('../utils/ttt', () => ({
+  getCachedAutoClarity: jest.fn(),
+  isClarityChangedSupported: () => true,
+  setCachedAutoClarity: jest.fn(),
+  subscribeClarityChanged: jest.fn(() => () => undefined)
+}));
+const cameraState = resolution => ({
+  resolution,
+  resolutionList: [ClarityType.HD, ClarityType.SD],
+  mute: true,
+  intercomMode: 'TwoWay',
+  isIntercomSupported: false,
+  maxZoomSettings: 6
+});
+describe('cached auto clarity restoration', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+  const mountContext = resolution => {
+    const setClarity = jest.fn();
+    const getMemoryState = jest.fn().mockResolvedValue(cameraState(resolution));
+    const useCtx = createUseCtx({
+      createPlayContext: () => ({
+        setClarity
+      }),
+      getMemoryState,
+      setResolutionMemoryState: jest.fn(),
+      setMuteMemoryState: jest.fn(),
+      authorizeStatus: jest.fn(),
+      toast: jest.fn()
+    });
+    const hook = renderHook(() => {
+      const ctx = useCtx({
+        devId: 'camera-1'
+      });
+      const state = useStore({
+        resolution: ctx.resolution,
+        autoClarity: ctx.autoClarity
+      });
+      return _objectSpread(_objectSpread({}, ctx), {}, {
+        state
+      });
+    });
+    return _objectSpread(_objectSpread({}, hook), {}, {
+      setClarity
+    });
+  };
+  it('shows last listener value on reopening AUTO and refreshes it after preview', async () => {
+    getCachedAutoClarity.mockReturnValue(ClarityType.HD);
+    const {
+      result,
+      setClarity,
+      unmount
+    } = mountContext(ClarityType.AUTO);
+    await act(async () => Promise.resolve());
+    expect(result.current.state).toEqual({
+      resolution: ClarityType.AUTO,
+      autoClarity: ClarityType.HD
+    });
+    act(() => result.current.setPlayState(PlayState.PLAYING));
+    await act(async () => Promise.resolve());
+    expect(setClarity).toHaveBeenCalledTimes(1);
+    expect(setClarity).toHaveBeenCalledWith(expect.objectContaining({
+      clarity: 'auto'
+    }));
+    const onReport = subscribeClarityChanged.mock.calls[0][1];
+    act(() => onReport({
+      deviceId: 'camera-1',
+      clarity: ClarityType.SD
+    }));
+    expect(result.current.state.autoClarity).toBe(ClarityType.SD);
+    expect(setCachedAutoClarity).toHaveBeenCalledWith('camera-1', ClarityType.SD);
+    unmount();
+  });
+  it('does not restore cached actual clarity in manual mode', async () => {
+    getCachedAutoClarity.mockReturnValue(ClarityType.HD);
+    const {
+      result,
+      unmount
+    } = mountContext(ClarityType.SD);
+    await act(async () => Promise.resolve());
+    expect(result.current.state).toEqual({
+      resolution: ClarityType.SD,
+      autoClarity: null
+    });
+    expect(getCachedAutoClarity).not.toHaveBeenCalled();
+    const onReport = subscribeClarityChanged.mock.calls[0][1];
+    act(() => onReport({
+      deviceId: 'camera-1',
+      clarity: ClarityType.HD
+    }));
+    expect(result.current.state.autoClarity).toBeNull();
+    expect(setCachedAutoClarity).not.toHaveBeenCalled();
+    unmount();
+  });
+  it('requests a fresh report when reopening AUTO without an actual clarity cache', async () => {
+    getCachedAutoClarity.mockReturnValue(null);
+    const {
+      result,
+      setClarity,
+      unmount
+    } = mountContext(ClarityType.AUTO);
+    await act(async () => Promise.resolve());
+    expect(result.current.state.autoClarity).toBeNull();
+    act(() => result.current.setPlayState(PlayState.PLAYING));
+    expect(setClarity).toHaveBeenCalledWith(expect.objectContaining({
+      clarity: 'auto'
+    }));
+    const onReport = subscribeClarityChanged.mock.calls[0][1];
+    act(() => onReport({
+      deviceId: 'camera-1',
+      clarity: ClarityType.HD
+    }));
+    expect(result.current.state.autoClarity).toBe(ClarityType.HD);
+    unmount();
+  });
+});

package/lib/ctx/ctx.js

@@ -12,6 +12,7 @@ import { changeIgnoreHideStopPreview } from '../ui/constant';
 import { ClarityType } from '@ray-js/ray-ipc-utils/lib/interface';
 import { getEventInstance } from './event';
 import { isMultiCameraTileSupported, useMultiCameraCtx } from './multiCameraCtx';
+import { getCachedAutoClarity, isClarityChangedSupported, setCachedAutoClarity, subscribeClarityChanged } from '../utils/ttt';
 const SAVE_TO_ALBUM = 1;
 export const createUseCtx = _ref => {
   let {
@@ -74,6 +75,8 @@ export const createUseCtx = _ref => {
     const [resolution] = useAtom('HD');
     // resolution 清晰度列表
     const [resolutionList, setResolutionList] = useAtom([]);
+    // 自动模式下宿主上报的实际清晰度，供横竖屏码率区域共用
+    const [autoClarity] = useAtom(null);
 
     // 单向对讲还是双向对讲
     const [intercomMode, setIntercomMode] = useAtom(IntercomMode.TwoWay);
@@ -101,22 +104,66 @@ export const createUseCtx = _ref => {
     const [bottomRightContent] = useAtom(initBottomRightContent || defaultBottomRightContent || []);
     const [absoluteContent] = useAtom(initAbsoluteContent || defaultAbsoluteContent || []);
     const {
-      _playState
+      _playState,
+      currentResolution
     } = useStore({
-      _playState: playState
+      _playState: playState,
+      currentResolution: resolution
     });
+    const restoredAutoRef = useRef(false);
+    const refreshedAutoRef = useRef(false);
+    const freshAutoClarityRef = useRef(false);
+    const pendingAutoSelectionRef = useRef(false);
+    const userSelectedResolutionRef = useRef(false);
+    useEffect(() => {
+      updateAtom(autoClarity, null);
+      restoredAutoRef.current = false;
+      refreshedAutoRef.current = false;
+      freshAutoClarityRef.current = false;
+      userSelectedResolutionRef.current = false;
+      if (!devId) return undefined;
+      return subscribeClarityChanged(devId, res => {
+        if (getDefaultStore().get(resolution) !== ClarityType.AUTO && !pendingAutoSelectionRef.current) {
+          return;
+        }
+        freshAutoClarityRef.current = true;
+        updateAtom(autoClarity, res.clarity);
+        setCachedAutoClarity(devId, res.clarity);
+      });
+    }, [autoClarity, devId, resolution]);
     const eventRef = useRef();
     if (!eventRef.current) {
       eventRef.current = getEventInstance();
     }
 
     /**
-     * 自动清晰度作为独立档位并入清晰度列表：
+     * 只有宿主支持自动清晰度事件，且接口返回的清晰度档位数量不少于 2 个时，才展示 AUTO：
      * 竖屏宿主弹框（由 resolutionList 构建 actionData）与横屏 FullResolutionControl 共用。
      */
+    const canShowAutoClarity = function () {
+      let list = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+      return isClarityChangedSupported() && list.length >= 2;
+    };
     const withAutoClarity = function () {
       let list = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
-      return list.includes(ClarityType.AUTO) ? list : [...list, ClarityType.AUTO];
+      const withoutAuto = list.filter(clarity => clarity !== ClarityType.AUTO);
+      return canShowAutoClarity(list) ? [...withoutAuto, ClarityType.AUTO] : withoutAuto;
+    };
+    const normalizeResolution = (resolution, list) => {
+      if (resolution !== ClarityType.AUTO || canShowAutoClarity(list)) return resolution;
+      return list.find(clarity => clarity !== ClarityType.AUTO) || ClarityType.HD;
+    };
+    const restoreResolution = (cachedResolution, list) => {
+      if (userSelectedResolutionRef.current) return;
+      const target = normalizeResolution(cachedResolution, list);
+      if (target === ClarityType.AUTO) {
+        restoredAutoRef.current = true;
+        const cachedClarity = getCachedAutoClarity(devId);
+        if (cachedClarity && list.includes(cachedClarity) && !getDefaultStore().get(autoClarity)) {
+          updateAtom(autoClarity, cachedClarity);
+        }
+      }
+      _setResolution(target, true);
     };
     useEffect(() => {
       // 初始化获取缓存值
@@ -127,7 +174,7 @@ export const createUseCtx = _ref => {
           var _res$maxZoomSettings;
           const res = await getMemoryState(devId);
           setResolutionList(withAutoClarity(res.resolutionList));
-          _setResolution(res.resolution, true);
+          restoreResolution(res.resolution, res.resolutionList);
           _setMute(res.mute, true);
           setIntercomMode(res.intercomMode);
           setIntercomSupported(res.isIntercomSupported);
@@ -144,7 +191,7 @@ export const createUseCtx = _ref => {
           var _res$maxZoomSettings2;
           setResolutionList(withAutoClarity(res.resolutionList));
           // 传true表示值即可,会取播放器的值
-          _setResolution(res.resolution, true);
+          restoreResolution(res.resolution, res.resolutionList);
           _setMute(res.mute, true);
           setIntercomMode(res.intercomMode);
           setIntercomSupported(res.isIntercomSupported);
@@ -152,6 +199,18 @@ export const createUseCtx = _ref => {
         });
       }
     }, [devId, _playState]);
+    useEffect(() => {
+      var _IPCPlayerInstance$cu;
+      if (!devId || _playState !== PlayState.PLAYING || currentResolution !== ClarityType.AUTO || !restoredAutoRef.current || freshAutoClarityRef.current || refreshedAutoRef.current) {
+        return;
+      }
+      refreshedAutoRef.current = true;
+      // 缓存只保证首屏有上次档位；出流后重申自动，让宿主回报本次实际档位。
+      (_IPCPlayerInstance$cu = IPCPlayerInstance.current) === null || _IPCPlayerInstance$cu === void 0 || _IPCPlayerInstance$cu.setClarity({
+        clarity: 'auto',
+        fail: error => console.warn('res===restore auto clarity fail', error)
+      });
+    }, [devId, _playState, currentResolution]);
     // 获取content数据
     const getContent = () => {
       const store = getDefaultStore();
@@ -246,6 +305,13 @@ export const createUseCtx = _ref => {
         updateAtom(resolution, target);
         return false;
       }
+      userSelectedResolutionRef.current = true;
+      // 清晰度事件可能在 setClarity 的 success 回调前到达，进入自动前先清掉上次的值。
+      restoredAutoRef.current = false;
+      if (target === ClarityType.AUTO) {
+        pendingAutoSelectionRef.current = true;
+        updateAtom(autoClarity, null);
+      }
       return new Promise((resolve, reject) => {
         const clarityMap = {
           [ClarityType.SS]: 'ss',
@@ -259,11 +325,13 @@ export const createUseCtx = _ref => {
         IPCPlayerInstance.current.setClarity({
           clarity: clarityMap[target] || 'normal',
           success: () => {
+            pendingAutoSelectionRef.current = false;
             setResolutionMemoryState(devId, target);
             updateAtom(resolution, target);
             resolve(true);
           },
           fail: err => {
+            pendingAutoSelectionRef.current = false;
             console.log(err, 'setClarity err');
             // updateAtom(mute, !target);
             reject(err);
@@ -315,6 +383,7 @@ export const createUseCtx = _ref => {
       mute,
       resolution,
       resolutionList,
+      autoClarity,
       intercom,
       intercomMode,
       intercomSupported,

package/lib/i18n/index.d.ts

@@ -1,9 +1,13 @@
 import { kit } from '@ray-js/panel-sdk';
 declare const Strings: kit.I18N<{
     en: {
+        ipc_player_resolution_SS: string;
         ipc_player_resolution_HD: string;
         ipc_player_resolution_SD: string;
+        ipc_player_resolution_UD: string;
+        ipc_player_resolution_SSP: string;
         ipc_player_resolution_AUTO: string;
+        ipc_player_resolution_AUDIO: string;
         ipc_player_current_resolution_is_equal: string;
         ipc_player_screenshot_success_tip: string;
         ipc_player_screenshot_multi_success_tip: string;
@@ -42,9 +46,13 @@ declare const Strings: kit.I18N<{
         ipc_player_low_phone_not_support: string;
     };
     zh: {
+        ipc_player_resolution_SS: string;
         ipc_player_resolution_HD: string;
         ipc_player_resolution_SD: string;
+        ipc_player_resolution_UD: string;
+        ipc_player_resolution_SSP: string;
         ipc_player_resolution_AUTO: string;
+        ipc_player_resolution_AUDIO: string;
         ipc_player_current_resolution_is_equal: string;
         ipc_player_screenshot_success_tip: string;
         ipc_player_screenshot_multi_success_tip: string;
@@ -83,9 +91,13 @@ declare const Strings: kit.I18N<{
         ipc_player_low_phone_not_support: string;
     };
 }, {
+    ipc_player_resolution_SS: string;
     ipc_player_resolution_HD: string;
     ipc_player_resolution_SD: string;
+    ipc_player_resolution_UD: string;
+    ipc_player_resolution_SSP: string;
     ipc_player_resolution_AUTO: string;
+    ipc_player_resolution_AUDIO: string;
     ipc_player_current_resolution_is_equal: string;
     ipc_player_screenshot_success_tip: string;
     ipc_player_screenshot_multi_success_tip: string;
@@ -123,9 +135,13 @@ declare const Strings: kit.I18N<{
     ipc_player_fetch_error: string;
     ipc_player_low_phone_not_support: string;
 } | {
+    ipc_player_resolution_SS: string;
     ipc_player_resolution_HD: string;
     ipc_player_resolution_SD: string;
+    ipc_player_resolution_UD: string;
+    ipc_player_resolution_SSP: string;
     ipc_player_resolution_AUTO: string;
+    ipc_player_resolution_AUDIO: string;
     ipc_player_current_resolution_is_equal: string;
     ipc_player_screenshot_success_tip: string;
     ipc_player_screenshot_multi_success_tip: string;

package/lib/i18n/strings.d.ts

@@ -1,8 +1,12 @@
 declare const _default: {
     en: {
+        ipc_player_resolution_SS: string;
         ipc_player_resolution_HD: string;
         ipc_player_resolution_SD: string;
+        ipc_player_resolution_UD: string;
+        ipc_player_resolution_SSP: string;
         ipc_player_resolution_AUTO: string;
+        ipc_player_resolution_AUDIO: string;
         ipc_player_current_resolution_is_equal: string;
         ipc_player_screenshot_success_tip: string;
         ipc_player_screenshot_multi_success_tip: string;
@@ -41,9 +45,13 @@ declare const _default: {
         ipc_player_low_phone_not_support: string;
     };
     zh: {
+        ipc_player_resolution_SS: string;
         ipc_player_resolution_HD: string;
         ipc_player_resolution_SD: string;
+        ipc_player_resolution_UD: string;
+        ipc_player_resolution_SSP: string;
         ipc_player_resolution_AUTO: string;
+        ipc_player_resolution_AUDIO: string;
         ipc_player_current_resolution_is_equal: string;
         ipc_player_screenshot_success_tip: string;
         ipc_player_screenshot_multi_success_tip: string;

package/lib/i18n/strings.js

@@ -1,8 +1,12 @@
 export default {
   en: {
+    ipc_player_resolution_SS: 'Data Saver',
     ipc_player_resolution_HD: 'HD',
     ipc_player_resolution_SD: 'SD',
+    ipc_player_resolution_UD: 'Ultra HD',
+    ipc_player_resolution_SSP: 'Super Ultra HD',
     ipc_player_resolution_AUTO: 'Auto',
+    ipc_player_resolution_AUDIO: 'Audio Mode',
     ipc_player_current_resolution_is_equal: 'Already at current clarity',
     ipc_player_screenshot_success_tip: 'Screenshot saved to album',
     ipc_player_screenshot_multi_success_tip: 'Screenshots saved to album',
@@ -41,9 +45,13 @@ export default {
     ipc_player_low_phone_not_support: 'This feature is not supported on this device'
   },
   zh: {
+    ipc_player_resolution_SS: '省流量',
     ipc_player_resolution_HD: '高清',
     ipc_player_resolution_SD: '标清',
+    ipc_player_resolution_UD: '超清',
+    ipc_player_resolution_SSP: '超超清',
     ipc_player_resolution_AUTO: '自动',
+    ipc_player_resolution_AUDIO: '音频模式',
     ipc_player_current_resolution_is_equal: '已是当前清晰度',
     ipc_player_screenshot_success_tip: '截图已保存在APP相册',
     ipc_player_screenshot_multi_success_tip: '图片已保存至相册',

package/lib/interface.d.ts

@@ -1,5 +1,6 @@
 import React from 'react';
 import { PrimitiveAtom } from 'jotai';
+import type { ClarityType } from '@ray-js/ray-ipc-utils/lib/interface';
 import type { Toast, IntercomMode } from './ports.output';
 import { useMultiCameraCtx } from './ctx/multiCameraCtx';
 import type { ZoomSkill } from './widgets/zoomTurntable/lensSkill';
@@ -74,6 +75,7 @@ export type UseCtx = (options: {
     setZoomLensIndex: (value: number) => void;
     resolution: RetAtom<string>;
     resolutionList: RetAtom<string[]>;
+    autoClarity: RetAtom<ClarityType | null>;
     playState: RetAtom<PlayState>;
     IPCPlayerInstance: IpcContext;
     topLeftContent: RetAtom<ComponentConfig[]>;
@@ -143,12 +145,7 @@ export type CaptureFileInfo = {
     height?: number;
     data?: string;
 };
-export type MultiCaptureFileInfo = CaptureFileInfo & {
-    index: number;
-};
-export type CaptureResult = boolean | CaptureFileInfo | {
-    items: MultiCaptureFileInfo[];
-};
+export type CaptureResult = boolean | CaptureFileInfo;
 export type RecordInfoData = CaptureResult;
 /**
  * 多目屏幕模式

package/lib/ui/constant.d.ts

@@ -60,12 +60,6 @@ export declare const widgetLabs: {
  */
 export declare const bottomLeftContentResize = "bottomLeftContentResize";
 export declare const zoomLevelChange = "zoomLevelChange";
-/**
- * 自动清晰度状态变化事件：Resolution 控件检测到清晰度进入/退出自动模式或收到
- * clarityChanged 回调结果时触发，携带 { enabled, clarity }（clarity 为 'HD' | 'SD' | null）。
- * VideoBitKBP 监听此事件，在码率前展示当前高清/标清文案。
- */
-export declare const autoClarityChange = "autoClarityChange";
 export declare const setScaleMultipleEvent = "setScaleMultipleEvent";
 export declare const decodeClarityDic: {
     SS: string;

package/lib/ui/constant.js

@@ -63,13 +63,6 @@ export const widgetLabs = {
  */
 export const bottomLeftContentResize = 'bottomLeftContentResize';
 export const zoomLevelChange = 'zoomLevelChange';
-
-/**
- * 自动清晰度状态变化事件：Resolution 控件检测到清晰度进入/退出自动模式或收到
- * clarityChanged 回调结果时触发，携带 { enabled, clarity }（clarity 为 'HD' | 'SD' | null）。
- * VideoBitKBP 监听此事件，在码率前展示当前高清/标清文案。
- */
-export const autoClarityChange = 'autoClarityChange';
 export const setScaleMultipleEvent = 'setScaleMultipleEvent';
 export const decodeClarityDic = {
   SS: 'ss',

package/lib/ui/ui.js

@@ -1,14 +1,17 @@
 import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _extends from "@babel/runtime/helpers/esm/extends";
 import "core-js/modules/esnext.iterator.constructor.js";
 import "core-js/modules/esnext.iterator.filter.js";
 import "core-js/modules/esnext.iterator.find.js";
 import "core-js/modules/esnext.iterator.map.js";
+import "core-js/modules/esnext.iterator.some.js";
 import React, { useContext, useState, useRef, useMemo, useEffect, useImperativeHandle } from 'react';
 import { View, CoverView, getSystemInfoSync, usePageEvent, setNavigationBarBack, setPageOrientation, getCurrentPages } from '@ray-js/ray';
 import { unstable_batchedUpdates as batchedUpdates } from '@ray-core/ray';
 import clsx from 'clsx';
 import IPCPlayer from '@ray-js/ray-ipc-player';
 import { ipcTTTOperatorLog } from '@ray-js/ray-ipc-utils';
+import { ClarityType } from '@ray-js/ray-ipc-utils/lib/interface';
 import { PlayState, PlayerStreamStatus, MultiCameraScreenMode } from '../interface';
 import { useCtx } from '../ctx/ctx.composition';
 import { useStore, updateAtom, getDefaultStore } from '../ctx/store';
@@ -18,7 +21,7 @@ import BottomLeftContent from './bottomLeftContent';
 import BottomRightContent from './bottomRightContent';
 import TopLeftContent from './topLeftContent';
 import TopRightContent from './topRightContent';
-import { FlowLowTip } from '../widgets';
+import { FlowLowTip, VideoBitKBP } from '../widgets';
 import { useMemoizedFn } from '../hooks';
 import { Storage } from '../utils/storage';
 import './ui.less';
@@ -27,6 +30,36 @@ import { getNgRawData, getSmartImageQualityState, isLowPhone, notifyOfflineShown
 import { getCaptureResultSummary } from '../utils/captureResult';
 import { lensCount } from '../widgets/zoomTurntable/lensSkill';
 import { shouldRenderContent } from './absoluteContent';
+const AutoClarityOnly = _ref => {
+  let {
+    instance
+  } = _ref;
+  return /*#__PURE__*/React.createElement(VideoBitKBP, _extends({}, instance, {
+    IPCPlayerContext: instance.IPCPlayerInstance,
+    className: "top-right-item-container",
+    hideKbsMenu: true,
+    hideSignalMenu: true
+  }));
+};
+const StandaloneAutoClarity = _ref2 => {
+  let {
+    instance,
+    show
+  } = _ref2;
+  const {
+    resolution,
+    autoClarity
+  } = useStore({
+    resolution: instance.resolution,
+    autoClarity: instance.autoClarity
+  });
+  if (!show || resolution !== ClarityType.AUTO || !autoClarity) return null;
+  return /*#__PURE__*/React.createElement(TopRightContent, {
+    ctx: instance
+  }, /*#__PURE__*/React.createElement(AutoClarityOnly, {
+    instance: instance
+  }));
+};
 function getCtxInstance(instance, devId) {
   if (instance) return instance;
   // eslint-disable-next-line react-hooks/rules-of-hooks
@@ -661,8 +694,12 @@ export const IPCPlayerIntegration = /*#__PURE__*/React.memo(props => {
     setRecording(false, true);
     setIntercom(false, true);
     instance === null || instance === void 0 || instance.stopRecordingOnUnload().then(async result => {
-      var _instance$multiCamera;
-      const summary = await getCaptureResultSummary(result, instance === null || instance === void 0 || (_instance$multiCamera = instance.multiCameraCtx) === null || _instance$multiCamera === void 0 || (_instance$multiCamera = _instance$multiCamera.protocol) === null || _instance$multiCamera === void 0 ? void 0 : _instance$multiCamera.total_split_num, devId);
+      var _instance$multiLens, _instance$multiCamera;
+      const summary = await getCaptureResultSummary(result, {
+        multiLens: (_instance$multiLens = instance === null || instance === void 0 ? void 0 : instance.multiLens) !== null && _instance$multiLens !== void 0 ? _instance$multiLens : false,
+        protocolCount: instance === null || instance === void 0 || (_instance$multiCamera = instance.multiCameraCtx) === null || _instance$multiCamera === void 0 || (_instance$multiCamera = _instance$multiCamera.protocol) === null || _instance$multiCamera === void 0 ? void 0 : _instance$multiCamera.total_split_num,
+        devId
+      });
       ipcTTTOperatorLog(summary !== null && summary !== void 0 && summary.isMultiLens ? `hide: stop recording succeeded with ${summary.count} files` : 'hide: 调用停止录制方法成功');
     }).catch(() => {
       ipcTTTOperatorLog('hide: 调用停止录制方法失败');
@@ -1009,6 +1046,7 @@ export const IPCPlayerIntegration = /*#__PURE__*/React.memo(props => {
     };
   }, []);
   const playerReady = playState === PlayState.PLAYING;
+  const hasVisibleBitrateWidget = topRightContent === null || topRightContent === void 0 ? void 0 : topRightContent.some(item => item.id === 'VideoBitKBP' && !item.hidden);
   /**
    * 监听当前的zoom比例状态
    */
@@ -1202,7 +1240,12 @@ export const IPCPlayerIntegration = /*#__PURE__*/React.memo(props => {
     ctx: instance
   }, renderTopLeftContent), /*#__PURE__*/React.createElement(TopRightContent, {
     ctx: instance
-  }, renderTopRightContent))), /*#__PURE__*/React.createElement(View, {
+  }, renderTopRightContent, !hasVisibleBitrateWidget && /*#__PURE__*/React.createElement(AutoClarityOnly, {
+    instance: instance
+  })))), /*#__PURE__*/React.createElement(StandaloneAutoClarity, {
+    instance: instance,
+    show: !showTopContent || componentHideState || !playerReady
+  }), /*#__PURE__*/React.createElement(View, {
     className: clsx('ipc-player-bottom-content', {
       'ipc-player-bottom-content-hide': componentHideState,
       'ipc-player-bottom-content-show': !componentHideState,

package/lib/utils/captureResult.d.ts

@@ -4,6 +4,11 @@ export type CaptureResultSummary = {
     isMultiLens: boolean;
     thumbnailPath: string;
 };
+export type CaptureResultOptions = {
+    multiLens: boolean;
+    protocolCount?: number | string;
+    devId: string;
+};
 /** 从新多目高级能力配置获取当前设备的总镜头数 */
 export declare function getMultiLensCountFromAbility(devId: string): Promise<number>;
-export declare function getCaptureResultSummary(result: CaptureResult, fallbackCount: number | undefined, devId: string): Promise<CaptureResultSummary | null>;
+export declare function getCaptureResultSummary(result: CaptureResult, { multiLens, protocolCount, devId }: CaptureResultOptions): Promise<CaptureResultSummary | null>;

package/lib/utils/captureResult.js

@@ -33,36 +33,38 @@ const extractPath = item => {
   if (typeof (item === null || item === void 0 ? void 0 : item.value) === 'string') return item.value;
   return '';
 };
-export async function getCaptureResultSummary(result, fallbackCount, devId) {
+export async function getCaptureResultSummary(result, _ref) {
+  let {
+    multiLens,
+    protocolCount,
+    devId
+  } = _ref;
   if (!result || typeof result === 'boolean') return null;
-  const rawResult = result;
-  const singleThumb = extractPath(rawResult.tempImagePath) || extractPath(rawResult.thumbPath) || extractPath(rawResult.filePath) || '';
-  if ('items' in result && Array.isArray(result.items) && result.items.length > 0) {
-    const firstItem = result.items[0];
-    const firstThumb = extractPath(firstItem === null || firstItem === void 0 ? void 0 : firstItem.tempImagePath) || extractPath(firstItem === null || firstItem === void 0 ? void 0 : firstItem.thumbPath) || extractPath(firstItem === null || firstItem === void 0 ? void 0 : firstItem.filePath) || singleThumb;
+  const thumbnailPath = extractPath(result.tempImagePath) || extractPath(result.thumbPath) || extractPath(result.filePath) || '';
+  if (!multiLens) {
     return {
-      count: result.items.length,
-      isMultiLens: true,
-      thumbnailPath: firstThumb
+      count: 1,
+      isMultiLens: false,
+      thumbnailPath
     };
   }
-  const legacySplitCount = fallbackCount && fallbackCount > 1 ? fallbackCount : 0;
+  const splitCount = Number(protocolCount) > 1 ? Number(protocolCount) : 0;
   const multiLensAbilityCount = await getMultiLensCountFromAbility(devId);
 
   // The native multi-lens snapshot can return one object while writing lens-specific
   // files. Use the ability result to distinguish that file-name convention from the
   // legacy split protocol.
-  const multiCount = legacySplitCount || multiLensAbilityCount;
+  const multiCount = splitCount || multiLensAbilityCount;
   if (multiCount > 1) {
     return {
       count: multiCount,
       isMultiLens: true,
-      thumbnailPath: multiLensAbilityCount > 1 ? normalizeMultiLensThumbnailPath(singleThumb) : singleThumb
+      thumbnailPath: multiLensAbilityCount > 1 ? normalizeMultiLensThumbnailPath(thumbnailPath) : thumbnailPath
     };
   }
   return {
     count: 1,
     isMultiLens: false,
-    thumbnailPath: singleThumb
+    thumbnailPath
   };
 }