agora-python-server-sdk 2.0.2__tar.gz → 2.0.4__tar.gz

agora_python_server_sdk-2.0.4/PKG-INFO

@@ -0,0 +1,53 @@
+Metadata-Version: 2.1
+Name: agora_python_server_sdk
+Version: 2.0.4
+Summary: A Python SDK for Agora Server
+Home-page: https://github.com/AgoraIO-Extensions/Agora-Python-Server-SDK
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Topic :: Multimedia :: Sound/Audio
+Classifier: Topic :: Multimedia :: Video
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# Note
+- This is a Python SDK wrapper for the Agora RTC SDK.
+- It supports Linux and Mac platforms.
+- The examples are provided as very simple demonstrations and are not recommended for use in production environments.
+
+# Very Important Notice !!!
+- A process can only have one instance.
+- An instance can have multiple connections.
+- In all observers or callbacks, you must not call the SDK's own APIs, nor perform CPU-intensive tasks in the callbacks; data copying is allowed.
+
+# Required Operating Systems and Python Versions
+- Supported Linux versions:
+  - Ubuntu 18.04 LTS and above
+  - CentOS 7.0 and above
+  
+- Supported Mac versions:
+  - MacOS 13 and above
+
+- Python version:
+  - Python 3.8 and above
+
+# Using Agora-Python-Server-SDK
+```
+pip install agora_python_server_sdk
+```
+
+# Running Examples
+
+## Preparing Test Data
+- Download and unzip [test_data.zip](https://download.agora.io/demo/test/test_data_202408221437.zip) to the Agora-Python-Server-SDK directory.
+
+## Executing Test Script
+```
+python agora_rtc/examples/example_audio_pcm_send.py --appId=xxx --channelId=xxx --userId=xxx --audioFile=./test_data/demo.pcm --sampleRate=16000 --numOfChannels=1
+```
+

agora_python_server_sdk-2.0.4/README.md

@@ -0,0 +1,36 @@
+# Note
+- This is a Python SDK wrapper for the Agora RTC SDK.
+- It supports Linux and Mac platforms.
+- The examples are provided as very simple demonstrations and are not recommended for use in production environments.
+
+# Very Important Notice !!!
+- A process can only have one instance.
+- An instance can have multiple connections.
+- In all observers or callbacks, you must not call the SDK's own APIs, nor perform CPU-intensive tasks in the callbacks; data copying is allowed.
+
+# Required Operating Systems and Python Versions
+- Supported Linux versions:
+  - Ubuntu 18.04 LTS and above
+  - CentOS 7.0 and above
+  
+- Supported Mac versions:
+  - MacOS 13 and above
+
+- Python version:
+  - Python 3.8 and above
+
+# Using Agora-Python-Server-SDK
+```
+pip install agora_python_server_sdk
+```
+
+# Running Examples
+
+## Preparing Test Data
+- Download and unzip [test_data.zip](https://download.agora.io/demo/test/test_data_202408221437.zip) to the Agora-Python-Server-SDK directory.
+
+## Executing Test Script
+```
+python agora_rtc/examples/example_audio_pcm_send.py --appId=xxx --channelId=xxx --userId=xxx --audioFile=./test_data/demo.pcm --sampleRate=16000 --numOfChannels=1
+```
+

agora_python_server_sdk-2.0.4/agora/rtc/__init__.py

@@ -0,0 +1,65 @@
+#!/usr/bin/env python
+
+import os
+import sys
+import logging
+logger = logging.getLogger(__name__)
+import ctypes
+from urllib import request
+import site
+import zipfile
+import ssl
+ssl._create_default_https_context = ssl._create_unverified_context
+
+def _check_download_and_extract_sdk():
+    agora_service_path = os.path.dirname(os.path.abspath(__file__))
+    sdk_dir = os.path.join(agora_service_path, "agora_sdk")
+    zip_path = os.path.join(agora_service_path, "agora_rtc_sdk.zip")
+
+    url = "https://download.agora.io/sdk/release/agora_rtc_sdk_linux_v4.4.30-20240928_160128-358664.zip"
+    libagora_rtc_sdk_path = os.path.join(sdk_dir, "libagora_rtc_sdk.so")
+    if sys.platform == 'darwin':
+        url = "https://download.agora.io/sdk/release/agora_sdk_mac_v4.4.30_22119_FULL_20240928_1647_358680.zip"
+        libagora_rtc_sdk_path = os.path.join(sdk_dir, "libAgoraRtcKit.dylib")
+
+    if os.path.exists(libagora_rtc_sdk_path):
+        return
+
+    logger.error("missing agora sdk, now download it, please wait for a while...")
+    if os.path.exists(sdk_dir):
+        os.system(f"rm -rf {sdk_dir}")        
+    os.makedirs(agora_service_path, exist_ok=True)
+    if os.path.exists(zip_path):
+        os.remove(zip_path)
+
+    logger.info(f"agora_service_path: {agora_service_path}")
+    logger.info(f"Downloading {url}...")
+    request.urlretrieve(url, zip_path)
+
+    logger.info(f"Extracting {zip_path}...")
+    with zipfile.ZipFile(zip_path, 'r') as zip_ref:
+        zip_ref.extractall(agora_service_path)
+
+    if os.path.exists(zip_path):
+        os.remove(zip_path)
+
+
+_check_download_and_extract_sdk()
+
+sdk_dir = os.path.dirname(os.path.abspath(__file__))
+lib_path = os.path.join(sdk_dir, 'agora_sdk')
+
+try:
+    if sys.platform == 'darwin':
+        lib_agora_rtc_path =os.path.join(lib_path, 'libAgoraRtcKit.dylib')
+        agora_lib = ctypes.CDLL(lib_agora_rtc_path)
+
+    elif sys.platform == 'linux':
+        lib_agora_rtc_path =os.path.join(lib_path, 'libagora_rtc_sdk.so')
+        ctypes.CDLL(os.path.join(lib_path, 'libagora-fdkaac.so'))
+        ctypes.CDLL(os.path.join(lib_path, 'libaosl.so'))
+        agora_lib = ctypes.CDLL(lib_agora_rtc_path)    
+except OSError as e:
+    logger.error(f"Error loading the library: {e}")
+    logger.error(f"Attempted to load from: {lib_agora_rtc_path}")
+    sys.exit(1)

{agora_python_server_sdk-2.0.2 → agora_python_server_sdk-2.0.4}/agora/rtc/_audio_frame_observer.py

@@ -3,6 +3,8 @@ from .agora_base import *
 from .local_user import *
 import ctypes
 from .audio_frame_observer import *
+import logging
+logger = logging.getLogger(__name__)
 
 
 class AudioFrameInner(ctypes.Structure):
@@ -14,7 +16,12 @@ class AudioFrameInner(ctypes.Structure):
         ("samples_per_sec", ctypes.c_int),
         ("buffer", ctypes.c_void_p),
         ("render_time_ms", ctypes.c_int64),
-        ("avsync_type", ctypes.c_int)
+        ("avsync_type", ctypes.c_int),
+        ("far_field_flag", ctypes.c_int),
+        ("rms", ctypes.c_int),
+        ("voice_prob", ctypes.c_int),
+        ("music_prob", ctypes.c_int),
+        ("pitch", ctypes.c_int)
     ]
     def _to_audio_frame(self):
         audio_frame = AudioFrame()
@@ -27,6 +34,12 @@ class AudioFrameInner(ctypes.Structure):
         audio_frame.buffer = bytearray(cdata)
         audio_frame.render_time_ms = self.render_time_ms
         audio_frame.avsync_type = self.avsync_type
+        audio_frame.far_field_flag = self.far_field_flag
+        audio_frame.rms = self.rms
+        audio_frame.voice_prob = self.voice_prob
+        audio_frame.music_prob = self.music_prob
+        audio_frame.pitch = self.pitch
+
         return audio_frame
     
 
@@ -73,31 +86,31 @@ class AudioFrameObserverInner(ctypes.Structure):
         # self.on_get_ear_monitoring_audio_frame_param = ON_GET_EAR_MONITORING_AUDIO_FRAME_PARAM_CALLBACK(self._on_get_ear_monitoring_audio_frame_param)
 
     def _on_record_audio_frame(self, local_user_handle, channel_id, audio_frame_inner):
-        # print("AudioFrameObserverInner _on_record_audio_frame", local_user_handle, channel_id, audio_frame_inner)
+        logger.debug(f"AudioFrameObserverInner _on_record_audio_frame: {local_user_handle}, {channel_id}, {audio_frame_inner}")
         channel_id_str = channel_id.decode('utf-8')
         frame = audio_frame_inner.contents._to_audio_frame()
         ret = self.observer.on_record_audio_frame(self.local_user, channel_id_str, frame)
         return ret
 
     def _on_playback_audio_frame(self, local_user_handle, channel_id, audio_frame_inner):
-        # print("AudioFrameObserverInner _on_playback_audio_frame", local_user_handle, channel_id, audio_frame_inner)
+        logger.debug(f"AudioFrameObserverInner _on_playback_audio_frame: {local_user_handle}, {channel_id}, {audio_frame_inner}")
         channel_id_str = channel_id.decode('utf-8')
         frame = audio_frame_inner.contents._to_audio_frame()
         ret = self.observer.on_playback_audio_frame(self.local_user, channel_id_str, frame)
         return ret
 
     def _on_mixed_audio_frame(self, local_user_handle, channel_id, audio_frame_inner):
-        # print("AudioFrameObserverInner _on_mixed_audio_frame", local_user_handle, channel_id, audio_frame_inner)
+        logger.debug(f"AudioFrameObserverInner _on_mixed_audio_frame: {local_user_handle}, {channel_id}, {audio_frame_inner}")
         ret = self.observer.on_mixed_audio_frame(self.local_user, audio_frame_inner)
         return ret
 
     def _on_ear_monitoring_audio_frame(self, local_user_handle, audio_frame_inner):
-        # print("AudioFrameObserverInner _on_ear_monitoring_audio_frame", local_user_handle, audio_frame_inner)
+        logger.debug(f"AudioFrameObserverInner _on_ear_monitoring_audio_frame: {local_user_handle}, {audio_frame_inner}")
         ret = self.observer.on_ear_monitoring_audio_frame(self.local_user, audio_frame_inner)
         return ret
 
     def _on_playback_audio_frame_before_mixing(self, local_user_handle, channel_id, user_id, audio_frame_inner):
-        # print("AudioFrameObserverInner _on_playback_audio_frame_before_mixing", local_user_handle, channel_id, user_id, audio_frame_inner)
+        #logger.debug(f"AudioFrameObserverInner _on_playback_audio_frame_before_mixing: {local_user_handle}, {channel_id}, {user_id}, {audio_frame_inner}")
         if channel_id is None:
             channel_id_str = ""
         else:
@@ -109,47 +122,22 @@ class AudioFrameObserverInner(ctypes.Structure):
         return ret
     
     def _on_get_audio_frame_position(self, local_user_handle):
-        # print("AudioFrameObserverInner _on_get_audio_frame_position", local_user_handle)
-        return 0
+        logger.debug(f"AudioFrameObserverInner _on_get_audio_frame_position: {local_user_handle}")
         return self.observer.on_get_audio_frame_position(self.local_user)
 
-    def _on_get_playback_audio_frame_param(self, local_user_handle):
-        # print("AudioFrameObserverInner _on_get_playback_audio_frame_param", local_user_handle)
-        params = AudioParams()
-        params.sample_rate = 16000  # 示例值
-        params.channels = 1          # 示例值
-        params.mode = 0              # 示例值
-        params.samples_per_call = 1024  # 示例值
-        return params
+    def _on_get_playback_audio_frame_param(self, local_user_handle) -> AudioParams:
+        logger.debug(f"AudioFrameObserverInner _on_get_playback_audio_frame_param: {local_user_handle}")
         return self.observer.on_get_playback_audio_frame_param(self.local_user)
 
-    def _on_get_record_audio_frame_param(self, local_user_handle):
-        # print("AudioFrameObserverInner _on_get_record_audio_frame_param", local_user_handle)
-        params = AudioParams()
-        params.sample_rate = 16000  # 示例值
-        params.channels = 1          # 示例值
-        params.mode = 0              # 示例值
-        params.samples_per_call = 1024  # 示例值
-        return params
+    def _on_get_record_audio_frame_param(self, local_user_handle) -> AudioParams:
+        logger.debug(f"AudioFrameObserverInner _on_get_record_audio_frame_param: {local_user_handle}")
         return self.observer.on_get_record_audio_frame_param(self.local_user)
 
-    def _on_get_mixed_audio_frame_param(self, local_user_handle):
-        # print("AudioFrameObserverInner _on_get_mixed_audio_frame_param", local_user_handle)
-        params = AudioParams()
-        params.sample_rate = 16000  # 示例值
-        params.channels = 1          # 示例值
-        params.mode = 0              # 示例值
-        params.samples_per_call = 1024  # 示例值
-        return params
+    def _on_get_mixed_audio_frame_param(self, local_user_handle) -> AudioParams:
+        logger.debug(f"AudioFrameObserverInner _on_get_mixed_audio_frame_param: {local_user_handle}")
         return self.observer.on_get_mixed_audio_frame_param(self.local_user)
 
-    def _on_get_ear_monitoring_audio_frame_param(self, local_user_handle):
-        # print("AudioFrameObserverInner _on_get_ear_monitoring_audio_frame_param", local_user_handle)
-        params = AudioParams()
-        params.sample_rate = 16000  # 示例值
-        params.channels = 1          # 示例值
-        params.mode = 0              # 示例值
-        params.samples_per_call = 1024  # 示例值
-        return params
+    def _on_get_ear_monitoring_audio_frame_param(self, local_user_handle) -> AudioParams:
+        logger.debug(f"AudioFrameObserverInner _on_get_ear_monitoring_audio_frame_param: {local_user_handle}")
         return self.observer.on_get_ear_monitoring_audio_frame_param(self.local_user)
 

{agora_python_server_sdk-2.0.2 → agora_python_server_sdk-2.0.4}/agora/rtc/_local_user_observer.py

@@ -3,12 +3,8 @@ from .agora_base import *
 from .local_user import *
 from .remote_audio_track import RemoteAudioTrack, RemoteAudioTrackStats
 from .remote_video_track import RemoteVideoTrack, RemoteVideoTrackStats
-uid_t = ctypes.c_uint
-track_id_t = ctypes.c_uint
-
-#========localuser observer=====
-
-
+import logging
+logger = logging.getLogger(__name__)
 
 class VideoTrackInfoInner(ctypes.Structure):
     _fields_ = [
@@ -52,7 +48,6 @@ class RemoteVideoStreamInfo(ctypes.Structure):
         ("total_downscale_level_counts", ctypes.c_uint8)
     ]
 
-# 定义回调函数类型
 ON_AUDIO_TRACK_PUBLISH_SUCCESS_CALLBACK = ctypes.CFUNCTYPE(None, AGORA_HANDLE, AGORA_HANDLE)
 ON_AUDIO_TRACK_PUBLISH_START_CALLBACK = ctypes.CFUNCTYPE(None, AGORA_HANDLE, AGORA_HANDLE)
 ON_AUDIO_TRACK_UNPUBLISHED_CALLBACK = ctypes.CFUNCTYPE(None, AGORA_HANDLE, AGORA_HANDLE)
@@ -91,31 +86,6 @@ ON_REMOTE_SUBSCRIBE_FALLBACK_TO_AUDIO_ONLY_CALLBACK = ctypes.CFUNCTYPE(None, AGO
 ON_STREAM_MESSAGE_CALLBACK = ctypes.CFUNCTYPE(None, AGORA_HANDLE, user_id_t, ctypes.c_int, ctypes.c_char_p, ctypes.c_size_t)
 ON_USER_STATE_CHANGED_CALLBACK = ctypes.CFUNCTYPE(None, AGORA_HANDLE, user_id_t, ctypes.c_uint32)
 
-
-"""
-on_user_info_updated(user_id_t: string ;  msg: int, val: int)
-msg:  
-enum USER_MEDIA_INFO {
-    /**
-     * 0: The user has muted the audio.
-     */
-    USER_MEDIA_INFO_MUTE_AUDIO = 0,
-    /**
-     * 1: The user has muted the video.
-     */
-    USER_MEDIA_INFO_MUTE_VIDEO = 1,
-    /**
-     * 4: The user has enabled the video, which includes video capturing and encoding.
-     */
-    USER_MEDIA_INFO_ENABLE_VIDEO = 4,
-    /**
-     * 8: The user has enabled the local video capturing.
-     */
-    USER_MEDIA_INFO_ENABLE_LOCAL_VIDEO = 8,
-  };
-  val: 1: The user has muted the audio.0: unmuted the audio
-参考：https://doc.shengwang.cn/api-ref/rtc-server-sdk/cpp/classagora_1_1rtc_1_1_i_local_user_observer#onUserInfoUpdated()
-"""
 class RTCLocalUserObserverInner(ctypes.Structure):
     _fields_ = [
         ("on_audio_track_publish_success", ON_AUDIO_TRACK_PUBLISH_SUCCESS_CALLBACK),
@@ -208,63 +178,49 @@ class RTCLocalUserObserverInner(ctypes.Structure):
     Avoid to create a global LocalAudioTrack map table as it can significantly impact performance .
     """
     def _on_audio_track_publish_success(self, local_user_handle, local_audio_track_handle):
-        print("LocalUserCB _on_audio_track_publish_success:", local_user_handle, local_audio_track_handle)
+        logger.debug(f"LocalUserCB _on_audio_track_publish_success: {local_user_handle}, {local_audio_track_handle}")
         #note: to get 
         audio_track = self.local_user.get_audio_map(local_audio_track_handle)
         self.local_user_observer.on_audio_track_publish_success(self.local_user, audio_track)
     
     def _on_video_track_publish_success(self, local_user_handle, local_video_track_handle):
-        print("LocalUserCB _on_video_track_publish_success:", local_user_handle, local_video_track_handle)
+        logger.debug(f"LocalUserCB _on_video_track_publish_success: {local_user_handle}, {local_video_track_handle}")
         video_track = self.local_user.get_video_map(local_video_track_handle)
         self.local_user_observer.on_video_track_publish_success(self.local_user, video_track)
 
     def _on_video_track_publish_start(self, local_user_handle, local_video_track_handle):
-        print("LocalUserCB _on_video_track_publish_start:", local_user_handle, local_video_track_handle)
+        logger.debug(f"LocalUserCB _on_video_track_publish_start: {local_user_handle}, {local_video_track_handle}")
         video_track = self.local_user.get_video_map(local_video_track_handle)
         self.local_user_observer.on_video_track_publish_start(self.local_user, video_track)
         
     def _on_audio_track_publish_start(self, local_user_handle, local_audio_track_handle):
-        print("LocalUserCB _on_audio_track_publish_start:", local_user_handle, local_audio_track_handle)
+        logger.debug(f"LocalUserCB _on_audio_track_publish_start: {local_user_handle}, {local_audio_track_handle}")
         audio_track = self.local_user.get_audio_map(local_audio_track_handle)
         self.local_user_observer.on_audio_track_publish_start(self.local_user, audio_track)
 
     def _on_audio_track_unpublished(self, local_user_handle, local_audio_track_handle):
-        print("LocalUserCB _on_audio_track_unpublished:", local_user_handle, local_audio_track_handle)
+        logger.debug(f"LocalUserCB _on_audio_track_unpublished: {local_user_handle}, {local_audio_track_handle}")
         audio_track = self.local_user.get_audio_map(local_audio_track_handle)
         self.local_user._del_audio_map(local_audio_track_handle)
         self.local_user_observer.on_audio_track_unpublished(self.local_user, audio_track)
 
     def _on_audio_track_publication_failure(self, local_user_handle, local_audio_track_handle, error_code):
-        print("LocalUserCB _on_audio_track_publication_failure:", local_user_handle, local_audio_track_handle, error_code)
+        logger.debug(f"LocalUserCB _on_audio_track_publication_failure: {local_user_handle}, {local_audio_track_handle}, {error_code}")
         audio_track = self.local_user.get_audio_map(local_audio_track_handle)
-        #note :move from map for failed publish
         self.local_user.del_audio_map(local_audio_track_handle)
         self.local_user_observer.on_audio_track_publication_failure(self.local_user, audio_track, error_code)
     
     def _on_local_audio_track_state_changed(self, local_user_handle, local_audio_track_handle, state, error):
-        print("LocalUserCB _on_local_audio_track_state_changed:", local_user_handle, local_audio_track_handle, state, error)
+        logger.debug(f"LocalUserCB _on_local_audio_track_state_changed: {local_user_handle}, {local_audio_track_handle}, {state}, {error}")
         audio_track = self.local_user.get_audio_map(local_audio_track_handle)
         self.local_user_observer.on_local_audio_track_state_changed(self.local_user, audio_track, state, error)
 
     def _on_local_audio_track_statistics(self, local_user_handle, stats):
-        #print("LocalUserCB _on_local_audio_track_statistics:", local_user_handle, stats)
-        #stats: pointer to LocalAudioStats
         local_audio_stats = stats.contents
         self.local_user_observer.on_local_audio_track_statistics(self.local_user, local_audio_stats)
-    #这个有点trick
-    """
-    # 在LocalUser中是通过LocalUser.sub_audio(uid) 创建的，所以这里直接用uid来获取对应的RemoteAudioTrack
-    # 也就是说从app层的视角，对audio的区分是uid，但这边的回调并没有userid，所以对app层是不太友好的
-    # 也就是需要在LocalUser层中建立一个map表，用来记录userid和handle
-    # 然后在回调中，通过handle，找到uid，然后call 给app层的是uid
-    # 这样的话，在LocalUser层，就可以直接通过uid来获取对应的RemoteAudioTrack
-    """
-    #
-    # _on_user_audio_track_subscribed:in LocalUser to do sub(userid), and in this call back it pass out with 
-    # user_id & remote_audio_track_handle, so we should construct RemoteAudioTrack with (user_id & remote_audio_track_handle
-    # and save it in local_user, then in app layer, we can get RemoteAudioTrack with userid)
+
     def _on_user_audio_track_subscribed(self, local_user_handle, user_id, remote_audio_track_handle):
-        print("LocalUserCB _on_user_audio_track_subscribed:", local_user_handle, user_id, remote_audio_track_handle)
+        logger.debug(f"LocalUserCB _on_user_audio_track_subscribed: {local_user_handle}, {user_id}, {remote_audio_track_handle}")
         user_id_str = user_id.decode('utf-8') if user_id else ""
         # note: this is a pointer to agora::rtc::IRemoteAudioTrack
         remote_audio_track = RemoteAudioTrack(remote_audio_track_handle, user_id_str)
@@ -273,65 +229,63 @@ class RTCLocalUserObserverInner(ctypes.Structure):
         self.local_user_observer.on_user_audio_track_subscribed(self.local_user, user_id_str, remote_audio_track)
 
     def _on_remote_audio_track_statistics(self, local_user_handle, remote_audio_track_handle, stats):
-        # print("LocalUserCB _on_remote_audio_track_statistics:", local_user_handle, remote_audio_track_handle, stats)
+        logger.debug(f"LocalUserCB _on_remote_audio_track_statistics: {local_user_handle}, {remote_audio_track_handle}, {stats}")
         audio_stats = stats.contents #RemoteAudioTrackStats
         remote_audio_track = self.local_user.get_remote_audio_map(remote_audio_track_handle)
         self.local_user_observer.on_remote_audio_track_statistics(self.local_user, remote_audio_track, audio_stats)
 
-
     def _on_user_audio_track_state_changed(self, local_user_handle, user_id, remote_audio_track_handle, state, reason, elapsed):
-        print("LocalUserCB _on_user_audio_track_state_changed:", local_user_handle, user_id, remote_audio_track_handle, state, reason, elapsed)
+        logger.debug(f"LocalUserCB _on_user_audio_track_state_changed: {local_user_handle}, {user_id}, {remote_audio_track_handle}, {state}, {reason}, {elapsed}")
         user_id_str = user_id.decode('utf-8') if user_id else ""
         remote_audio_track = self.local_user.get_remote_audio_map(remote_audio_track_handle)
         self.local_user_observer.on_user_audio_track_state_changed(self.local_user, user_id_str, remote_audio_track, state, reason, elapsed)
     
     def _on_audio_subscribe_state_changed(self, local_user_handle, channel_id, user_id, state, reason, elapsed):
-        print("LocalUserCB _on_audio_subscribe_state_changed:", local_user_handle, channel_id, user_id, state, reason, elapsed)
+        logger.debug(f"LocalUserCB _on_audio_subscribe_state_changed: {local_user_handle}, {channel_id}, {user_id}, {state}, {reason}, {elapsed}")
         user_id_str = user_id.decode('utf-8') if user_id else ""
         channel_id_str = channel_id.decode('utf-8') if channel_id else ""
         self.local_user_observer.on_audio_subscribe_state_changed(self.local_user, channel_id_str, user_id_str, state, reason, elapsed)
 
     def _on_audio_publish_state_changed(self, local_user_handle, channel_id, state, reason, elapsed):
-        #print("LocalUserCB _on_audio_publish_state_changed:", local_user_handle, channel_id, state, reason, elapsed)
+        logger.debug(f"LocalUserCB _on_audio_publish_state_changed: {local_user_handle}, {channel_id}, {state}, {reason}, {elapsed}")
         channel_id_str = channel_id.decode('utf-8') if channel_id else ""
         self.local_user_observer.on_audio_publish_state_changed(self.local_user, channel_id_str, state, reason, elapsed)
 
     def _on_first_remote_audio_frame(self, local_user_handle, user_id, elapsed):
-        print("LocalUserCB _on_first_remote_audio_frame:", local_user_handle, user_id, elapsed)
+        logger.debug(f"LocalUserCB _on_first_remote_audio_frame: {local_user_handle}, {user_id}, {elapsed}")
         user_id_str = user_id.decode('utf-8') if user_id else ""
         self.local_user_observer.on_first_remote_audio_frame(self.local_user, user_id_str, elapsed)
     
     def _on_first_remote_audio_decoded(self, local_user_handle, user_id, elapsed):
-        print("LocalUserCB _on_first_remote_audio_decoded:", local_user_handle, user_id, elapsed)
+        logger.debug(f"LocalUserCB _on_first_remote_audio_decoded: {local_user_handle}, {user_id}, {elapsed}")
         user_id_str = user_id.decode('utf-8') if user_id else ""
         self.local_user_observer.on_first_remote_audio_decoded(self.local_user, user_id_str, elapsed)
 
     def _on_video_track_unpublished(self, local_user_handle, local_video_track_handle):
-        print("LocalUserCB _on_video_track_unpublished:", local_user_handle, local_video_track_handle)
+        logger.debug(f"LocalUserCB _on_video_track_unpublished: {local_user_handle}, {local_video_track_handle}")
         local_video_track = self.local_user.get_video_map(local_video_track_handle)
         #and then remove it from the local user
         self.local_user.del_video_map(local_video_track_handle)
         self.local_user_observer.on_video_track_unpublished(self.local_user, local_video_track)
 
     def _on_video_track_publication_failure(self, local_user_handle, local_video_track_handle, error_code):
-        print("LocalUserCB _on_video_track_publication_failure:", local_user_handle, local_video_track_handle, error_code)
+        logger.debug(f"LocalUserCB _on_video_track_publication_failure: {local_user_handle}, {local_video_track_handle}, {error_code}")
         local_video_track = self.local_user.get_video_map(local_video_track_handle)
         self.local_user_observer.on_video_track_publication_failure(self.local_user, local_video_track, error_code)
 
     def _on_local_video_track_state_changed(self, local_user_handle, local_video_track_handle, state, error):
-        print("LocalUserCB _on_local_video_track_state_changed:", local_user_handle, local_video_track_handle, state, error)
+        logger.debug(f"LocalUserCB _on_local_video_track_state_changed: {local_user_handle}, {local_video_track_handle}, {state}, {error}")
         local_video_track = self.local_user.get_video_map(local_video_track_handle)
         self.local_user_observer.on_local_video_track_state_changed(self.local_user, local_video_track, state, error)
 
     def _on_local_video_track_statistics(self, local_user_handle, local_video_track_handle, stats):
-        print("LocalUserCB _on_local_video_track_statistics:", local_user_handle, local_video_track_handle, stats)
+        logger.debug(f"LocalUserCB _on_local_video_track_statistics: {local_user_handle}, {local_video_track_handle}, {stats}")
         #stats: ctypes.pointer to LocalVideoTrackStats
         local_video_track = self.local_user.get_video_map(local_video_track_handle)
         video_stats = stats.contents
         self.local_user_observer.on_local_video_track_statistics(self.local_user, local_video_track, video_stats)
-    # # #ctypes.CFUNCTYPE(None, AGORA_HANDLE, user_id_t, ctypes.POINTER(VideoTrackInfo), AGORA_HANDLE)
     def _on_user_video_track_subscribed(self, local_user_handle, user_id, video_track_info, remote_video_track_handle):
-        print("LocalUserCB _on_user_video_track_subscribed:", local_user_handle, user_id, remote_video_track_handle, video_track_info)
+        logger.debug(f"LocalUserCB _on_user_video_track_subscribed: {local_user_handle}, {user_id}, {remote_video_track_handle}, {video_track_info}")
         user_id_str = user_id.decode('utf-8') if user_id else ""
         # track_info = video_track_info.contents._to_track_info()
         track_info = video_track_info.contents #videoTrackInfo
@@ -343,79 +297,79 @@ class RTCLocalUserObserverInner(ctypes.Structure):
         self.local_user_observer.on_user_video_track_subscribed(self.local_user, user_id_str, track_info, remote_video_track)
 
     def _on_user_video_track_state_changed(self, local_user_handle, user_id, remote_video_track_handle, state, reason, elapsed):
-        print("LocalUserCB _on_user_video_track_state_changed:", local_user_handle, user_id, remote_video_track_handle, state, reason, elapsed)
+        logger.debug(f"LocalUserCB _on_user_video_track_state_changed: {local_user_handle}, {user_id}, {remote_video_track_handle}, {state}, {reason}, {elapsed}")
         user_id_str = user_id.decode('utf-8') if user_id else ""
         video_track = self.local_user.get_remote_video_map(remote_video_track_handle)
         self.local_user_observer.on_user_video_track_state_changed(self.local_user, user_id_str, video_track, state, reason, elapsed)
 
     def _on_remote_video_track_statistics(self, local_user_handle, remote_video_track_handle, stats_ptr):
-        print("LocalUserCB _on_remote_video_track_statistics:", local_user_handle, remote_video_track_handle, stats_ptr)
+        logger.debug(f"LocalUserCB _on_remote_video_track_statistics: {local_user_handle}, {remote_video_track_handle}, {stats_ptr}")
         remote_stats = stats_ptr.contents #RemoteVideoTrackStats
         video_track = self.local_user.get_remote_video_map(remote_video_track_handle)
         self.local_user_observer.on_remote_video_track_statistics(self.local_user, video_track, remote_stats)
 
     def _on_audio_volume_indication(self, local_user_handle, audio_volume_info_ptr, speaker_number, total_volume):
-        print("LocalUserCB _on_audio_volume_indication:", local_user_handle, audio_volume_info_ptr, speaker_number, total_volume)
+        logger.debug(f"LocalUserCB _on_audio_volume_indication: {local_user_handle}, {audio_volume_info_ptr}, {speaker_number}, {total_volume}")
         audio_volume_info = audio_volume_info_ptr.contents
         self.local_user_observer.on_audio_volume_indication(self.local_user, audio_volume_info, speaker_number, total_volume)
 
     def _on_active_speaker(self, local_user_handle, user_id):
-        print("LocalUserCB _on_active_speaker:", local_user_handle, user_id)
+        logger.debug(f"LocalUserCB _on_active_speaker: {local_user_handle}, {user_id}")
         user_id_str = user_id.decode('utf-8')
         self.local_user_observer.on_active_speaker(self.local_user, user_id_str)
 
     def _on_remote_video_stream_info_updated(self, local_user_handle, remote_video_stream_info_ptr):
-        print("LocalUserCB _on_remote_video_stream_info_updated:", local_user_handle, remote_video_stream_info_ptr)
+        logger.debug(f"LocalUserCB _on_remote_video_stream_info_updated: {local_user_handle}, {remote_video_stream_info_ptr}")
         video_stream_info = remote_video_stream_info_ptr.contents
         self.local_user_observer.on_remote_video_stream_info_updated(self.local_user, video_stream_info)
 
     def _on_video_subscribe_state_changed(self, local_user_handle, channel_id, user_id, state, reason, elapsed):
-        print("LocalUserCB _on_video_subscribe_state_changed:", local_user_handle, channel_id, user_id, state, reason, elapsed)
+        logger.debug(f"LocalUserCB _on_video_subscribe_state_changed: {local_user_handle}, {channel_id}, {user_id}, {state}, {reason}, {elapsed}")
         user_id_str = user_id.decode('utf-8')
         channel_id_str = channel_id.decode('utf-8')
         self.local_user_observer.on_video_subscribe_state_changed(self.local_user, channel_id_str, user_id_str, state, reason, elapsed)
 
     def _on_video_publish_state_changed(self, local_user_handle, channel_id, state, reason, elapsed):
-        print("LocalUserCB _on_video_publish_state_changed:", local_user_handle, channel_id, state, reason, elapsed)
+        logger.debug(f"LocalUserCB _on_video_publish_state_changed: {local_user_handle}, {channel_id}, {state}, {reason}, {elapsed}")
         channel_id_str = channel_id.decode('utf-8')
         self.local_user_observer.on_video_publish_state_changed(self.local_user, channel_id_str, state, reason, elapsed)
 
     def _on_first_remote_video_frame(self, local_user_handle, user_id, width, height, elapsed):
-        print("LocalUserCB _on_first_remote_video_frame:", local_user_handle, user_id, width, height, elapsed)
+        logger.debug(f"LocalUserCB _on_first_remote_video_frame: {local_user_handle}, {user_id}, {width}, {height}, {elapsed}")
         user_id_str = user_id.decode('utf-8') if user_id else ""
         self.local_user_observer.on_first_remote_video_frame(self.local_user, user_id_str, width, height, elapsed)
 
     def _on_first_remote_video_decoded(self, local_user_handle, user_id, width, height, elapsed):
-        print("LocalUserCB _on_first_remote_video_decoded:", local_user_handle, user_id, width, height, elapsed)
+        logger.debug(f"LocalUserCB _on_first_remote_video_decoded: {local_user_handle}, {user_id}, {width}, {height}, {elapsed}")
         user_id_str = user_id.decode('utf-8') if user_id else ""
         self.local_user_observer.on_first_remote_video_decoded(self.local_user, user_id_str, width, height, elapsed)
 
     def _on_first_remote_video_frame_rendered(self, local_user_handle, user_id, width, height, elapsed):
-        print("LocalUserCB _on_first_remote_video_frame_rendered:", local_user_handle, user_id, width, height, elapsed)
+        logger.debug(f"LocalUserCB _on_first_remote_video_frame_rendered: {local_user_handle}, {user_id}, {width}, {height}, {elapsed}")
         user_id_str = user_id.decode('utf-8') if user_id else ""
         self.local_user_observer.on_first_remote_video_frame_rendered(self.local_user, user_id_str, width, height, elapsed)
 
     def _on_video_size_changed(self, local_user_handle, user_id, width, height, elapsed):
-        print("LocalUserCB _on_video_size_changed:", local_user_handle, user_id, width, height, elapsed)
+        logger.debug(f"LocalUserCB _on_video_size_changed: {local_user_handle}, {user_id}, {width}, {height}, {elapsed}")
         user_id_str = user_id.decode('utf-8') if user_id else ""
         self.local_user_observer.on_video_size_changed(self.local_user, user_id_str, width, height, elapsed)
 
     def _on_user_info_updated(self, local_user_handle, user_id, msg, val):
-        print("LocalUserCB _on_user_info_updated:", local_user_handle, user_id, msg, val)
+        logger.debug(f"LocalUserCB _on_user_info_updated: {local_user_handle}, {user_id}, {msg}, {val}")
         user_id_str = user_id.decode('utf-8') if user_id else ""
         self.local_user_observer.on_user_info_updated(self.local_user, user_id_str, msg, val)
 
     def _on_intra_request_received(self, local_user_handle):
-        # print("LocalUserCB _on_intra_request_received:", local_user_handle)
+        logger.debug(f"LocalUserCB _on_intra_request_received: {local_user_handle}")
         self.local_user_observer.on_intra_request_received(self.local_user)
 
     def _on_remote_subscribe_fallback_to_audio_only(self, local_user_handle, user_id, is_fallback):
-        print("LocalUserCB _on_remote_subscribe_fallback_to_audio_only:", local_user_handle, user_id, is_fallback)
+        logger.debug(f"LocalUserCB _on_remote_subscribe_fallback_to_audio_only: {local_user_handle}, {user_id}, {is_fallback}")
         user_id_str = user_id.decode('utf-8') if user_id else ""
         self.local_user_observer.on_remote_subscribe_fallback_to_audio_only(self.local_user, user_id_str, is_fallback)
 
     def _on_stream_message(self, local_user_handle, user_id, stream_id, data, size):
-        # print("LocalUserCB _on_stream_message:", local_user_handle, user_id, stream_id, data, size)
+        logger.debug(f"LocalUserCB _on_stream_message: {local_user_handle}, {user_id}, {stream_id}, {data}, {size}")
         user_id_str = user_id.decode('utf-8') if user_id else ""
         bytes_from_c = ctypes.string_at(data, size)  
         data_byte_array = bytearray(bytes_from_c).decode()     
@@ -423,7 +377,7 @@ class RTCLocalUserObserverInner(ctypes.Structure):
         self.local_user_observer.on_stream_message(self.local_user, user_id_str, stream_id, data_byte_array, size)
 
     def _on_user_state_changed(self, local_user_handle, user_id, state):
-        print("LocalUserCB _on_user_state_changed:", local_user_handle, user_id, state)
+        logger.debug(f"LocalUserCB _on_user_state_changed: {local_user_handle}, {user_id}, {state}")
         user_id_str = user_id.decode('utf-8') if user_id else ""
         self.local_user_observer.on_user_state_changed(self.local_user, user_id_str, state)