agora-appbuilder-core 1.0.8 → 2.0.1

package/template/agora-rn-uikit/src/Controls/Local/LocalAudioMute.tsx

@@ -1,27 +1,71 @@
 import React, {useContext} from 'react';
-import PropsContext from '../../PropsContext';
-import RtcContext, {DispatchType} from '../../RtcContext';
+import PropsContext, {ToggleState} from '../../Contexts/PropsContext';
+import RtcContext from '../../Contexts/RtcContext';
 import BtnTemplate from '../BtnTemplate';
 import styles from '../../Style';
-import {LocalContext} from '../../LocalUserContext';
+import {LocalContext} from '../../Contexts/LocalUserContext';
 
-function LocalAudioMute() {
+interface Props {
+  btnText?: string;
+  variant?: 'outlined' | 'text';
+}
+function LocalAudioMute(props: Props) {
+  const {btnText = 'Audio', variant = 'Outlined'} = props;
   const {styleProps} = useContext(PropsContext);
-  const {localBtnStyles} = styleProps || {};
+  const {localBtnStyles, remoteBtnStyles} = styleProps || {};
   const {muteLocalAudio} = localBtnStyles || {};
-  const {dispatch} = useContext(RtcContext);
+  const {muteRemoteAudio} = remoteBtnStyles || {};
+  const {RtcEngine, dispatch} = useContext(RtcContext);
   const local = useContext(LocalContext);
 
   return (
     <BtnTemplate
-      name={local.audio ? 'mic' : 'micOff'}
-      btnText={'Audio'}
-      style={{...styles.localBtn, ...(muteLocalAudio as object)}}
-      onPress={() => {
-        (dispatch as DispatchType<'LocalMuteAudio'>)({
-          type: 'LocalMuteAudio',
-          value: [local.audio],
-        });
+      name={local.audio === ToggleState.enabled ? 'mic' : 'micOff'}
+      btnText={btnText}
+      style={{
+        ...styles.localBtn,
+        ...(variant === 'Outlined'
+          ? (muteLocalAudio as object)
+          : (muteRemoteAudio as object)),
+      }}
+      onPress={async () => {
+        const localState = local.audio;
+        // Don't do anything if it is in a transitional state
+        if (
+          localState === ToggleState.enabled ||
+          localState === ToggleState.disabled
+        ) {
+          // Disable UI
+          dispatch({
+            type: 'LocalMuteAudio',
+            value: [
+              localState === ToggleState.enabled
+                ? ToggleState.disabling
+                : ToggleState.enabling,
+            ],
+          });
+
+          try {
+            await RtcEngine.muteLocalAudioStream(
+              localState === ToggleState.enabled,
+            );
+            // Enable UI
+            dispatch({
+              type: 'LocalMuteAudio',
+              value: [
+                localState === ToggleState.enabled
+                  ? ToggleState.disabled
+                  : ToggleState.enabled,
+              ],
+            });
+          } catch (e) {
+            console.error(e);
+            dispatch({
+              type: 'LocalMuteAudio',
+              value: [localState],
+            });
+          }
+        }
       }}
     />
   );

package/template/agora-rn-uikit/src/Controls/Local/LocalVideoMute.tsx

@@ -1,27 +1,73 @@
 import React, {useContext} from 'react';
-import PropsContext from '../../PropsContext';
-import RtcContext, {DispatchType} from '../../RtcContext';
+import PropsContext, {ToggleState} from '../../Contexts/PropsContext';
+import RtcContext from '../../Contexts/RtcContext';
 import BtnTemplate from '../BtnTemplate';
 import styles from '../../Style';
-import {LocalContext} from '../../LocalUserContext';
+import {LocalContext} from '../../Contexts/LocalUserContext';
 
-function LocalVideoMute() {
+interface Props {
+  btnText?: string;
+  variant?: 'outlined' | 'text';
+}
+
+function LocalVideoMute(props: Props) {
+  const {btnText = 'Video', variant = 'Outlined'} = props;
   const {styleProps} = useContext(PropsContext);
-  const {localBtnStyles} = styleProps || {};
+  const {localBtnStyles, remoteBtnStyles} = styleProps || {};
   const {muteLocalVideo} = localBtnStyles || {};
-  const {dispatch} = useContext(RtcContext);
+  const {muteRemoteVideo} = remoteBtnStyles || {};
+  const {RtcEngine, dispatch} = useContext(RtcContext);
   const local = useContext(LocalContext);
 
   return (
     <BtnTemplate
-      name={local.video ? 'videocam' : 'videocamOff'}
-      btnText={'Video'}
-      style={{...styles.localBtn, ...(muteLocalVideo as object)}}
-      onPress={() => {
-        (dispatch as DispatchType<'LocalMuteVideo'>)({
-          type: 'LocalMuteVideo',
-          value: [local.video],
-        });
+      name={local.video === ToggleState.enabled ? 'videocam' : 'videocamOff'}
+      btnText={btnText}
+      style={{
+        ...styles.localBtn,
+        ...(variant === 'Outlined'
+          ? (muteLocalVideo as object)
+          : (muteRemoteVideo as object)),
+      }}
+      onPress={async () => {
+        const localState = local.video;
+        // Don't do anything if it is in a transitional state
+        if (
+          localState === ToggleState.enabled ||
+          localState === ToggleState.disabled
+        ) {
+          // Disable UI
+          dispatch({
+            type: 'LocalMuteVideo',
+            value: [
+              localState === ToggleState.enabled
+                ? ToggleState.disabling
+                : ToggleState.enabling,
+            ],
+          });
+
+          try {
+            await RtcEngine.muteLocalVideoStream(
+              localState === ToggleState.enabled ? true : false,
+            );
+            console.log('muted video', localState);
+            // Enable UI
+            dispatch({
+              type: 'LocalMuteVideo',
+              value: [
+                localState === ToggleState.enabled
+                  ? ToggleState.disabled
+                  : ToggleState.enabled,
+              ],
+            });
+          } catch (e) {
+            console.log('error while dispatching');
+            dispatch({
+              type: 'LocalMuteVideo',
+              value: [localState],
+            });
+          }
+        }
       }}
     />
   );

package/template/agora-rn-uikit/src/Controls/Local/Recording.tsx

@@ -1,6 +1,6 @@
 import React, {useContext} from 'react';
-import PropsContext from '../../PropsContext';
-import RtcContext, {DispatchType} from '../../RtcContext';
+import PropsContext from '../../Contexts/PropsContext';
+import RtcContext, {DispatchType} from '../../Contexts/RtcContext';
 import BtnTemplate from '../BtnTemplate';
 import styles from '../../Style';
 

package/template/agora-rn-uikit/src/Controls/Local/Screenshare.tsx

@@ -1,6 +1,6 @@
 import React, {useContext} from 'react';
-import PropsContext from '../../PropsContext';
-import RtcContext, {DispatchType} from '../../RtcContext';
+import PropsContext from '../../Contexts/PropsContext';
+import RtcContext, {DispatchType} from '../../Contexts/RtcContext';
 import BtnTemplate from '../BtnTemplate';
 import styles from '../../Style';
 

package/template/agora-rn-uikit/src/Controls/Local/SwitchCamera.tsx

@@ -1,25 +1,25 @@
 import React, {useContext} from 'react';
-import PropsContext from '../../PropsContext';
-import RtcContext, {DispatchType} from '../../RtcContext';
+import PropsContext,{ToggleState} from '../../Contexts/PropsContext';
+import {LocalContext} from '../../Contexts/LocalUserContext';
+import RtcContext from '../../Contexts/RtcContext';
 import BtnTemplate from '../BtnTemplate';
 import styles from '../../Style';
 
 function SwitchCamera() {
-  const {styleProps} = useContext(PropsContext);
+  const {styleProps, callbacks} = useContext(PropsContext);
   const {localBtnStyles} = styleProps || {};
   const {switchCamera} = localBtnStyles || {};
-  const {dispatch} = useContext(RtcContext);
+  const {RtcEngine} = useContext(RtcContext);
+  const local = useContext(LocalContext);
   return (
     <BtnTemplate
       name={'switchCamera'}
       style={{...styles.localBtn, ...(switchCamera as object)}}
       btnText={'Switch'}
+      disabled={local.video === ToggleState.enabled ? false : true}
       onPress={() => {
-        // RtcEngine.switchCamera();
-        (dispatch as DispatchType<'SwitchCamera'>)({
-          type: 'SwitchCamera',
-          value: [],
-        });
+        RtcEngine.switchCamera();
+        callbacks?.SwitchCamera && callbacks.SwitchCamera();
       }}
     />
   );

package/template/agora-rn-uikit/src/Controls/LocalControls.tsx

@@ -5,13 +5,16 @@ import EndCall from './Local/EndCall';
 import LocalAudioMute from './Local/LocalAudioMute';
 import LocalVideoMute from './Local/LocalVideoMute';
 import SwitchCamera from './Local/SwitchCamera';
-import FullScreen from './Local/FullScreen';
 import RemoteControls from './RemoteControls';
-import {MaxUidConsumer} from '../MaxUidContext';
-import PropsContext from '../PropsContext';
-import LocalUserContextComponent from '../LocalUserContext';
+import {MaxUidConsumer} from '../Contexts/MaxUidContext';
+import PropsContext from '../Contexts/PropsContext';
+import LocalUserContextComponent from '../Contexts/LocalUserContext';
 
-function Controls(props) {
+interface ControlsPropsInterface {
+  showButton?: boolean;
+}
+
+function Controls(props: ControlsPropsInterface) {
   const {styleProps} = useContext(PropsContext);
   const {localBtnContainer} = styleProps || {};
   const showButton = props.showButton !== undefined ? props.showButton : true;
@@ -20,20 +23,20 @@ function Controls(props) {
       <View style={{...styles.Controls, ...(localBtnContainer as object)}}>
         <LocalAudioMute />
         <LocalVideoMute />
-        <EndCall />
         <SwitchCamera />
-        <FullScreen />
+        <EndCall />
       </View>
-      {showButton ? <MaxUidConsumer>
-        {(users) => (
-          <View
-            style={{...styles.Controls, bottom: styles.Controls.bottom + 70}}>
-            <RemoteControls user={users[0]} showRemoteSwap={false} />
-          </View>
-        )}
-      </MaxUidConsumer>
-      : <></>
-      }
+      {showButton ? (
+        <MaxUidConsumer>
+          {(users) => (
+            <View style={{...styles.Controls, top: styles.Controls.top - 100}}>
+              <RemoteControls user={users[0]} showRemoteSwap={false} />
+            </View>
+          )}
+        </MaxUidConsumer>
+      ) : (
+        <></>
+      )}
     </LocalUserContextComponent>
   );
 }

package/template/agora-rn-uikit/src/Controls/Remote/RemoteAudioMute.tsx

@@ -1,8 +1,8 @@
 import React, {useContext} from 'react';
-import RtcContext, {UidInterface, DispatchType} from '../../RtcContext';
+import RtcContext from '../../Contexts/RtcContext';
 import BtnTemplate from '../BtnTemplate';
 import styles from '../../Style';
-import PropsContext from '../../PropsContext';
+import PropsContext, {ToggleState, UidInterface} from '../../Contexts/PropsContext';
 
 interface RemoteAudioMuteInterface {
   user: UidInterface;
@@ -16,17 +16,17 @@ const RemoteAudioMute: React.FC<RemoteAudioMuteInterface> = (props) => {
 
   return props.user.uid !== 'local' ? (
     <BtnTemplate
-      name={props.user.audio ? 'mic' : 'micOff'}
+      name={props.user.audio === ToggleState.enabled ? 'mic' : 'micOff'}
       style={{...styles.leftRemoteBtn, ...(muteRemoteAudio as object)}}
       onPress={() => {
         RtcEngine.muteRemoteAudioStream(
           props.user.uid as number,
-          props.user.audio,
+          props.user.audio === ToggleState.enabled,
         );
-        (dispatch as DispatchType<'UserMuteRemoteAudio'>)({
-          type: 'UserMuteRemoteAudio',
-          value: [props.user, props.user.audio],
-        });
+        // dispatch({
+        //   type: 'UserMuteRemoteAudio',
+        //   value: [props.user, props.user.audio],
+        // });
       }}
     />
   ) : (

package/template/agora-rn-uikit/src/Controls/Remote/RemoteSwap.tsx

@@ -1,8 +1,8 @@
 import React, {useContext} from 'react';
-import RtcContext, {DispatchType, UidInterface} from '../../RtcContext';
+import RtcContext from '../../Contexts/RtcContext';
 import BtnTemplate from '../BtnTemplate';
 import styles from '../../Style';
-import PropsContext from '../../PropsContext';
+import PropsContext, {UidInterface} from '../../Contexts/PropsContext';
 
 interface RemoteSwapInterface {
   user: UidInterface;
@@ -23,7 +23,7 @@ const RemoteSwap: React.FC<RemoteSwapInterface> = (props) => {
           : {}
       }
       onPress={() => {
-        (dispatch as DispatchType<'SwapVideo'>)({
+        dispatch({
           type: 'SwapVideo',
           value: [props.user],
         });

package/template/agora-rn-uikit/src/Controls/Remote/RemoteVideoMute.tsx

@@ -1,6 +1,9 @@
 import React, {useContext} from 'react';
-import PropsContext from '../../PropsContext';
-import RtcContext, {DispatchType, UidInterface} from '../../RtcContext';
+import PropsContext, {
+  ToggleState,
+  UidInterface,
+} from '../../Contexts/PropsContext';
+import RtcContext from '../../Contexts/RtcContext';
 import styles from '../../Style';
 import BtnTemplate from '../BtnTemplate';
 
@@ -17,7 +20,9 @@ const RemoteVideoMute: React.FC<RemoteVideoMuteInterface> = (props) => {
 
   return props.user.uid !== 'local' ? (
     <BtnTemplate
-      name={props.user.video ? 'videocam' : 'videocamOff'}
+      name={
+        props.user.video === ToggleState.enabled ? 'videocam' : 'videocamOff'
+      }
       style={
         props.rightButton
           ? {...styles.rightRemoteBtn, ...(muteRemoteVideo as object)}
@@ -26,12 +31,12 @@ const RemoteVideoMute: React.FC<RemoteVideoMuteInterface> = (props) => {
       onPress={() => {
         RtcEngine.muteRemoteVideoStream(
           props.user.uid as number,
-          props.user.video,
+          props.user.video === ToggleState.enabled, //If enabled, disable or vice-versa
         );
-        (dispatch as DispatchType<'UserMuteRemoteVideo'>)({
-          type: 'UserMuteRemoteVideo',
-          value: [props.user, props.user.video],
-        });
+        // dispatch({
+        //   type: 'UserMuteRemoteVideo',
+        //   value: [props.user, props.user.video],
+        // });
       }}
     />
   ) : (

package/template/agora-rn-uikit/src/Controls/RemoteControls.tsx

@@ -1,7 +1,6 @@
 import React, {useContext} from 'react';
 import {View} from 'react-native';
-import PropsContext from '../PropsContext';
-import {UidInterface} from '../RtcContext';
+import PropsContext, {UidInterface} from '../Contexts/PropsContext';
 import styles from '../Style';
 import RemoteAudioMute from './Remote/RemoteAudioMute';
 import RemoteSwap from './Remote/RemoteSwap';

package/template/agora-rn-uikit/src/Reducer/LocalMuteAudio.ts

@@ -0,0 +1,20 @@
+import {UidInterface} from '../Contexts/PropsContext';
+import {ActionType, UidStateInterface} from '../Contexts/RtcContext';
+
+export default function LocalMuteAudio(
+  state: UidStateInterface,
+  action: ActionType<'LocalMuteAudio'>,
+) {
+  let stateUpdate = {};
+  const LocalAudioMute = (user: UidInterface) => {
+    if (user.uid === 'local') {
+      user.audio = action.value[0];
+    }
+    return user;
+  };
+  stateUpdate = {
+    min: state.min.map(LocalAudioMute),
+    max: state.max.map(LocalAudioMute),
+  };
+  return stateUpdate;
+}

package/template/agora-rn-uikit/src/Reducer/LocalMuteVideo.ts

@@ -0,0 +1,20 @@
+import {UidInterface} from '../Contexts/PropsContext';
+import {ActionType, UidStateInterface} from '../Contexts/RtcContext';
+
+export default function LocalMuteVideo(
+  state: UidStateInterface,
+  action: ActionType<'LocalMuteVideo'>,
+) {
+  let stateUpdate = {};
+  const LocalVideoMute = (user: UidInterface) => {
+    if (user.uid === 'local') {
+      user.video = action.value[0];
+    }
+    return user;
+  };
+  stateUpdate = {
+    min: state.min.map(LocalVideoMute),
+    max: state.max.map(LocalVideoMute),
+  };
+  return stateUpdate;
+}

package/template/agora-rn-uikit/src/Reducer/RemoteAudioStateChanged.ts

@@ -0,0 +1,26 @@
+import {ToggleState, UidInterface} from '../Contexts/PropsContext';
+import {ActionType, UidStateInterface} from '../Contexts/RtcContext';
+
+export default function RemoteAudioStateChanged(
+  state: UidStateInterface,
+  action: ActionType<'RemoteAudioStateChanged'>,
+) {
+  let stateUpdate = {};
+  let audioState: ToggleState;
+  if (action.value[1] === 2 || action.value[1] === 1) {
+    audioState = ToggleState.enabled;
+  } else {
+    audioState = ToggleState.disabled;
+  }
+  const audioChange = (user: UidInterface) => {
+    if (user.uid === action.value[0]) {
+      user.audio = audioState;
+    }
+    return user;
+  };
+  stateUpdate = {
+    min: state.min.map(audioChange),
+    max: state.max.map(audioChange),
+  };
+  return stateUpdate;
+}

package/template/agora-rn-uikit/src/Reducer/RemoteVideoStateChanged.ts

@@ -0,0 +1,26 @@
+import {ToggleState, UidInterface} from '../Contexts/PropsContext';
+import {ActionType, UidStateInterface} from '../Contexts/RtcContext';
+
+export default function RemoteVideoStateChanged(
+  state: UidStateInterface,
+  action: ActionType<'RemoteVideoStateChanged'>,
+) {
+  let stateUpdate = {};
+  let videoState: ToggleState;
+  if (action.value[1] === 0) {
+    videoState = ToggleState.disabled;
+  } else if (action.value[1] === 2) {
+    videoState = ToggleState.enabled;
+  }
+  const videoChange = (user: UidInterface) => {
+    if (user.uid === action.value[0] && videoState !== undefined) {
+      user.video = videoState;
+    }
+    return user;
+  };
+  stateUpdate = {
+    min: state.min.map(videoChange),
+    max: state.max.map(videoChange),
+  };
+  return stateUpdate;
+}

package/template/agora-rn-uikit/src/Reducer/UpdateDualStreamMode.ts

@@ -0,0 +1,46 @@
+import {DualStreamMode, UidInterface} from '../Contexts/PropsContext';
+import {ActionType, UidStateInterface} from '../Contexts/RtcContext';
+
+export default function UpdateDualStreamMode(
+  state: UidStateInterface,
+  action: ActionType<'UpdateDualStreamMode'>,
+) {
+  const newMode = action.value[0];
+  let stateUpdate: UidStateInterface;
+  if (newMode === DualStreamMode.HIGH) {
+    // Update everybody to high
+    const maxStateUpdate: UidInterface[] = state.max.map((user) => ({
+      ...user,
+      streamType: 'high',
+    }));
+    const minStateUpdate: UidInterface[] = state.min.map((user) => ({
+      ...user,
+      streamType: 'high',
+    }));
+    stateUpdate = {min: minStateUpdate, max: maxStateUpdate};
+  } else if (newMode === DualStreamMode.LOW) {
+    // Update everybody to low
+    const maxStateUpdate: UidInterface[] = state.max.map((user) => ({
+      ...user,
+      streamType: 'low',
+    }));
+    const minStateUpdate: UidInterface[] = state.min.map((user) => ({
+      ...user,
+      streamType: 'low',
+    }));
+    stateUpdate = {min: minStateUpdate, max: maxStateUpdate};
+  } else {
+    // if (newMode === DualStreamMode.DYNAMIC)
+    // Max users are high other are low
+    const maxStateUpdate: UidInterface[] = state.max.map((user) => ({
+      ...user,
+      streamType: 'high',
+    }));
+    const minStateUpdate: UidInterface[] = state.min.map((user) => ({
+      ...user,
+      streamType: 'low',
+    }));
+    stateUpdate = {min: minStateUpdate, max: maxStateUpdate};
+  }
+  return stateUpdate;
+}

package/template/agora-rn-uikit/src/Reducer/UserJoined.ts

@@ -0,0 +1,47 @@
+import {DualStreamMode, ToggleState} from '../Contexts/PropsContext';
+import {ActionType, UidStateInterface} from '../Contexts/RtcContext';
+
+export default function UserJoined(
+  state: UidStateInterface,
+  action: ActionType<'UserJoined'>,
+  dualStreamMode: DualStreamMode,
+  uids: (string | number)[],
+) {
+  let stateUpdate = {};
+  if (uids.indexOf(action.value[0]) === -1) {
+    //If new user has joined
+    //By default add to minimized
+    let minUpdate = [
+      ...state.min,
+      {
+        uid: action.value[0],
+        audio: ToggleState.disabled,
+        video: ToggleState.disabled,
+        streamType: dualStreamMode === DualStreamMode.HIGH ? 'high' : 'low', // Low if DualStreamMode is LOW or DYNAMIC by default
+      },
+    ];
+
+    if (minUpdate.length === 1 && state.max[0].uid === 'local') {
+      //Only one remote and local is maximized
+      //Change stream type to high if dualStreaMode is DYNAMIC
+      if (dualStreamMode === DualStreamMode.DYNAMIC) {
+        minUpdate[0].streamType = 'high';
+      }
+      //Swap max and min
+      stateUpdate = {
+        max: minUpdate,
+        min: state.max,
+      };
+    } else {
+      //More than one remote
+      stateUpdate = {
+        min: minUpdate,
+      };
+    }
+
+    console.log('new user joined!\n', state, stateUpdate, {
+      dualStreamMode,
+    });
+  }
+  return stateUpdate;
+}

package/template/agora-rn-uikit/src/Reducer/UserMuteRemoteAudio.ts

@@ -0,0 +1,20 @@
+import {UidInterface} from '../Contexts/PropsContext';
+import {ActionType, UidStateInterface} from '../Contexts/RtcContext';
+
+export default function UserMuteRemoteAudio(
+  state: UidStateInterface,
+  action: ActionType<'UserMuteRemoteAudio'>,
+) {
+  let stateUpdate = {};
+  const audioMute = (user: UidInterface) => {
+    if (user.uid === action.value[0].uid) {
+      user.audio = action.value[1];
+    }
+    return user;
+  };
+  stateUpdate = {
+    min: state.min.map(audioMute),
+    max: state.max.map(audioMute),
+  };
+  return stateUpdate;
+}

package/template/agora-rn-uikit/src/Reducer/UserMuteRemoteVideo.ts

@@ -0,0 +1,20 @@
+import {UidInterface} from '../Contexts/PropsContext';
+import {ActionType, UidStateInterface} from '../Contexts/RtcContext';
+
+export default function UserMuteRemoteVideo(
+  state: UidStateInterface,
+  action: ActionType<'UserMuteRemoteVideo'>,
+) {
+  let stateUpdate = {};
+  const videoMute = (user: UidInterface) => {
+    if (user.uid === action.value[0].uid) {
+      user.video = action.value[1];
+    }
+    return user;
+  };
+  stateUpdate = {
+    min: state.min.map(videoMute),
+    max: state.max.map(videoMute),
+  };
+  return stateUpdate;
+}

package/template/agora-rn-uikit/src/Reducer/UserOffline.ts

@@ -0,0 +1,21 @@
+import {ActionType, UidStateInterface} from '../Contexts/RtcContext';
+
+export default function UserOffline(
+  state: UidStateInterface,
+  action: ActionType<'UserOffline'>,
+) {
+  let stateUpdate = {};
+  if (state.max[0].uid === action.value[0]) {
+    //If max has the remote video
+    let minUpdate = [...state.min];
+    stateUpdate = {
+      max: [minUpdate.pop()],
+      min: minUpdate,
+    };
+  } else {
+    stateUpdate = {
+      min: state.min.filter((user) => user.uid !== action.value[0]),
+    };
+  }
+  return stateUpdate;
+}

package/template/agora-rn-uikit/src/Reducer/index.ts

@@ -0,0 +1,9 @@
+export {default as UpdateDualStreamMode} from './UpdateDualStreamMode';
+export {default as UserJoined} from './UserJoined';
+export {default as UserOffline} from './UserOffline';
+export {default as UserMuteRemoteAudio} from './UserMuteRemoteAudio';
+export {default as UserMuteRemoteVideo} from './UserMuteRemoteVideo';
+export {default as LocalMuteAudio} from './LocalMuteAudio';
+export {default as LocalMuteVideo} from './LocalMuteVideo';
+export {default as RemoteAudioStateChanged} from './RemoteAudioStateChanged';
+export {default as RemoteVideoStateChanged} from './RemoteVideoStateChanged';