@ray-js/ipc-player-integration 0.0.1-beta-13 → 0.0.1-beta-15

package/lib/ctx/ctx.composition.js

@@ -2,7 +2,7 @@ import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
 import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
 const _excluded = ["title", "duration"];
 import IPCUtils from '@ray-js/ray-ipc-utils';
-import { MuteMode } from '@ray-js/ray-ipc-utils/lib/interface';
+import { IntercomMode, MuteMode, ClarityType } from '@ray-js/ray-ipc-utils/lib/interface';
 import { createUseCtx } from './ctx';
 import { Battery, Screenshot, TempHumidity, RecordVideo, FullScreen, VideoBitKbps, Muted, Resolution, Ptz } from '../plugins';
 import { authorizeStatus } from '../utils/authorize';
@@ -52,21 +52,27 @@ const toast = _ref => {
   }, config));
 };
 const getMemoryState = devId => {
+  const defaultValue = {
+    mute: true,
+    intercomMode: IntercomMode.TwoWay,
+    resolution: ClarityType.HD,
+    resolutionList: [ClarityType.HD, ClarityType.SD]
+  };
   return new Promise(resolve => {
     IPCUtils.getCameraConfigInfo(devId).then(res => {
       if (res.code === -1) {
-        return resolve({
-          mute: true
-        });
+        return resolve(defaultValue);
       }
-      const value = res.data.microphoneSettings.cachedMuteMode === MuteMode.OFF;
+      console.log(res, '========');
+      const muteValue = res.data.microphoneSettings.cachedMuteMode === MuteMode.OFF;
       return resolve({
-        mute: value
+        mute: muteValue,
+        intercomMode: res.data.intercomInfo.cachedIntercomMode,
+        resolution: res.data.videoResolution.cachedResolution,
+        resolutionList: res.data.videoResolution.availableResolutions
       });
     }).catch(() => {
-      resolve({
-        mute: true
-      });
+      resolve(defaultValue);
     });
   });
 };

package/lib/ctx/ctx.js

@@ -1,6 +1,7 @@
 import { useRef, useCallback, useEffect } from 'react';
 import { useAtom, updateAtom, getDefaultStore, useStore } from './store';
-import { PlayState } from '../interface';
+import { PlayState, IntercomMode } from '../interface';
+import { ClarityType } from '@ray-js/ray-ipc-utils/lib/interface';
 const SAVE_TO_ALBUM = 1;
 export const createUseCtx = _ref => {
   let {
@@ -23,29 +24,40 @@ export const createUseCtx = _ref => {
     } = _ref2;
     const streamStatus = useRef();
     // 全屏、竖屏
-    const screenType = useAtom('vertical');
+    const [screenType, setScreenType] = useAtom('vertical');
+
     // 录像中
-    const recording = useAtom(false);
+    const [recording] = useAtom(false);
 
     // 静音 true 代表静音 false 代表不静音
-    const mute = useAtom(false);
+    const [mute] = useAtom(false);
 
-    // 清晰度
-    const resolution = useAtom('HD');
+    // 品牌色 默认
+    const [brandColor, setBrandColor] = useAtom('#FF592A');
 
     // ptz 是否点击
-    const ptzActive = useAtom(false);
+    const [ptzActive, setPtzActive] = useAtom(false);
+
+    // resolution 当前清晰度
+    const [resolution] = useAtom('HD');
+    // resolution 清晰度列表
+    const [resolutionList, setResolutionList] = useAtom([]);
+
+    // 单向对讲还是双向对讲
+    const [intercomMode, setIntercomMode] = useAtom(IntercomMode.TwoWay);
+
     // 全屏清晰度UI切换是否展示
-    const fullResolutionActive = useAtom(false);
+    const [fullResolutionActive, setFullResolutionActive] = useAtom(false);
+
     // 对讲中
-    const intercom = useAtom(false);
-    const playState = useAtom(PlayState.CONNECTING);
+    const [intercom] = useAtom(false);
+    const [playState] = useAtom(PlayState.CONNECTING);
     const setPlayState = useCallback(value => {
       updateAtom(playState, value);
     }, [playState]);
-    const topContent = useAtom(initTopContent || defaultTopContent || []);
-    const bottomContent = useAtom(initBottomContent || defaultBottomContent || []);
-    const absoluteContent = useAtom(initAbsoluteContent || defaultAbsoluteContent || []);
+    const [topContent] = useAtom(initTopContent || defaultTopContent || []);
+    const [bottomContent] = useAtom(initBottomContent || defaultBottomContent || []);
+    const [absoluteContent] = useAtom(initAbsoluteContent || defaultAbsoluteContent || []);
     const {
       _playState
     } = useStore({
@@ -55,7 +67,11 @@ export const createUseCtx = _ref => {
       if (devId && _playState === PlayState.PLAYING) {
         // 获取缓存的值且同步
         getMemoryState(devId).then(res => {
+          console.log('==== getMemoryState ====', res);
           _setMute(res.mute);
+          setIntercomMode(res.intercomMode);
+          _setResolution(res.resolution, 'res.resolution');
+          setResolutionList(res.resolutionList);
         });
       }
     }, [devId, _playState]);
@@ -95,19 +111,40 @@ export const createUseCtx = _ref => {
      * 设置清晰度
      *
      */
-
+    const _setResolution = async target => {
+      // target 为需要切换的清晰度
+      return new Promise((resolve, reject) => {
+        IPCPlayerInstance.current.setClarity({
+          clarity: target === ClarityType.HD ? 'hd' : 'normal',
+          success: () => {
+            console.log('setClarity success', target);
+            updateAtom(resolution, target);
+            resolve(true);
+          },
+          fail: err => {
+            console.log(err, 'setClarity err');
+            // updateAtom(mute, !target);
+            reject(err);
+          }
+        });
+      });
+    };
     return {
       devId,
+      brandColor,
       saveToAlbum,
       screenType,
       recording,
       mute,
       resolution,
+      resolutionList,
       ptzActive,
       fullResolutionActive,
       intercom,
+      intercomMode,
       playState,
       setPlayState,
+      setBrandColor,
       setIntercom: async target => {
         const store = getDefaultStore();
         const _intercom = store.get(intercom);
@@ -147,24 +184,8 @@ export const createUseCtx = _ref => {
         });
       },
       setMute: _setMute,
-      setResolution: async target => {
-        console.log('执行清晰度方法');
-        return new Promise((resolve, reject) => {
-          IPCPlayerInstance.current.setClarity({
-            clarity: target,
-            success: () => {
-              console.log('setClarity success');
-              updateAtom(resolution, target === 'hd' ? 'HD' : 'SD');
-              resolve(true);
-            },
-            fail: err => {
-              console.log('setClarity err');
-              // updateAtom(mute, !target);
-              reject(err);
-            }
-          });
-        });
-      },
+      setResolution: _setResolution,
+      setResolutionList,
       setRecording: async target => {
         const store = getDefaultStore();
         const _recording = store.get(recording);
@@ -204,15 +225,9 @@ export const createUseCtx = _ref => {
           }
         });
       },
-      setPtzActive: value => {
-        updateAtom(ptzActive, value);
-      },
-      setFullResolutionActive: value => {
-        updateAtom(fullResolutionActive, value);
-      },
-      setScreenType: value => {
-        updateAtom(screenType, value);
-      },
+      setPtzActive,
+      setFullResolutionActive,
+      setScreenType,
       topContent,
       bottomContent,
       absoluteContent,

package/lib/ctx/ports.output.d.ts

@@ -1,7 +1,9 @@
-export type { Toast } from '../ports.output';
+import { IntercomMode } from '../ports.output';
+export type { Toast, IntercomMode } from '../ports.output';
 export type createPlayContext = (devId: string) => IpcContext;
 export type AuthorizeStatus = (type: string) => Promise<boolean>;
 export type GetMemoryState = (devId: string) => Promise<{
     mute: boolean;
+    intercomMode: IntercomMode;
 }>;
 export type SetMuteMemoryState = (devId: string, value: boolean) => void;

package/lib/ctx/store.d.ts

@@ -3,9 +3,10 @@ export { getDefaultStore } from 'jotai';
 export declare const topContent: import("jotai").PrimitiveAtom<never[]> & {
     init: never[];
 };
-export declare const useAtom: <T extends unknown>(defaultValue: T) => RetAtom<T>;
+type Action<T> = T | ((prevValue: T) => T);
+export declare const useAtom: <T extends unknown>(defaultValue: T) => [RetAtom<T>, (value: Action<T>) => void];
 type ExtractReturnType<T> = {
     [K in keyof T]: T[K] extends RetAtom<infer R> ? R : never;
 };
 export declare const useStore: <V, T extends Record<string, RetAtom<V>>>(options: T) => ExtractReturnType<T>;
-export declare const updateAtom: <T>(atom: RetAtom<T>, value: T | ((prevValue: T) => T)) => void;
+export declare const updateAtom: <T>(atom: RetAtom<T>, value: Action<T>) => void;

package/lib/ctx/store.js

@@ -8,7 +8,7 @@ export const useAtom = defaultValue => {
     // @ts-ignore
     ref.current = atom(defaultValue);
   }
-  return ref.current;
+  return [ref.current, value => updateAtom(ref.current, value)];
 };
 export const useStore = options => {
   const combinedAtomRef = useRef();

package/lib/i18n/index.d.ts

@@ -0,0 +1,22 @@
+import { kit } from '@ray-js/panel-sdk';
+declare const Strings: kit.I18N<{
+    en: {
+        ipc_player_resolution_HD: string;
+        ipc_player_resolution_SD: string;
+        ipc_player_current_resolution_is_equal: string;
+    };
+    zh: {
+        ipc_player_resolution_HD: string;
+        ipc_player_resolution_SD: string;
+        ipc_player_current_resolution_is_equal: string;
+    };
+}, {
+    ipc_player_resolution_HD: string;
+    ipc_player_resolution_SD: string;
+    ipc_player_current_resolution_is_equal: string;
+} | {
+    ipc_player_resolution_HD: string;
+    ipc_player_resolution_SD: string;
+    ipc_player_current_resolution_is_equal: string;
+}>;
+export default Strings;

package/lib/i18n/index.js

@@ -0,0 +1,7 @@
+import { kit } from '@ray-js/panel-sdk';
+import strings from './strings';
+const {
+  I18N
+} = kit;
+const Strings = new I18N(strings);
+export default Strings;

package/lib/i18n/strings.d.ts

@@ -0,0 +1,13 @@
+declare const _default: {
+    en: {
+        ipc_player_resolution_HD: string;
+        ipc_player_resolution_SD: string;
+        ipc_player_current_resolution_is_equal: string;
+    };
+    zh: {
+        ipc_player_resolution_HD: string;
+        ipc_player_resolution_SD: string;
+        ipc_player_current_resolution_is_equal: string;
+    };
+};
+export default _default;

package/lib/i18n/strings.js

@@ -0,0 +1,12 @@
+export default {
+  en: {
+    ipc_player_resolution_HD: 'HD',
+    ipc_player_resolution_SD: 'SD',
+    ipc_player_current_resolution_is_equal: 'Already at current clarity'
+  },
+  zh: {
+    ipc_player_resolution_HD: '高清',
+    ipc_player_resolution_SD: '标清',
+    ipc_player_current_resolution_is_equal: '已是当前清晰度'
+  }
+};

package/lib/interface.d.ts

@@ -1,6 +1,7 @@
 import React from 'react';
 import { PrimitiveAtom } from 'jotai';
-import type { Toast } from './ports.output';
+import type { Toast, IntercomMode } from './ports.output';
+export { IntercomMode } from './ports.output';
 type WithInitialValue<Value> = {
     init: Value;
 };
@@ -31,20 +32,27 @@ export type UseCtx = (options: {
     saveToAlbum?: 0 | 1;
 }) => {
     devId: string;
+    brandColor: string;
     saveToAlbum: 0 | 1;
     screenType: RetAtom<ScreenType>;
     recording: RetAtom<boolean>;
     mute: RetAtom<boolean>;
     intercom: RetAtom<boolean>;
+    intercomMode: RetAtom<IntercomMode>;
     ptzActive: RetAtom<boolean>;
+    resolution: RetAtom<string>;
+    resolutionList: RetAtom<string[]>;
     fullResolutionActive: RetAtom<boolean>;
     playState: RetAtom<PlayState>;
     IPCPlayerInstance: IpcContext;
     topContent: RetAtom<ComponentConfig[]>;
     bottomContent: RetAtom<ComponentConfig[]>;
     absoluteContent: RetAtom<ComponentConfig[]>;
+    setBrandColor: (color: string) => void;
     setScreenType: (type: ScreenType) => void;
     setPtzActive: (type: boolean) => void;
+    setResolution: (type: string) => void;
+    setResolutionList: (type: string[]) => void;
     setFullResolutionActive: (type: boolean) => void;
     setRecording: (value: boolean) => Promise<boolean>;
     setIntercom: (value: boolean) => Promise<boolean>;
@@ -70,4 +78,3 @@ export type PlayStatusData = {
     playState: PlayState;
     playCode: number;
 };
-export {};

package/lib/interface.js

@@ -1,3 +1,4 @@
+export { IntercomMode } from './ports.output';
 export let PlayerStreamStatus = /*#__PURE__*/function (PlayerStreamStatus) {
   PlayerStreamStatus[PlayerStreamStatus["UnknownException"] = -1000] = "UnknownException";
   PlayerStreamStatus[PlayerStreamStatus["ConnectSuccess"] = 1001] = "ConnectSuccess";

package/lib/plugins/battery/battery.composition.d.ts

@@ -3,20 +3,27 @@ export declare const Battery: import("react").FunctionComponent<{
     IPCPlayerContext: IpcContext;
 } & {
     devId: string;
+    brandColor: string;
     saveToAlbum: 0 | 1;
     screenType: import("../..").RetAtom<import("../..").ScreenType>;
     recording: import("../..").RetAtom<boolean>;
     mute: import("../..").RetAtom<boolean>;
     intercom: import("../..").RetAtom<boolean>;
+    intercomMode: import("../..").RetAtom<import("@ray-js/ray-ipc-utils/lib/interface").IntercomMode>;
     ptzActive: import("../..").RetAtom<boolean>;
+    resolution: import("../..").RetAtom<string>;
+    resolutionList: import("../..").RetAtom<string[]>;
     fullResolutionActive: import("../..").RetAtom<boolean>;
     playState: import("../..").RetAtom<import("../..").PlayState>;
     IPCPlayerInstance: IpcContext;
     topContent: import("../..").RetAtom<import("../..").ComponentConfig<any & Record<string, any>>[]>;
     bottomContent: import("../..").RetAtom<import("../..").ComponentConfig<any & Record<string, any>>[]>;
     absoluteContent: import("../..").RetAtom<import("../..").ComponentConfig<any & Record<string, any>>[]>;
+    setBrandColor: (color: string) => void;
     setScreenType: (type: import("../..").ScreenType) => void;
     setPtzActive: (type: boolean) => void;
+    setResolution: (type: string) => void;
+    setResolutionList: (type: string[]) => void;
     setFullResolutionActive: (type: boolean) => void;
     setRecording: (value: boolean) => Promise<boolean>;
     setIntercom: (value: boolean) => Promise<boolean>;

package/lib/plugins/recordVideo/recordVideo.less

@@ -3,7 +3,7 @@
   color: var(--iconColor);
 }
 .ipc-player-plugin-record-video-toast-wrap {
-  z-index: 2;
+  z-index: 110;
   position: absolute;
   top: calc(7px * var(--ipc-player-size-scale, 1));
   left: 50%;
@@ -15,6 +15,8 @@
   align-items: center;
   background-color: var(--bg-color);
   border-radius: calc(8px * var(--ipc-player-size-scale, 1));
+  // background-color: #fff;
+  background: linear-gradient(0deg, rgba(255, 255, 255, 0.15), rgba(255, 255, 255, 0.15)), #000000;
   .ipc-player-plugin-record-video-toast-point {
     width: calc(6px * var(--ipc-player-size-scale, 1));
     height: calc(6px * var(--ipc-player-size-scale, 1));

package/lib/plugins/resolution/fullResolutionControl.js

@@ -2,30 +2,59 @@ import _extends from "@babel/runtime/helpers/esm/extends";
 import React, { useContext } from 'react';
 import { Text, View } from '@ray-js/ray';
 import clsx from 'clsx';
+import Strings from '../../i18n';
 import { useComponentHideState } from '../../ui/hooks';
 import { UIEventContext } from '../../ui/context';
 import { useStore } from '../../ctx/store';
 import { startTimeToHideAllComponent, pauseTimeToHideAllComponent } from '../../ui/constant';
 import './resolution.less';
 export const FullResolutionControl = props => {
+  const {
+    setResolution,
+    setFullResolutionActive
+  } = props;
   const {
     screenType,
-    fullResolutionActive
+    fullResolutionActive,
+    resolution,
+    resolutionList,
+    brandColor
   } = useStore({
     screenType: props.screenType,
-    fullResolutionActive: props.fullResolutionActive
+    fullResolutionActive: props.fullResolutionActive,
+    resolutionList: props.resolutionList,
+    brandColor: props.brandColor,
+    resolution: props.resolution
   });
+  console.log(resolutionList, 'resolutionList');
   const [shouldHide] = useComponentHideState(screenType);
   const {
     event
   } = useContext(UIEventContext);
+  const changeResolution = value => {
+    if (value === resolution) {
+      ty.showToast({
+        icon: 'none',
+        title: Strings.getLang('ipc_player_current_resolution_is_equal')
+      });
+    } else {
+      setResolution(value);
+      setFullResolutionActive(false);
+    }
+  };
+  console.log(brandColor, 'brandColor');
+  console.log(resolution, 'resolution');
+  console.log(resolutionList, 'resolutionList');
   return /*#__PURE__*/React.createElement(View, _extends({
     className: clsx('ipc-player-plugin-full-resolution-control', {
       'ipc-player-plugin-full-resolution-control-hide': shouldHide || !fullResolutionActive
     })
-  }, props), /*#__PURE__*/React.createElement(Text, {
-    className: clsx('ipc-player-plugin-full-resolution-control-text')
-  }, "\u9AD8\u6E05"), /*#__PURE__*/React.createElement(Text, {
-    className: clsx('ipc-player-plugin-full-resolution-control-text')
-  }, "\u6807\u6E05"));
+  }, props), resolutionList.map(item => /*#__PURE__*/React.createElement(Text, {
+    onClick: () => changeResolution(item),
+    key: item,
+    className: clsx('ipc-player-plugin-full-resolution-control-text'),
+    style: item === resolution && {
+      color: brandColor
+    }
+  }, Strings.getLang(`ipc_player_resolution_${item}`))));
 };

package/lib/plugins/resolution/resolution.js

@@ -1,41 +1,31 @@
 import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
 import { View, Text } from '@ray-js/ray';
 import clsx from 'clsx';
-import React, { useContext, useEffect } from 'react';
+import React, { useContext } from 'react';
+import Strings from '../../i18n';
 import { FullResolutionControl } from './fullResolutionControl';
 import { fullResolutionId, pauseTimeToHideAllComponent } from '../../ui/constant';
 import { UIEventContext } from '../../ui/context';
-import { useStore, updateAtom } from '../../ctx/store';
+import { useStore } from '../../ctx/store';
 import './resolution.less';
 export const Resolution = props => {
   const {
     IPCPlayerContext,
-    resolution,
     setResolution,
-    screenType: screenTypeAtom,
-    fullResolutionActive,
-    addContent
+    addContent,
+    setFullResolutionActive
   } = props;
   const {
-    currentResolution,
-    screenType,
-    isFullResolutionActive
+    resolution,
+    screenType
   } = useStore({
-    currentResolution: resolution,
-    screenType: screenTypeAtom,
-    isFullResolutionActive: fullResolutionActive
+    resolution: props.resolution,
+    screenType: props.screenType,
+    fullResolutionActive: props.fullResolutionActive
   });
   const {
     event
   } = useContext(UIEventContext);
-  console.log(screenType, 'screenType');
-  // const setIsMuted = (value: typeof currentResolution) => {
-  //   // updateAtom(mute, value);
-  // };
-
-  useEffect(() => {
-    // init();
-  }, []);
   return /*#__PURE__*/React.createElement(View, {
     onClick: () => {
       if (screenType === 'full') {
@@ -48,15 +38,15 @@ export const Resolution = props => {
           absoluteContentClassName: 'ipc-player-plugin-full-resolution-control-wrap',
           initProps: _objectSpread({}, props)
         });
-        updateAtom(fullResolutionActive, true);
+        setFullResolutionActive(true);
         event.emit(pauseTimeToHideAllComponent);
         return false;
       }
-      setResolution(currentResolution === 'HD' ? 'normal' : 'hd');
+      setResolution(resolution === 'HD' ? 'SD' : 'HD');
       return true;
     },
     className: clsx('ipc-player-plugin-resolution', screenType === 'vertical' ? 'ipc-player-plugin-resolution-vertical' : 'ipc-player-plugin-resolution-full')
   }, /*#__PURE__*/React.createElement(Text, {
     className: "resolutionText"
-  }, currentResolution));
+  }, Strings.getLang(`ipc_player_resolution_${resolution}`)));
 };

package/lib/plugins/resolution/resolution.less

@@ -38,6 +38,7 @@
   display: flex;
   justify-content: center;
   align-items: center;
+  background-color: transparent;
   // transform: translate(200%, 0);
   z-index: 3;
 }
@@ -48,4 +49,5 @@
   text-align: center;
   color: #ffffff;
   min-height: 40px;
+  width: 100%;
 }

package/lib/plugins/voiceIntercom/voiceIntercom.d.ts

@@ -9,5 +9,5 @@ type Props = ComponentConfigProps & {
     onTouchStart?: TouchEventHandler['onTouchStart'];
     onTouchEnd?: TouchEventHandler['onTouchEnd'];
 };
-export declare function VoiceIntercom({ style, className, iconClassName, recording: recordingAtom, intercom: intercomAtom, setIntercom, mute: muteAtom, setMute, getStreamStatus, onTouchStart, onTouchEnd, }: Props): React.JSX.Element;
+export declare function VoiceIntercom({ style, className, iconClassName, recording: recordingAtom, intercom: intercomAtom, intercomMode: intercomModeAtom, setIntercom, mute: muteAtom, setMute, getStreamStatus, onTouchStart, onTouchEnd, }: Props): React.JSX.Element;
 export {};

package/lib/plugins/voiceIntercom/voiceIntercom.js

@@ -5,7 +5,7 @@ import clsx from 'clsx';
 import Res from './voice.gif';
 import { useStore, getDefaultStore } from '../../ctx/store';
 import './voiceIntercom.less';
-import { PlayerStreamStatus } from '../../interface';
+import { PlayerStreamStatus, IntercomMode } from '../../interface';
 import { UIEventContext } from '../../ui/context';
 import { startTimeToHideAllComponent, pauseTimeToHideAllComponent } from '../../ui/constant';
 const NILL = () => null;
@@ -16,6 +16,7 @@ export function VoiceIntercom(_ref) {
     iconClassName,
     recording: recordingAtom,
     intercom: intercomAtom,
+    intercomMode: intercomModeAtom,
     setIntercom,
     mute: muteAtom,
     setMute,
@@ -28,10 +29,12 @@ export function VoiceIntercom(_ref) {
   } = useContext(UIEventContext);
   const {
     mute,
-    intercom
+    intercom,
+    intercomMode
   } = useStore({
     mute: muteAtom,
-    intercom: intercomAtom
+    intercom: intercomAtom,
+    intercomMode: intercomModeAtom
   });
   // 对讲开始之前的静音状态
   const originMuteStatusBeforeVoice = useRef(mute);
@@ -41,16 +44,28 @@ export function VoiceIntercom(_ref) {
       console.log('PlayerStreamStatus not 1002');
       return;
     }
+    console.log('==== 开始对讲 =====');
     originMuteStatusBeforeVoice.current = _mute;
-    // 如果对讲开始之前，是静音的，则需要关闭静音
-    if (_mute) {
-      await setMute(false);
+    // 单路对讲，开始对讲前需要静音
+    // 双路对讲，开始对讲前需要打开拾音器
+    const muteTarget = intercomMode === IntercomMode.OneWay;
+    if (_mute !== muteTarget) {
+      console.log(`=== 切换静音状态： ${_mute}`, `${intercomMode}`);
+      await setMute(muteTarget);
     }
     await setIntercom(true);
     event.emit(pauseTimeToHideAllComponent);
   };
   const endVoice = async () => {
-    await setMute(originMuteStatusBeforeVoice.current);
+    console.log('=== 结束对讲 ====');
+    // 单向对讲，结束对讲之后，强制关闭静态状态
+    if (intercomMode === IntercomMode.OneWay) {
+      console.log('=== 单向对讲，强制关闭静音状态 ===');
+      await setMute(false);
+    } else {
+      console.log(`=== 双向对讲，恢复对讲之前的静音状态 ${originMuteStatusBeforeVoice.current}===`);
+      await setMute(originMuteStatusBeforeVoice.current);
+    }
     await setIntercom(false);
     event.emit(startTimeToHideAllComponent);
   };
@@ -70,12 +85,17 @@ export function VoiceIntercom(_ref) {
         loading.current = false;
         return;
       }
-      if (target) {
-        await startVoice(mute);
-      } else {
-        await endVoice();
+      try {
+        if (target) {
+          await startVoice(mute);
+        } else {
+          await endVoice();
+        }
+      } catch (err) {
+        loading.current = false;
+      } finally {
+        loading.current = false;
       }
-      loading.current = false;
     },
     onTouchEnd: onTouchEnd
   }, intercom ? /*#__PURE__*/React.createElement(Image, {

package/lib/ports.output.d.ts

@@ -1,3 +1,4 @@
+export { IntercomMode } from '@ray-js/ray-ipc-utils/lib/interface';
 export type UseBattery = (devId: string) => {
     batteryValue: number;
     batteryCharging: boolean;

package/lib/ports.output.js

@@ -1 +1,7 @@
-export {};
+export { IntercomMode } from '@ray-js/ray-ipc-utils/lib/interface';
+
+// plugin 获取电池电量 todo
+
+// plugin 获取温度
+
+// plugin 获取湿度

package/lib/ui/ui.d.ts

@@ -16,6 +16,8 @@ type Props = {
     className?: string;
     onPlayStatus?: (data: PlayStatusData) => void;
     style?: React.CSSProperties;
+    privateState?: boolean;
+    deviceOnline?: boolean;
     CSSVariable?: Partial<CSSVariable>;
 };
 export declare const IPCPlayerIntegration: React.MemoExoticComponent<(props: Props) => React.JSX.Element>;

package/lib/ui/ui.js

@@ -38,10 +38,11 @@ export const IPCPlayerIntegration = /*#__PURE__*/React.memo(props => {
     className,
     devId,
     style,
-    CSSVariable = defaultCSSVariable
+    CSSVariable = defaultCSSVariable,
+    privateState = false,
+    deviceOnline = true
   } = props;
   const instance = getCtxInstance(props.instance, devId);
-  console.log(instance, 'instance');
   const {
     setPlayState,
     setScreenType,
@@ -184,7 +185,7 @@ export const IPCPlayerIntegration = /*#__PURE__*/React.memo(props => {
     objectFit: "",
     defaultMute: true,
     devId: devId,
-    onlineStatus: true,
+    onlineStatus: deviceOnline,
     ipcPlayerContext: instance.IPCPlayerInstance,
     onChangeStreamStatus: code => {
       var _props$onPlayStatus;
@@ -234,7 +235,7 @@ export const IPCPlayerIntegration = /*#__PURE__*/React.memo(props => {
       }, 3000);
     },
     clarity: "hd",
-    privateState: false,
+    privateState: privateState,
     onPlayerTap: handPlayerTap // 对应原来的onVideoTap
   }), playerReady && /*#__PURE__*/React.createElement(TopContent, {
     ctx: instance

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ray-js/ipc-player-integration",
-  "version": "0.0.1-beta-13",
+  "version": "0.0.1-beta-15",
   "description": "IPC 播放器功能集成",
   "main": "lib/index",
   "files": [