agora-appbuilder-core 4.0.7 → 4.0.8

package/template/bridge/rtc/webNg/RtcEngine.ts

@@ -39,6 +39,7 @@ import {role, mode, RtcEngineContext} from './Types';
 import {LOG_ENABLED, GEO_FENCING} from '../../../config.json';
 import {Platform} from 'react-native';
 import isMobileOrTablet from '../../../src/utils/isMobileOrTablet';
+import {LogSource, logger} from '../../../src/logger/AppBuilderLogger';
 
 interface MediaDeviceInfo {
   readonly deviceId: string;
@@ -248,22 +249,58 @@ export default class RtcEngine {
 
   initialize(context: RtcEngineContext) {
     const {appId} = context;
+    logger.log(LogSource.AgoraSDK, 'Log', 'RTC engine initialized');
     this.appId = appId;
   }
 
   getRemoteVideoStats(id: string) {
     try {
+      logger.log(
+        LogSource.AgoraSDK,
+        'API',
+        'RTC [getRemoteVideoStats] getting remote video stats',
+      );
       const data = this.client.getRemoteVideoStats();
+      logger.debug(
+        LogSource.AgoraSDK,
+        'API',
+        'RTC [getRemoteVideoStats] got remote video stats successfully',
+        data,
+      );
       return data && data[id] ? data[id] : null;
     } catch (error) {
-      console.log(`ERROR: on getRemoteVideoStats - ` + error?.message);
+      logger.error(
+        LogSource.AgoraSDK,
+        'API',
+        'RTC [getRemoteVideoStats] Error while getting remote video stats',
+        error,
+      );
       return null;
     }
   }
 
   async setVideoProfile(profile: VideoProfile): Promise<void> {
-    this.videoProfile = profile;
-    this.localStream?.video?.setEncoderConfiguration(profile);
+    try {
+      this.videoProfile = profile;
+      logger.log(
+        LogSource.AgoraSDK,
+        'API',
+        `RTC [setEncoderConfiguration] setting video profile to - ${profile}`,
+      );
+      this.localStream?.video?.setEncoderConfiguration(profile);
+      logger.log(
+        LogSource.AgoraSDK,
+        'API',
+        `RTC [setEncoderConfiguration] set video profile to - ${profile} successfully`,
+      );
+    } catch (error) {
+      logger.error(
+        LogSource.AgoraSDK,
+        'API',
+        'RTC [setEncoderConfiguration] Error while setting video profile',
+        error,
+      );
+    }
   }
 
   async enableAudio(): Promise<void> {
@@ -272,13 +309,31 @@ export default class RtcEngine {
       // microphoneId: this.audioDeviceId,
     };
     try {
+      logger.log(
+        LogSource.AgoraSDK,
+        'API',
+        'RTC [createMicrophoneAudioTrack] creating audio track',
+        audioConfig,
+      );
       let localAudio = await AgoraRTC.createMicrophoneAudioTrack(audioConfig);
+      logger.log(
+        LogSource.AgoraSDK,
+        'API',
+        'RTC [createMicrophoneAudioTrack] created audio track successfully',
+        audioConfig,
+      );
       this.localStream.audio = localAudio;
       this.audioDeviceId = localAudio
         ?.getMediaStreamTrack()
         .getSettings().deviceId;
       this.isAudioEnabled = true;
     } catch (e) {
+      logger.error(
+        LogSource.AgoraSDK,
+        'API',
+        'RTC [createMicrophoneAudioTrack] Error while creating audio track',
+        error,
+      );
       let audioError = e;
       e.status = {audioError};
       throw e;
@@ -307,6 +362,15 @@ export default class RtcEngine {
       cameraId: preferredCameraId,
     };
     try {
+      logger.log(
+        LogSource.AgoraSDK,
+        'API',
+        'RTC [createMicrophoneAndCameraTracks] creating audio and video tracks',
+        {
+          audioConfig,
+          videoConfig,
+        },
+      );
       let [localAudio, localVideo] =
         // If preferred devices are not present, the createTrack call will fallover to
         // the catch block below.
@@ -314,6 +378,15 @@ export default class RtcEngine {
           audioConfig,
           videoConfig,
         );
+      logger.log(
+        LogSource.AgoraSDK,
+        'API',
+        'RTC [createMicrophoneAndCameraTracks] audio and video tracks created successfully',
+        {
+          audio: localAudio,
+          video: localVideo,
+        },
+      );
       this.localStream.audio = localAudio;
       this.localStream.video = localVideo;
       this.audioDeviceId = localAudio
@@ -325,16 +398,52 @@ export default class RtcEngine {
       this.isVideoEnabled = true;
       this.isAudioEnabled = true;
     } catch (e) {
+      logger.log(
+        LogSource.AgoraSDK,
+        'API',
+        'RTC [createMicrophoneAndCameraTracks] Error while creating audio and video tracks',
+        {
+          error: e,
+        },
+      );
       let audioError = false;
       let videoError = false;
-
       try {
         let localAudio: IMicrophoneAudioTrack;
+        logger.log(
+          LogSource.AgoraSDK,
+          'API',
+          'RTC [createMicrophoneAudioTrack] creating audio track ',
+          audioConfig,
+        );
         try {
           localAudio = await AgoraRTC.createMicrophoneAudioTrack(audioConfig);
-        } catch (e) {
+          logger.log(
+            LogSource.AgoraSDK,
+            'API',
+            'RTC [createMicrophoneAudioTrack] audio track created',
+            localAudio,
+          );
+        } catch (eAudio) {
+          logger.log(
+            LogSource.AgoraSDK,
+            'API',
+            'RTC [createMicrophoneAudioTrack] Error while creating audio tracks',
+            eAudio,
+          );
+          logger.log(
+            LogSource.AgoraSDK,
+            'Log',
+            'RTC [createMicrophoneAudioTrack] Setting microphoneId as empty and again creating audio track',
+          );
           videoConfig.microphoneId = '';
           localAudio = await AgoraRTC.createMicrophoneAudioTrack(audioConfig);
+          logger.log(
+            LogSource.AgoraSDK,
+            'API',
+            'RTC [createMicrophoneAudioTrack] audio track created successfully',
+            localAudio,
+          );
         }
         this.localStream.audio = localAudio;
         this.audioDeviceId = localAudio
@@ -342,22 +451,71 @@ export default class RtcEngine {
           .getSettings().deviceId;
         this.isAudioEnabled = true;
       } catch (error) {
+        logger.error(
+          LogSource.AgoraSDK,
+          'API',
+          'RTC [createMicrophoneAudioTrack] Error while creating audio track',
+          error,
+        );
         audioError = error;
       }
 
       try {
         let localVideo: ICameraVideoTrack;
         try {
+          logger.log(
+            LogSource.AgoraSDK,
+            'API',
+            'RTC [createCameraVideoTrack] creating video track',
+            videoConfig,
+          );
           localVideo = await AgoraRTC.createCameraVideoTrack(videoConfig);
-        } catch (e) {
+          logger.log(
+            LogSource.AgoraSDK,
+            'API',
+            'RTC [createCameraVideoTrack] video track created successfully',
+            localVideo,
+          );
+        } catch (eVideo) {
+          logger.debug(
+            LogSource.AgoraSDK,
+            'API',
+            'RTC [createCameraVideoTrack] Error while creating video tracks',
+            eVideo,
+          );
+          logger.log(
+            LogSource.AgoraSDK,
+            'Log',
+            'RTC [createCameraVideoTrack] Setting cameraId as empty and again creating video track',
+          );
           videoConfig.cameraId = '';
           try {
             localVideo = await AgoraRTC.createCameraVideoTrack(videoConfig);
-          } catch (e) {
-            console.log(
-              '[RTCEngineBridge]: Provided cameraId and default camera failed, trying other available devices',
+            logger.log(
+              LogSource.AgoraSDK,
+              'API',
+              'RTC video track created',
+              localVideo,
+            );
+          } catch (error) {
+            logger.debug(
+              LogSource.AgoraSDK,
+              'API',
+              'RTC [createCameraVideoTrack] Error while creating video track',
+              error,
+            );
+            logger.log(
+              LogSource.AgoraSDK,
+              'Log',
+              'RTC [RTCEngineBridge]: Provided cameraId and default camera failed, Trying other available devices',
             );
             const devices = await navigator.mediaDevices.enumerateDevices();
+            logger.log(
+              LogSource.AgoraSDK,
+              'Log',
+              'RTC [enumerateDevices] media devices available',
+              devices,
+            );
             for (let device of devices) {
               if (device.kind === 'videoinput') {
                 videoConfig.cameraId = device.deviceId;
@@ -366,13 +524,16 @@ export default class RtcEngine {
                     videoConfig,
                   );
                   break;
-                } catch (e) {
-                  videoError = e;
-                  console.log(
-                    '[RTCEngineBridge]:',
-                    'Camera not available with deviceId' + device,
-                    'Reason: ',
-                    e,
+                } catch (eVideoDevice) {
+                  videoError = eVideoDevice;
+                  logger.log(
+                    LogSource.AgoraSDK,
+                    'Log',
+                    'RTC Camera not available with deviceId',
+                    {
+                      device,
+                      reason: eVideoDevice,
+                    },
                   );
                 }
               }
@@ -385,9 +546,14 @@ export default class RtcEngine {
           .getSettings().deviceId;
         this.isVideoEnabled = true;
       } catch (error) {
+        logger.error(
+          LogSource.AgoraSDK,
+          'API',
+          'RTC [createCameraVideoTrack] Error while creating video track',
+          error,
+        );
         videoError = error;
       }
-
       e.status = {audioError, videoError};
       throw e;
       // if (audioError && videoError) throw e;
@@ -400,7 +566,17 @@ export default class RtcEngine {
 
   async enableAudioVolumeIndication(interval, smooth, isLocal) {
     AgoraRTC.setParameter('AUDIO_VOLUME_INDICATION_INTERVAL', interval);
+    logger.log(
+      LogSource.AgoraSDK,
+      'API',
+      `RTC [setParameter] parameter AUDIO_VOLUME_INDICATION_INTERVAL set to interval ${interval}`,
+    );
     this.client.enableAudioVolumeIndicator();
+    logger.log(
+      LogSource.AgoraSDK,
+      'API',
+      'RTC [enableAudioVolumeIndicator] enabled to report the local and remote users who are speaking and their volumes',
+    );
   }
 
   async publish() {
@@ -415,7 +591,18 @@ export default class RtcEngine {
           tracks.push(this.localStream.video);
 
         if (tracks.length > 0) {
+          logger.log(
+            LogSource.AgoraSDK,
+            'API',
+            'RTC [publish] trying to publish tracks',
+            tracks,
+          );
           await this.client.publish(tracks);
+          logger.log(
+            LogSource.AgoraSDK,
+            'API',
+            'RTC [publish] tracks done successfully',
+          );
           if (tracks[0].trackMediaType === 'audio') {
             this.isAudioPublished = true;
           } else if (tracks[0].trackMediaType === 'video') {
@@ -434,6 +621,15 @@ export default class RtcEngine {
           }
         }
       } catch (e) {
+        logger.error(
+          LogSource.AgoraSDK,
+          'API',
+          'RTC [publish] Error publish tracks failed',
+          {
+            error: e,
+            stream: this.localStream,
+          },
+        );
         console.error(e, this.localStream);
         this.isPublished = false;
       }
@@ -448,6 +644,7 @@ export default class RtcEngine {
   ): Promise<void> {
     // TODO create agora client here
     this.client.on('user-joined', user => {
+      logger.log(LogSource.AgoraSDK, 'Event', 'RTC [user-joined]', user);
       (this.eventsMap.get('onUserJoined') as callbackType)({}, user.uid);
       (this.eventsMap.get('onRemoteVideoStateChanged') as callbackType)(
         {},
@@ -466,6 +663,7 @@ export default class RtcEngine {
     });
 
     this.client.on('user-left', user => {
+      logger.log(LogSource.AgoraSDK, 'Event', 'RTC [user-left]', user);
       const uid = user.uid;
       if (this.remoteStreams.has(uid)) {
         this.remoteStreams.delete(uid);
@@ -475,6 +673,13 @@ export default class RtcEngine {
     });
     this.client.on('user-published', async (user, mediaType) => {
       // Initiate the subscription
+      logger.log(
+        LogSource.AgoraSDK,
+        'Event',
+        'RTC [user-published]',
+        user,
+        mediaType,
+      );
       if (this.inScreenshare && user.uid === this.screenClient.uid) {
         (this.eventsMap.get('onRemoteVideoStateChanged') as callbackType)(
           {},
@@ -485,6 +690,13 @@ export default class RtcEngine {
         );
       } else {
         await this.client.subscribe(user, mediaType);
+        logger.log(
+          LogSource.AgoraSDK,
+          'API',
+          'RTC [subscribe] to track successfully done',
+          user,
+          mediaType,
+        );
       }
       // If the subscribed track is an audio track
       if (mediaType === 'audio') {
@@ -526,6 +738,13 @@ export default class RtcEngine {
       }
     });
     this.client.on('user-unpublished', async (user, mediaType) => {
+      logger.log(
+        LogSource.AgoraSDK,
+        'Event',
+        'RTC [user-unpublished]',
+        user,
+        mediaType,
+      );
       if (mediaType === 'audio') {
         const {audio, ...rest} = this.remoteStreams.get(user.uid);
         this.remoteStreams.set(user.uid, rest);
@@ -585,7 +804,13 @@ export default class RtcEngine {
 
     // this.client.on('stream-fallback', (evt))
     this.client.on('stream-type-changed', function (uid, streamType) {
-      console.log('[fallback]: ', uid, streamType);
+      logger.debug(
+        LogSource.AgoraSDK,
+        'Event',
+        'RTC [stream-type-changed]',
+        uid,
+        streamType,
+      );
     });
 
     this.client.on(
@@ -618,20 +843,40 @@ export default class RtcEngine {
 
     /* Recieve Captions  */
     this.client.on('stream-message', (uid: UID, payload: UInt8Array) => {
-      console.log(
-        `stt-web: onStreamMessageCallback uid:${uid} , payload:${payload}`,
+      logger.debug(
+        LogSource.AgoraSDK,
+        'Event',
+        'RTC [stream-message](stt-web: onStreamMessageCallback)',
+        uid,
+        payload,
       );
       (this.eventsMap.get('onStreamMessage') as callbackType)(uid, payload);
     });
 
+    logger.log(LogSource.AgoraSDK, 'API', 'RTC [join] trying to join channel', {
+      appId: this.appId,
+      channelName,
+      token,
+      optionalUid,
+    });
     await this.client.join(
       this.appId,
       channelName,
       token || null,
       optionalUid || null,
     );
+    logger.log(
+      LogSource.AgoraSDK,
+      'API',
+      'RTC [join] channel joined successfully',
+    );
     this.isJoined = true;
 
+    logger.log(
+      LogSource.AgoraSDK,
+      'Log',
+      'RTC [publish] start publishing in the channel',
+    );
     await this.publish();
     console.log('enabling screen sleep');
   }
@@ -642,11 +887,21 @@ export default class RtcEngine {
 
   async leaveChannel(): Promise<void> {
     this.client.leave();
+    logger.log(
+      LogSource.AgoraSDK,
+      'API',
+      'RTC [leave] client has left the channel successfully',
+    );
     this.remoteStreams.forEach((stream, uid, map) => {
       stream.video?.close();
       stream.audio?.close();
     });
     this.remoteStreams.clear();
+    logger.log(
+      LogSource.AgoraSDK,
+      'Log',
+      'RTC closed all remote streams successfully',
+    );
     console.log('disabling screen sleep');
   }
 
@@ -689,12 +944,34 @@ export default class RtcEngine {
          *  The camera light stays on for video
          *  It takes less time for the audio or video to resume.
          */
+        logger.log(
+          LogSource.AgoraSDK,
+          'Log',
+          `RTC [setMuted] trying to ${
+            muted ? 'mute' : 'unmute'
+          } local audio stream`,
+        );
+        logger.log(
+          LogSource.AgoraSDK,
+          'API',
+          `RTC [setMuted] on audio track with value - ${muted}`,
+        );
         await this.localStream.audio?.setMuted(muted);
+        logger.log(
+          LogSource.AgoraSDK,
+          'API',
+          'RTC [setMuted] on audio track successfully done',
+        );
         // Release the lock once done
         this.muteLocalAudioMutex = false;
         this.isAudioEnabled = !muted;
         // Unpublish only after when the user has joined the call
         if (!muted && !this.isAudioPublished && this.isJoined) {
+          logger.log(
+            LogSource.AgoraSDK,
+            'Log',
+            'RTC [publish] trying to publish audio track',
+          );
           await this.publish();
         }
       }
@@ -702,9 +979,11 @@ export default class RtcEngine {
       if (didProcureMutexLock) {
         this.muteLocalAudioMutex = false;
       }
-      console.error(
+      logger.error(
+        LogSource.AgoraSDK,
+        'Log',
+        'RTC [setMuted] Error Be sure to invoke the enableVideo method before calling setMuted method.',
         e,
-        '\n Be sure to invoke the enableVideo method before using this method.',
       );
     }
   }
@@ -721,13 +1000,35 @@ export default class RtcEngine {
          *  The indicator light of the camera turns off and stays off.
          *  It takes more time for the audio or video to resume.
          */
+        logger.log(
+          LogSource.AgoraSDK,
+          'Log',
+          `RTC [setEnabled] trying to ${
+            muted ? 'mute' : 'unmute'
+          } local video stream`,
+        );
+        logger.log(
+          LogSource.AgoraSDK,
+          'API',
+          `RTC [setEnabled] on video track with value - ${!muted}`,
+        );
         await this.localStream.video?.setEnabled(!muted);
+        logger.log(
+          LogSource.AgoraSDK,
+          'API',
+          'RTC [setEnabled] on video track done successfully',
+        );
         // Release the lock once done
         this.muteLocalVideoMutex = false;
 
         this.isVideoEnabled = !muted;
         // Unpublish only after when the user has joined the call
         if (!muted && !this.isVideoPublished && this.isJoined) {
+          logger.log(
+            LogSource.AgoraSDK,
+            'Log',
+            'RTC [publish] publish video track',
+          );
           await this.publish();
         }
       }
@@ -737,25 +1038,70 @@ export default class RtcEngine {
       if (didProcureMutexLock) {
         this.muteLocalVideoMutex = false;
       }
-      console.error(
+      logger.error(
+        LogSource.AgoraSDK,
+        'Log',
+        'RTC  [setEnabled] Error Be sure to invoke the enableVideo method before calling setEnabled method.',
         e,
-        '\n Be sure to invoke the enableVideo method before using this method.',
       );
     }
   }
 
   async muteRemoteAudioStream(uid: number, muted: boolean): Promise<void> {
     try {
+      logger.log(
+        LogSource.AgoraSDK,
+        'API',
+        `RTC [setEnabled] trying to ${
+          muted ? 'mute' : 'unmute'
+        } remote audio stream of user ${uid}`,
+      );
       this.remoteStreams.get(uid)?.audio?.setEnabled(!muted);
+      logger.log(
+        LogSource.AgoraSDK,
+        'API',
+        `RTC  [setEnabled] ${
+          muted ? 'muted' : 'unmuted'
+        } remote audio stream of user ${uid} done successfully`,
+      );
     } catch (e) {
-      console.error(e);
+      logger.error(
+        LogSource.AgoraSDK,
+        'API',
+        `RTC [setEnabled] Error: while ${
+          muted ? 'muting' : 'unmuting'
+        } remote audio stream of user ${uid}`,
+        e,
+      );
     }
   }
 
   async muteRemoteVideoStream(uid: number, muted: boolean): Promise<void> {
     try {
+      logger.log(
+        LogSource.AgoraSDK,
+        'API',
+        `RTC [setEnabled] trying to ${
+          muted ? 'mute' : 'unmute'
+        } remote video stream of user ${uid}`,
+      );
       this.remoteStreams.get(uid)?.video?.setEnabled(!muted);
+      logger.log(
+        LogSource.AgoraSDK,
+        'API',
+        `RTC [setEnabled]  ${
+          muted ? 'muted' : 'unmuted'
+        } remote video stream of user ${uid} successfully`,
+      );
     } catch (e) {
+      logger.error(
+        LogSource.AgoraSDK,
+        'API',
+        `RTC [setEnabled] Error while ${
+          muted ? 'muting' : 'unmuting'
+        } remote video stream of user ${uid}`,
+        e,
+      );
       console.error(e);
     }
   }
@@ -770,6 +1116,11 @@ export default class RtcEngine {
 
   async setChannelProfile(profile: ChannelProfileType): Promise<void> {
     try {
+      logger.log(
+        LogSource.AgoraSDK,
+        'API',
+        `RTC [createClient] creating user and screen client with profile ${profile}`,
+      );
       this.client = AgoraRTC.createClient({
         codec: 'vp9',
         mode:
@@ -784,7 +1135,22 @@ export default class RtcEngine {
             ? mode.live
             : mode.rtc,
       });
+      logger.log(
+        LogSource.AgoraSDK,
+        'API',
+        `RTC [createClient] user and screen client with profile ${profile} created successfully`,
+        {
+          client: this.client,
+          screenClient: this.screenClient,
+        },
+      );
     } catch (e) {
+      logger.error(
+        LogSource.AgoraSDK,
+        'API',
+        `RTC [createClient] Error while creating user and screen client with profile ${profile}`,
+        e,
+      );
       throw e;
     }
   }
@@ -794,10 +1160,34 @@ export default class RtcEngine {
     options?: ClientRoleOptions,
   ): Promise<void> {
     try {
+      logger.log(
+        LogSource.AgoraSDK,
+        'API',
+        `RTC [setClientRole] for user and screen client with role ${
+          clientRole == ClientRoleType.ClientRoleAudience
+            ? 'audience'
+            : 'broadcaster'
+        }`,
+      );
       if (clientRole == ClientRoleType.ClientRoleAudience) {
         if (this.isJoined) {
           // Unpublish the streams when role is changed to Audience
+          logger.log(
+            LogSource.AgoraSDK,
+            'Log',
+            'RTC user is already joined, and role is to be changed to audience so we need to unpublish the streams',
+          );
+          logger.log(
+            LogSource.AgoraSDK,
+            'API',
+            'RTC [unpublish] unpublish in the channel',
+          );
           await this.client.unpublish();
+          logger.log(
+            LogSource.AgoraSDK,
+            'API',
+            'RTC [unpublish] unpublish in the channel done successfully',
+          );
           this.isAudioPublished = false;
           this.isVideoPublished = false;
           this.isPublished = false;
@@ -808,43 +1198,115 @@ export default class RtcEngine {
         await this.client.setClientRole(role.host);
         await this.screenClient.setClientRole(role.host);
       }
+      logger.log(
+        LogSource.AgoraSDK,
+        'API',
+        `RTC [setClientRole] for user and screen client with role ${
+          clientRole == ClientRoleType.ClientRoleAudience
+            ? 'audience'
+            : 'broadcaster'
+        } done successfully`,
+      );
     } catch (e) {
+      logger.error(
+        LogSource.AgoraSDK,
+        'API',
+        `RTC [setClientRole] Error while doing setClientRole for user and screen client with role ${
+          clientRole == ClientRoleType.ClientRoleAudience
+            ? 'audience'
+            : 'broadcaster'
+        }`,
+        e,
+      );
       throw e;
     }
   }
 
   async changeCamera(cameraId, callback, error): Promise<void> {
     try {
+      logger.log(
+        LogSource.AgoraSDK,
+        'API',
+        `RTC [setDevice] trying to change camera to ${cameraId}`,
+      );
       await this.localStream.video?.setDevice(cameraId);
+      logger.log(
+        LogSource.AgoraSDK,
+        'API',
+        'RTC [setDevice] camera set done successfully',
+      );
       this.videoDeviceId = cameraId;
       callback(cameraId);
     } catch (e) {
+      logger.error(
+        LogSource.AgoraSDK,
+        'API',
+        'RTC [setDevice] Error setting camera',
+        e,
+      );
       error(e);
     }
   }
 
   async switchCamera(): Promise<void> {
     try {
+      logger.log(
+        LogSource.AgoraSDK,
+        'Log',
+        'RTC switching camera on mobile web',
+      );
       const devices = await AgoraRTC.getDevices(true);
       for (let i = 0; i < devices.length; i++) {
         let d = devices[i];
         if (d.kind === 'videoinput' && d.deviceId !== this.videoDeviceId) {
+          logger.log(
+            LogSource.AgoraSDK,
+            'API',
+            `RTC [setDevice]: trying to change camera to ${d.deviceId}`,
+          );
           await this.localStream.video?.setDevice(d.deviceId);
+          logger.log(
+            LogSource.AgoraSDK,
+            'API',
+            'RTC [setDevice]: camera set successfully',
+          );
           this.videoDeviceId = d.deviceId;
           break;
         }
       }
     } catch (e) {
+      logger.error(
+        LogSource.AgoraSDK,
+        'Log',
+        'RTC Error switching camera on mobile web',
+        e,
+      );
       throw e;
     }
   }
 
   async changeMic(micId, callback, error) {
     try {
+      logger.log(
+        LogSource.AgoraSDK,
+        'API',
+        `RTC [setDevice]: trying to change microphone to ${micId}`,
+      );
       await this.localStream.audio?.setDevice(micId);
+      logger.log(
+        LogSource.AgoraSDK,
+        'API',
+        'RTC [setDevice]: microphone set successfully',
+      );
       this.audioDeviceId = micId;
       callback(micId);
     } catch (e) {
+      logger.error(
+        LogSource.AgoraSDK,
+        'API',
+        'RTC [setDevice]: Error setting microphone',
+        e,
+      );
       error(e);
     }
   }
@@ -939,6 +1401,15 @@ export default class RtcEngine {
     let mode: EncryptionMode;
     mode = this.getEncryptionMode(enabled, config?.encryptionMode);
     try {
+      logger.log(
+        LogSource.AgoraSDK,
+        'API',
+        'RTC [setEncryptionConfig] trying to set encryption config on user and screen client',
+        {
+          mode,
+          key: config.encryptionKey,
+        },
+      );
       await Promise.all([
         this.client.setEncryptionConfig(
           mode,
@@ -953,7 +1424,20 @@ export default class RtcEngine {
           true, // encryptDataStream
         ),
       ]);
+      logger.log(
+        LogSource.AgoraSDK,
+        'API',
+        'RTC [setEncryptionConfig] set encryption config on user and screen client done successfully',
+      );
     } catch (e) {
+      logger.log(
+        LogSource.AgoraSDK,
+        'API',
+        'RTC [setEncryptionConfig] Error while setting encryption config on user and screen client',
+        {
+          error: e,
+        },
+      );
       throw e;
     }
   }
@@ -1008,6 +1492,11 @@ export default class RtcEngine {
     this.screenStream.audio?.close();
     this.screenStream.video?.close();
     this.screenStream = {};
+    logger.log(
+      LogSource.AgoraSDK,
+      'Log',
+      'RTC destroy called. Clearing all events and closing all streams',
+    );
   }
 
   async setRemoteVideoStreamType(
@@ -1047,8 +1536,11 @@ export default class RtcEngine {
   ): Promise<void> {
     if (!this.inScreenshare) {
       try {
-        console.log('[screenshare]: creating stream');
-
+        logger.debug(
+          LogSource.AgoraSDK,
+          'Log',
+          'RTC start screenshare, creating stream',
+        );
         if (encryption && encryption.screenKey && encryption.mode) {
           let mode: EncryptionMode;
           mode = this.getEncryptionMode(true, encryption?.mode);
@@ -1058,6 +1550,11 @@ export default class RtcEngine {
              * and joins again the encryption needs to be
              * set again
              */
+            logger.log(
+              LogSource.AgoraSDK,
+              'Log',
+              'RTC [setEncryptionConfig] setting encryption again on screen client',
+            );
             await this.screenClient.setEncryptionConfig(
               mode,
               encryption.screenKey,
@@ -1065,14 +1562,36 @@ export default class RtcEngine {
               true, // encryptDataStream
             );
           } catch (e) {
-            console.log('e: Encryption for screenshare failed', e);
+            logger.error(
+              LogSource.AgoraSDK,
+              'Log',
+              'RTC [setEncryptionConfig] Error setting encryption for screenshare failed',
+              e,
+            );
           }
         }
 
+        logger.log(
+          LogSource.AgoraSDK,
+          'API',
+          'RTC [createScreenVideoTrack] Trying to create screenshare tracks',
+          {
+            config,
+            audio,
+          },
+        );
         const screenTracks = await AgoraRTC.createScreenVideoTrack(
           config,
           audio,
         );
+        logger.log(
+          LogSource.AgoraSDK,
+          'API',
+          'RTC [createScreenVideoTrack] screenshare tracks created successfully',
+          {
+            tracks: screenTracks,
+          },
+        );
         if (this.isSingleTrack(screenTracks)) {
           this.screenStream.video = screenTracks;
         } else {
@@ -1080,24 +1599,55 @@ export default class RtcEngine {
           this.screenStream.audio = screenTracks[1];
         }
       } catch (e) {
-        console.log('[screenshare]: Error during intialization');
+        logger.error(
+          LogSource.AgoraSDK,
+          'API',
+          'RTC [createScreenVideoTrack] Error while creating screenshare tracks',
+          e,
+        );
         throw e;
       }
 
+      logger.log(
+        LogSource.AgoraSDK,
+        'API',
+        'RTC [join] joining channel of screenclient',
+        {
+          appId: this.appId,
+          channelName,
+          token,
+          optionalUid,
+        },
+      );
       await this.screenClient.join(
         this.appId,
         channelName,
         token || null,
         optionalUid || null,
       );
-
+      logger.log(
+        LogSource.AgoraSDK,
+        'API',
+        'RTC [join] joined channel successfully',
+      );
       this.inScreenshare = true;
+      logger.log(
+        LogSource.AgoraSDK,
+        'API',
+        'RTC [publish] trying to publish tracks',
+        this.screenStream,
+      );
       await this.screenClient.publish(
         this.screenStream.audio
           ? [this.screenStream.video, this.screenStream.audio]
           : this.screenStream.video,
       );
-
+      logger.log(
+        LogSource.AgoraSDK,
+        'API',
+        'RTC [publish] screenshare tracks published successfully',
+        this.screenStream,
+      );
       this.screenStream.video.on('track-ended', () => {
         (this.eventsMap.get('onUserOffline') as callbackType)(
           {},