agora-appbuilder-core 4.1.7 → 4.1.8-2

package/template/src/utils/useCreateRoom.ts

@@ -1,31 +1,13 @@
-import {gql, useMutation} from '@apollo/client';
 import {RoomInfoContextInterface} from '../components/room-info/useRoomInfo';
 import {useSetRoomInfo} from '../components/room-info/useSetRoomInfo';
 import SDKEvents from '../utils/SdkEvents';
-import isSDK from './isSDK';
 import {LogSource, logger} from '../logger/AppBuilderLogger';
 import getUniqueID from './getUniqueID';
+import {useContext} from 'react';
+import StorageContext from '../components/StorageContext';
+
+const CREATE_ROOM_URL = `${$config.BACKEND_ENDPOINT}/v1/channel`;
 
-const CREATE_CHANNEL = gql`
-  mutation CreateChannel($title: String!, $enablePSTN: Boolean) {
-    createChannel(title: $title, enablePSTN: $enablePSTN) {
-      passphrase {
-        host
-        view
-      }
-      channel
-      title
-      pstn {
-        number
-        dtmf
-        error {
-          code
-          message
-        }
-      }
-    }
-  }
-`;
 /**
  * Returns an asynchronous function to create a meeting with the given options.
  */
@@ -34,8 +16,8 @@ export type createRoomFun = (
   enablePSTN?: boolean,
 ) => Promise<void>;
 export default function useCreateRoom(): createRoomFun {
-  const [createChannel, {error}] = useMutation(CREATE_CHANNEL);
   const {setRoomInfo} = useSetRoomInfo();
+  const {store} = useContext(StorageContext);
   return async (
     roomTitle: string,
     enablePSTN?: boolean,
@@ -56,25 +38,99 @@ export default function useCreateRoom(): createRoomFun {
         requestId,
       },
     );
-    const res = await createChannel({
-      context: {
+    try {
+      const payload = JSON.stringify({
+        title: roomTitle,
+        enable_pstn: enablePSTN,
+      });
+      const response = await fetch(`${CREATE_ROOM_URL}`, {
+        method: 'POST',
         headers: {
+          'Content-Type': 'application/json',
+          authorization: store.token ? `Bearer ${store.token}` : '',
           'X-Request-Id': requestId,
           'X-Session-Id': logger.getSessionId(),
         },
-      },
-      variables: {
-        title: roomTitle,
-        enablePSTN: enablePSTN,
-      },
-    });
-    const endReqTs = Date.now();
-    const latency = endReqTs - startReqTs;
-    // in React-SDK mode, we use a more recent package of @apollo/client
-    // which is compatible with react18, long term we should be looking to
-    // upgrade core dependency as well. The following condition accounts
-    // for differences in the way the two version function.
-    if (error && !isSDK) {
+        body: payload,
+      });
+      const res = await response.json();
+      if (res?.error) {
+        throw res.error;
+      } else if (res?.channel) {
+        const endReqTs = Date.now();
+        const latency = endReqTs - startReqTs;
+        logger.log(
+          LogSource.NetworkRest,
+          'createChannel',
+          'API createChannel. Channel created successfully',
+          {
+            responseData: res,
+            startReqTs,
+            endReqTs,
+            latency: latency,
+            requestId,
+          },
+        );
+        let roomInfo: Partial<RoomInfoContextInterface['data']> = {
+          roomId: {
+            attendee: '',
+          },
+        };
+        if (res?.viewer_pass_phrase) {
+          roomInfo.roomId.attendee = res.viewer_pass_phrase;
+        }
+        if (res?.host_pass_phrase) {
+          roomInfo.roomId.host = res.host_pass_phrase;
+        }
+        if (enablePSTN === true && res?.pstn) {
+          if (res.pstn?.error?.code || res.pstn?.error?.message) {
+            roomInfo.pstn = {
+              number: '',
+              pin: '',
+              error: {
+                code: res.pstn?.error?.code,
+                message: res.pstn?.error?.message,
+              },
+            };
+          } else {
+            roomInfo.pstn = {
+              number: res.pstn?.number,
+              pin: res.pstn?.dtmf,
+              error: null,
+            };
+          }
+        }
+        logger.log(LogSource.Internals, 'CREATE_MEETING', 'Room created', {
+          isHost: true,
+          isSeparateHostLink: isSeparateHostLink ? true : false,
+          meetingTitle: roomTitle,
+          roomId: roomInfo?.roomId,
+          pstn: roomInfo?.pstn,
+        });
+        setRoomInfo(prev => {
+          return {
+            ...prev,
+            data: {
+              isHost: true,
+              isSeparateHostLink: isSeparateHostLink ? true : false,
+              meetingTitle: roomTitle,
+              roomId: roomInfo?.roomId,
+              pstn: roomInfo?.pstn,
+            },
+          };
+        });
+        SDKEvents.emit(
+          'create',
+          roomInfo.roomId.host,
+          roomInfo.roomId.attendee,
+          roomInfo?.pstn,
+        );
+      } else {
+        throw new Error(`An error occurred in parsing the channel data.`);
+      }
+    } catch (error) {
+      const endReqTs = Date.now();
+      const latency = endReqTs - startReqTs;
       logger.error(
         LogSource.NetworkRest,
         'createChannel',
@@ -89,79 +145,5 @@ export default function useCreateRoom(): createRoomFun {
       );
       throw error;
     }
-
-    if (res && res?.data && res?.data?.createChannel) {
-      logger.log(
-        LogSource.NetworkRest,
-        'createChannel',
-        'API createChannel. Channel created successfully',
-        {
-          responseData: res.data.createChannel,
-          startReqTs,
-          endReqTs,
-          latency: latency,
-          requestId,
-        },
-      );
-      let roomInfo: Partial<RoomInfoContextInterface['data']> = {
-        roomId: {
-          attendee: '',
-        },
-      };
-      if (res?.data?.createChannel?.passphrase?.view) {
-        roomInfo.roomId.attendee = res.data.createChannel.passphrase.view;
-      }
-      if (res?.data?.createChannel?.passphrase?.host) {
-        roomInfo.roomId.host = res.data.createChannel.passphrase.host;
-      }
-      if (enablePSTN === true && res?.data?.createChannel?.pstn) {
-        if (
-          res.data.createChannel.pstn?.error?.code ||
-          res.data.createChannel.pstn?.error?.message
-        ) {
-          roomInfo.pstn = {
-            number: '',
-            pin: '',
-            error: {
-              code: res.data.createChannel.pstn?.error?.code,
-              message: res.data.createChannel.pstn?.error?.message,
-            },
-          };
-        } else {
-          roomInfo.pstn = {
-            number: res.data.createChannel.pstn?.number,
-            pin: res.data.createChannel.pstn?.dtmf,
-            error: null,
-          };
-        }
-      }
-      logger.log(LogSource.Internals, 'CREATE_MEETING', 'Room created', {
-        isHost: true,
-        isSeparateHostLink: isSeparateHostLink ? true : false,
-        meetingTitle: roomTitle,
-        roomId: roomInfo?.roomId,
-        pstn: roomInfo?.pstn,
-      });
-      setRoomInfo(prev => {
-        return {
-          ...prev,
-          data: {
-            isHost: true,
-            isSeparateHostLink: isSeparateHostLink ? true : false,
-            meetingTitle: roomTitle,
-            roomId: roomInfo?.roomId,
-            pstn: roomInfo?.pstn,
-          },
-        };
-      });
-      SDKEvents.emit(
-        'create',
-        roomInfo.roomId.host,
-        roomInfo.roomId.attendee,
-        roomInfo?.pstn,
-      );
-    } else {
-      throw new Error(`An error occurred in parsing the channel data.`);
-    }
   };
 }

package/template/src/utils/useEndCall.ts

@@ -1,6 +1,11 @@
 import {useContext} from 'react';
 import {useCustomization} from 'customization-implementation';
-import {useCaption, useContent, useRoomInfo} from 'customization-api';
+import {
+  useCaption,
+  useContent,
+  useRoomInfo,
+  useSTTAPI,
+} from 'customization-api';
 import {PropsContext, DispatchContext} from '../../agora-rn-uikit';
 import {useHistory} from '../components/Router';
 import {stopForegroundService} from '../subComponents/LocalEndCall';
@@ -18,6 +23,7 @@ const useEndCall = () => {
   } = useRoomInfo();
   const {authLogin} = useAuth();
   const {deleteChatUser} = useChatConfigure();
+  const {stop: stopSTTAPI} = useSTTAPI();
 
   const {rtcProps} = useContext(PropsContext);
   const {dispatch} = useContext(DispatchContext);
@@ -49,9 +55,16 @@ const useEndCall = () => {
     stopForegroundService();
     // stopping STT on call end,if only last user is remaining in call
     const usersInCall = Object.entries(defaultContent).filter(
-      item => item[1].type === 'rtc',
+      item =>
+        item[1].type === 'rtc' && item[1].isHost === 'true' && !item[1].offline,
     );
-    usersInCall.length === 1 && isSTTActive && stop();
+    if (usersInCall.length === 1 && isSTTActive) {
+      console.log('Stopping stt api as only one host is in the call');
+      stopSTTAPI().catch(error => {
+        console.log('Error stopping stt', error);
+      });
+    }
+
     // removing user from chat server
     if ($config.CHAT) {
       deleteChatUser();

package/template/src/utils/useGetMeetingPhrase.ts

@@ -1,31 +1,15 @@
 import {useContext} from 'react';
-import {gql} from '@apollo/client';
 import {RoomInfoContextInterface} from '../components/room-info/useRoomInfo';
 import {useSetRoomInfo} from '../components/room-info/useSetRoomInfo';
-import {GraphQLContext} from '../components/GraphQLProvider';
 import getUniqueID from './getUniqueID';
 import {LogSource, logger} from '../logger/AppBuilderLogger';
+import StorageContext from '../components/StorageContext';
 
-const SHARE = gql`
-  query share($passphrase: String!) {
-    share(passphrase: $passphrase) {
-      passphrase {
-        host
-        view
-      }
-      channel
-      title
-      pstn {
-        number
-        dtmf
-      }
-    }
-  }
-`;
+const SHARE_URL = `${$config.BACKEND_ENDPOINT}/v1/channel/share`;
 
 export default function useGetMeetingPhrase() {
   const {setRoomInfo} = useSetRoomInfo();
-  const {client} = useContext(GraphQLContext);
+  const {store} = useContext(StorageContext);
   return async (phrase: string) => {
     const requestId = getUniqueID();
     const startReqTs = Date.now();
@@ -38,25 +22,77 @@ export default function useGetMeetingPhrase() {
         startReqTs,
       },
     );
-    const response = await client.query({
-      context: {
+    try {
+      const payload = JSON.stringify({
+        passphrase: phrase,
+      });
+      const res = await fetch(`${SHARE_URL}`, {
+        method: 'POST',
         headers: {
+          'Content-Type': 'application/json',
+          authorization: store.token ? `Bearer ${store.token}` : '',
           'X-Request-Id': requestId,
           'X-Session-Id': logger.getSessionId(),
         },
-      },
-      query: SHARE,
-      variables: {
-        passphrase: phrase,
-      },
-    });
-    const endReqTs = Date.now();
-    if (response.error) {
+        body: payload,
+      });
+      const response = await res.json();
+      if (response?.error) {
+        throw response.error;
+      } else {
+        const endReqTs = Date.now();
+        logger.log(
+          LogSource.Internals,
+          'GET_MEETING_PHRASE',
+          'Query GET_MEETING_PHRASE success',
+          {
+            responseData: response,
+            requestId,
+            startReqTs,
+            endReqTs,
+            latency: endReqTs - startReqTs,
+          },
+        );
+        try {
+          if (response) {
+            let data = response;
+            let roomInfo: Partial<RoomInfoContextInterface['data']> = {
+              roomId: {attendee: ''},
+            };
+            if (data?.passphrases?.attendee) {
+              roomInfo.roomId.attendee = data.passphrases.attendee;
+            }
+            if (data?.passphrases?.host) {
+              roomInfo.roomId.host = data.passphrases.host;
+            }
+            if (data?.pstn) {
+              roomInfo.pstn = {
+                number: data.pstn.number,
+                pin: data.pstn.dtmf,
+              };
+            }
+            setRoomInfo(prevState => {
+              return {
+                ...prevState,
+                data: {
+                  ...prevState.data,
+                  roomId: roomInfo.roomId,
+                  pstn: roomInfo?.pstn,
+                },
+              };
+            });
+          }
+        } catch (error) {
+          throw new Error('An error occurred in parsing the channel data.');
+        }
+      }
+    } catch (error) {
+      const endReqTs = Date.now();
       logger.error(
         LogSource.Internals,
         'GET_MEETING_PHRASE',
         'Query GET_MEETING_PHRASE failed',
-        JSON.stringify(response?.error || {}),
+        JSON.stringify(error || {}),
         {
           requestId,
           startReqTs,
@@ -64,52 +100,7 @@ export default function useGetMeetingPhrase() {
           latency: endReqTs - startReqTs,
         },
       );
-      throw response.error;
-    } else {
-      logger.log(
-        LogSource.Internals,
-        'GET_MEETING_PHRASE',
-        'Query GET_MEETING_PHRASE success',
-        {
-          responseData: response,
-          requestId,
-          startReqTs,
-          endReqTs,
-          latency: endReqTs - startReqTs,
-        },
-      );
-      try {
-        if (response && response.data) {
-          let data = response.data;
-          let roomInfo: Partial<RoomInfoContextInterface['data']> = {
-            roomId: {attendee: ''},
-          };
-          if (data?.share?.passphrase?.view) {
-            roomInfo.roomId.attendee = data.share.passphrase.view;
-          }
-          if (data?.share?.passphrase?.host) {
-            roomInfo.roomId.host = data.share.passphrase.host;
-          }
-          if (data?.share?.pstn) {
-            roomInfo.pstn = {
-              number: data.share.pstn.number,
-              pin: data.share.pstn.dtmf,
-            };
-          }
-          setRoomInfo(prevState => {
-            return {
-              ...prevState,
-              data: {
-                ...prevState.data,
-                roomId: roomInfo.roomId,
-                pstn: roomInfo?.pstn,
-              },
-            };
-          });
-        }
-      } catch (error) {
-        throw new Error('An error occurred in parsing the channel data.');
-      }
+      throw error;
     }
   };
 }

package/template/src/utils/useJoinRoom.ts

@@ -1,10 +1,7 @@
 import {useContext} from 'react';
-import {gql} from '@apollo/client';
 import StorageContext from '../components/StorageContext';
 import {RoomInfoContextInterface} from '../components/room-info/useRoomInfo';
 import {useSetRoomInfo} from '../components/room-info/useSetRoomInfo';
-import {GraphQLContext} from '../components/GraphQLProvider';
-import useGetName from './useGetName';
 import useWaitingRoomAPI from '../subComponents/waiting-rooms/useWaitingRoomAPI';
 import {base64ToUint8Array} from '../utils';
 import {LogSource, logger} from '../logger/AppBuilderLogger';
@@ -61,7 +58,6 @@ export default function useJoinRoom() {
           send_event: false,
         });
       } else {
-        console.log('debugging store.token', store.token);
         logger.log(
           LogSource.NetworkRest,
           'joinChannel',
@@ -160,6 +156,11 @@ export default function useJoinRoom() {
               isWaitingRoomEnabled ? data.secretSalt : data.secret_salt,
             ) as Uint8Array;
           }
+
+          if (data?.encryption_mode) {
+            roomInfo.encryptionMode = data.encryption_mode;
+          }
+
           if (data?.screen_share_user?.uid || data?.screenShare?.uid) {
             roomInfo.screenShareUid = isWaitingRoomEnabled
               ? data.screenShare.uid

package/template/src/utils/useMutePSTN.ts

@@ -1,23 +1,18 @@
-import {gql, useMutation} from '@apollo/client';
 import {UidType} from '../../agora-rn-uikit';
 import {useRoomInfo} from '../components/room-info/useRoomInfo';
 import useIsPSTN from './useIsPSTN';
 import getUniqueID from './getUniqueID';
 import {LogSource, logger} from '../logger/AppBuilderLogger';
-const MUTE_PSTN = gql`
-  mutation mutePSTN($uid: Int!, $passphrase: String!, $mute: Boolean!) {
-    mutePSTN(uid: $uid, passphrase: $passphrase, mute: $mute) {
-      uid
-      mute
-    }
-  }
-`;
+import {useContext} from 'react';
+import StorageContext from '../components/StorageContext';
+
+const MUTE_PSTN_URL = `${$config.BACKEND_ENDPOINT}/v1/channel/pstn/mute`;
 
 const useMutePSTN = () => {
-  const [mutePSTN, {data, loading, error}] = useMutation(MUTE_PSTN);
   const {
     data: {isHost, roomId},
   } = useRoomInfo();
+  const {store} = useContext(StorageContext);
   const isPSTN = useIsPSTN();
   return async (uid: UidType) => {
     const startReqTs = Date.now();
@@ -30,48 +25,55 @@ const useMutePSTN = () => {
           'Mutation try to call MUTE_PSTN ',
           {startReqTs, requestId},
         );
-        await mutePSTN({
-          context: {
+        const payload = JSON.stringify({
+          uid: uid?.toString(),
+          passphrase: roomId?.host,
+          mute: true,
+        });
+        try {
+          const res = await fetch(`${MUTE_PSTN_URL}`, {
+            method: 'POST',
             headers: {
+              'Content-Type': 'application/json',
+              authorization: store.token ? `Bearer ${store.token}` : '',
               'X-Request-Id': requestId,
               'X-Session-Id': logger.getSessionId(),
             },
-          },
-          variables: {
-            uid: uid,
-            passphrase: roomId?.host,
-            //todo: hari need to test mute flag for PSTN
-            mute: 1,
-          },
-        });
+            body: payload,
+          });
+          const response = await res.json();
+
+          if (response?.error) {
+            throw response?.error;
+          } else {
+            const endReqTs = Date.now();
+            logger.log(
+              LogSource.Internals,
+              'MUTE_PSTN',
+              'Mutation MUTE_PSTN success',
+              {startReqTs, endReqTs, latency: endReqTs - startReqTs, requestId},
+            );
+            return response;
+          }
+        } catch (error) {
+          const endReqTs = Date.now();
+          logger.error(
+            LogSource.Internals,
+            'MUTE_PSTN',
+            'Mutation MUTE_PSTN success',
+            JSON.stringify(error || {}),
+            {
+              startReqTs,
+              endReqTs,
+              latency: endReqTs - startReqTs,
+              requestId,
+            },
+          );
+          throw error;
+        }
       } else {
         console.error('UID does not belong to the PSTN user.');
       }
-      if (!loading && error) {
-        const endReqTs = Date.now();
-        logger.error(
-          LogSource.Internals,
-          'MUTE_PSTN',
-          'Mutation MUTE_PSTN success',
-          JSON.stringify(error || {}),
-          {
-            startReqTs,
-            endReqTs,
-            latency: endReqTs - startReqTs,
-            requestId,
-          },
-        );
-        throw error;
-      } else {
-        const endReqTs = Date.now();
-        logger.log(
-          LogSource.Internals,
-          'MUTE_PSTN',
-          'Mutation MUTE_PSTN success',
-          {startReqTs, endReqTs, latency: endReqTs - startReqTs, requestId},
-        );
-        return data;
-      }
     } else {
       console.error('A host can only mute audience audio or video.');
     }

package/template/webpack.rsdk.config.js

@@ -1,6 +1,6 @@
 const commons = require('./webpack.commons');
 const path = require('path');
-const { merge } = require('webpack-merge');
+const {merge} = require('webpack-merge');
 
 const isDevelopment = process.env.NODE_ENV === 'development';
 
@@ -16,7 +16,6 @@ module.exports = merge(commons, {
     'react-dom': 'react-dom',
     'react-router': 'react-router',
     'react-router-dom': 'react-router-dom',
-    '@apollo/client': '@apollo/client',
   },
   // Main entry point for the web application
   entry: {