agorartc.py

# This file was automatically generated by SWIG (http://www.swig.org).
# Version 4.0.2
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.

from sys import version_info as _swig_python_version_info
if _swig_python_version_info < (2, 7, 0):
    raise RuntimeError("Python 2.7 or later required")

# Import the low-level C/C++ module
if __package__ or "." in __name__:
    from . import _agorartc
else:
    import _agorartc

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

def _swig_repr(self):
    try:
        strthis = "proxy of " + self.this.__repr__()
    except __builtin__.Exception:
        strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)


def _swig_setattr_nondynamic_instance_variable(set):
    def set_instance_attr(self, name, value):
        if name == "thisown":
            self.this.own(value)
        elif name == "this":
            set(self, name, value)
        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add instance attributes to %s" % self)
    return set_instance_attr


def _swig_setattr_nondynamic_class_variable(set):
    def set_class_attr(cls, name, value):
        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
            set(cls, name, value)
        else:
            raise AttributeError("You cannot add class attributes to %s" % cls)
    return set_class_attr


def _swig_add_metaclass(metaclass):
    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
    def wrapper(cls):
        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
    return wrapper


class _SwigNonDynamicMeta(type):
    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)


import weakref

class IString(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def empty(self) -> "bool":
        return _agorartc.IString_empty(self)

    def c_str(self) -> "char const *":
        return _agorartc.IString_c_str(self)

    def data(self) -> "char const *":
        return _agorartc.IString_data(self)

    def length(self) -> "size_t":
        return _agorartc.IString_length(self)

    def release(self) -> "void":
        return _agorartc.IString_release(self)

# Register IString in _agorartc:
_agorartc.IString_swigregister(IString)

AGORA_IID_AUDIO_DEVICE_MANAGER = _agorartc.AGORA_IID_AUDIO_DEVICE_MANAGER
AGORA_IID_VIDEO_DEVICE_MANAGER = _agorartc.AGORA_IID_VIDEO_DEVICE_MANAGER
AGORA_IID_RTC_ENGINE_PARAMETER = _agorartc.AGORA_IID_RTC_ENGINE_PARAMETER
AGORA_IID_MEDIA_ENGINE = _agorartc.AGORA_IID_MEDIA_ENGINE
AGORA_IID_SIGNALING_ENGINE = _agorartc.AGORA_IID_SIGNALING_ENGINE
WARN_INVALID_VIEW = _agorartc.WARN_INVALID_VIEW
r""" 8: The specified view is invalid. Specify a view when using the video call function."""
WARN_INIT_VIDEO = _agorartc.WARN_INIT_VIDEO
r""" 16: Failed to initialize the video function, possibly caused by a lack of resources. The users cannot see the video while the voice communication is not affected."""
WARN_PENDING = _agorartc.WARN_PENDING
r""" 20: The request is pending, usually due to some module not being ready, and the SDK postponed processing the request."""
WARN_NO_AVAILABLE_CHANNEL = _agorartc.WARN_NO_AVAILABLE_CHANNEL
r""" 103: No channel resources are available. Maybe because the server cannot allocate any channel resource."""
WARN_LOOKUP_CHANNEL_TIMEOUT = _agorartc.WARN_LOOKUP_CHANNEL_TIMEOUT
r""" 104: A timeout occurs when looking up the channel. When joining a channel, the SDK looks up the specified channel. This warning usually occurs when the network condition is too poor for the SDK to connect to the server."""
WARN_LOOKUP_CHANNEL_REJECTED = _agorartc.WARN_LOOKUP_CHANNEL_REJECTED
r"""
    DEPRECATED** 105: The server rejects the request to look up the channel. The server cannot process this request or the request is illegal.

         Deprecated as of v2.4.1. Use CONNECTION_CHANGED_REJECTED_BY_SERVER(10) in the 'onConnectionStateChanged' callback instead.
    """
WARN_OPEN_CHANNEL_TIMEOUT = _agorartc.WARN_OPEN_CHANNEL_TIMEOUT
r""" 106: A timeout occurs when opening the channel. Once the specific channel is found, the SDK opens the channel. This warning usually occurs when the network condition is too poor for the SDK to connect to the server."""
WARN_OPEN_CHANNEL_REJECTED = _agorartc.WARN_OPEN_CHANNEL_REJECTED
r""" 107: The server rejects the request to open the channel. The server cannot process this request or the request is illegal."""
WARN_SWITCH_LIVE_VIDEO_TIMEOUT = _agorartc.WARN_SWITCH_LIVE_VIDEO_TIMEOUT
r""" 111: A timeout occurs when switching to the live video."""
WARN_SET_CLIENT_ROLE_TIMEOUT = _agorartc.WARN_SET_CLIENT_ROLE_TIMEOUT
r""" 118: A timeout occurs when setting the client role in the live interactive streaming profile."""
WARN_OPEN_CHANNEL_INVALID_TICKET = _agorartc.WARN_OPEN_CHANNEL_INVALID_TICKET
r""" 121: The ticket to open the channel is invalid."""
WARN_OPEN_CHANNEL_TRY_NEXT_VOS = _agorartc.WARN_OPEN_CHANNEL_TRY_NEXT_VOS
r""" 122: Try connecting to another server."""
WARN_CHANNEL_CONNECTION_UNRECOVERABLE = _agorartc.WARN_CHANNEL_CONNECTION_UNRECOVERABLE
r""" 131: The channel connection cannot be recovered."""
WARN_CHANNEL_CONNECTION_IP_CHANGED = _agorartc.WARN_CHANNEL_CONNECTION_IP_CHANGED
WARN_CHANNEL_CONNECTION_PORT_CHANGED = _agorartc.WARN_CHANNEL_CONNECTION_PORT_CHANGED
WARN_AUDIO_MIXING_OPEN_ERROR = _agorartc.WARN_AUDIO_MIXING_OPEN_ERROR
r""" 701: An error occurs in opening the audio mixing file."""
WARN_ADM_RUNTIME_PLAYOUT_WARNING = _agorartc.WARN_ADM_RUNTIME_PLAYOUT_WARNING
r""" 1014: Audio Device Module: A warning occurs in the playback device."""
WARN_ADM_RUNTIME_RECORDING_WARNING = _agorartc.WARN_ADM_RUNTIME_RECORDING_WARNING
r""" 1016: Audio Device Module: a warning occurs in the recording device."""
WARN_ADM_RECORD_AUDIO_SILENCE = _agorartc.WARN_ADM_RECORD_AUDIO_SILENCE
r""" 1019: Audio Device Module: no valid audio data is recorded."""
WARN_ADM_PLAYOUT_MALFUNCTION = _agorartc.WARN_ADM_PLAYOUT_MALFUNCTION
r""" 1020: Audio device module: The audio playback frequency is abnormal, which may cause audio freezes. This abnormality is caused by high CPU usage. Agora recommends stopping other apps."""
WARN_ADM_RECORD_MALFUNCTION = _agorartc.WARN_ADM_RECORD_MALFUNCTION
r""" 1021: Audio device module: the audio recording frequency is abnormal, which may cause audio freezes. This abnormality is caused by high CPU usage. Agora recommends stopping other apps."""
WARN_ADM_CALL_INTERRUPTION = _agorartc.WARN_ADM_CALL_INTERRUPTION
r""" 1025: The audio playback or recording is interrupted by system events (such as a phone call)."""
WARN_ADM_IOS_CATEGORY_NOT_PLAYANDRECORD = _agorartc.WARN_ADM_IOS_CATEGORY_NOT_PLAYANDRECORD
r"""
     1029: During a call, the audio session category should be set to
    AVAudioSessionCategoryPlayAndRecord, and RtcEngine monitors this value.
    If the audio session category is set to other values, this warning code
    is triggered and RtcEngine will forcefully set it back to
    AVAudioSessionCategoryPlayAndRecord.
    """
WARN_ADM_RECORD_AUDIO_LOWLEVEL = _agorartc.WARN_ADM_RECORD_AUDIO_LOWLEVEL
r""" 1031: Audio Device Module: The recorded audio voice is too low."""
WARN_ADM_PLAYOUT_AUDIO_LOWLEVEL = _agorartc.WARN_ADM_PLAYOUT_AUDIO_LOWLEVEL
r""" 1032: Audio Device Module: The playback audio voice is too low."""
WARN_ADM_RECORD_AUDIO_IS_ACTIVE = _agorartc.WARN_ADM_RECORD_AUDIO_IS_ACTIVE
r""" 1033: Audio device module: The audio recording device is occupied."""
WARN_ADM_WINDOWS_NO_DATA_READY_EVENT = _agorartc.WARN_ADM_WINDOWS_NO_DATA_READY_EVENT
r"""
     1040: Audio device module: An exception occurs with the audio drive.
    Solutions:
    - Disable or re-enable the audio device.
    - Re-enable your device.
    - Update the sound card drive.
    """
WARN_ADM_INCONSISTENT_AUDIO_DEVICE = _agorartc.WARN_ADM_INCONSISTENT_AUDIO_DEVICE
r"""
     1042: Audio device module: The audio recording device is different from the audio playback device,
    which may cause echoes problem. Agora recommends using the same audio device to record and playback
    audio.
    """
WARN_APM_HOWLING = _agorartc.WARN_APM_HOWLING
r""" 1051: (Communication profile only) Audio processing module: A howling sound is detected when recording the audio data."""
WARN_ADM_GLITCH_STATE = _agorartc.WARN_ADM_GLITCH_STATE
r""" 1052: Audio Device Module: The device is in the glitch state."""
WARN_APM_RESIDUAL_ECHO = _agorartc.WARN_APM_RESIDUAL_ECHO
r""" 1053: Audio Processing Module: A residual echo is detected, which may be caused by the belated scheduling of system threads or the signal overflow."""
WARN_ADM_WIN_CORE_NO_RECORDING_DEVICE = _agorartc.WARN_ADM_WIN_CORE_NO_RECORDING_DEVICE
r""" Conditional comment:"""
WARN_ADM_WIN_CORE_NO_PLAYOUT_DEVICE = _agorartc.WARN_ADM_WIN_CORE_NO_PLAYOUT_DEVICE
r"""
     End of conditional comment. 1323: Audio device module: No available playback device.
    Solution: Plug in the audio device.
    """
WARN_ADM_WIN_CORE_IMPROPER_CAPTURE_RELEASE = _agorartc.WARN_ADM_WIN_CORE_IMPROPER_CAPTURE_RELEASE
r"""
     Audio device module: The capture device is released improperly.
    Solutions:
    - Disable or re-enable the audio device.
    - Re-enable your device.
    - Update the sound card drive.
    """
WARN_SUPER_RESOLUTION_STREAM_OVER_LIMITATION = _agorartc.WARN_SUPER_RESOLUTION_STREAM_OVER_LIMITATION
r""" 1610: Super-resolution warning: The original video dimensions of the remote user exceed 640 * 480."""
WARN_SUPER_RESOLUTION_USER_COUNT_OVER_LIMITATION = _agorartc.WARN_SUPER_RESOLUTION_USER_COUNT_OVER_LIMITATION
r""" 1611: Super-resolution warning: Another user is using super resolution."""
WARN_SUPER_RESOLUTION_DEVICE_NOT_SUPPORTED = _agorartc.WARN_SUPER_RESOLUTION_DEVICE_NOT_SUPPORTED
r""" 1612: The device is not supported."""
WARN_RTM_LOGIN_TIMEOUT = _agorartc.WARN_RTM_LOGIN_TIMEOUT
r""" Conditional comment:"""
WARN_RTM_KEEP_ALIVE_TIMEOUT = _agorartc.WARN_RTM_KEEP_ALIVE_TIMEOUT
ERR_OK = _agorartc.ERR_OK
r""" 0: No error occurs."""
ERR_FAILED = _agorartc.ERR_FAILED
r""" 1: A general error occurs (no specified reason)."""
ERR_INVALID_ARGUMENT = _agorartc.ERR_INVALID_ARGUMENT
r""" 2: An invalid parameter is used. For example, the specific channel name includes illegal characters."""
ERR_NOT_READY = _agorartc.ERR_NOT_READY
r"""
    3: The SDK module is not ready. Possible solutions:

        - Check the audio device.
        - Check the completeness of the application.
        - Re-initialize the RTC engine.
    """
ERR_NOT_SUPPORTED = _agorartc.ERR_NOT_SUPPORTED
r""" 4: The SDK does not support this function."""
ERR_REFUSED = _agorartc.ERR_REFUSED
r""" 5: The request is rejected."""
ERR_BUFFER_TOO_SMALL = _agorartc.ERR_BUFFER_TOO_SMALL
r""" 6: The buffer size is not big enough to store the returned data."""
ERR_NOT_INITIALIZED = _agorartc.ERR_NOT_INITIALIZED
r""" 7: The SDK is not initialized before calling this method."""
ERR_NO_PERMISSION = _agorartc.ERR_NO_PERMISSION
r""" 9: No permission exists. Check if the user has granted access to the audio or video device."""
ERR_TIMEDOUT = _agorartc.ERR_TIMEDOUT
r""" 10: An API method timeout occurs. Some API methods require the SDK to return the execution result, and this error occurs if the request takes too long (more than 10 seconds) for the SDK to process."""
ERR_CANCELED = _agorartc.ERR_CANCELED
r""" 11: The request is canceled. This is for internal SDK use only, and it does not return to the application through any method or callback."""
ERR_TOO_OFTEN = _agorartc.ERR_TOO_OFTEN
r""" 12: The method is called too often. This is for internal SDK use only, and it does not return to the application through any method or callback."""
ERR_BIND_SOCKET = _agorartc.ERR_BIND_SOCKET
r""" 13: The SDK fails to bind to the network socket. This is for internal SDK use only, and it does not return to the application through any method or callback."""
ERR_NET_DOWN = _agorartc.ERR_NET_DOWN
r""" 14: The network is unavailable. This is for internal SDK use only, and it does not return to the application through any method or callback."""
ERR_NET_NOBUFS = _agorartc.ERR_NET_NOBUFS
r""" 15: No network buffers are available. This is for internal SDK internal use only, and it does not return to the application through any method or callback."""
ERR_JOIN_CHANNEL_REJECTED = _agorartc.ERR_JOIN_CHANNEL_REJECTED
r"""
     17: The request to join the channel is rejected.

    - This error usually occurs when the user is already in the channel, and still calls the method to join the channel, for example, 'joinChannel'.
    - This error usually occurs when the user tries to join a channel during a call test ('startEchoTest'). Once you call 'startEchoTest', you need to call 'stopEchoTest' before joining a channel.
    """
ERR_LEAVE_CHANNEL_REJECTED = _agorartc.ERR_LEAVE_CHANNEL_REJECTED
r"""
    18: The request to leave the channel is rejected.

        This error usually occurs:

        - When the user has left the channel and still calls 'leaveChannel' to leave the channel. In this case, stop calling 'leaveChannel'.
        - When the user has not joined the channel and still calls 'leaveChannel' to leave the channel. In this case, no extra operation is needed.
    """
ERR_ALREADY_IN_USE = _agorartc.ERR_ALREADY_IN_USE
r""" 19: Resources are occupied and cannot be reused."""
ERR_ABORTED = _agorartc.ERR_ABORTED
r""" 20: The SDK gives up the request due to too many requests."""
ERR_INIT_NET_ENGINE = _agorartc.ERR_INIT_NET_ENGINE
r""" 21: In Windows, specific firewall settings can cause the SDK to fail to initialize and crash."""
ERR_RESOURCE_LIMITED = _agorartc.ERR_RESOURCE_LIMITED
r""" 22: The application uses too much of the system resources and the SDK fails to allocate the resources."""
ERR_INVALID_APP_ID = _agorartc.ERR_INVALID_APP_ID
r""" 101: The specified App ID is invalid. Please try to rejoin the channel with a valid App ID."""
ERR_INVALID_CHANNEL_NAME = _agorartc.ERR_INVALID_CHANNEL_NAME
r""" 102: The specified channel name is invalid. Please try to rejoin the channel with a valid channel name."""
ERR_NO_SERVER_RESOURCES = _agorartc.ERR_NO_SERVER_RESOURCES
r""" 103: Fails to get server resources in the specified region. Please try to specify another region when calling 'initialize'."""
ERR_TOKEN_EXPIRED = _agorartc.ERR_TOKEN_EXPIRED
r"""
    DEPRECATED** 109: Deprecated as of v2.4.1. Use CONNECTION_CHANGED_TOKEN_EXPIRED(9) in the 'onConnectionStateChanged' callback instead.

         The token expired due to one of the following reasons:

         - Authorized Timestamp expired: The timestamp is represented by the number of seconds elapsed since 1/1/1970. The user can use the Token to access the Agora service within 24 hours after the Token is generated. If the user does not access the Agora service after 24 hours, this Token is no longer valid.
         - Call Expiration Timestamp expired: The timestamp is the exact time when a user can no longer use the Agora service (for example, when a user is forced to leave an ongoing call). When a value is set for the Call Expiration Timestamp, it does not mean that the token will expire, but that the user will be banned from the channel.
    """
ERR_INVALID_TOKEN = _agorartc.ERR_INVALID_TOKEN
r"""
    DEPRECATED** 110: Deprecated as of v2.4.1. Use CONNECTION_CHANGED_INVALID_TOKEN(8) in the 'onConnectionStateChanged' callback instead.

         The token is invalid due to one of the following reasons:

         - The App Certificate for the project is enabled in Console, but the user is still using the App ID. Once the App Certificate is enabled, the user must use a token.
         - The uid is mandatory, and users must set the same uid as the one set in the 'joinChannel' method.
    """
ERR_CONNECTION_INTERRUPTED = _agorartc.ERR_CONNECTION_INTERRUPTED
r""" 111: The internet connection is interrupted. This applies to the Agora Web SDK only."""
ERR_CONNECTION_LOST = _agorartc.ERR_CONNECTION_LOST
r""" 112: The internet connection is lost. This applies to the Agora Web SDK only."""
ERR_NOT_IN_CHANNEL = _agorartc.ERR_NOT_IN_CHANNEL
r""" 113: The user is not in the channel when calling the method."""
ERR_SIZE_TOO_LARGE = _agorartc.ERR_SIZE_TOO_LARGE
r""" 114: The size of the sent data is over 1024 bytes when the user calls the 'sendStreamMessage' method."""
ERR_BITRATE_LIMIT = _agorartc.ERR_BITRATE_LIMIT
r""" 115: The bitrate of the sent data exceeds the limit of 6 Kbps when the user calls the 'sendStreamMessage' method."""
ERR_TOO_MANY_DATA_STREAMS = _agorartc.ERR_TOO_MANY_DATA_STREAMS
r""" 116: Too many data streams (over 5 streams) are created when the user calls the 'createDataStream' method."""
ERR_STREAM_MESSAGE_TIMEOUT = _agorartc.ERR_STREAM_MESSAGE_TIMEOUT
r""" 117: The data stream transmission timed out."""
ERR_SET_CLIENT_ROLE_NOT_AUTHORIZED = _agorartc.ERR_SET_CLIENT_ROLE_NOT_AUTHORIZED
r""" 119: Switching roles fail. Please try to rejoin the channel."""
ERR_DECRYPTION_FAILED = _agorartc.ERR_DECRYPTION_FAILED
r""" 120: Decryption fails. The user may have used a different encryption password to join the channel. Check your settings or try rejoining the channel."""
ERR_CLIENT_IS_BANNED_BY_SERVER = _agorartc.ERR_CLIENT_IS_BANNED_BY_SERVER
r""" 123: The client is banned by the server."""
ERR_WATERMARK_PARAM = _agorartc.ERR_WATERMARK_PARAM
r""" 124: Incorrect watermark file parameter."""
ERR_WATERMARK_PATH = _agorartc.ERR_WATERMARK_PATH
r""" 125: Incorrect watermark file path."""
ERR_WATERMARK_PNG = _agorartc.ERR_WATERMARK_PNG
r""" 126: Incorrect watermark file format."""
ERR_WATERMARKR_INFO = _agorartc.ERR_WATERMARKR_INFO
r""" 127: Incorrect watermark file information."""
ERR_WATERMARK_ARGB = _agorartc.ERR_WATERMARK_ARGB
r""" 128: Incorrect watermark file data format."""
ERR_WATERMARK_READ = _agorartc.ERR_WATERMARK_READ
r""" 129: An error occurs in reading the watermark file."""
ERR_ENCRYPTED_STREAM_NOT_ALLOWED_PUBLISH = _agorartc.ERR_ENCRYPTED_STREAM_NOT_ALLOWED_PUBLISH
r""" 130: Encryption is enabled when the user calls the 'addPublishStreamUrl' method (CDN live streaming does not support encrypted streams)."""
ERR_INVALID_USER_ACCOUNT = _agorartc.ERR_INVALID_USER_ACCOUNT
r""" 134: The user account is invalid."""
ERR_PUBLISH_STREAM_CDN_ERROR = _agorartc.ERR_PUBLISH_STREAM_CDN_ERROR
r""" 151: CDN related errors. Remove the original URL address and add a new one by calling the 'removePublishStreamUrl' and 'addPublishStreamUrl' methods."""
ERR_PUBLISH_STREAM_NUM_REACH_LIMIT = _agorartc.ERR_PUBLISH_STREAM_NUM_REACH_LIMIT
r""" 152: The host publishes more than 10 URLs. Delete the unnecessary URLs before adding new ones."""
ERR_PUBLISH_STREAM_NOT_AUTHORIZED = _agorartc.ERR_PUBLISH_STREAM_NOT_AUTHORIZED
r""" 153: The host manipulates other hosts' URLs. Check your app logic."""
ERR_PUBLISH_STREAM_INTERNAL_SERVER_ERROR = _agorartc.ERR_PUBLISH_STREAM_INTERNAL_SERVER_ERROR
r""" 154: An error occurs in Agora's streaming server. Call the addPublishStreamUrl method to publish the streaming again."""
ERR_PUBLISH_STREAM_NOT_FOUND = _agorartc.ERR_PUBLISH_STREAM_NOT_FOUND
r""" 155: The server fails to find the stream."""
ERR_PUBLISH_STREAM_FORMAT_NOT_SUPPORTED = _agorartc.ERR_PUBLISH_STREAM_FORMAT_NOT_SUPPORTED
r""" 156: The format of the RTMP stream URL is not supported. Check whether the URL format is correct."""
ERR_LOGOUT_OTHER = _agorartc.ERR_LOGOUT_OTHER
ERR_LOGOUT_USER = _agorartc.ERR_LOGOUT_USER
ERR_LOGOUT_NET = _agorartc.ERR_LOGOUT_NET
ERR_LOGOUT_KICKED = _agorartc.ERR_LOGOUT_KICKED
ERR_LOGOUT_PACKET = _agorartc.ERR_LOGOUT_PACKET
ERR_LOGOUT_TOKEN_EXPIRED = _agorartc.ERR_LOGOUT_TOKEN_EXPIRED
ERR_LOGOUT_OLDVERSION = _agorartc.ERR_LOGOUT_OLDVERSION
ERR_LOGOUT_TOKEN_WRONG = _agorartc.ERR_LOGOUT_TOKEN_WRONG
ERR_LOGOUT_ALREADY_LOGOUT = _agorartc.ERR_LOGOUT_ALREADY_LOGOUT
ERR_LOGIN_OTHER = _agorartc.ERR_LOGIN_OTHER
ERR_LOGIN_NET = _agorartc.ERR_LOGIN_NET
ERR_LOGIN_FAILED = _agorartc.ERR_LOGIN_FAILED
ERR_LOGIN_CANCELED = _agorartc.ERR_LOGIN_CANCELED
ERR_LOGIN_TOKEN_EXPIRED = _agorartc.ERR_LOGIN_TOKEN_EXPIRED
ERR_LOGIN_OLD_VERSION = _agorartc.ERR_LOGIN_OLD_VERSION
ERR_LOGIN_TOKEN_WRONG = _agorartc.ERR_LOGIN_TOKEN_WRONG
ERR_LOGIN_TOKEN_KICKED = _agorartc.ERR_LOGIN_TOKEN_KICKED
ERR_LOGIN_ALREADY_LOGIN = _agorartc.ERR_LOGIN_ALREADY_LOGIN
ERR_JOIN_CHANNEL_OTHER = _agorartc.ERR_JOIN_CHANNEL_OTHER
ERR_SEND_MESSAGE_OTHER = _agorartc.ERR_SEND_MESSAGE_OTHER
ERR_SEND_MESSAGE_TIMEOUT = _agorartc.ERR_SEND_MESSAGE_TIMEOUT
ERR_QUERY_USERNUM_OTHER = _agorartc.ERR_QUERY_USERNUM_OTHER
ERR_QUERY_USERNUM_TIMEOUT = _agorartc.ERR_QUERY_USERNUM_TIMEOUT
ERR_QUERY_USERNUM_BYUSER = _agorartc.ERR_QUERY_USERNUM_BYUSER
ERR_LEAVE_CHANNEL_OTHER = _agorartc.ERR_LEAVE_CHANNEL_OTHER
ERR_LEAVE_CHANNEL_KICKED = _agorartc.ERR_LEAVE_CHANNEL_KICKED
ERR_LEAVE_CHANNEL_BYUSER = _agorartc.ERR_LEAVE_CHANNEL_BYUSER
ERR_LEAVE_CHANNEL_LOGOUT = _agorartc.ERR_LEAVE_CHANNEL_LOGOUT
ERR_LEAVE_CHANNEL_DISCONNECTED = _agorartc.ERR_LEAVE_CHANNEL_DISCONNECTED
ERR_INVITE_OTHER = _agorartc.ERR_INVITE_OTHER
ERR_INVITE_REINVITE = _agorartc.ERR_INVITE_REINVITE
ERR_INVITE_NET = _agorartc.ERR_INVITE_NET
ERR_INVITE_PEER_OFFLINE = _agorartc.ERR_INVITE_PEER_OFFLINE
ERR_INVITE_TIMEOUT = _agorartc.ERR_INVITE_TIMEOUT
ERR_INVITE_CANT_RECV = _agorartc.ERR_INVITE_CANT_RECV
ERR_LOAD_MEDIA_ENGINE = _agorartc.ERR_LOAD_MEDIA_ENGINE
r""" 1001: Fails to load the media engine."""
ERR_START_CALL = _agorartc.ERR_START_CALL
r""" 1002: Fails to start the call after enabling the media engine."""
ERR_START_CAMERA = _agorartc.ERR_START_CAMERA
r"""
    DEPRECATED** 1003: Fails to start the camera.

        Deprecated as of v2.4.1. Use LOCAL_VIDEO_STREAM_ERROR_CAPTURE_FAILURE(4) in the 'onConnectionStateChanged' callback instead.
    """
ERR_START_VIDEO_RENDER = _agorartc.ERR_START_VIDEO_RENDER
r""" 1004: Fails to start the video rendering module."""
ERR_ADM_GENERAL_ERROR = _agorartc.ERR_ADM_GENERAL_ERROR
r""" 1005: A general error occurs in the Audio Device Module (no specified reason). Check if the audio device is used by another application, or try rejoining the channel."""
ERR_ADM_JAVA_RESOURCE = _agorartc.ERR_ADM_JAVA_RESOURCE
r""" 1006: Audio Device Module: An error occurs in using the Java resources."""
ERR_ADM_SAMPLE_RATE = _agorartc.ERR_ADM_SAMPLE_RATE
r""" 1007: Audio Device Module: An error occurs in setting the sampling frequency."""
ERR_ADM_INIT_PLAYOUT = _agorartc.ERR_ADM_INIT_PLAYOUT
r""" 1008: Audio Device Module: An error occurs in initializing the playback device."""
ERR_ADM_START_PLAYOUT = _agorartc.ERR_ADM_START_PLAYOUT
r""" 1009: Audio Device Module: An error occurs in starting the playback device."""
ERR_ADM_STOP_PLAYOUT = _agorartc.ERR_ADM_STOP_PLAYOUT
r""" 1010: Audio Device Module: An error occurs in stopping the playback device."""
ERR_ADM_INIT_RECORDING = _agorartc.ERR_ADM_INIT_RECORDING
r""" 1011: Audio Device Module: An error occurs in initializing the recording device."""
ERR_ADM_START_RECORDING = _agorartc.ERR_ADM_START_RECORDING
r""" 1012: Audio Device Module: An error occurs in starting the recording device."""
ERR_ADM_STOP_RECORDING = _agorartc.ERR_ADM_STOP_RECORDING
r""" 1013: Audio Device Module: An error occurs in stopping the recording device."""
ERR_ADM_RUNTIME_PLAYOUT_ERROR = _agorartc.ERR_ADM_RUNTIME_PLAYOUT_ERROR
r""" 1015: Audio Device Module: A playback error occurs. Check your playback device and try rejoining the channel."""
ERR_ADM_RUNTIME_RECORDING_ERROR = _agorartc.ERR_ADM_RUNTIME_RECORDING_ERROR
r""" 1017: Audio Device Module: A recording error occurs."""
ERR_ADM_RECORD_AUDIO_FAILED = _agorartc.ERR_ADM_RECORD_AUDIO_FAILED
r""" 1018: Audio Device Module: Fails to record."""
ERR_ADM_INIT_LOOPBACK = _agorartc.ERR_ADM_INIT_LOOPBACK
r"""
     1022: Audio Device Module: An error occurs in initializing the
    loopback device.
    """
ERR_ADM_START_LOOPBACK = _agorartc.ERR_ADM_START_LOOPBACK
r"""
     1023: Audio Device Module: An error occurs in starting the loopback
    device.
    """
ERR_ADM_NO_PERMISSION = _agorartc.ERR_ADM_NO_PERMISSION
r"""
    1027: Audio Device Module: No recording permission exists. Check if the
    recording permission is granted.
    """
ERR_ADM_RECORD_AUDIO_IS_ACTIVE = _agorartc.ERR_ADM_RECORD_AUDIO_IS_ACTIVE
r""" 1033: Audio device module: The device is occupied."""
ERR_ADM_ANDROID_JNI_JAVA_RESOURCE = _agorartc.ERR_ADM_ANDROID_JNI_JAVA_RESOURCE
r""" 1101: Audio device module: A fatal exception occurs."""
ERR_ADM_ANDROID_JNI_NO_RECORD_FREQUENCY = _agorartc.ERR_ADM_ANDROID_JNI_NO_RECORD_FREQUENCY
r"""
     1108: Audio device module: The recording frequency is lower than 50.
    0 indicates that the recording is not yet started. We recommend
    checking your recording permission.
    """
ERR_ADM_ANDROID_JNI_NO_PLAYBACK_FREQUENCY = _agorartc.ERR_ADM_ANDROID_JNI_NO_PLAYBACK_FREQUENCY
r"""
     1109: The playback frequency is lower than 50. 0 indicates that the
    playback is not yet started. We recommend checking if you have created
    too many AudioTrack instances.
    """
ERR_ADM_ANDROID_JNI_JAVA_START_RECORD = _agorartc.ERR_ADM_ANDROID_JNI_JAVA_START_RECORD
r"""
     1111: Audio device module: AudioRecord fails to start up. A ROM system
    error occurs. We recommend the following options to debug:
    - Restart your App.
    - Restart your cellphone.
    - Check your recording permission.
    """
ERR_ADM_ANDROID_JNI_JAVA_START_PLAYBACK = _agorartc.ERR_ADM_ANDROID_JNI_JAVA_START_PLAYBACK
r"""
     1112: Audio device module: AudioTrack fails to start up. A ROM system
    error occurs. We recommend the following options to debug:
    - Restart your App.
    - Restart your cellphone.
    - Check your playback permission.
    """
ERR_ADM_ANDROID_JNI_JAVA_RECORD_ERROR = _agorartc.ERR_ADM_ANDROID_JNI_JAVA_RECORD_ERROR
r"""
     1115: Audio device module: AudioRecord returns error. The SDK will
    automatically restart AudioRecord.
    """
ERR_ADM_ANDROID_OPENSL_CREATE_ENGINE = _agorartc.ERR_ADM_ANDROID_OPENSL_CREATE_ENGINE
r"""DEPRECATED**"""
ERR_ADM_ANDROID_OPENSL_CREATE_AUDIO_RECORDER = _agorartc.ERR_ADM_ANDROID_OPENSL_CREATE_AUDIO_RECORDER
r"""DEPRECATED**"""
ERR_ADM_ANDROID_OPENSL_START_RECORDER_THREAD = _agorartc.ERR_ADM_ANDROID_OPENSL_START_RECORDER_THREAD
r"""DEPRECATED**"""
ERR_ADM_ANDROID_OPENSL_CREATE_AUDIO_PLAYER = _agorartc.ERR_ADM_ANDROID_OPENSL_CREATE_AUDIO_PLAYER
r"""DEPRECATED**"""
ERR_ADM_ANDROID_OPENSL_START_PLAYER_THREAD = _agorartc.ERR_ADM_ANDROID_OPENSL_START_PLAYER_THREAD
r"""DEPRECATED**"""
ERR_ADM_IOS_INPUT_NOT_AVAILABLE = _agorartc.ERR_ADM_IOS_INPUT_NOT_AVAILABLE
r"""
     1201: Audio device module: The current device does not support audio
    input, possibly because you have mistakenly configured the audio session
     category, or because some other app is occupying the input device. We
    recommend terminating all background apps and re-joining the channel.
    """
ERR_ADM_IOS_ACTIVATE_SESSION_FAIL = _agorartc.ERR_ADM_IOS_ACTIVATE_SESSION_FAIL
r""" 1206: Audio device module: Cannot activate the Audio Session."""
ERR_ADM_IOS_VPIO_INIT_FAIL = _agorartc.ERR_ADM_IOS_VPIO_INIT_FAIL
r"""
     1210: Audio device module: Fails to initialize the audio device,
    normally because the audio device parameters are wrongly set.
    """
ERR_ADM_IOS_VPIO_REINIT_FAIL = _agorartc.ERR_ADM_IOS_VPIO_REINIT_FAIL
r"""
     1213: Audio device module: Fails to re-initialize the audio device,
    normally because the audio device parameters are wrongly set.
    """
ERR_ADM_IOS_VPIO_RESTART_FAIL = _agorartc.ERR_ADM_IOS_VPIO_RESTART_FAIL
r"""
     1214: Fails to re-start up the Audio Unit, possibly because the audio
    session category is not compatible with the settings of the Audio Unit.
    """
ERR_ADM_IOS_SET_RENDER_CALLBACK_FAIL = _agorartc.ERR_ADM_IOS_SET_RENDER_CALLBACK_FAIL
r""" Conditional comment:"""
ERR_ADM_IOS_SESSION_SAMPLERATR_ZERO = _agorartc.ERR_ADM_IOS_SESSION_SAMPLERATR_ZERO
r""" End of conditional comment. **DEPRECATED**"""
ERR_ADM_WIN_CORE_INIT = _agorartc.ERR_ADM_WIN_CORE_INIT
r"""
     1301: Audio device module: An audio driver abnomality or a
    compatibility issue occurs. Solutions: Disable and restart the audio
    device, or reboot the system.
    """
ERR_ADM_WIN_CORE_INIT_RECORDING = _agorartc.ERR_ADM_WIN_CORE_INIT_RECORDING
r"""
     1303: Audio device module: A recording driver abnomality or a
    compatibility issue occurs. Solutions: Disable and restart the audio
    device, or reboot the system.
    """
ERR_ADM_WIN_CORE_INIT_PLAYOUT = _agorartc.ERR_ADM_WIN_CORE_INIT_PLAYOUT
r"""
     1306: Audio device module: A playout driver abnomality or a
    compatibility issue occurs. Solutions: Disable and restart the audio
    device, or reboot the system.
    """
ERR_ADM_WIN_CORE_INIT_PLAYOUT_NULL = _agorartc.ERR_ADM_WIN_CORE_INIT_PLAYOUT_NULL
r"""
     1307: Audio device module: No audio device is available. Solutions:
    Plug in a proper audio device.
    """
ERR_ADM_WIN_CORE_START_RECORDING = _agorartc.ERR_ADM_WIN_CORE_START_RECORDING
r"""
     1309: Audio device module: An audio driver abnomality or a
    compatibility issue occurs. Solutions: Disable and restart the audio
    device, or reboot the system.
    """
ERR_ADM_WIN_CORE_CREATE_REC_THREAD = _agorartc.ERR_ADM_WIN_CORE_CREATE_REC_THREAD
r"""
     1311: Audio device module: Insufficient system memory or poor device
    performance. Solutions: Reboot the system or replace the device.
    """
ERR_ADM_WIN_CORE_CAPTURE_NOT_STARTUP = _agorartc.ERR_ADM_WIN_CORE_CAPTURE_NOT_STARTUP
r"""
     1314: Audio device module: An audio driver abnormality occurs.
    Solutions:
    - Disable and then re-enable the audio device.
    - Reboot the system.
    - Upgrade your audio card driver.
    """
ERR_ADM_WIN_CORE_CREATE_RENDER_THREAD = _agorartc.ERR_ADM_WIN_CORE_CREATE_RENDER_THREAD
r"""
     1319: Audio device module: Insufficient system memory or poor device
    performance. Solutions: Reboot the system or replace the device.
    """
ERR_ADM_WIN_CORE_RENDER_NOT_STARTUP = _agorartc.ERR_ADM_WIN_CORE_RENDER_NOT_STARTUP
r"""
     1320: Audio device module: An audio driver abnormality occurs.
    Solutions:
    - Disable and then re-enable the audio device.
    - Reboot the system.
    - Replace the device.
    """
ERR_ADM_WIN_CORE_NO_RECORDING_DEVICE = _agorartc.ERR_ADM_WIN_CORE_NO_RECORDING_DEVICE
r"""
     1322: Audio device module: No audio sampling device is available.
    Solutions: Plug in a proper recording device.
    """
ERR_ADM_WIN_CORE_NO_PLAYOUT_DEVICE = _agorartc.ERR_ADM_WIN_CORE_NO_PLAYOUT_DEVICE
r"""
     1323: Audio device module: No audio playout device is available.
    Solutions: Plug in a proper playback device.
    """
ERR_ADM_WIN_WAVE_INIT = _agorartc.ERR_ADM_WIN_WAVE_INIT
r"""
     1351: Audio device module: An audio driver abnormality or a
    compatibility issue occurs. Solutions:
    - Disable and then re-enable the audio device.
    - Reboot the system.
    - Upgrade your audio card driver.
    """
ERR_ADM_WIN_WAVE_INIT_RECORDING = _agorartc.ERR_ADM_WIN_WAVE_INIT_RECORDING
r"""
     1353: Audio device module: An audio driver abnormality occurs.
    Solutions:
    - Disable and then re-enable the audio device.
    - Reboot the system.
    - Upgrade your audio card driver.
    """
ERR_ADM_WIN_WAVE_INIT_MICROPHONE = _agorartc.ERR_ADM_WIN_WAVE_INIT_MICROPHONE
r"""
     1354: Audio device module: An audio driver abnormality occurs.
    Solutions:
    - Disable and then re-enable the audio device.
    - Reboot the system.
    - Upgrade your audio card driver.
    """
ERR_ADM_WIN_WAVE_INIT_PLAYOUT = _agorartc.ERR_ADM_WIN_WAVE_INIT_PLAYOUT
r"""
     1355: Audio device module: An audio driver abnormality occurs.
    Solutions:
    - Disable and then re-enable the audio device.
    - Reboot the system.
    - Upgrade your audio card driver.
    """
ERR_ADM_WIN_WAVE_INIT_SPEAKER = _agorartc.ERR_ADM_WIN_WAVE_INIT_SPEAKER
r"""
     1356: Audio device module: An audio driver abnormality occurs.
    Solutions:
    - Disable and then re-enable the audio device.
    - Reboot the system.
    - Upgrade your audio card driver.
    """
ERR_ADM_WIN_WAVE_START_RECORDING = _agorartc.ERR_ADM_WIN_WAVE_START_RECORDING
r"""
     1357: Audio device module: An audio driver abnormality occurs.
    Solutions:
    - Disable and then re-enable the audio device.
    - Reboot the system.
    - Upgrade your audio card driver.
    """
ERR_ADM_WIN_WAVE_START_PLAYOUT = _agorartc.ERR_ADM_WIN_WAVE_START_PLAYOUT
r"""
     1358: Audio device module: An audio driver abnormality occurs.
    Solutions:
    - Disable and then re-enable the audio device.
    - Reboot the system.
    - Upgrade your audio card driver.
    """
ERR_ADM_NO_RECORDING_DEVICE = _agorartc.ERR_ADM_NO_RECORDING_DEVICE
r""" 1359: Audio Device Module: No recording device exists."""
ERR_ADM_NO_PLAYOUT_DEVICE = _agorartc.ERR_ADM_NO_PLAYOUT_DEVICE
r""" 1360: Audio Device Module: No playback device exists."""
ERR_VDM_CAMERA_NOT_AUTHORIZED = _agorartc.ERR_VDM_CAMERA_NOT_AUTHORIZED
r""" 1501: Video Device Module: The camera is unauthorized."""
ERR_VDM_WIN_DEVICE_IN_USE = _agorartc.ERR_VDM_WIN_DEVICE_IN_USE
r"""
    DEPRECATED** 1502: Video Device Module: The camera in use.

         Deprecated as of v2.4.1. Use LOCAL_VIDEO_STREAM_ERROR_DEVICE_BUSY(3) in the 'onConnectionStateChanged' callback instead.
    """
ERR_VCM_UNKNOWN_ERROR = _agorartc.ERR_VCM_UNKNOWN_ERROR
r""" 1600: Video Device Module: An unknown error occurs."""
ERR_VCM_ENCODER_INIT_ERROR = _agorartc.ERR_VCM_ENCODER_INIT_ERROR
r""" 1601: Video Device Module: An error occurs in initializing the video encoder."""
ERR_VCM_ENCODER_ENCODE_ERROR = _agorartc.ERR_VCM_ENCODER_ENCODE_ERROR
r""" 1602: Video Device Module: An error occurs in encoding."""
ERR_VCM_ENCODER_SET_ERROR = _agorartc.ERR_VCM_ENCODER_SET_ERROR
r""" 1603: Video Device Module: An error occurs in setting the video encoder."""
LOG_FILTER_OFF = _agorartc.LOG_FILTER_OFF
r""" 0: Do not output any log information."""
LOG_FILTER_DEBUG = _agorartc.LOG_FILTER_DEBUG
r"""
    0x080f: Output all log information.
         Set your log filter as debug if you want to get the most complete log file.
    """
LOG_FILTER_INFO = _agorartc.LOG_FILTER_INFO
r"""
    0x000f: Output CRITICAL, ERROR, WARNING, and INFO level log information.
         We recommend setting your log filter as this level.
    """
LOG_FILTER_WARN = _agorartc.LOG_FILTER_WARN
r""" 0x000e: Outputs CRITICAL, ERROR, and WARNING level log information."""
LOG_FILTER_ERROR = _agorartc.LOG_FILTER_ERROR
r""" 0x000c: Outputs CRITICAL and ERROR level log information."""
LOG_FILTER_CRITICAL = _agorartc.LOG_FILTER_CRITICAL
r""" 0x0008: Outputs CRITICAL level log information."""
LOG_FILTER_MASK = _agorartc.LOG_FILTER_MASK
r""" Conditional comment:"""
MAX_DEVICE_ID_LENGTH = _agorartc.MAX_DEVICE_ID_LENGTH
r""" The maximum length of the device ID is 512 bytes."""
MAX_USER_ACCOUNT_LENGTH = _agorartc.MAX_USER_ACCOUNT_LENGTH
r""" The maximum length of user account is 255 bytes."""
MAX_CHANNEL_ID_LENGTH = _agorartc.MAX_CHANNEL_ID_LENGTH
r""" The maximum length of channel id is 64 bytes."""
QUALITY_REPORT_JSON = _agorartc.QUALITY_REPORT_JSON
r""" 0: The quality report in JSON format,"""
QUALITY_REPORT_HTML = _agorartc.QUALITY_REPORT_HTML
r""" 1: The quality report in HTML format."""
MEDIA_ENGINE_RECORDING_ERROR = _agorartc.MEDIA_ENGINE_RECORDING_ERROR
r""" 0: For internal use only."""
MEDIA_ENGINE_PLAYOUT_ERROR = _agorartc.MEDIA_ENGINE_PLAYOUT_ERROR
r""" 1: For internal use only."""
MEDIA_ENGINE_RECORDING_WARNING = _agorartc.MEDIA_ENGINE_RECORDING_WARNING
r""" 2: For internal use only."""
MEDIA_ENGINE_PLAYOUT_WARNING = _agorartc.MEDIA_ENGINE_PLAYOUT_WARNING
r""" 3: For internal use only."""
MEDIA_ENGINE_AUDIO_FILE_MIX_FINISH = _agorartc.MEDIA_ENGINE_AUDIO_FILE_MIX_FINISH
r""" 10: For internal use only."""
MEDIA_ENGINE_AUDIO_FAREND_MUSIC_BEGINS = _agorartc.MEDIA_ENGINE_AUDIO_FAREND_MUSIC_BEGINS
r""" 12: For internal use only."""
MEDIA_ENGINE_AUDIO_FAREND_MUSIC_ENDS = _agorartc.MEDIA_ENGINE_AUDIO_FAREND_MUSIC_ENDS
r""" 13: For internal use only."""
MEDIA_ENGINE_LOCAL_AUDIO_RECORD_ENABLED = _agorartc.MEDIA_ENGINE_LOCAL_AUDIO_RECORD_ENABLED
r""" 14: For internal use only."""
MEDIA_ENGINE_LOCAL_AUDIO_RECORD_DISABLED = _agorartc.MEDIA_ENGINE_LOCAL_AUDIO_RECORD_DISABLED
r""" 15: For internal use only."""
MEDIA_ENGINE_ROLE_BROADCASTER_SOLO = _agorartc.MEDIA_ENGINE_ROLE_BROADCASTER_SOLO
r""" 20: For internal use only."""
MEDIA_ENGINE_ROLE_BROADCASTER_INTERACTIVE = _agorartc.MEDIA_ENGINE_ROLE_BROADCASTER_INTERACTIVE
r""" 21: For internal use only."""
MEDIA_ENGINE_ROLE_AUDIENCE = _agorartc.MEDIA_ENGINE_ROLE_AUDIENCE
r""" 22: For internal use only."""
MEDIA_ENGINE_ROLE_COMM_PEER = _agorartc.MEDIA_ENGINE_ROLE_COMM_PEER
r""" 23: For internal use only."""
MEDIA_ENGINE_ROLE_GAME_PEER = _agorartc.MEDIA_ENGINE_ROLE_GAME_PEER
r""" 24: For internal use only."""
MEDIA_ENGINE_AUDIO_ADM_REQUIRE_RESTART = _agorartc.MEDIA_ENGINE_AUDIO_ADM_REQUIRE_RESTART
r""" 110: For internal use only."""
MEDIA_ENGINE_AUDIO_ADM_SPECIAL_RESTART = _agorartc.MEDIA_ENGINE_AUDIO_ADM_SPECIAL_RESTART
r""" 111: For internal use only."""
MEDIA_ENGINE_AUDIO_ADM_USING_COMM_PARAMS = _agorartc.MEDIA_ENGINE_AUDIO_ADM_USING_COMM_PARAMS
r""" 112: For internal use only."""
MEDIA_ENGINE_AUDIO_ADM_USING_NORM_PARAMS = _agorartc.MEDIA_ENGINE_AUDIO_ADM_USING_NORM_PARAMS
r""" 113: For internal use only."""
MEDIA_ENGINE_AUDIO_EVENT_MIXING_PLAY = _agorartc.MEDIA_ENGINE_AUDIO_EVENT_MIXING_PLAY
r""" 710: For internal use only."""
MEDIA_ENGINE_AUDIO_EVENT_MIXING_PAUSED = _agorartc.MEDIA_ENGINE_AUDIO_EVENT_MIXING_PAUSED
r""" 711: For internal use only."""
MEDIA_ENGINE_AUDIO_EVENT_MIXING_RESTART = _agorartc.MEDIA_ENGINE_AUDIO_EVENT_MIXING_RESTART
r""" 712: For internal use only."""
MEDIA_ENGINE_AUDIO_EVENT_MIXING_STOPPED = _agorartc.MEDIA_ENGINE_AUDIO_EVENT_MIXING_STOPPED
r""" 713: For internal use only."""
MEDIA_ENGINE_AUDIO_EVENT_MIXING_ERROR = _agorartc.MEDIA_ENGINE_AUDIO_EVENT_MIXING_ERROR
r""" 714: For internal use only."""
MEDIA_ENGINE_AUDIO_ERROR_MIXING_OPEN = _agorartc.MEDIA_ENGINE_AUDIO_ERROR_MIXING_OPEN
r""" 701: For internal use only."""
MEDIA_ENGINE_AUDIO_ERROR_MIXING_TOO_FREQUENT = _agorartc.MEDIA_ENGINE_AUDIO_ERROR_MIXING_TOO_FREQUENT
r""" 702: For internal use only."""
MEDIA_ENGINE_AUDIO_ERROR_MIXING_INTERRUPTED_EOF = _agorartc.MEDIA_ENGINE_AUDIO_ERROR_MIXING_INTERRUPTED_EOF
r""" 703: The audio mixing file playback is interrupted. For internal use only."""
MEDIA_ENGINE_AUDIO_ERROR_MIXING_NO_ERROR = _agorartc.MEDIA_ENGINE_AUDIO_ERROR_MIXING_NO_ERROR
r""" 0: For internal use only."""
AUDIO_MIXING_STATE_PLAYING = _agorartc.AUDIO_MIXING_STATE_PLAYING
r""" 710: The audio mixing file is playing."""
AUDIO_MIXING_STATE_PAUSED = _agorartc.AUDIO_MIXING_STATE_PAUSED
r""" 711: The audio mixing file pauses playing."""
AUDIO_MIXING_STATE_STOPPED = _agorartc.AUDIO_MIXING_STATE_STOPPED
r""" 713: The audio mixing file stops playing."""
AUDIO_MIXING_STATE_FAILED = _agorartc.AUDIO_MIXING_STATE_FAILED
r""" 714: An exception occurs when playing the audio mixing file. See #AUDIO_MIXING_ERROR_TYPE."""
AUDIO_MIXING_ERROR_CAN_NOT_OPEN = _agorartc.AUDIO_MIXING_ERROR_CAN_NOT_OPEN
r""" 701: The SDK cannot open the audio mixing file."""
AUDIO_MIXING_ERROR_TOO_FREQUENT_CALL = _agorartc.AUDIO_MIXING_ERROR_TOO_FREQUENT_CALL
r""" 702: The SDK opens the audio mixing file too frequently."""
AUDIO_MIXING_ERROR_INTERRUPTED_EOF = _agorartc.AUDIO_MIXING_ERROR_INTERRUPTED_EOF
r""" 703: The audio mixing file playback is interrupted."""
AUDIO_MIXING_ERROR_OK = _agorartc.AUDIO_MIXING_ERROR_OK
r""" 0: The SDK can open the audio mixing file."""
MEDIA_DEVICE_STATE_ACTIVE = _agorartc.MEDIA_DEVICE_STATE_ACTIVE
r""" 1: The device is active."""
MEDIA_DEVICE_STATE_DISABLED = _agorartc.MEDIA_DEVICE_STATE_DISABLED
r""" 2: The device is disabled."""
MEDIA_DEVICE_STATE_NOT_PRESENT = _agorartc.MEDIA_DEVICE_STATE_NOT_PRESENT
r""" 4: The device is not present."""
MEDIA_DEVICE_STATE_UNPLUGGED = _agorartc.MEDIA_DEVICE_STATE_UNPLUGGED
r""" 8: The device is unplugged."""
UNKNOWN_AUDIO_DEVICE = _agorartc.UNKNOWN_AUDIO_DEVICE
r""" -1: Unknown device type."""
AUDIO_PLAYOUT_DEVICE = _agorartc.AUDIO_PLAYOUT_DEVICE
r""" 0: Audio playback device."""
AUDIO_RECORDING_DEVICE = _agorartc.AUDIO_RECORDING_DEVICE
r""" 1: Audio recording device."""
VIDEO_RENDER_DEVICE = _agorartc.VIDEO_RENDER_DEVICE
r""" 2: Video renderer."""
VIDEO_CAPTURE_DEVICE = _agorartc.VIDEO_CAPTURE_DEVICE
r""" 3: Video capturer."""
AUDIO_APPLICATION_PLAYOUT_DEVICE = _agorartc.AUDIO_APPLICATION_PLAYOUT_DEVICE
r""" 4: Application audio playback device."""
LOCAL_VIDEO_STREAM_STATE_STOPPED = _agorartc.LOCAL_VIDEO_STREAM_STATE_STOPPED
r""" 0: Initial state"""
LOCAL_VIDEO_STREAM_STATE_CAPTURING = _agorartc.LOCAL_VIDEO_STREAM_STATE_CAPTURING
r"""
     1: The local video capturing device starts successfully.

    The SDK also reports this state when you share a maximized window by calling 'startScreenCaptureByWindowId'.
    """
LOCAL_VIDEO_STREAM_STATE_ENCODING = _agorartc.LOCAL_VIDEO_STREAM_STATE_ENCODING
r""" 2: The first video frame is successfully encoded."""
LOCAL_VIDEO_STREAM_STATE_FAILED = _agorartc.LOCAL_VIDEO_STREAM_STATE_FAILED
r""" 3: The local video fails to start."""
LOCAL_VIDEO_STREAM_ERROR_OK = _agorartc.LOCAL_VIDEO_STREAM_ERROR_OK
r""" 0: The local video is normal."""
LOCAL_VIDEO_STREAM_ERROR_FAILURE = _agorartc.LOCAL_VIDEO_STREAM_ERROR_FAILURE
r""" 1: No specified reason for the local video failure."""
LOCAL_VIDEO_STREAM_ERROR_DEVICE_NO_PERMISSION = _agorartc.LOCAL_VIDEO_STREAM_ERROR_DEVICE_NO_PERMISSION
r""" 2: No permission to use the local video capturing device."""
LOCAL_VIDEO_STREAM_ERROR_DEVICE_BUSY = _agorartc.LOCAL_VIDEO_STREAM_ERROR_DEVICE_BUSY
r""" 3: The local video capturing device is in use."""
LOCAL_VIDEO_STREAM_ERROR_CAPTURE_FAILURE = _agorartc.LOCAL_VIDEO_STREAM_ERROR_CAPTURE_FAILURE
r""" 4: The local video capture fails. Check whether the capturing device is working properly."""
LOCAL_VIDEO_STREAM_ERROR_ENCODE_FAILURE = _agorartc.LOCAL_VIDEO_STREAM_ERROR_ENCODE_FAILURE
r""" 5: The local video encoding fails."""
LOCAL_VIDEO_STREAM_ERROR_SCREEN_CAPTURE_WINDOW_MINIMIZED = _agorartc.LOCAL_VIDEO_STREAM_ERROR_SCREEN_CAPTURE_WINDOW_MINIMIZED
r""" 11: The shared window is minimized when you call 'startScreenCaptureByWindowId' to share a window."""
LOCAL_AUDIO_STREAM_STATE_STOPPED = _agorartc.LOCAL_AUDIO_STREAM_STATE_STOPPED
r""" 0: The local audio is in the initial state."""
LOCAL_AUDIO_STREAM_STATE_RECORDING = _agorartc.LOCAL_AUDIO_STREAM_STATE_RECORDING
r""" 1: The recording device starts successfully."""
LOCAL_AUDIO_STREAM_STATE_ENCODING = _agorartc.LOCAL_AUDIO_STREAM_STATE_ENCODING
r""" 2: The first audio frame encodes successfully."""
LOCAL_AUDIO_STREAM_STATE_FAILED = _agorartc.LOCAL_AUDIO_STREAM_STATE_FAILED
r""" 3: The local audio fails to start."""
LOCAL_AUDIO_STREAM_ERROR_OK = _agorartc.LOCAL_AUDIO_STREAM_ERROR_OK
r""" 0: The local audio is normal."""
LOCAL_AUDIO_STREAM_ERROR_FAILURE = _agorartc.LOCAL_AUDIO_STREAM_ERROR_FAILURE
r""" 1: No specified reason for the local audio failure."""
LOCAL_AUDIO_STREAM_ERROR_DEVICE_NO_PERMISSION = _agorartc.LOCAL_AUDIO_STREAM_ERROR_DEVICE_NO_PERMISSION
r""" 2: No permission to use the local audio device."""
LOCAL_AUDIO_STREAM_ERROR_DEVICE_BUSY = _agorartc.LOCAL_AUDIO_STREAM_ERROR_DEVICE_BUSY
r""" 3: The microphone is in use."""
LOCAL_AUDIO_STREAM_ERROR_RECORD_FAILURE = _agorartc.LOCAL_AUDIO_STREAM_ERROR_RECORD_FAILURE
r"""
     4: The local audio recording fails. Check whether the recording device
    is working properly.
    """
LOCAL_AUDIO_STREAM_ERROR_ENCODE_FAILURE = _agorartc.LOCAL_AUDIO_STREAM_ERROR_ENCODE_FAILURE
r""" 5: The local audio encoding fails."""
AUDIO_RECORDING_QUALITY_LOW = _agorartc.AUDIO_RECORDING_QUALITY_LOW
r"""
     0: Low quality. The sample rate is 32 kHz, and the file size is around
    1.2 MB after 10 minutes of recording.
    """
AUDIO_RECORDING_QUALITY_MEDIUM = _agorartc.AUDIO_RECORDING_QUALITY_MEDIUM
r"""
     1: Medium quality. The sample rate is 32 kHz, and the file size is
    around 2 MB after 10 minutes of recording.
    """
AUDIO_RECORDING_QUALITY_HIGH = _agorartc.AUDIO_RECORDING_QUALITY_HIGH
r"""
     2: High quality. The sample rate is 32 kHz, and the file size is
    around 3.75 MB after 10 minutes of recording.
    """
QUALITY_UNKNOWN = _agorartc.QUALITY_UNKNOWN
r""" 0: The network quality is unknown."""
QUALITY_EXCELLENT = _agorartc.QUALITY_EXCELLENT
r"""  1: The network quality is excellent."""
QUALITY_GOOD = _agorartc.QUALITY_GOOD
r""" 2: The network quality is quite good, but the bitrate may be slightly lower than excellent."""
QUALITY_POOR = _agorartc.QUALITY_POOR
r""" 3: Users can feel the communication slightly impaired."""
QUALITY_BAD = _agorartc.QUALITY_BAD
r""" 4: Users cannot communicate smoothly."""
QUALITY_VBAD = _agorartc.QUALITY_VBAD
r""" 5: The network is so bad that users can barely communicate."""
QUALITY_DOWN = _agorartc.QUALITY_DOWN
r""" 6: The network is down and users cannot communicate at all."""
QUALITY_UNSUPPORTED = _agorartc.QUALITY_UNSUPPORTED
r""" 7: Users cannot detect the network quality. (Not in use.)"""
QUALITY_DETECTING = _agorartc.QUALITY_DETECTING
r""" 8: Detecting the network quality."""
RENDER_MODE_HIDDEN = _agorartc.RENDER_MODE_HIDDEN
r"""1: Uniformly scale the video until it fills the visible boundaries (cropped). One dimension of the video may have clipped contents."""
RENDER_MODE_FIT = _agorartc.RENDER_MODE_FIT
r"""2: Uniformly scale the video until one of its dimension fits the boundary (zoomed to fit). Areas that are not filled due to disparity in the aspect ratio are filled with black."""
RENDER_MODE_ADAPTIVE = _agorartc.RENDER_MODE_ADAPTIVE
r"""DEPRECATED** 3: This mode is deprecated."""
RENDER_MODE_FILL = _agorartc.RENDER_MODE_FILL
r"""    4: The fill mode. In this mode, the SDK stretches or zooms the video to fill the display window."""
VIDEO_MIRROR_MODE_AUTO = _agorartc.VIDEO_MIRROR_MODE_AUTO
r""" 0: (Default) The SDK enables the mirror mode."""
VIDEO_MIRROR_MODE_ENABLED = _agorartc.VIDEO_MIRROR_MODE_ENABLED
r""" 1: Enable mirror mode."""
VIDEO_MIRROR_MODE_DISABLED = _agorartc.VIDEO_MIRROR_MODE_DISABLED
r""" 2: Disable mirror mode."""
VIDEO_PROFILE_LANDSCAPE_120P = _agorartc.VIDEO_PROFILE_LANDSCAPE_120P
r""" 0: 160 * 120, frame rate 15 fps, bitrate 65 Kbps."""
VIDEO_PROFILE_LANDSCAPE_120P_3 = _agorartc.VIDEO_PROFILE_LANDSCAPE_120P_3
r""" 2: 120 * 120, frame rate 15 fps, bitrate 50 Kbps."""
VIDEO_PROFILE_LANDSCAPE_180P = _agorartc.VIDEO_PROFILE_LANDSCAPE_180P
r""" 10: 320*180, frame rate 15 fps, bitrate 140 Kbps."""
VIDEO_PROFILE_LANDSCAPE_180P_3 = _agorartc.VIDEO_PROFILE_LANDSCAPE_180P_3
r""" 12: 180 * 180, frame rate 15 fps, bitrate 100 Kbps."""
VIDEO_PROFILE_LANDSCAPE_180P_4 = _agorartc.VIDEO_PROFILE_LANDSCAPE_180P_4
r""" 13: 240 * 180, frame rate 15 fps, bitrate 120 Kbps."""
VIDEO_PROFILE_LANDSCAPE_240P = _agorartc.VIDEO_PROFILE_LANDSCAPE_240P
r""" 20: 320 * 240, frame rate 15 fps, bitrate 200 Kbps."""
VIDEO_PROFILE_LANDSCAPE_240P_3 = _agorartc.VIDEO_PROFILE_LANDSCAPE_240P_3
r""" 22: 240 * 240, frame rate 15 fps, bitrate 140 Kbps."""
VIDEO_PROFILE_LANDSCAPE_240P_4 = _agorartc.VIDEO_PROFILE_LANDSCAPE_240P_4
r""" 23: 424 * 240, frame rate 15 fps, bitrate 220 Kbps."""
VIDEO_PROFILE_LANDSCAPE_360P = _agorartc.VIDEO_PROFILE_LANDSCAPE_360P
r""" 30: 640 * 360, frame rate 15 fps, bitrate 400 Kbps."""
VIDEO_PROFILE_LANDSCAPE_360P_3 = _agorartc.VIDEO_PROFILE_LANDSCAPE_360P_3
r""" 32: 360 * 360, frame rate 15 fps, bitrate 260 Kbps."""
VIDEO_PROFILE_LANDSCAPE_360P_4 = _agorartc.VIDEO_PROFILE_LANDSCAPE_360P_4
r""" 33: 640 * 360, frame rate 30 fps, bitrate 600 Kbps."""
VIDEO_PROFILE_LANDSCAPE_360P_6 = _agorartc.VIDEO_PROFILE_LANDSCAPE_360P_6
r""" 35: 360 * 360, frame rate 30 fps, bitrate 400 Kbps."""
VIDEO_PROFILE_LANDSCAPE_360P_7 = _agorartc.VIDEO_PROFILE_LANDSCAPE_360P_7
r""" 36: 480 * 360, frame rate 15 fps, bitrate 320 Kbps."""
VIDEO_PROFILE_LANDSCAPE_360P_8 = _agorartc.VIDEO_PROFILE_LANDSCAPE_360P_8
r""" 37: 480 * 360, frame rate 30 fps, bitrate 490 Kbps."""
VIDEO_PROFILE_LANDSCAPE_360P_9 = _agorartc.VIDEO_PROFILE_LANDSCAPE_360P_9
r"""
    38: 640 * 360, frame rate 15 fps, bitrate 800 Kbps.
        Notes: `LIVE_BROADCASTING` profile only.
    """
VIDEO_PROFILE_LANDSCAPE_360P_10 = _agorartc.VIDEO_PROFILE_LANDSCAPE_360P_10
r"""
    39: 640 * 360, frame rate 24 fps, bitrate 800 Kbps.
        Notes: `LIVE_BROADCASTING` profile only.
    """
VIDEO_PROFILE_LANDSCAPE_360P_11 = _agorartc.VIDEO_PROFILE_LANDSCAPE_360P_11
r"""
    100: 640 * 360, frame rate 24 fps, bitrate 1000 Kbps.
        Notes: `LIVE_BROADCASTING` profile only.
    """
VIDEO_PROFILE_LANDSCAPE_480P = _agorartc.VIDEO_PROFILE_LANDSCAPE_480P
r""" 40: 640 * 480, frame rate 15 fps, bitrate 500 Kbps."""
VIDEO_PROFILE_LANDSCAPE_480P_3 = _agorartc.VIDEO_PROFILE_LANDSCAPE_480P_3
r""" 42: 480 * 480, frame rate 15 fps, bitrate 400 Kbps."""
VIDEO_PROFILE_LANDSCAPE_480P_4 = _agorartc.VIDEO_PROFILE_LANDSCAPE_480P_4
r""" 43: 640 * 480, frame rate 30 fps, bitrate 750 Kbps."""
VIDEO_PROFILE_LANDSCAPE_480P_6 = _agorartc.VIDEO_PROFILE_LANDSCAPE_480P_6
r""" 45: 480 * 480, frame rate 30 fps, bitrate 600 Kbps."""
VIDEO_PROFILE_LANDSCAPE_480P_8 = _agorartc.VIDEO_PROFILE_LANDSCAPE_480P_8
r""" 47: 848 * 480, frame rate 15 fps, bitrate 610 Kbps."""
VIDEO_PROFILE_LANDSCAPE_480P_9 = _agorartc.VIDEO_PROFILE_LANDSCAPE_480P_9
r""" 48: 848 * 480, frame rate 30 fps, bitrate 930 Kbps."""
VIDEO_PROFILE_LANDSCAPE_480P_10 = _agorartc.VIDEO_PROFILE_LANDSCAPE_480P_10
r""" 49: 640 * 480, frame rate 10 fps, bitrate 400 Kbps."""
VIDEO_PROFILE_LANDSCAPE_720P = _agorartc.VIDEO_PROFILE_LANDSCAPE_720P
r""" 50: 1280 * 720, frame rate 15 fps, bitrate 1130 Kbps."""
VIDEO_PROFILE_LANDSCAPE_720P_3 = _agorartc.VIDEO_PROFILE_LANDSCAPE_720P_3
r""" 52: 1280 * 720, frame rate 30 fps, bitrate 1710 Kbps."""
VIDEO_PROFILE_LANDSCAPE_720P_5 = _agorartc.VIDEO_PROFILE_LANDSCAPE_720P_5
r""" 54: 960 * 720, frame rate 15 fps, bitrate 910 Kbps."""
VIDEO_PROFILE_LANDSCAPE_720P_6 = _agorartc.VIDEO_PROFILE_LANDSCAPE_720P_6
r""" 55: 960 * 720, frame rate 30 fps, bitrate 1380 Kbps."""
VIDEO_PROFILE_LANDSCAPE_1080P = _agorartc.VIDEO_PROFILE_LANDSCAPE_1080P
r""" 60: 1920 * 1080, frame rate 15 fps, bitrate 2080 Kbps."""
VIDEO_PROFILE_LANDSCAPE_1080P_3 = _agorartc.VIDEO_PROFILE_LANDSCAPE_1080P_3
r""" 62: 1920 * 1080, frame rate 30 fps, bitrate 3150 Kbps."""
VIDEO_PROFILE_LANDSCAPE_1080P_5 = _agorartc.VIDEO_PROFILE_LANDSCAPE_1080P_5
r""" 64: 1920 * 1080, frame rate 60 fps, bitrate 4780 Kbps."""
VIDEO_PROFILE_LANDSCAPE_1440P = _agorartc.VIDEO_PROFILE_LANDSCAPE_1440P
r""" 66: 2560 * 1440, frame rate 30 fps, bitrate 4850 Kbps."""
VIDEO_PROFILE_LANDSCAPE_1440P_2 = _agorartc.VIDEO_PROFILE_LANDSCAPE_1440P_2
r""" 67: 2560 * 1440, frame rate 60 fps, bitrate 6500 Kbps."""
VIDEO_PROFILE_LANDSCAPE_4K = _agorartc.VIDEO_PROFILE_LANDSCAPE_4K
r""" 70: 3840 * 2160, frame rate 30 fps, bitrate 6500 Kbps."""
VIDEO_PROFILE_LANDSCAPE_4K_3 = _agorartc.VIDEO_PROFILE_LANDSCAPE_4K_3
r""" 72: 3840 * 2160, frame rate 60 fps, bitrate 6500 Kbps."""
VIDEO_PROFILE_PORTRAIT_120P = _agorartc.VIDEO_PROFILE_PORTRAIT_120P
r""" 1000: 120 * 160, frame rate 15 fps, bitrate 65 Kbps."""
VIDEO_PROFILE_PORTRAIT_120P_3 = _agorartc.VIDEO_PROFILE_PORTRAIT_120P_3
r""" 1002: 120 * 120, frame rate 15 fps, bitrate 50 Kbps."""
VIDEO_PROFILE_PORTRAIT_180P = _agorartc.VIDEO_PROFILE_PORTRAIT_180P
r""" 1010: 180 * 320, frame rate 15 fps, bitrate 140 Kbps."""
VIDEO_PROFILE_PORTRAIT_180P_3 = _agorartc.VIDEO_PROFILE_PORTRAIT_180P_3
r""" 1012: 180 * 180, frame rate 15 fps, bitrate 100 Kbps."""
VIDEO_PROFILE_PORTRAIT_180P_4 = _agorartc.VIDEO_PROFILE_PORTRAIT_180P_4
r""" 1013: 180 * 240, frame rate 15 fps, bitrate 120 Kbps."""
VIDEO_PROFILE_PORTRAIT_240P = _agorartc.VIDEO_PROFILE_PORTRAIT_240P
r""" 1020: 240 * 320, frame rate 15 fps, bitrate 200 Kbps."""
VIDEO_PROFILE_PORTRAIT_240P_3 = _agorartc.VIDEO_PROFILE_PORTRAIT_240P_3
r""" 1022: 240 * 240, frame rate 15 fps, bitrate 140 Kbps."""
VIDEO_PROFILE_PORTRAIT_240P_4 = _agorartc.VIDEO_PROFILE_PORTRAIT_240P_4
r""" 1023: 240 * 424, frame rate 15 fps, bitrate 220 Kbps."""
VIDEO_PROFILE_PORTRAIT_360P = _agorartc.VIDEO_PROFILE_PORTRAIT_360P
r""" 1030: 360 * 640, frame rate 15 fps, bitrate 400 Kbps."""
VIDEO_PROFILE_PORTRAIT_360P_3 = _agorartc.VIDEO_PROFILE_PORTRAIT_360P_3
r""" 1032: 360 * 360, frame rate 15 fps, bitrate 260 Kbps."""
VIDEO_PROFILE_PORTRAIT_360P_4 = _agorartc.VIDEO_PROFILE_PORTRAIT_360P_4
r""" 1033: 360 * 640, frame rate 30 fps, bitrate 600 Kbps."""
VIDEO_PROFILE_PORTRAIT_360P_6 = _agorartc.VIDEO_PROFILE_PORTRAIT_360P_6
r""" 1035: 360 * 360, frame rate 30 fps, bitrate 400 Kbps."""
VIDEO_PROFILE_PORTRAIT_360P_7 = _agorartc.VIDEO_PROFILE_PORTRAIT_360P_7
r""" 1036: 360 * 480, frame rate 15 fps, bitrate 320 Kbps."""
VIDEO_PROFILE_PORTRAIT_360P_8 = _agorartc.VIDEO_PROFILE_PORTRAIT_360P_8
r""" 1037: 360 * 480, frame rate 30 fps, bitrate 490 Kbps."""
VIDEO_PROFILE_PORTRAIT_360P_9 = _agorartc.VIDEO_PROFILE_PORTRAIT_360P_9
r"""
    1038: 360 * 640, frame rate 15 fps, bitrate 800 Kbps.
        Notes: `LIVE_BROADCASTING` profile only.
    """
VIDEO_PROFILE_PORTRAIT_360P_10 = _agorartc.VIDEO_PROFILE_PORTRAIT_360P_10
r"""
    1039: 360 * 640, frame rate 24 fps, bitrate 800 Kbps.
        Notes: `LIVE_BROADCASTING` profile only.
    """
VIDEO_PROFILE_PORTRAIT_360P_11 = _agorartc.VIDEO_PROFILE_PORTRAIT_360P_11
r"""
    1100: 360 * 640, frame rate 24 fps, bitrate 1000 Kbps.
        Notes: `LIVE_BROADCASTING` profile only.
    """
VIDEO_PROFILE_PORTRAIT_480P = _agorartc.VIDEO_PROFILE_PORTRAIT_480P
r""" 1040: 480 * 640, frame rate 15 fps, bitrate 500 Kbps."""
VIDEO_PROFILE_PORTRAIT_480P_3 = _agorartc.VIDEO_PROFILE_PORTRAIT_480P_3
r""" 1042: 480 * 480, frame rate 15 fps, bitrate 400 Kbps."""
VIDEO_PROFILE_PORTRAIT_480P_4 = _agorartc.VIDEO_PROFILE_PORTRAIT_480P_4
r""" 1043: 480 * 640, frame rate 30 fps, bitrate 750 Kbps."""
VIDEO_PROFILE_PORTRAIT_480P_6 = _agorartc.VIDEO_PROFILE_PORTRAIT_480P_6
r""" 1045: 480 * 480, frame rate 30 fps, bitrate 600 Kbps."""
VIDEO_PROFILE_PORTRAIT_480P_8 = _agorartc.VIDEO_PROFILE_PORTRAIT_480P_8
r""" 1047: 480 * 848, frame rate 15 fps, bitrate 610 Kbps."""
VIDEO_PROFILE_PORTRAIT_480P_9 = _agorartc.VIDEO_PROFILE_PORTRAIT_480P_9
r""" 1048: 480 * 848, frame rate 30 fps, bitrate 930 Kbps."""
VIDEO_PROFILE_PORTRAIT_480P_10 = _agorartc.VIDEO_PROFILE_PORTRAIT_480P_10
r""" 1049: 480 * 640, frame rate 10 fps, bitrate 400 Kbps."""
VIDEO_PROFILE_PORTRAIT_720P = _agorartc.VIDEO_PROFILE_PORTRAIT_720P
r""" 1050: 720 * 1280, frame rate 15 fps, bitrate 1130 Kbps."""
VIDEO_PROFILE_PORTRAIT_720P_3 = _agorartc.VIDEO_PROFILE_PORTRAIT_720P_3
r""" 1052: 720 * 1280, frame rate 30 fps, bitrate 1710 Kbps."""
VIDEO_PROFILE_PORTRAIT_720P_5 = _agorartc.VIDEO_PROFILE_PORTRAIT_720P_5
r""" 1054: 720 * 960, frame rate 15 fps, bitrate 910 Kbps."""
VIDEO_PROFILE_PORTRAIT_720P_6 = _agorartc.VIDEO_PROFILE_PORTRAIT_720P_6
r""" 1055: 720 * 960, frame rate 30 fps, bitrate 1380 Kbps."""
VIDEO_PROFILE_PORTRAIT_1080P = _agorartc.VIDEO_PROFILE_PORTRAIT_1080P
r""" 1060: 1080 * 1920, frame rate 15 fps, bitrate 2080 Kbps."""
VIDEO_PROFILE_PORTRAIT_1080P_3 = _agorartc.VIDEO_PROFILE_PORTRAIT_1080P_3
r""" 1062: 1080 * 1920, frame rate 30 fps, bitrate 3150 Kbps."""
VIDEO_PROFILE_PORTRAIT_1080P_5 = _agorartc.VIDEO_PROFILE_PORTRAIT_1080P_5
r""" 1064: 1080 * 1920, frame rate 60 fps, bitrate 4780 Kbps."""
VIDEO_PROFILE_PORTRAIT_1440P = _agorartc.VIDEO_PROFILE_PORTRAIT_1440P
r""" 1066: 1440 * 2560, frame rate 30 fps, bitrate 4850 Kbps."""
VIDEO_PROFILE_PORTRAIT_1440P_2 = _agorartc.VIDEO_PROFILE_PORTRAIT_1440P_2
r""" 1067: 1440 * 2560, frame rate 60 fps, bitrate 6500 Kbps."""
VIDEO_PROFILE_PORTRAIT_4K = _agorartc.VIDEO_PROFILE_PORTRAIT_4K
r""" 1070: 2160 * 3840, frame rate 30 fps, bitrate 6500 Kbps."""
VIDEO_PROFILE_PORTRAIT_4K_3 = _agorartc.VIDEO_PROFILE_PORTRAIT_4K_3
r""" 1072: 2160 * 3840, frame rate 60 fps, bitrate 6500 Kbps."""
VIDEO_PROFILE_DEFAULT = _agorartc.VIDEO_PROFILE_DEFAULT
r""" Default 640 * 360, frame rate 15 fps, bitrate 400 Kbps."""
AUDIO_PROFILE_DEFAULT = _agorartc.AUDIO_PROFILE_DEFAULT
r"""
    0: Default audio profile:
    - For the interactive streaming profile: A sample rate of 48 KHz, music encoding, mono, and a bitrate of up to 64 Kbps.
    - For the `COMMUNICATION` profile:
       - Windows: A sample rate of 16 KHz, music encoding, mono, and a bitrate of up to 16 Kbps.
       - Android/macOS/iOS: A sample rate of 32 KHz, music encoding, mono, and a bitrate of up to 18 Kbps.
    """
AUDIO_PROFILE_SPEECH_STANDARD = _agorartc.AUDIO_PROFILE_SPEECH_STANDARD
r"""     1: A sample rate of 32 KHz, audio encoding, mono, and a bitrate of up to 18 Kbps."""
AUDIO_PROFILE_MUSIC_STANDARD = _agorartc.AUDIO_PROFILE_MUSIC_STANDARD
r"""     2: A sample rate of 48 KHz, music encoding, mono, and a bitrate of up to 64 Kbps."""
AUDIO_PROFILE_MUSIC_STANDARD_STEREO = _agorartc.AUDIO_PROFILE_MUSIC_STANDARD_STEREO
r"""     3: A sample rate of 48 KHz, music encoding, stereo, and a bitrate of up to 80 Kbps."""
AUDIO_PROFILE_MUSIC_HIGH_QUALITY = _agorartc.AUDIO_PROFILE_MUSIC_HIGH_QUALITY
r"""     4: A sample rate of 48 KHz, music encoding, mono, and a bitrate of up to 96 Kbps."""
AUDIO_PROFILE_MUSIC_HIGH_QUALITY_STEREO = _agorartc.AUDIO_PROFILE_MUSIC_HIGH_QUALITY_STEREO
r"""     5: A sample rate of 48 KHz, music encoding, stereo, and a bitrate of up to 128 Kbps."""
AUDIO_PROFILE_IOT = _agorartc.AUDIO_PROFILE_IOT
r"""     6: A sample rate of 16 KHz, audio encoding, mono, and Acoustic Echo Cancellation (AES) enabled."""
AUDIO_PROFILE_NUM = _agorartc.AUDIO_PROFILE_NUM
AUDIO_SCENARIO_DEFAULT = _agorartc.AUDIO_SCENARIO_DEFAULT
r""" 0: Default."""
AUDIO_SCENARIO_CHATROOM_ENTERTAINMENT = _agorartc.AUDIO_SCENARIO_CHATROOM_ENTERTAINMENT
r""" 1: Entertainment scenario, supporting voice during gameplay."""
AUDIO_SCENARIO_EDUCATION = _agorartc.AUDIO_SCENARIO_EDUCATION
r""" 2: Education scenario, prioritizing smoothness and stability."""
AUDIO_SCENARIO_GAME_STREAMING = _agorartc.AUDIO_SCENARIO_GAME_STREAMING
r""" 3: Live gaming scenario, enabling the gaming audio effects in the speaker mode in the interactive live streaming scenario. Choose this scenario for high-fidelity music playback."""
AUDIO_SCENARIO_SHOWROOM = _agorartc.AUDIO_SCENARIO_SHOWROOM
r""" 4: Showroom scenario, optimizing the audio quality with external professional equipment."""
AUDIO_SCENARIO_CHATROOM_GAMING = _agorartc.AUDIO_SCENARIO_CHATROOM_GAMING
r""" 5: Gaming scenario."""
AUDIO_SCENARIO_IOT = _agorartc.AUDIO_SCENARIO_IOT
r""" 6: Applicable to the IoT scenario."""
AUDIO_SCENARIO_NUM = _agorartc.AUDIO_SCENARIO_NUM
CHANNEL_PROFILE_COMMUNICATION = _agorartc.CHANNEL_PROFILE_COMMUNICATION
r"""
     (Default) Communication. This profile applies to scenarios such as an audio call or video call,
    where all users can publish and subscribe to streams.
    """
CHANNEL_PROFILE_LIVE_BROADCASTING = _agorartc.CHANNEL_PROFILE_LIVE_BROADCASTING
r"""
     Live streaming. In this profile, uses have roles, namely, host and audience (default).
    A host both publishes and subscribes to streams, while an audience subscribes to streams only.
    This profile applies to scenarios such as a chat room or interactive video streaming.
    """
CHANNEL_PROFILE_GAME = _agorartc.CHANNEL_PROFILE_GAME
r""" 2: Gaming. This profile uses a codec with a lower bitrate and consumes less power. Applies to the gaming scenario, where all game players can talk freely."""
CLIENT_ROLE_BROADCASTER = _agorartc.CLIENT_ROLE_BROADCASTER
r""" 1: Host. A host can both send and receive streams."""
CLIENT_ROLE_AUDIENCE = _agorartc.CLIENT_ROLE_AUDIENCE
r""" 2: Audience, the default role. An audience can only receive streams."""
USER_OFFLINE_QUIT = _agorartc.USER_OFFLINE_QUIT
r""" 0: The user quits the call."""
USER_OFFLINE_DROPPED = _agorartc.USER_OFFLINE_DROPPED
r""" 1: The SDK times out and the user drops offline because no data packet is received within a certain period of time. If the user quits the call and the message is not passed to the SDK (due to an unreliable channel), the SDK assumes the user dropped offline."""
USER_OFFLINE_BECOME_AUDIENCE = _agorartc.USER_OFFLINE_BECOME_AUDIENCE
r""" 2: (`LIVE_BROADCASTING` only.) The client role switched from the host to the audience."""
RTMP_STREAM_PUBLISH_STATE_IDLE = _agorartc.RTMP_STREAM_PUBLISH_STATE_IDLE
r""" The RTMP streaming has not started or has ended. This state is also triggered after you remove an RTMP address from the CDN by calling removePublishStreamUrl."""
RTMP_STREAM_PUBLISH_STATE_CONNECTING = _agorartc.RTMP_STREAM_PUBLISH_STATE_CONNECTING
r""" The SDK is connecting to Agora's streaming server and the RTMP server. This state is triggered after you call the 'addPublishStreamUrl' method."""
RTMP_STREAM_PUBLISH_STATE_RUNNING = _agorartc.RTMP_STREAM_PUBLISH_STATE_RUNNING
r""" The RTMP streaming publishes. The SDK successfully publishes the RTMP streaming and returns this state."""
RTMP_STREAM_PUBLISH_STATE_RECOVERING = _agorartc.RTMP_STREAM_PUBLISH_STATE_RECOVERING
r"""
    The RTMP streaming is recovering. When exceptions occur to the CDN, or the streaming is interrupted, the SDK tries to resume RTMP streaming and returns this state.

      - If the SDK successfully resumes the streaming, #RTMP_STREAM_PUBLISH_STATE_RUNNING (2) returns.
      - If the streaming does not resume within 60 seconds or server errors occur, #RTMP_STREAM_PUBLISH_STATE_FAILURE (4) returns. You can also reconnect to the server by calling the 'removePublishStreamUrl' and 'addPublishStreamUrl' methods.
    """
RTMP_STREAM_PUBLISH_STATE_FAILURE = _agorartc.RTMP_STREAM_PUBLISH_STATE_FAILURE
r""" The RTMP streaming fails. See the errCode parameter for the detailed error information. You can also call the 'addPublishStreamUrl' method to publish the RTMP streaming again."""
RTMP_STREAM_PUBLISH_ERROR_OK = _agorartc.RTMP_STREAM_PUBLISH_ERROR_OK
r""" The RTMP streaming publishes successfully."""
RTMP_STREAM_PUBLISH_ERROR_INVALID_ARGUMENT = _agorartc.RTMP_STREAM_PUBLISH_ERROR_INVALID_ARGUMENT
r""" Invalid argument used. If, for example, you do not call the 'setLiveTranscoding' method to configure the LiveTranscoding parameters before calling the addPublishStreamUrl method, the SDK returns this error. Check whether you set the parameters in the *setLiveTranscoding* method properly."""
RTMP_STREAM_PUBLISH_ERROR_ENCRYPTED_STREAM_NOT_ALLOWED = _agorartc.RTMP_STREAM_PUBLISH_ERROR_ENCRYPTED_STREAM_NOT_ALLOWED
r""" The RTMP streaming is encrypted and cannot be published."""
RTMP_STREAM_PUBLISH_ERROR_CONNECTION_TIMEOUT = _agorartc.RTMP_STREAM_PUBLISH_ERROR_CONNECTION_TIMEOUT
r""" Timeout for the RTMP streaming. Call the 'addPublishStreamUrl' method to publish the streaming again."""
RTMP_STREAM_PUBLISH_ERROR_INTERNAL_SERVER_ERROR = _agorartc.RTMP_STREAM_PUBLISH_ERROR_INTERNAL_SERVER_ERROR
r""" An error occurs in Agora's streaming server. Call the addPublishStreamUrl method to publish the streaming again."""
RTMP_STREAM_PUBLISH_ERROR_RTMP_SERVER_ERROR = _agorartc.RTMP_STREAM_PUBLISH_ERROR_RTMP_SERVER_ERROR
r""" An error occurs in the RTMP server."""
RTMP_STREAM_PUBLISH_ERROR_TOO_OFTEN = _agorartc.RTMP_STREAM_PUBLISH_ERROR_TOO_OFTEN
r""" The RTMP streaming publishes too frequently."""
RTMP_STREAM_PUBLISH_ERROR_REACH_LIMIT = _agorartc.RTMP_STREAM_PUBLISH_ERROR_REACH_LIMIT
r""" The host publishes more than 10 URLs. Delete the unnecessary URLs before adding new ones."""
RTMP_STREAM_PUBLISH_ERROR_NOT_AUTHORIZED = _agorartc.RTMP_STREAM_PUBLISH_ERROR_NOT_AUTHORIZED
r""" The host manipulates other hosts' URLs. Check your app logic."""
RTMP_STREAM_PUBLISH_ERROR_STREAM_NOT_FOUND = _agorartc.RTMP_STREAM_PUBLISH_ERROR_STREAM_NOT_FOUND
r""" Agora's server fails to find the RTMP streaming."""
RTMP_STREAM_PUBLISH_ERROR_FORMAT_NOT_SUPPORTED = _agorartc.RTMP_STREAM_PUBLISH_ERROR_FORMAT_NOT_SUPPORTED
r""" The format of the RTMP streaming URL is not supported. Check whether the URL format is correct."""
RTMP_STREAMING_EVENT_FAILED_LOAD_IMAGE = _agorartc.RTMP_STREAMING_EVENT_FAILED_LOAD_IMAGE
r""" An error occurs when you add a background image or a watermark image to the RTMP stream."""
INJECT_STREAM_STATUS_START_SUCCESS = _agorartc.INJECT_STREAM_STATUS_START_SUCCESS
r""" 0: The external video stream imported successfully."""
INJECT_STREAM_STATUS_START_ALREADY_EXISTS = _agorartc.INJECT_STREAM_STATUS_START_ALREADY_EXISTS
r""" 1: The external video stream already exists."""
INJECT_STREAM_STATUS_START_UNAUTHORIZED = _agorartc.INJECT_STREAM_STATUS_START_UNAUTHORIZED
r""" 2: The external video stream to be imported is unauthorized."""
INJECT_STREAM_STATUS_START_TIMEDOUT = _agorartc.INJECT_STREAM_STATUS_START_TIMEDOUT
r""" 3: Import external video stream timeout."""
INJECT_STREAM_STATUS_START_FAILED = _agorartc.INJECT_STREAM_STATUS_START_FAILED
r""" 4: Import external video stream failed."""
INJECT_STREAM_STATUS_STOP_SUCCESS = _agorartc.INJECT_STREAM_STATUS_STOP_SUCCESS
r""" 5: The external video stream stopped importing successfully."""
INJECT_STREAM_STATUS_STOP_NOT_FOUND = _agorartc.INJECT_STREAM_STATUS_STOP_NOT_FOUND
r""" 6: No external video stream is found."""
INJECT_STREAM_STATUS_STOP_UNAUTHORIZED = _agorartc.INJECT_STREAM_STATUS_STOP_UNAUTHORIZED
r""" 7: The external video stream to be stopped importing is unauthorized."""
INJECT_STREAM_STATUS_STOP_TIMEDOUT = _agorartc.INJECT_STREAM_STATUS_STOP_TIMEDOUT
r""" 8: Stop importing external video stream timeout."""
INJECT_STREAM_STATUS_STOP_FAILED = _agorartc.INJECT_STREAM_STATUS_STOP_FAILED
r""" 9: Stop importing external video stream failed."""
INJECT_STREAM_STATUS_BROKEN = _agorartc.INJECT_STREAM_STATUS_BROKEN
r""" 10: The external video stream is corrupted."""
REMOTE_VIDEO_STREAM_HIGH = _agorartc.REMOTE_VIDEO_STREAM_HIGH
r""" 0: High-stream video."""
REMOTE_VIDEO_STREAM_LOW = _agorartc.REMOTE_VIDEO_STREAM_LOW
r""" 1: Low-stream video."""
RAW_AUDIO_FRAME_OP_MODE_READ_ONLY = _agorartc.RAW_AUDIO_FRAME_OP_MODE_READ_ONLY
r""" 0: Read-only mode: Users only read the 'AudioFrame' data without modifying anything. For example, when users acquire the data with the Agora SDK, then push the RTMP streams."""
RAW_AUDIO_FRAME_OP_MODE_WRITE_ONLY = _agorartc.RAW_AUDIO_FRAME_OP_MODE_WRITE_ONLY
r""" 1: Write-only mode: Users replace the 'AudioFrame' data with their own data and pass the data to the SDK for encoding. For example, when users acquire the data."""
RAW_AUDIO_FRAME_OP_MODE_READ_WRITE = _agorartc.RAW_AUDIO_FRAME_OP_MODE_READ_WRITE
r""" 2: Read and write mode: Users read the data from 'AudioFrame', modify it, and then play it. For example, when users have their own sound-effect processing module and perform some voice pre-processing, such as a voice change."""
AUDIO_SAMPLE_RATE_32000 = _agorartc.AUDIO_SAMPLE_RATE_32000
r""" 32000: 32 kHz"""
AUDIO_SAMPLE_RATE_44100 = _agorartc.AUDIO_SAMPLE_RATE_44100
r""" 44100: 44.1 kHz"""
AUDIO_SAMPLE_RATE_48000 = _agorartc.AUDIO_SAMPLE_RATE_48000
r""" 48000: 48 kHz"""
VIDEO_CODEC_PROFILE_BASELINE = _agorartc.VIDEO_CODEC_PROFILE_BASELINE
r""" 66: Baseline video codec profile. Generally used in video calls on mobile phones."""
VIDEO_CODEC_PROFILE_MAIN = _agorartc.VIDEO_CODEC_PROFILE_MAIN
r""" 77: Main video codec profile. Generally used in mainstream electronics such as MP4 players, portable video players, PSP, and iPads."""
VIDEO_CODEC_PROFILE_HIGH = _agorartc.VIDEO_CODEC_PROFILE_HIGH
r""" 100: (Default) High video codec profile. Generally used in high-resolution live streaming or television."""
VIDEO_CODEC_VP8 = _agorartc.VIDEO_CODEC_VP8
r""" Standard VP8"""
VIDEO_CODEC_H264 = _agorartc.VIDEO_CODEC_H264
r""" Standard H264"""
VIDEO_CODEC_EVP = _agorartc.VIDEO_CODEC_EVP
r""" Enhanced VP8"""
VIDEO_CODEC_E264 = _agorartc.VIDEO_CODEC_E264
r""" Enhanced H264"""
AUDIO_EQUALIZATION_BAND_31 = _agorartc.AUDIO_EQUALIZATION_BAND_31
r""" 0: 31 Hz"""
AUDIO_EQUALIZATION_BAND_62 = _agorartc.AUDIO_EQUALIZATION_BAND_62
r""" 1: 62 Hz"""
AUDIO_EQUALIZATION_BAND_125 = _agorartc.AUDIO_EQUALIZATION_BAND_125
r""" 2: 125 Hz"""
AUDIO_EQUALIZATION_BAND_250 = _agorartc.AUDIO_EQUALIZATION_BAND_250
r""" 3: 250 Hz"""
AUDIO_EQUALIZATION_BAND_500 = _agorartc.AUDIO_EQUALIZATION_BAND_500
r""" 4: 500 Hz"""
AUDIO_EQUALIZATION_BAND_1K = _agorartc.AUDIO_EQUALIZATION_BAND_1K
r""" 5: 1 kHz"""
AUDIO_EQUALIZATION_BAND_2K = _agorartc.AUDIO_EQUALIZATION_BAND_2K
r""" 6: 2 kHz"""
AUDIO_EQUALIZATION_BAND_4K = _agorartc.AUDIO_EQUALIZATION_BAND_4K
r""" 7: 4 kHz"""
AUDIO_EQUALIZATION_BAND_8K = _agorartc.AUDIO_EQUALIZATION_BAND_8K
r""" 8: 8 kHz"""
AUDIO_EQUALIZATION_BAND_16K = _agorartc.AUDIO_EQUALIZATION_BAND_16K
r""" 9: 16 kHz"""
AUDIO_REVERB_DRY_LEVEL = _agorartc.AUDIO_REVERB_DRY_LEVEL
r""" 0: The level of the dry signal (db). The value is between -20 and 10."""
AUDIO_REVERB_WET_LEVEL = _agorartc.AUDIO_REVERB_WET_LEVEL
r""" 1: The level of the early reflection signal (wet signal) (dB). The value is between -20 and 10."""
AUDIO_REVERB_ROOM_SIZE = _agorartc.AUDIO_REVERB_ROOM_SIZE
r""" 2: The room size of the reflection. The value is between 0 and 100."""
AUDIO_REVERB_WET_DELAY = _agorartc.AUDIO_REVERB_WET_DELAY
r""" 3: The length of the initial delay of the wet signal (ms). The value is between 0 and 200."""
AUDIO_REVERB_STRENGTH = _agorartc.AUDIO_REVERB_STRENGTH
r""" 4: The reverberation strength. The value is between 0 and 100."""
VOICE_CHANGER_OFF = _agorartc.VOICE_CHANGER_OFF
r"""The original voice (no local voice change)."""
VOICE_CHANGER_OLDMAN = _agorartc.VOICE_CHANGER_OLDMAN
r"""The voice of an old man."""
VOICE_CHANGER_BABYBOY = _agorartc.VOICE_CHANGER_BABYBOY
r"""The voice of a little boy."""
VOICE_CHANGER_BABYGIRL = _agorartc.VOICE_CHANGER_BABYGIRL
r"""The voice of a little girl."""
VOICE_CHANGER_ZHUBAJIE = _agorartc.VOICE_CHANGER_ZHUBAJIE
r"""The voice of Zhu Bajie, a character in Journey to the West who has a voice like that of a growling bear."""
VOICE_CHANGER_ETHEREAL = _agorartc.VOICE_CHANGER_ETHEREAL
r"""The ethereal voice."""
VOICE_CHANGER_HULK = _agorartc.VOICE_CHANGER_HULK
r"""The voice of Hulk."""
VOICE_BEAUTY_VIGOROUS = _agorartc.VOICE_BEAUTY_VIGOROUS
r"""A more vigorous voice."""
VOICE_BEAUTY_DEEP = _agorartc.VOICE_BEAUTY_DEEP
r"""A deeper voice."""
VOICE_BEAUTY_MELLOW = _agorartc.VOICE_BEAUTY_MELLOW
r"""A mellower voice."""
VOICE_BEAUTY_FALSETTO = _agorartc.VOICE_BEAUTY_FALSETTO
r"""Falsetto."""
VOICE_BEAUTY_FULL = _agorartc.VOICE_BEAUTY_FULL
r"""A fuller voice."""
VOICE_BEAUTY_CLEAR = _agorartc.VOICE_BEAUTY_CLEAR
r"""A clearer voice."""
VOICE_BEAUTY_RESOUNDING = _agorartc.VOICE_BEAUTY_RESOUNDING
r"""A more resounding voice."""
VOICE_BEAUTY_RINGING = _agorartc.VOICE_BEAUTY_RINGING
r"""A more ringing voice."""
VOICE_BEAUTY_SPACIAL = _agorartc.VOICE_BEAUTY_SPACIAL
r"""A more spatially resonant voice."""
GENERAL_BEAUTY_VOICE_MALE_MAGNETIC = _agorartc.GENERAL_BEAUTY_VOICE_MALE_MAGNETIC
r"""(For male only) A more magnetic voice. Do not use it when the speaker is a female; otherwise, voice distortion occurs."""
GENERAL_BEAUTY_VOICE_FEMALE_FRESH = _agorartc.GENERAL_BEAUTY_VOICE_FEMALE_FRESH
r"""(For female only) A fresher voice. Do not use it when the speaker is a male; otherwise, voice distortion occurs."""
GENERAL_BEAUTY_VOICE_FEMALE_VITALITY = _agorartc.GENERAL_BEAUTY_VOICE_FEMALE_VITALITY
r"""	(For female only) A more vital voice. Do not use it when the speaker is a male; otherwise, voice distortion occurs."""
AUDIO_REVERB_OFF = _agorartc.AUDIO_REVERB_OFF
r"""Turn off local voice reverberation, that is, to use the original voice."""
AUDIO_REVERB_FX_KTV = _agorartc.AUDIO_REVERB_FX_KTV
r"""The reverberation style typical of a KTV venue (enhanced)."""
AUDIO_REVERB_FX_VOCAL_CONCERT = _agorartc.AUDIO_REVERB_FX_VOCAL_CONCERT
r"""The reverberation style typical of a concert hall (enhanced)."""
AUDIO_REVERB_FX_UNCLE = _agorartc.AUDIO_REVERB_FX_UNCLE
r"""The reverberation style typical of an uncle's voice."""
AUDIO_REVERB_FX_SISTER = _agorartc.AUDIO_REVERB_FX_SISTER
r"""The reverberation style typical of a little sister's voice."""
AUDIO_REVERB_FX_STUDIO = _agorartc.AUDIO_REVERB_FX_STUDIO
r"""The reverberation style typical of a recording studio (enhanced)."""
AUDIO_REVERB_FX_POPULAR = _agorartc.AUDIO_REVERB_FX_POPULAR
r"""The reverberation style typical of popular music (enhanced)."""
AUDIO_REVERB_FX_RNB = _agorartc.AUDIO_REVERB_FX_RNB
r"""The reverberation style typical of R&B music (enhanced)."""
AUDIO_REVERB_FX_PHONOGRAPH = _agorartc.AUDIO_REVERB_FX_PHONOGRAPH
r"""The reverberation style typical of the vintage phonograph."""
AUDIO_REVERB_POPULAR = _agorartc.AUDIO_REVERB_POPULAR
r"""The reverberation style typical of popular music."""
AUDIO_REVERB_RNB = _agorartc.AUDIO_REVERB_RNB
r"""The reverberation style typical of R&B music."""
AUDIO_REVERB_ROCK = _agorartc.AUDIO_REVERB_ROCK
r"""The reverberation style typical of rock music."""
AUDIO_REVERB_HIPHOP = _agorartc.AUDIO_REVERB_HIPHOP
r"""The reverberation style typical of hip-hop music."""
AUDIO_REVERB_VOCAL_CONCERT = _agorartc.AUDIO_REVERB_VOCAL_CONCERT
r"""The reverberation style typical of a concert hall."""
AUDIO_REVERB_KTV = _agorartc.AUDIO_REVERB_KTV
r"""The reverberation style typical of a KTV venue."""
AUDIO_REVERB_STUDIO = _agorartc.AUDIO_REVERB_STUDIO
r"""The reverberation style typical of a recording studio."""
AUDIO_VIRTUAL_STEREO = _agorartc.AUDIO_VIRTUAL_STEREO
r"""
    The reverberation of the virtual stereo. The virtual stereo is an effect that renders the monophonic
    audio as the stereo audio, so that all users in the channel can hear the stereo voice effect.
    To achieve better virtual stereo reverberation, Agora recommends setting `profile` in `setAudioProfile`
    as `AUDIO_PROFILE_MUSIC_HIGH_QUALITY_STEREO(5)`.
    """
AUDIO_CODEC_PROFILE_LC_AAC = _agorartc.AUDIO_CODEC_PROFILE_LC_AAC
r""" 0: LC-AAC, which is the low-complexity audio codec type."""
AUDIO_CODEC_PROFILE_HE_AAC = _agorartc.AUDIO_CODEC_PROFILE_HE_AAC
r""" 1: HE-AAC, which is the high-efficiency audio codec type."""
REMOTE_AUDIO_STATE_STOPPED = _agorartc.REMOTE_AUDIO_STATE_STOPPED
r"""
     0: The remote audio is in the default state, probably due to
    #REMOTE_AUDIO_REASON_LOCAL_MUTED (3),
    #REMOTE_AUDIO_REASON_REMOTE_MUTED (5), or
    #REMOTE_AUDIO_REASON_REMOTE_OFFLINE (7).
    """
REMOTE_AUDIO_STATE_STARTING = _agorartc.REMOTE_AUDIO_STATE_STARTING
r""" 1: The first remote audio packet is received."""
REMOTE_AUDIO_STATE_DECODING = _agorartc.REMOTE_AUDIO_STATE_DECODING
r"""
     2: The remote audio stream is decoded and plays normally, probably
    due to #REMOTE_AUDIO_REASON_NETWORK_RECOVERY (2),
    #REMOTE_AUDIO_REASON_LOCAL_UNMUTED (4), or
    #REMOTE_AUDIO_REASON_REMOTE_UNMUTED (6).
    """
REMOTE_AUDIO_STATE_FROZEN = _agorartc.REMOTE_AUDIO_STATE_FROZEN
r"""
     3: The remote audio is frozen, probably due to
    #REMOTE_AUDIO_REASON_NETWORK_CONGESTION (1).
    """
REMOTE_AUDIO_STATE_FAILED = _agorartc.REMOTE_AUDIO_STATE_FAILED
r"""
     4: The remote audio fails to start, probably due to
    #REMOTE_AUDIO_REASON_INTERNAL (0).
    """
REMOTE_AUDIO_REASON_INTERNAL = _agorartc.REMOTE_AUDIO_REASON_INTERNAL
r""" 0: Internal reasons."""
REMOTE_AUDIO_REASON_NETWORK_CONGESTION = _agorartc.REMOTE_AUDIO_REASON_NETWORK_CONGESTION
r""" 1: Network congestion."""
REMOTE_AUDIO_REASON_NETWORK_RECOVERY = _agorartc.REMOTE_AUDIO_REASON_NETWORK_RECOVERY
r""" 2: Network recovery."""
REMOTE_AUDIO_REASON_LOCAL_MUTED = _agorartc.REMOTE_AUDIO_REASON_LOCAL_MUTED
r"""
     3: The local user stops receiving the remote audio stream or
    disables the audio module.
    """
REMOTE_AUDIO_REASON_LOCAL_UNMUTED = _agorartc.REMOTE_AUDIO_REASON_LOCAL_UNMUTED
r"""
     4: The local user resumes receiving the remote audio stream or
    enables the audio module.
    """
REMOTE_AUDIO_REASON_REMOTE_MUTED = _agorartc.REMOTE_AUDIO_REASON_REMOTE_MUTED
r"""
     5: The remote user stops sending the audio stream or disables the
    audio module.
    """
REMOTE_AUDIO_REASON_REMOTE_UNMUTED = _agorartc.REMOTE_AUDIO_REASON_REMOTE_UNMUTED
r"""
     6: The remote user resumes sending the audio stream or enables the
    audio module.
    """
REMOTE_AUDIO_REASON_REMOTE_OFFLINE = _agorartc.REMOTE_AUDIO_REASON_REMOTE_OFFLINE
r""" 7: The remote user leaves the channel."""
REMOTE_VIDEO_STATE_STOPPED = _agorartc.REMOTE_VIDEO_STATE_STOPPED
r""" 0: The remote video is in the default state, probably due to #REMOTE_VIDEO_STATE_REASON_LOCAL_MUTED (3), #REMOTE_VIDEO_STATE_REASON_REMOTE_MUTED (5), or #REMOTE_VIDEO_STATE_REASON_REMOTE_OFFLINE (7)."""
REMOTE_VIDEO_STATE_STARTING = _agorartc.REMOTE_VIDEO_STATE_STARTING
r""" 1: The first remote video packet is received."""
REMOTE_VIDEO_STATE_DECODING = _agorartc.REMOTE_VIDEO_STATE_DECODING
r""" 2: The remote video stream is decoded and plays normally, probably due to #REMOTE_VIDEO_STATE_REASON_NETWORK_RECOVERY (2), #REMOTE_VIDEO_STATE_REASON_LOCAL_UNMUTED (4), #REMOTE_VIDEO_STATE_REASON_REMOTE_UNMUTED (6), or #REMOTE_VIDEO_STATE_REASON_AUDIO_FALLBACK_RECOVERY (9)."""
REMOTE_VIDEO_STATE_FROZEN = _agorartc.REMOTE_VIDEO_STATE_FROZEN
r""" 3: The remote video is frozen, probably due to #REMOTE_VIDEO_STATE_REASON_NETWORK_CONGESTION (1) or #REMOTE_VIDEO_STATE_REASON_AUDIO_FALLBACK (8)."""
REMOTE_VIDEO_STATE_FAILED = _agorartc.REMOTE_VIDEO_STATE_FAILED
r""" 4: The remote video fails to start, probably due to #REMOTE_VIDEO_STATE_REASON_INTERNAL (0)."""
PUB_STATE_IDLE = _agorartc.PUB_STATE_IDLE
r""" 0: The initial publishing state after joining the channel."""
PUB_STATE_NO_PUBLISHED = _agorartc.PUB_STATE_NO_PUBLISHED
r"""
     1: Fails to publish the local stream. Possible reasons:
    - The local user calls 'muteLocalAudioStream(true)' or 'muteLocalVideoStream(true)' to stop sending local streams.
    - The local user calls 'disableAudio' or 'disableVideo' to disable the entire audio or video module.
    - The local user calls 'enableLocalAudio(false)' or 'enableLocalVideo(false)' to disable the local audio sampling or video capturing.
    - The role of the local user is `AUDIENCE`.
    """
PUB_STATE_PUBLISHING = _agorartc.PUB_STATE_PUBLISHING
r""" 2: Publishing."""
PUB_STATE_PUBLISHED = _agorartc.PUB_STATE_PUBLISHED
r""" 3: Publishes successfully."""
SUB_STATE_IDLE = _agorartc.SUB_STATE_IDLE
r""" 0: The initial subscribing state after joining the channel."""
SUB_STATE_NO_SUBSCRIBED = _agorartc.SUB_STATE_NO_SUBSCRIBED
r"""
     1: Fails to subscribe to the remote stream. Possible reasons:
    - The remote user:
     - Calls 'muteLocalAudioStream(true)' or 'muteLocalVideoStream(true)' to stop sending local streams.
     - Calls 'disableAudio' or 'disableVideo' to disable the entire audio or video modules.
     - Calls 'enableLocalAudio(false)' or 'enableLocalVideo(false)' to disable the local audio sampling or video capturing.
     - The role of the remote user is `AUDIENCE`.
    - The local user calls the following methods to stop receiving remote streams:
     - Calls 'muteRemoteAudioStream(true)', 'muteAllRemoteAudioStreams(true)', or 'setDefaultMuteAllRemoteAudioStreams(true)' to stop receiving remote audio streams.
     - Calls 'muteRemoteVideoStream(true)', 'muteAllRemoteVideoStreams(true)', or 'setDefaultMuteAllRemoteVideoStreams(true)' to stop receiving remote video streams.
    """
SUB_STATE_SUBSCRIBING = _agorartc.SUB_STATE_SUBSCRIBING
r""" 2: Subscribing."""
SUB_STATE_SUBSCRIBED = _agorartc.SUB_STATE_SUBSCRIBED
r""" 3: Subscribes to and receives the remote stream successfully."""
REMOTE_VIDEO_STATE_REASON_INTERNAL = _agorartc.REMOTE_VIDEO_STATE_REASON_INTERNAL
r""" 0: Internal reasons."""
REMOTE_VIDEO_STATE_REASON_NETWORK_CONGESTION = _agorartc.REMOTE_VIDEO_STATE_REASON_NETWORK_CONGESTION
r""" 1: Network congestion."""
REMOTE_VIDEO_STATE_REASON_NETWORK_RECOVERY = _agorartc.REMOTE_VIDEO_STATE_REASON_NETWORK_RECOVERY
r""" 2: Network recovery."""
REMOTE_VIDEO_STATE_REASON_LOCAL_MUTED = _agorartc.REMOTE_VIDEO_STATE_REASON_LOCAL_MUTED
r""" 3: The local user stops receiving the remote video stream or disables the video module."""
REMOTE_VIDEO_STATE_REASON_LOCAL_UNMUTED = _agorartc.REMOTE_VIDEO_STATE_REASON_LOCAL_UNMUTED
r""" 4: The local user resumes receiving the remote video stream or enables the video module."""
REMOTE_VIDEO_STATE_REASON_REMOTE_MUTED = _agorartc.REMOTE_VIDEO_STATE_REASON_REMOTE_MUTED
r""" 5: The remote user stops sending the video stream or disables the video module."""
REMOTE_VIDEO_STATE_REASON_REMOTE_UNMUTED = _agorartc.REMOTE_VIDEO_STATE_REASON_REMOTE_UNMUTED
r""" 6: The remote user resumes sending the video stream or enables the video module."""
REMOTE_VIDEO_STATE_REASON_REMOTE_OFFLINE = _agorartc.REMOTE_VIDEO_STATE_REASON_REMOTE_OFFLINE
r""" 7: The remote user leaves the channel."""
REMOTE_VIDEO_STATE_REASON_AUDIO_FALLBACK = _agorartc.REMOTE_VIDEO_STATE_REASON_AUDIO_FALLBACK
r""" 8: The remote audio-and-video stream falls back to the audio-only stream due to poor network conditions."""
REMOTE_VIDEO_STATE_REASON_AUDIO_FALLBACK_RECOVERY = _agorartc.REMOTE_VIDEO_STATE_REASON_AUDIO_FALLBACK_RECOVERY
r""" 9: The remote audio-only stream switches back to the audio-and-video stream after the network conditions improve."""
FRAME_RATE_FPS_1 = _agorartc.FRAME_RATE_FPS_1
r""" 1: 1 fps"""
FRAME_RATE_FPS_7 = _agorartc.FRAME_RATE_FPS_7
r""" 7: 7 fps"""
FRAME_RATE_FPS_10 = _agorartc.FRAME_RATE_FPS_10
r""" 10: 10 fps"""
FRAME_RATE_FPS_15 = _agorartc.FRAME_RATE_FPS_15
r""" 15: 15 fps"""
FRAME_RATE_FPS_24 = _agorartc.FRAME_RATE_FPS_24
r""" 24: 24 fps"""
FRAME_RATE_FPS_30 = _agorartc.FRAME_RATE_FPS_30
r""" 30: 30 fps"""
FRAME_RATE_FPS_60 = _agorartc.FRAME_RATE_FPS_60
r""" 60: 60 fps (Windows and macOS only)"""
ORIENTATION_MODE_ADAPTIVE = _agorartc.ORIENTATION_MODE_ADAPTIVE
r"""
    0: (Default) Adaptive mode.

      The video encoder adapts to the orientation mode of the video input device.

      - If the width of the captured video from the SDK is greater than the height, the encoder sends the video in landscape mode. The encoder also sends the rotational information of the video, and the receiver uses the rotational information to rotate the received video.
      - When you use a custom video source, the output video from the encoder inherits the orientation of the original video. If the original video is in portrait mode, the output video from the encoder is also in portrait mode. The encoder also sends the rotational information of the video to the receiver.
    """
ORIENTATION_MODE_FIXED_LANDSCAPE = _agorartc.ORIENTATION_MODE_FIXED_LANDSCAPE
r"""
    1: Landscape mode.

        The video encoder always sends the video in landscape mode. The video encoder rotates the original video before sending it and the rotational infomation is 0. This mode applies to scenarios involving CDN live streaming.
    """
ORIENTATION_MODE_FIXED_PORTRAIT = _agorartc.ORIENTATION_MODE_FIXED_PORTRAIT
r"""
    2: Portrait mode.

        The video encoder always sends the video in portrait mode. The video encoder rotates the original video before sending it and the rotational infomation is 0. This mode applies to scenarios involving CDN live streaming.
    """
MAINTAIN_QUALITY = _agorartc.MAINTAIN_QUALITY
r""" 0: (Default) Degrade the frame rate in order to maintain the video quality."""
MAINTAIN_FRAMERATE = _agorartc.MAINTAIN_FRAMERATE
r""" 1: Degrade the video quality in order to maintain the frame rate."""
MAINTAIN_BALANCED = _agorartc.MAINTAIN_BALANCED
r""" 2: (For future use) Maintain a balance between the frame rate and video quality."""
STREAM_FALLBACK_OPTION_DISABLED = _agorartc.STREAM_FALLBACK_OPTION_DISABLED
r""" 0: No fallback behavior for the local/remote video stream when the uplink/downlink network conditions are poor. The quality of the stream is not guaranteed."""
STREAM_FALLBACK_OPTION_VIDEO_STREAM_LOW = _agorartc.STREAM_FALLBACK_OPTION_VIDEO_STREAM_LOW
r""" 1: Under poor downlink network conditions, the remote video stream, to which you subscribe, falls back to the low-stream (low resolution and low bitrate) video. You can set this option only in the 'setRemoteSubscribeFallbackOption' method. Nothing happens when you set this in the 'setLocalPublishFallbackOption' method."""
STREAM_FALLBACK_OPTION_AUDIO_ONLY = _agorartc.STREAM_FALLBACK_OPTION_AUDIO_ONLY
r"""
    2: Under poor uplink network conditions, the published video stream falls back to audio only.

       Under poor downlink network conditions, the remote video stream, to which you subscribe, first falls back to the low-stream (low resolution and low bitrate) video; and then to an audio-only stream if the network conditions worsen.
    """
CAPTURER_OUTPUT_PREFERENCE_AUTO = _agorartc.CAPTURER_OUTPUT_PREFERENCE_AUTO
r""" 0: (Default) self-adapts the camera output parameters to the system performance and network conditions to balance CPU consumption and video preview quality."""
CAPTURER_OUTPUT_PREFERENCE_PERFORMANCE = _agorartc.CAPTURER_OUTPUT_PREFERENCE_PERFORMANCE
r""" 1: Prioritizes the system performance. The SDK chooses the dimension and frame rate of the local camera capture closest to those set by 'setVideoEncoderConfiguration'."""
CAPTURER_OUTPUT_PREFERENCE_PREVIEW = _agorartc.CAPTURER_OUTPUT_PREFERENCE_PREVIEW
r""" 2: Prioritizes the local preview quality. The SDK chooses higher camera output parameters to improve the local video preview quality. This option requires extra CPU and RAM usage for video pre-processing."""
PRIORITY_HIGH = _agorartc.PRIORITY_HIGH
r""" 50: The user's priority is high."""
PRIORITY_NORMAL = _agorartc.PRIORITY_NORMAL
r""" 100: (Default) The user's priority is normal."""
CONNECTION_STATE_DISCONNECTED = _agorartc.CONNECTION_STATE_DISCONNECTED
r"""
    1: The SDK is disconnected from Agora's edge server.

      - This is the initial state before calling the 'joinChannel' method.
      - The SDK also enters this state when the application calls the 'leaveChannel' method.
    """
CONNECTION_STATE_CONNECTING = _agorartc.CONNECTION_STATE_CONNECTING
r"""
    2: The SDK is connecting to Agora's edge server.

      - When the application calls the 'joinChannel' method, the SDK starts to establish a connection to the specified channel, triggers the 'onConnectionStateChanged' callback, and switches to the #CONNECTION_STATE_CONNECTING state.
      - When the SDK successfully joins the channel, it triggers the 'onConnectionStateChanged' callback and switches to the #CONNECTION_STATE_CONNECTED state.
      - After the SDK joins the channel and when it finishes initializing the media engine, the SDK triggers the 'onJoinChannelSuccess' callback.
    """
CONNECTION_STATE_CONNECTED = _agorartc.CONNECTION_STATE_CONNECTED
r"""
    3: The SDK is connected to Agora's edge server and has joined a channel. You can now publish or subscribe to a media stream in the channel.

      If the connection to the channel is lost because, for example, if the network is down or switched, the SDK automatically tries to reconnect and triggers:
      - The 'onConnectionInterrupted' callback (deprecated).
      - The 'onConnectionStateChanged' callback and switches to the #CONNECTION_STATE_RECONNECTING state.
    """
CONNECTION_STATE_RECONNECTING = _agorartc.CONNECTION_STATE_RECONNECTING
r"""
    4: The SDK keeps rejoining the channel after being disconnected from a joined channel because of network issues.

      - If the SDK cannot rejoin the channel within 10 seconds after being disconnected from Agora's edge server, the SDK triggers the 'onConnectionLost' callback, stays in the #CONNECTION_STATE_RECONNECTING state, and keeps rejoining the channel.
      - If the SDK fails to rejoin the channel 20 minutes after being disconnected from Agora's edge server, the SDK triggers the 'onConnectionStateChanged' callback, switches to the #CONNECTION_STATE_FAILED state, and stops rejoining the channel.
    """
CONNECTION_STATE_FAILED = _agorartc.CONNECTION_STATE_FAILED
r"""
    5: The SDK fails to connect to Agora's edge server or join the channel.

      You must call the 'leaveChannel' method to leave this state, and call the 'joinChannel' method again to rejoin the channel.

      If the SDK is banned from joining the channel by Agora's edge server (through the RESTful API), the SDK triggers the 'onConnectionBanned' (deprecated) and 'onConnectionStateChanged' callbacks.
    """
CONNECTION_CHANGED_CONNECTING = _agorartc.CONNECTION_CHANGED_CONNECTING
r""" 0: The SDK is connecting to Agora's edge server."""
CONNECTION_CHANGED_JOIN_SUCCESS = _agorartc.CONNECTION_CHANGED_JOIN_SUCCESS
r""" 1: The SDK has joined the channel successfully."""
CONNECTION_CHANGED_INTERRUPTED = _agorartc.CONNECTION_CHANGED_INTERRUPTED
r""" 2: The connection between the SDK and Agora's edge server is interrupted."""
CONNECTION_CHANGED_BANNED_BY_SERVER = _agorartc.CONNECTION_CHANGED_BANNED_BY_SERVER
r""" 3: The connection between the SDK and Agora's edge server is banned by Agora's edge server."""
CONNECTION_CHANGED_JOIN_FAILED = _agorartc.CONNECTION_CHANGED_JOIN_FAILED
r""" 4: The SDK fails to join the channel for more than 20 minutes and stops reconnecting to the channel."""
CONNECTION_CHANGED_LEAVE_CHANNEL = _agorartc.CONNECTION_CHANGED_LEAVE_CHANNEL
r""" 5: The SDK has left the channel."""
CONNECTION_CHANGED_INVALID_APP_ID = _agorartc.CONNECTION_CHANGED_INVALID_APP_ID
r""" 6: The connection failed since Appid is not valid."""
CONNECTION_CHANGED_INVALID_CHANNEL_NAME = _agorartc.CONNECTION_CHANGED_INVALID_CHANNEL_NAME
r""" 7: The connection failed since channel name is not valid."""
CONNECTION_CHANGED_INVALID_TOKEN = _agorartc.CONNECTION_CHANGED_INVALID_TOKEN
r"""
    8: The connection failed since token is not valid, possibly because:

      - The App Certificate for the project is enabled in Console, but you do not use Token when joining the channel. If you enable the App Certificate, you must use a token to join the channel.
      - The uid that you specify in the 'joinChannel' method is different from the uid that you pass for generating the token.
    """
CONNECTION_CHANGED_TOKEN_EXPIRED = _agorartc.CONNECTION_CHANGED_TOKEN_EXPIRED
r""" 9: The connection failed since token is expired."""
CONNECTION_CHANGED_REJECTED_BY_SERVER = _agorartc.CONNECTION_CHANGED_REJECTED_BY_SERVER
r""" 10: The connection is rejected by server."""
CONNECTION_CHANGED_SETTING_PROXY_SERVER = _agorartc.CONNECTION_CHANGED_SETTING_PROXY_SERVER
r""" 11: The connection changed to reconnecting since SDK has set a proxy server."""
CONNECTION_CHANGED_RENEW_TOKEN = _agorartc.CONNECTION_CHANGED_RENEW_TOKEN
r""" 12: When SDK is in connection failed, the renew token operation will make it connecting."""
CONNECTION_CHANGED_CLIENT_IP_ADDRESS_CHANGED = _agorartc.CONNECTION_CHANGED_CLIENT_IP_ADDRESS_CHANGED
r""" 13: The IP Address of SDK client has changed. i.e., Network type or IP/Port changed by network operator might change client IP address."""
CONNECTION_CHANGED_KEEP_ALIVE_TIMEOUT = _agorartc.CONNECTION_CHANGED_KEEP_ALIVE_TIMEOUT
r""" 14: Timeout for the keep-alive of the connection between the SDK and Agora's edge server. The connection state changes to CONNECTION_STATE_RECONNECTING(4)."""
NETWORK_TYPE_UNKNOWN = _agorartc.NETWORK_TYPE_UNKNOWN
r""" -1: The network type is unknown."""
NETWORK_TYPE_DISCONNECTED = _agorartc.NETWORK_TYPE_DISCONNECTED
r""" 0: The SDK disconnects from the network."""
NETWORK_TYPE_LAN = _agorartc.NETWORK_TYPE_LAN
r""" 1: The network type is LAN."""
NETWORK_TYPE_WIFI = _agorartc.NETWORK_TYPE_WIFI
r""" 2: The network type is Wi-Fi(including hotspots)."""
NETWORK_TYPE_MOBILE_2G = _agorartc.NETWORK_TYPE_MOBILE_2G
r""" 3: The network type is mobile 2G."""
NETWORK_TYPE_MOBILE_3G = _agorartc.NETWORK_TYPE_MOBILE_3G
r""" 4: The network type is mobile 3G."""
NETWORK_TYPE_MOBILE_4G = _agorartc.NETWORK_TYPE_MOBILE_4G
r""" 5: The network type is mobile 4G."""
LASTMILE_PROBE_RESULT_COMPLETE = _agorartc.LASTMILE_PROBE_RESULT_COMPLETE
r""" 1: The last-mile network probe test is complete."""
LASTMILE_PROBE_RESULT_INCOMPLETE_NO_BWE = _agorartc.LASTMILE_PROBE_RESULT_INCOMPLETE_NO_BWE
r""" 2: The last-mile network probe test is incomplete and the bandwidth estimation is not available, probably due to limited test resources."""
LASTMILE_PROBE_RESULT_UNAVAILABLE = _agorartc.LASTMILE_PROBE_RESULT_UNAVAILABLE
r""" 3: The last-mile network probe test is not carried out, probably due to poor network conditions."""
AUDIO_ROUTE_DEFAULT = _agorartc.AUDIO_ROUTE_DEFAULT
r""" Default."""
AUDIO_ROUTE_HEADSET = _agorartc.AUDIO_ROUTE_HEADSET
r""" Headset."""
AUDIO_ROUTE_EARPIECE = _agorartc.AUDIO_ROUTE_EARPIECE
r""" Earpiece."""
AUDIO_ROUTE_HEADSET_NO_MIC = _agorartc.AUDIO_ROUTE_HEADSET_NO_MIC
r""" Headset with no microphone."""
AUDIO_ROUTE_SPEAKERPHONE = _agorartc.AUDIO_ROUTE_SPEAKERPHONE
r""" Speakerphone."""
AUDIO_ROUTE_LOUDSPEAKER = _agorartc.AUDIO_ROUTE_LOUDSPEAKER
r""" Loudspeaker."""
AUDIO_ROUTE_BLUETOOTH = _agorartc.AUDIO_ROUTE_BLUETOOTH
r""" Bluetooth headset."""
AUDIO_ROUTE_USB = _agorartc.AUDIO_ROUTE_USB
r""" USB peripheral."""
AUDIO_ROUTE_HDMI = _agorartc.AUDIO_ROUTE_HDMI
r""" HDMI peripheral."""
AUDIO_ROUTE_DISPLAYPORT = _agorartc.AUDIO_ROUTE_DISPLAYPORT
r""" DisplayPort peripheral."""
AUDIO_ROUTE_AIRPLAY = _agorartc.AUDIO_ROUTE_AIRPLAY
r""" Apple AirPlay."""
class LastmileProbeOneWayResult(object):
    r""" The uplink or downlink last-mile network probe test result."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    packetLossRate = property(_agorartc.LastmileProbeOneWayResult_packetLossRate_get, _agorartc.LastmileProbeOneWayResult_packetLossRate_set, doc=r""" The packet loss rate (%).""")
    jitter = property(_agorartc.LastmileProbeOneWayResult_jitter_get, _agorartc.LastmileProbeOneWayResult_jitter_set, doc=r""" The network jitter (ms).""")
    availableBandwidth = property(_agorartc.LastmileProbeOneWayResult_availableBandwidth_get, _agorartc.LastmileProbeOneWayResult_availableBandwidth_set)

    def __init__(self):
        _agorartc.LastmileProbeOneWayResult_swiginit(self, _agorartc.new_LastmileProbeOneWayResult())
    __swig_destroy__ = _agorartc.delete_LastmileProbeOneWayResult

# Register LastmileProbeOneWayResult in _agorartc:
_agorartc.LastmileProbeOneWayResult_swigregister(LastmileProbeOneWayResult)

class LastmileProbeResult(object):
    r""" The uplink and downlink last-mile network probe test result."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    state = property(_agorartc.LastmileProbeResult_state_get, _agorartc.LastmileProbeResult_state_set, doc=r""" The state of the probe test.""")
    uplinkReport = property(_agorartc.LastmileProbeResult_uplinkReport_get, _agorartc.LastmileProbeResult_uplinkReport_set, doc=r""" The uplink last-mile network probe test result.""")
    downlinkReport = property(_agorartc.LastmileProbeResult_downlinkReport_get, _agorartc.LastmileProbeResult_downlinkReport_set, doc=r""" The downlink last-mile network probe test result.""")
    rtt = property(_agorartc.LastmileProbeResult_rtt_get, _agorartc.LastmileProbeResult_rtt_set, doc=r""" The round-trip delay time (ms).""")

    def __init__(self):
        _agorartc.LastmileProbeResult_swiginit(self, _agorartc.new_LastmileProbeResult())
    __swig_destroy__ = _agorartc.delete_LastmileProbeResult

# Register LastmileProbeResult in _agorartc:
_agorartc.LastmileProbeResult_swigregister(LastmileProbeResult)

class LastmileProbeConfig(object):
    r""" Configurations of the last-mile network probe test."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    probeUplink = property(_agorartc.LastmileProbeConfig_probeUplink_get, _agorartc.LastmileProbeConfig_probeUplink_set, doc=r"""
    Sets whether or not to test the uplink network. Some users, for example, the audience in a `LIVE_BROADCASTING` channel, do not need such a test:
     - true: test.
     - false: do not test.
    """)
    probeDownlink = property(_agorartc.LastmileProbeConfig_probeDownlink_get, _agorartc.LastmileProbeConfig_probeDownlink_set, doc=r"""
    Sets whether or not to test the downlink network:
     - true: test.
     - false: do not test.
    """)
    expectedUplinkBitrate = property(_agorartc.LastmileProbeConfig_expectedUplinkBitrate_get, _agorartc.LastmileProbeConfig_expectedUplinkBitrate_set, doc=r""" The expected maximum sending bitrate (bps) of the local user. The value ranges between 100000 and 5000000. We recommend setting this parameter according to the bitrate value set by 'setVideoEncoderConfiguration'.""")
    expectedDownlinkBitrate = property(_agorartc.LastmileProbeConfig_expectedDownlinkBitrate_get, _agorartc.LastmileProbeConfig_expectedDownlinkBitrate_set, doc=r""" The expected maximum receiving bitrate (bps) of the local user. The value ranges between 100000 and 5000000.""")

    def __init__(self):
        _agorartc.LastmileProbeConfig_swiginit(self, _agorartc.new_LastmileProbeConfig())
    __swig_destroy__ = _agorartc.delete_LastmileProbeConfig

# Register LastmileProbeConfig in _agorartc:
_agorartc.LastmileProbeConfig_swigregister(LastmileProbeConfig)

class AudioVolumeInfo(object):
    r"""
    Properties of the audio volume information.

    An array containing the user ID and volume information for each speaker.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    uid = property(_agorartc.AudioVolumeInfo_uid_get, _agorartc.AudioVolumeInfo_uid_set, doc=r"""    User ID of the speaker. The uid of the local user is 0.""")
    volume = property(_agorartc.AudioVolumeInfo_volume_get, _agorartc.AudioVolumeInfo_volume_set, doc=r""" The volume of the speaker. The volume ranges between 0 (lowest volume) and 255 (highest volume).""")
    vad = property(_agorartc.AudioVolumeInfo_vad_get, _agorartc.AudioVolumeInfo_vad_set, doc=r"""
     Voice activity status of the local user.
    - 0: The local user is not speaking.
    - 1: The local user is speaking.

    Notes: 
    - The `vad` parameter cannot report the voice activity status of the remote users. In the remote users' callback, `vad` = 0.
    - Ensure that you set `report_vad`(true) in the 'agora::rtc::IRtcEngine::enableAudioVolumeIndication(int', int, bool) "enableAudioVolumeIndication" method to enable the voice activity detection of the local user.
    """)
    channelId = property(_agorartc.AudioVolumeInfo_channelId_get, _agorartc.AudioVolumeInfo_channelId_set, doc=r""" The channel ID, which indicates which channel the speaker is in.""")

    def __init__(self):
        _agorartc.AudioVolumeInfo_swiginit(self, _agorartc.new_AudioVolumeInfo())
    __swig_destroy__ = _agorartc.delete_AudioVolumeInfo

# Register AudioVolumeInfo in _agorartc:
_agorartc.AudioVolumeInfo_swigregister(AudioVolumeInfo)

class RtcStats(object):
    r""" Statistics of the channel."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    duration = property(_agorartc.RtcStats_duration_get, _agorartc.RtcStats_duration_set, doc=r"""   Call duration (s), represented by an aggregate value.""")
    txBytes = property(_agorartc.RtcStats_txBytes_get, _agorartc.RtcStats_txBytes_set, doc=r"""     Total number of bytes transmitted, represented by an aggregate value.""")
    rxBytes = property(_agorartc.RtcStats_rxBytes_get, _agorartc.RtcStats_rxBytes_set, doc=r"""     Total number of bytes received, represented by an aggregate value.""")
    txAudioBytes = property(_agorartc.RtcStats_txAudioBytes_get, _agorartc.RtcStats_txAudioBytes_set, doc=r"""
     Total number of audio bytes sent (bytes), represented
    by an aggregate value.
    """)
    txVideoBytes = property(_agorartc.RtcStats_txVideoBytes_get, _agorartc.RtcStats_txVideoBytes_set, doc=r"""
     Total number of video bytes sent (bytes), represented
    by an aggregate value.
    """)
    rxAudioBytes = property(_agorartc.RtcStats_rxAudioBytes_get, _agorartc.RtcStats_rxAudioBytes_set, doc=r"""
     Total number of audio bytes received (bytes) before
    network countermeasures, represented by an aggregate value.
    """)
    rxVideoBytes = property(_agorartc.RtcStats_rxVideoBytes_get, _agorartc.RtcStats_rxVideoBytes_set, doc=r"""
     Total number of video bytes received (bytes),
    represented by an aggregate value.
    """)
    txKBitRate = property(_agorartc.RtcStats_txKBitRate_get, _agorartc.RtcStats_txKBitRate_set, doc=r"""     Transmission bitrate (Kbps), represented by an instantaneous value.""")
    rxKBitRate = property(_agorartc.RtcStats_rxKBitRate_get, _agorartc.RtcStats_rxKBitRate_set, doc=r"""     Receive bitrate (Kbps), represented by an instantaneous value.""")
    rxAudioKBitRate = property(_agorartc.RtcStats_rxAudioKBitRate_get, _agorartc.RtcStats_rxAudioKBitRate_set, doc=r"""     Audio receive bitrate (Kbps), represented by an instantaneous value.""")
    txAudioKBitRate = property(_agorartc.RtcStats_txAudioKBitRate_get, _agorartc.RtcStats_txAudioKBitRate_set, doc=r"""     Audio transmission bitrate (Kbps), represented by an instantaneous value.""")
    rxVideoKBitRate = property(_agorartc.RtcStats_rxVideoKBitRate_get, _agorartc.RtcStats_rxVideoKBitRate_set, doc=r"""     Video receive bitrate (Kbps), represented by an instantaneous value.""")
    txVideoKBitRate = property(_agorartc.RtcStats_txVideoKBitRate_get, _agorartc.RtcStats_txVideoKBitRate_set, doc=r"""     Video transmission bitrate (Kbps), represented by an instantaneous value.""")
    lastmileDelay = property(_agorartc.RtcStats_lastmileDelay_get, _agorartc.RtcStats_lastmileDelay_set, doc=r""" Client-server latency (ms)""")
    txPacketLossRate = property(_agorartc.RtcStats_txPacketLossRate_get, _agorartc.RtcStats_txPacketLossRate_set, doc=r"""
     The packet loss rate (%) from the local client to Agora's edge server,
    before using the anti-packet-loss method.
    """)
    rxPacketLossRate = property(_agorartc.RtcStats_rxPacketLossRate_get, _agorartc.RtcStats_rxPacketLossRate_set, doc=r"""
     The packet loss rate (%) from Agora's edge server to the local client,
    before using the anti-packet-loss method.
    """)
    userCount = property(_agorartc.RtcStats_userCount_get, _agorartc.RtcStats_userCount_set, doc=r"""
    Number of users in the channel.

        - `COMMUNICATION` profile: The number of users in the channel.
        - `LIVE_BROADCASTING` profile:

            -  If the local user is an audience: The number of users in the channel = The number of hosts in the channel + 1.
            -  If the user is a host: The number of users in the channel = The number of hosts in the channel.
    """)
    cpuAppUsage = property(_agorartc.RtcStats_cpuAppUsage_get, _agorartc.RtcStats_cpuAppUsage_set, doc=r"""     Application CPU usage (%).""")
    cpuTotalUsage = property(_agorartc.RtcStats_cpuTotalUsage_get, _agorartc.RtcStats_cpuTotalUsage_set, doc=r"""
    System CPU usage (%).

    In the multi-kernel environment, this member represents the average CPU usage.
    The value **=** 100 **-** System Idle Progress in Task Manager (%).
    """)
    gatewayRtt = property(_agorartc.RtcStats_gatewayRtt_get, _agorartc.RtcStats_gatewayRtt_set, doc=r""" The round-trip time delay from the client to the local router.""")
    memoryAppUsageRatio = property(_agorartc.RtcStats_memoryAppUsageRatio_get, _agorartc.RtcStats_memoryAppUsageRatio_set, doc=r"""
    The memory usage ratio of the app (%).
    Notes: This value is for reference only. Due to system limitations, you may not get the value of this member.
    """)
    memoryTotalUsageRatio = property(_agorartc.RtcStats_memoryTotalUsageRatio_get, _agorartc.RtcStats_memoryTotalUsageRatio_set, doc=r"""
    The memory usage ratio of the system (%).
    Notes: This value is for reference only. Due to system limitations, you may not get the value of this member.
    """)
    memoryAppUsageInKbytes = property(_agorartc.RtcStats_memoryAppUsageInKbytes_get, _agorartc.RtcStats_memoryAppUsageInKbytes_set, doc=r"""
    The memory usage of the app (KB).
    Notes: This value is for reference only. Due to system limitations, you may not get the value of this member.
    """)

    def __init__(self):
        _agorartc.RtcStats_swiginit(self, _agorartc.new_RtcStats())
    __swig_destroy__ = _agorartc.delete_RtcStats

# Register RtcStats in _agorartc:
_agorartc.RtcStats_swigregister(RtcStats)

ADAPT_NONE = _agorartc.ADAPT_NONE
r""" The quality of the local video stays the same."""
ADAPT_UP_BANDWIDTH = _agorartc.ADAPT_UP_BANDWIDTH
r""" The quality improves because the network bandwidth increases."""
ADAPT_DOWN_BANDWIDTH = _agorartc.ADAPT_DOWN_BANDWIDTH
r""" The quality worsens because the network bandwidth decreases."""
RELAY_OK = _agorartc.RELAY_OK
r""" 0: The state is normal."""
RELAY_ERROR_SERVER_ERROR_RESPONSE = _agorartc.RELAY_ERROR_SERVER_ERROR_RESPONSE
r""" 1: An error occurs in the server response."""
RELAY_ERROR_SERVER_NO_RESPONSE = _agorartc.RELAY_ERROR_SERVER_NO_RESPONSE
r"""
     2: No server response. You can call the
    'leaveChannel' method to
    leave the channel.
    """
RELAY_ERROR_NO_RESOURCE_AVAILABLE = _agorartc.RELAY_ERROR_NO_RESOURCE_AVAILABLE
r"""
     3: The SDK fails to access the service, probably due to limited
    resources of the server.
    """
RELAY_ERROR_FAILED_JOIN_SRC = _agorartc.RELAY_ERROR_FAILED_JOIN_SRC
r""" 4: Fails to send the relay request."""
RELAY_ERROR_FAILED_JOIN_DEST = _agorartc.RELAY_ERROR_FAILED_JOIN_DEST
r""" 5: Fails to accept the relay request."""
RELAY_ERROR_FAILED_PACKET_RECEIVED_FROM_SRC = _agorartc.RELAY_ERROR_FAILED_PACKET_RECEIVED_FROM_SRC
r""" 6: The server fails to receive the media stream."""
RELAY_ERROR_FAILED_PACKET_SENT_TO_DEST = _agorartc.RELAY_ERROR_FAILED_PACKET_SENT_TO_DEST
r""" 7: The server fails to send the media stream."""
RELAY_ERROR_SERVER_CONNECTION_LOST = _agorartc.RELAY_ERROR_SERVER_CONNECTION_LOST
r"""
     8: The SDK disconnects from the server due to poor network
    connections. You can call the 'agora::rtc::IRtcEngine::leaveChannel'
    "leaveChannel" method to leave the channel.
    """
RELAY_ERROR_INTERNAL_ERROR = _agorartc.RELAY_ERROR_INTERNAL_ERROR
r""" 9: An internal error occurs in the server."""
RELAY_ERROR_SRC_TOKEN_EXPIRED = _agorartc.RELAY_ERROR_SRC_TOKEN_EXPIRED
r""" 10: The token of the source channel has expired."""
RELAY_ERROR_DEST_TOKEN_EXPIRED = _agorartc.RELAY_ERROR_DEST_TOKEN_EXPIRED
r""" 11: The token of the destination channel has expired."""
RELAY_EVENT_NETWORK_DISCONNECTED = _agorartc.RELAY_EVENT_NETWORK_DISCONNECTED
r"""
     0: The user disconnects from the server due to poor network
    connections.
    """
RELAY_EVENT_NETWORK_CONNECTED = _agorartc.RELAY_EVENT_NETWORK_CONNECTED
r""" 1: The network reconnects."""
RELAY_EVENT_PACKET_JOINED_SRC_CHANNEL = _agorartc.RELAY_EVENT_PACKET_JOINED_SRC_CHANNEL
r""" 2: The user joins the source channel."""
RELAY_EVENT_PACKET_JOINED_DEST_CHANNEL = _agorartc.RELAY_EVENT_PACKET_JOINED_DEST_CHANNEL
r""" 3: The user joins the destination channel."""
RELAY_EVENT_PACKET_SENT_TO_DEST_CHANNEL = _agorartc.RELAY_EVENT_PACKET_SENT_TO_DEST_CHANNEL
r""" 4: The SDK starts relaying the media stream to the destination channel."""
RELAY_EVENT_PACKET_RECEIVED_VIDEO_FROM_SRC = _agorartc.RELAY_EVENT_PACKET_RECEIVED_VIDEO_FROM_SRC
r""" 5: The server receives the video stream from the source channel."""
RELAY_EVENT_PACKET_RECEIVED_AUDIO_FROM_SRC = _agorartc.RELAY_EVENT_PACKET_RECEIVED_AUDIO_FROM_SRC
r""" 6: The server receives the audio stream from the source channel."""
RELAY_EVENT_PACKET_UPDATE_DEST_CHANNEL = _agorartc.RELAY_EVENT_PACKET_UPDATE_DEST_CHANNEL
r""" 7: The destination channel is updated."""
RELAY_EVENT_PACKET_UPDATE_DEST_CHANNEL_REFUSED = _agorartc.RELAY_EVENT_PACKET_UPDATE_DEST_CHANNEL_REFUSED
r""" 8: The destination channel update fails due to internal reasons."""
RELAY_EVENT_PACKET_UPDATE_DEST_CHANNEL_NOT_CHANGE = _agorartc.RELAY_EVENT_PACKET_UPDATE_DEST_CHANNEL_NOT_CHANGE
r"""
     9: The destination channel does not change, which means that the
    destination channel fails to be updated.
    """
RELAY_EVENT_PACKET_UPDATE_DEST_CHANNEL_IS_NULL = _agorartc.RELAY_EVENT_PACKET_UPDATE_DEST_CHANNEL_IS_NULL
r""" 10: The destination channel name is NULL."""
RELAY_EVENT_VIDEO_PROFILE_UPDATE = _agorartc.RELAY_EVENT_VIDEO_PROFILE_UPDATE
r""" 11: The video profile is sent to the server."""
RELAY_STATE_IDLE = _agorartc.RELAY_STATE_IDLE
r""" 0: The SDK is initializing."""
RELAY_STATE_CONNECTING = _agorartc.RELAY_STATE_CONNECTING
r""" 1: The SDK tries to relay the media stream to the destination channel."""
RELAY_STATE_RUNNING = _agorartc.RELAY_STATE_RUNNING
r"""
     2: The SDK successfully relays the media stream to the destination
    channel.
    """
RELAY_STATE_FAILURE = _agorartc.RELAY_STATE_FAILURE
r""" 3: A failure occurs. See the details in code."""
class LocalVideoStats(object):
    r""" Statistics of the local video stream."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    sentBitrate = property(_agorartc.LocalVideoStats_sentBitrate_get, _agorartc.LocalVideoStats_sentBitrate_set, doc=r"""
     Bitrate (Kbps) sent in the reported interval, which does not include
    the bitrate of the retransmission video after packet loss.
    """)
    sentFrameRate = property(_agorartc.LocalVideoStats_sentFrameRate_get, _agorartc.LocalVideoStats_sentFrameRate_set, doc=r"""
     Frame rate (fps) sent in the reported interval, which does not include
    the frame rate of the retransmission video after packet loss.
    """)
    encoderOutputFrameRate = property(_agorartc.LocalVideoStats_encoderOutputFrameRate_get, _agorartc.LocalVideoStats_encoderOutputFrameRate_set, doc=r""" The encoder output frame rate (fps) of the local video.""")
    rendererOutputFrameRate = property(_agorartc.LocalVideoStats_rendererOutputFrameRate_get, _agorartc.LocalVideoStats_rendererOutputFrameRate_set, doc=r""" The render output frame rate (fps) of the local video.""")
    targetBitrate = property(_agorartc.LocalVideoStats_targetBitrate_get, _agorartc.LocalVideoStats_targetBitrate_set, doc=r""" The target bitrate (Kbps) of the current encoder. This value is estimated by the SDK based on the current network conditions.""")
    targetFrameRate = property(_agorartc.LocalVideoStats_targetFrameRate_get, _agorartc.LocalVideoStats_targetFrameRate_set, doc=r""" The target frame rate (fps) of the current encoder.""")
    qualityAdaptIndication = property(_agorartc.LocalVideoStats_qualityAdaptIndication_get, _agorartc.LocalVideoStats_qualityAdaptIndication_set, doc=r"""
     Quality change of the local video in terms of target frame rate and
    target bit rate in this reported interval. See #QUALITY_ADAPT_INDICATION.
    """)
    encodedBitrate = property(_agorartc.LocalVideoStats_encodedBitrate_get, _agorartc.LocalVideoStats_encodedBitrate_set, doc=r"""
     The encoding bitrate (Kbps), which does not include the bitrate of the
    re-transmission video after packet loss.
    """)
    encodedFrameWidth = property(_agorartc.LocalVideoStats_encodedFrameWidth_get, _agorartc.LocalVideoStats_encodedFrameWidth_set, doc=r""" The width of the encoding frame (px).""")
    encodedFrameHeight = property(_agorartc.LocalVideoStats_encodedFrameHeight_get, _agorartc.LocalVideoStats_encodedFrameHeight_set, doc=r""" The height of the encoding frame (px).""")
    encodedFrameCount = property(_agorartc.LocalVideoStats_encodedFrameCount_get, _agorartc.LocalVideoStats_encodedFrameCount_set, doc=r""" The value of the sent frames, represented by an aggregate value.""")
    codecType = property(_agorartc.LocalVideoStats_codecType_get, _agorartc.LocalVideoStats_codecType_set, doc=r"""
     The codec type of the local video:
    - VIDEO_CODEC_VP8 = 1: VP8.
    - VIDEO_CODEC_H264 = 2: (Default) H.264.
    """)
    txPacketLossRate = property(_agorartc.LocalVideoStats_txPacketLossRate_get, _agorartc.LocalVideoStats_txPacketLossRate_set, doc=r""" The video packet loss rate (%) from the local client to the Agora edge server before applying the anti-packet loss strategies.""")
    captureFrameRate = property(_agorartc.LocalVideoStats_captureFrameRate_get, _agorartc.LocalVideoStats_captureFrameRate_set, doc=r""" The capture frame rate (fps) of the local video.""")

    def __init__(self):
        _agorartc.LocalVideoStats_swiginit(self, _agorartc.new_LocalVideoStats())
    __swig_destroy__ = _agorartc.delete_LocalVideoStats

# Register LocalVideoStats in _agorartc:
_agorartc.LocalVideoStats_swigregister(LocalVideoStats)

class RemoteVideoStats(object):
    r""" Statistics of the remote video stream."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    uid = property(_agorartc.RemoteVideoStats_uid_get, _agorartc.RemoteVideoStats_uid_set, doc=r""" User ID of the remote user sending the video streams.""")
    delay = property(_agorartc.RemoteVideoStats_delay_get, _agorartc.RemoteVideoStats_delay_set, doc=r"""
    DEPRECATED** Time delay (ms).

    In scenarios where audio and video is synchronized, you can use the value of
    `networkTransportDelay` and `jitterBufferDelay` in `RemoteAudioStats` to know the delay statistics of the remote video.
    """)
    width = property(_agorartc.RemoteVideoStats_width_get, _agorartc.RemoteVideoStats_width_set, doc=r""" Width (pixels) of the video stream.""")
    height = property(_agorartc.RemoteVideoStats_height_get, _agorartc.RemoteVideoStats_height_set, doc=r""" Height (pixels) of the video stream.""")
    receivedBitrate = property(_agorartc.RemoteVideoStats_receivedBitrate_get, _agorartc.RemoteVideoStats_receivedBitrate_set, doc=r""" Bitrate (Kbps) received since the last count.""")
    decoderOutputFrameRate = property(_agorartc.RemoteVideoStats_decoderOutputFrameRate_get, _agorartc.RemoteVideoStats_decoderOutputFrameRate_set, doc=r""" The decoder output frame rate (fps) of the remote video.""")
    rendererOutputFrameRate = property(_agorartc.RemoteVideoStats_rendererOutputFrameRate_get, _agorartc.RemoteVideoStats_rendererOutputFrameRate_set, doc=r""" The render output frame rate (fps) of the remote video.""")
    packetLossRate = property(_agorartc.RemoteVideoStats_packetLossRate_get, _agorartc.RemoteVideoStats_packetLossRate_set, doc=r""" Packet loss rate (%) of the remote video stream after using the anti-packet-loss method.""")
    rxStreamType = property(_agorartc.RemoteVideoStats_rxStreamType_get, _agorartc.RemoteVideoStats_rxStreamType_set, doc=r""" The type of the remote video stream: #REMOTE_VIDEO_STREAM_TYPE""")
    totalFrozenTime = property(_agorartc.RemoteVideoStats_totalFrozenTime_get, _agorartc.RemoteVideoStats_totalFrozenTime_set, doc=r"""
    The total freeze time (ms) of the remote video stream after the remote user joins the channel.
    In a video session where the frame rate is set to no less than 5 fps, video freeze occurs when
    the time interval between two adjacent renderable video frames is more than 500 ms.
    """)
    frozenRate = property(_agorartc.RemoteVideoStats_frozenRate_get, _agorartc.RemoteVideoStats_frozenRate_set, doc=r""" The total video freeze time as a percentage (%) of the total time when the video is available.""")
    totalActiveTime = property(_agorartc.RemoteVideoStats_totalActiveTime_get, _agorartc.RemoteVideoStats_totalActiveTime_set, doc=r"""
    The total time (ms) when the remote user in the Communication profile or the remote
    broadcaster in the Live-broadcast profile neither stops sending the video stream nor
    disables the video module after joining the channel.

    Since: v3.0.1
    """)
    publishDuration = property(_agorartc.RemoteVideoStats_publishDuration_get, _agorartc.RemoteVideoStats_publishDuration_set, doc=r"""The total publish duration (ms) of the remote video stream.""")

    def __init__(self):
        _agorartc.RemoteVideoStats_swiginit(self, _agorartc.new_RemoteVideoStats())
    __swig_destroy__ = _agorartc.delete_RemoteVideoStats

# Register RemoteVideoStats in _agorartc:
_agorartc.RemoteVideoStats_swigregister(RemoteVideoStats)

class LocalAudioStats(object):
    r""" Audio statistics of the local user"""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    numChannels = property(_agorartc.LocalAudioStats_numChannels_get, _agorartc.LocalAudioStats_numChannels_set, doc=r""" The number of channels.""")
    sentSampleRate = property(_agorartc.LocalAudioStats_sentSampleRate_get, _agorartc.LocalAudioStats_sentSampleRate_set, doc=r""" The sample rate (Hz).""")
    sentBitrate = property(_agorartc.LocalAudioStats_sentBitrate_get, _agorartc.LocalAudioStats_sentBitrate_set, doc=r""" The average sending bitrate (Kbps).""")
    txPacketLossRate = property(_agorartc.LocalAudioStats_txPacketLossRate_get, _agorartc.LocalAudioStats_txPacketLossRate_set, doc=r""" The audio packet loss rate (%) from the local client to the Agora edge server before applying the anti-packet loss strategies.""")

    def __init__(self):
        _agorartc.LocalAudioStats_swiginit(self, _agorartc.new_LocalAudioStats())
    __swig_destroy__ = _agorartc.delete_LocalAudioStats

# Register LocalAudioStats in _agorartc:
_agorartc.LocalAudioStats_swigregister(LocalAudioStats)

class RemoteAudioStats(object):
    r""" Audio statistics of a remote user"""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    uid = property(_agorartc.RemoteAudioStats_uid_get, _agorartc.RemoteAudioStats_uid_set, doc=r""" User ID of the remote user sending the audio streams.""")
    quality = property(_agorartc.RemoteAudioStats_quality_get, _agorartc.RemoteAudioStats_quality_set, doc=r""" Audio quality received by the user: #QUALITY_TYPE.""")
    networkTransportDelay = property(_agorartc.RemoteAudioStats_networkTransportDelay_get, _agorartc.RemoteAudioStats_networkTransportDelay_set, doc=r""" Network delay (ms) from the sender to the receiver.""")
    jitterBufferDelay = property(_agorartc.RemoteAudioStats_jitterBufferDelay_get, _agorartc.RemoteAudioStats_jitterBufferDelay_set, doc=r""" Network delay (ms) from the receiver to the jitter buffer.""")
    audioLossRate = property(_agorartc.RemoteAudioStats_audioLossRate_get, _agorartc.RemoteAudioStats_audioLossRate_set, doc=r""" The audio frame loss rate in the reported interval.""")
    numChannels = property(_agorartc.RemoteAudioStats_numChannels_get, _agorartc.RemoteAudioStats_numChannels_set, doc=r""" The number of channels.""")
    receivedSampleRate = property(_agorartc.RemoteAudioStats_receivedSampleRate_get, _agorartc.RemoteAudioStats_receivedSampleRate_set, doc=r"""
     The sample rate (Hz) of the received audio stream in the reported
    interval.
    """)
    receivedBitrate = property(_agorartc.RemoteAudioStats_receivedBitrate_get, _agorartc.RemoteAudioStats_receivedBitrate_set, doc=r"""
     The average bitrate (Kbps) of the received audio stream in the
    reported interval.
    """)
    totalFrozenTime = property(_agorartc.RemoteAudioStats_totalFrozenTime_get, _agorartc.RemoteAudioStats_totalFrozenTime_set, doc=r""" The total freeze time (ms) of the remote audio stream after the remote user joins the channel. In a session, audio freeze occurs when the audio frame loss rate reaches 4%.""")
    frozenRate = property(_agorartc.RemoteAudioStats_frozenRate_get, _agorartc.RemoteAudioStats_frozenRate_set, doc=r""" The total audio freeze time as a percentage (%) of the total time when the audio is available.""")
    totalActiveTime = property(_agorartc.RemoteAudioStats_totalActiveTime_get, _agorartc.RemoteAudioStats_totalActiveTime_set, doc=r"""
    The total time (ms) when the remote user in the `COMMUNICATION` profile or the remote host in
        the `LIVE_BROADCASTING` profile neither stops sending the audio stream nor disables the audio module after joining the channel.
    """)
    publishDuration = property(_agorartc.RemoteAudioStats_publishDuration_get, _agorartc.RemoteAudioStats_publishDuration_set, doc=r"""The total publish duration (ms) of the remote audio stream.""")

    def __init__(self):
        _agorartc.RemoteAudioStats_swiginit(self, _agorartc.new_RemoteAudioStats())
    __swig_destroy__ = _agorartc.delete_RemoteAudioStats

# Register RemoteAudioStats in _agorartc:
_agorartc.RemoteAudioStats_swigregister(RemoteAudioStats)

class VideoDimensions(object):
    r"""Video dimensions."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    width = property(_agorartc.VideoDimensions_width_get, _agorartc.VideoDimensions_width_set, doc=r""" Width (pixels) of the video.""")
    height = property(_agorartc.VideoDimensions_height_get, _agorartc.VideoDimensions_height_set, doc=r""" Height (pixels) of the video.""")

    def __init__(self, *args):
        _agorartc.VideoDimensions_swiginit(self, _agorartc.new_VideoDimensions(*args))
    __swig_destroy__ = _agorartc.delete_VideoDimensions

# Register VideoDimensions in _agorartc:
_agorartc.VideoDimensions_swigregister(VideoDimensions)

class VideoEncoderConfiguration(object):
    r""" Video encoder configurations."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    dimensions = property(_agorartc.VideoEncoderConfiguration_dimensions_get, _agorartc.VideoEncoderConfiguration_dimensions_set, doc=r""" The video frame dimensions (px) used to specify the video quality and measured by the total number of pixels along a frame's width and height: VideoDimensions. The default value is 640 x 360.""")
    frameRate = property(_agorartc.VideoEncoderConfiguration_frameRate_get, _agorartc.VideoEncoderConfiguration_frameRate_set, doc=r"""
    The frame rate of the video: #FRAME_RATE. The default value is 15.

        Note that we do not recommend setting this to a value greater than 30.
    """)
    minFrameRate = property(_agorartc.VideoEncoderConfiguration_minFrameRate_get, _agorartc.VideoEncoderConfiguration_minFrameRate_set, doc=r""" The minimum frame rate of the video. The default value is -1.""")
    bitrate = property(_agorartc.VideoEncoderConfiguration_bitrate_get, _agorartc.VideoEncoderConfiguration_bitrate_set, doc=r"""
    The video encoding bitrate (Kbps).

        Choose one of the following options:

        - #STANDARD_BITRATE: (Recommended) The standard bitrate.
           - the `COMMUNICATION` profile: the encoding bitrate equals the base bitrate.
           - the `LIVE_BROADCASTING` profile: the encoding bitrate is twice the base bitrate.
        - #COMPATIBLE_BITRATE: The compatible bitrate: the bitrate stays the same regardless of the profile.

        the `COMMUNICATION` profile prioritizes smoothness, while the `LIVE_BROADCASTING` profile prioritizes video quality (requiring a higher bitrate). We recommend setting the bitrate mode as #STANDARD_BITRATE to address this difference.

        The following table lists the recommended video encoder configurations, where the base bitrate applies to the `COMMUNICATION` profile. Set your bitrate based on this table. If you set a bitrate beyond the proper range, the SDK automatically sets it to within the range.

        Notes: 
        In the following table, **Base Bitrate** applies to the `COMMUNICATION` profile, and **Live Bitrate** applies to the `LIVE_BROADCASTING` profile.

        | Resolution             | Frame Rate (fps) | Base Bitrate (Kbps)                    | Live Bitrate (Kbps)                    |
        |------------------------|------------------|----------------------------------------|----------------------------------------|
        | 160 * 120              | 15               | 65                                     | 130                                    |
        | 120 * 120              | 15               | 50                                     | 100                                    |
        | 320 * 180              | 15               | 140                                    | 280                                    |
        | 180 * 180              | 15               | 100                                    | 200                                    |
        | 240 * 180              | 15               | 120                                    | 240                                    |
        | 320 * 240              | 15               | 200                                    | 400                                    |
        | 240 * 240              | 15               | 140                                    | 280                                    |
        | 424 * 240              | 15               | 220                                    | 440                                    |
        | 640 * 360              | 15               | 400                                    | 800                                    |
        | 360 * 360              | 15               | 260                                    | 520                                    |
        | 640 * 360              | 30               | 600                                    | 1200                                   |
        | 360 * 360              | 30               | 400                                    | 800                                    |
        | 480 * 360              | 15               | 320                                    | 640                                    |
        | 480 * 360              | 30               | 490                                    | 980                                    |
        | 640 * 480              | 15               | 500                                    | 1000                                   |
        | 480 * 480              | 15               | 400                                    | 800                                    |
        | 640 * 480              | 30               | 750                                    | 1500                                   |
        | 480 * 480              | 30               | 600                                    | 1200                                   |
        | 848 * 480              | 15               | 610                                    | 1220                                   |
        | 848 * 480              | 30               | 930                                    | 1860                                   |
        | 640 * 480              | 10               | 400                                    | 800                                    |
        | 1280 * 720             | 15               | 1130                                   | 2260                                   |
        | 1280 * 720             | 30               | 1710                                   | 3420                                   |
        | 960 * 720              | 15               | 910                                    | 1820                                   |
        | 960 * 720              | 30               | 1380                                   | 2760                                   |
        | 1920 * 1080            | 15               | 2080                                   | 4160                                   |
        | 1920 * 1080            | 30               | 3150                                   | 6300                                   |
        | 1920 * 1080            | 60               | 4780                                   | 6500                                   |
        | 2560 * 1440            | 30               | 4850                                   | 6500                                   |
        | 2560 * 1440            | 60               | 6500                                   | 6500                                   |
        | 3840 * 2160            | 30               | 6500                                   | 6500                                   |
        | 3840 * 2160            | 60               | 6500                                   | 6500                                   |
    """)
    minBitrate = property(_agorartc.VideoEncoderConfiguration_minBitrate_get, _agorartc.VideoEncoderConfiguration_minBitrate_set, doc=r"""
    The minimum encoding bitrate (Kbps).

        The SDK automatically adjusts the encoding bitrate to adapt to the network conditions. Using a value greater than the default value forces the video encoder to output high-quality images but may cause more packet loss and hence sacrifice the smoothness of the video transmission. That said, unless you have special requirements for image quality, Agora does not recommend changing this value.

        Notes: This parameter applies only to the `LIVE_BROADCASTING` profile.
    """)
    orientationMode = property(_agorartc.VideoEncoderConfiguration_orientationMode_get, _agorartc.VideoEncoderConfiguration_orientationMode_set, doc=r""" The video orientation mode of the video: #ORIENTATION_MODE.""")
    degradationPreference = property(_agorartc.VideoEncoderConfiguration_degradationPreference_get, _agorartc.VideoEncoderConfiguration_degradationPreference_set, doc=r""" The video encoding degradation preference under limited bandwidth: #DEGRADATION_PREFERENCE.""")
    mirrorMode = property(_agorartc.VideoEncoderConfiguration_mirrorMode_get, _agorartc.VideoEncoderConfiguration_mirrorMode_set, doc=r"""
    Sets the mirror mode of the published local video stream. It only affects the video that the remote user sees. See #VIDEO_MIRROR_MODE_TYPE

       Notes: : The SDK disables the mirror mode by default.
    """)

    def __init__(self, *args):
        _agorartc.VideoEncoderConfiguration_swiginit(self, _agorartc.new_VideoEncoderConfiguration(*args))
    __swig_destroy__ = _agorartc.delete_VideoEncoderConfiguration

# Register VideoEncoderConfiguration in _agorartc:
_agorartc.VideoEncoderConfiguration_swigregister(VideoEncoderConfiguration)
cvar = _agorartc.cvar
STANDARD_BITRATE = cvar.STANDARD_BITRATE
COMPATIBLE_BITRATE = cvar.COMPATIBLE_BITRATE
DEFAULT_MIN_BITRATE = cvar.DEFAULT_MIN_BITRATE

class TranscodingUser(object):
    r""" The video and audio properties of the user displaying the video in the CDN live. Agora supports a maximum of 17 transcoding users in a CDN streaming channel."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    uid = property(_agorartc.TranscodingUser_uid_get, _agorartc.TranscodingUser_uid_set, doc=r""" User ID of the user displaying the video in the CDN live.""")
    x = property(_agorartc.TranscodingUser_x_get, _agorartc.TranscodingUser_x_set, doc=r""" Horizontal position (pixel) of the video frame relative to the top left corner.""")
    y = property(_agorartc.TranscodingUser_y_get, _agorartc.TranscodingUser_y_set, doc=r""" Vertical position (pixel) of the video frame relative to the top left corner.""")
    width = property(_agorartc.TranscodingUser_width_get, _agorartc.TranscodingUser_width_set, doc=r""" Width (pixel) of the video frame. The default value is 360.""")
    height = property(_agorartc.TranscodingUser_height_get, _agorartc.TranscodingUser_height_set, doc=r""" Height (pixel) of the video frame. The default value is 640.""")
    zOrder = property(_agorartc.TranscodingUser_zOrder_get, _agorartc.TranscodingUser_zOrder_set, doc=r"""
    The layer index of the video frame. An integer. The value range is [0, 100].

        - 0: (Default) Bottom layer.
        - 100: Top layer.

        Notes: 
        - If zOrder is beyond this range, the SDK reports #ERR_INVALID_ARGUMENT.
        - As of v2.3, the SDK supports zOrder = 0.
    """)
    alpha = property(_agorartc.TranscodingUser_alpha_get, _agorartc.TranscodingUser_alpha_set, doc=r"""
    The transparency level of the user's video. The value ranges between 0 and 1.0:

        - 0: Completely transparent
        - 1.0: (Default) Opaque
    """)
    audioChannel = property(_agorartc.TranscodingUser_audioChannel_get, _agorartc.TranscodingUser_audioChannel_set, doc=r"""
    The audio channel of the sound. The default value is 0:

        - 0: (Default) Supports dual channels at most, depending on the upstream of the host.
        - 1: The audio stream of the host uses the FL audio channel. If the upstream of the host uses multiple audio channels, these channels are mixed into mono first.
        - 2: The audio stream of the host uses the FC audio channel. If the upstream of the host uses multiple audio channels, these channels are mixed into mono first.
        - 3: The audio stream of the host uses the FR audio channel. If the upstream of the host uses multiple audio channels, these channels are mixed into mono first.
        - 4: The audio stream of the host uses the BL audio channel. If the upstream of the host uses multiple audio channels, these channels are mixed into mono first.
        - 5: The audio stream of the host uses the BR audio channel. If the upstream of the host uses multiple audio channels, these channels are mixed into mono first.

        Notes: If your setting is not 0, you may need a specialized player.
    """)

    def __init__(self):
        _agorartc.TranscodingUser_swiginit(self, _agorartc.new_TranscodingUser())
    __swig_destroy__ = _agorartc.delete_TranscodingUser

# Register TranscodingUser in _agorartc:
_agorartc.TranscodingUser_swigregister(TranscodingUser)

class RtcImage(object):
    r"""
    Image properties.

    The properties of the watermark and background images.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _agorartc.RtcImage_swiginit(self, _agorartc.new_RtcImage())
    url = property(_agorartc.RtcImage_url_get, _agorartc.RtcImage_url_set, doc=r""" HTTP/HTTPS URL address of the image on the live video. The maximum length of this parameter is 1024 bytes.""")
    x = property(_agorartc.RtcImage_x_get, _agorartc.RtcImage_x_set, doc=r""" Horizontal position of the image from the upper left of the live video.""")
    y = property(_agorartc.RtcImage_y_get, _agorartc.RtcImage_y_set, doc=r""" Vertical position of the image from the upper left of the live video.""")
    width = property(_agorartc.RtcImage_width_get, _agorartc.RtcImage_width_set, doc=r""" Width of the image on the live video.""")
    height = property(_agorartc.RtcImage_height_get, _agorartc.RtcImage_height_set, doc=r""" Height of the image on the live video.""")
    __swig_destroy__ = _agorartc.delete_RtcImage

# Register RtcImage in _agorartc:
_agorartc.RtcImage_swigregister(RtcImage)

class LiveStreamAdvancedFeature(object):
    r""" The configuration for advanced features of the RTMP streaming with transcoding."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _agorartc.LiveStreamAdvancedFeature_swiginit(self, _agorartc.new_LiveStreamAdvancedFeature())
    LBHQ = property(_agorartc.LiveStreamAdvancedFeature_LBHQ_get, _agorartc.LiveStreamAdvancedFeature_LBHQ_set, doc=r""" The advanced feature for high-quality video with a lower bitrate.""")
    VEO = property(_agorartc.LiveStreamAdvancedFeature_VEO_get, _agorartc.LiveStreamAdvancedFeature_VEO_set, doc=r""" The advanced feature for the optimized video encoder.""")
    featureName = property(_agorartc.LiveStreamAdvancedFeature_featureName_get, _agorartc.LiveStreamAdvancedFeature_featureName_set, doc=r""" The name of the advanced feature. It contains LBHQ and VEO.""")
    opened = property(_agorartc.LiveStreamAdvancedFeature_opened_get, _agorartc.LiveStreamAdvancedFeature_opened_set, doc=r"""
     Whether to enable the advanced feature:
    - true: Enable the advanced feature.
    - false: (Default) Disable the advanced feature.
    """)
    __swig_destroy__ = _agorartc.delete_LiveStreamAdvancedFeature

# Register LiveStreamAdvancedFeature in _agorartc:
_agorartc.LiveStreamAdvancedFeature_swigregister(LiveStreamAdvancedFeature)

class LiveTranscoding(object):
    r""" A struct for managing CDN live audio/video transcoding settings."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    width = property(_agorartc.LiveTranscoding_width_get, _agorartc.LiveTranscoding_width_set, doc=r"""
     The width of the video in pixels. The default value is 360.
    - When pushing video streams to the CDN, ensure that `width` is at least 64; otherwise, the Agora server adjusts the value to 64.
    - When pushing audio streams to the CDN, set `width` and `height` as 0.
    """)
    height = property(_agorartc.LiveTranscoding_height_get, _agorartc.LiveTranscoding_height_set, doc=r"""
     The height of the video in pixels. The default value is 640.
    - When pushing video streams to the CDN, ensure that `height` is at least 64; otherwise, the Agora server adjusts the value to 64.
    - When pushing audio streams to the CDN, set `width` and `height` as 0.
    """)
    videoBitrate = property(_agorartc.LiveTranscoding_videoBitrate_get, _agorartc.LiveTranscoding_videoBitrate_set, doc=r"""
    Bitrate of the CDN live output video stream. The default value is 400 Kbps.

       Set this parameter according to the Video Bitrate Table. If you set a bitrate beyond the proper range, the SDK automatically adapts it to a value within the range.
    """)
    videoFramerate = property(_agorartc.LiveTranscoding_videoFramerate_get, _agorartc.LiveTranscoding_videoFramerate_set, doc=r"""
    Frame rate of the output video stream set for the CDN live streaming. The default value is 15 fps, and the value range is (0,30].

       Notes: The Agora server adjusts any value over 30 to 30.
    """)
    lowLatency = property(_agorartc.LiveTranscoding_lowLatency_get, _agorartc.LiveTranscoding_lowLatency_set, doc=r"""
    DEPRECATED** Latency mode:

         - true: Low latency with unassured quality.
         - false: (Default) High latency with assured quality.
    """)
    videoGop = property(_agorartc.LiveTranscoding_videoGop_get, _agorartc.LiveTranscoding_videoGop_set, doc=r""" Video GOP in frames. The default value is 30 fps.""")
    videoCodecProfile = property(_agorartc.LiveTranscoding_videoCodecProfile_get, _agorartc.LiveTranscoding_videoCodecProfile_set, doc=r"""
    Self-defined video codec profile: #VIDEO_CODEC_PROFILE_TYPE.

       Notes: If you set this parameter to other values, Agora adjusts it to the default value of 100.
    """)
    backgroundColor = property(_agorartc.LiveTranscoding_backgroundColor_get, _agorartc.LiveTranscoding_backgroundColor_set, doc=r""" The background color in RGB hex value. Value only. Do not include a preceeding #. For example, 0xFFB6C1 (light pink). The default value is 0x000000 (black).""")
    userCount = property(_agorartc.LiveTranscoding_userCount_get, _agorartc.LiveTranscoding_userCount_set, doc=r""" The number of users in the live interactive streaming.""")
    transcodingUsers = property(_agorartc.LiveTranscoding_transcodingUsers_get, _agorartc.LiveTranscoding_transcodingUsers_set, doc=r""" TranscodingUser""")
    transcodingExtraInfo = property(_agorartc.LiveTranscoding_transcodingExtraInfo_get, _agorartc.LiveTranscoding_transcodingExtraInfo_set, doc=r"""
    Reserved property. Extra user-defined information to send SEI for the H.264/H.265 video stream to the CDN live client. Maximum length: 4096 Bytes.

        For more information on SEI frame, see [SEI-related questions](https://docs.agora.io/en/faq/sei).
    """)
    metadata = property(_agorartc.LiveTranscoding_metadata_get, _agorartc.LiveTranscoding_metadata_set, doc=r"""DEPRECATED** The metadata sent to the CDN live client defined by the RTMP or HTTP-FLV metadata.""")
    watermark = property(_agorartc.LiveTranscoding_watermark_get, _agorartc.LiveTranscoding_watermark_set, doc=r"""
    The watermark image added to the CDN live publishing stream.

       Ensure that the format of the image is PNG. Once a watermark image is added, the audience of the CDN live publishing stream can see the watermark image. See RtcImage.
    """)
    backgroundImage = property(_agorartc.LiveTranscoding_backgroundImage_get, _agorartc.LiveTranscoding_backgroundImage_set, doc=r"""
    The background image added to the CDN live publishing stream.

        Once a background image is added, the audience of the CDN live publishing stream can see the background image. See RtcImage.
    """)
    audioSampleRate = property(_agorartc.LiveTranscoding_audioSampleRate_get, _agorartc.LiveTranscoding_audioSampleRate_set, doc=r""" Self-defined audio-sample rate: #AUDIO_SAMPLE_RATE_TYPE.""")
    audioBitrate = property(_agorartc.LiveTranscoding_audioBitrate_get, _agorartc.LiveTranscoding_audioBitrate_set, doc=r""" Bitrate of the CDN live audio output stream. The default value is 48 Kbps, and the highest value is 128.""")
    audioChannels = property(_agorartc.LiveTranscoding_audioChannels_get, _agorartc.LiveTranscoding_audioChannels_set, doc=r"""
    The numbder of audio channels for the CDN live stream. Agora recommends choosing 1 (mono), or 2 (stereo) audio channels. Special players are required if you choose option 3, 4, or 5:

        - 1: (Default) Mono.
        - 2: Stereo.
        - 3: Three audio channels.
        - 4: Four audio channels.
        - 5: Five audio channels.
    """)
    audioCodecProfile = property(_agorartc.LiveTranscoding_audioCodecProfile_get, _agorartc.LiveTranscoding_audioCodecProfile_set, doc=r""" Self-defined audio codec profile: #AUDIO_CODEC_PROFILE_TYPE.""")
    advancedFeatures = property(_agorartc.LiveTranscoding_advancedFeatures_get, _agorartc.LiveTranscoding_advancedFeatures_set, doc=r"""
     Advanced features of the RTMP streaming with transcoding. See LiveStreamAdvancedFeature.

    Since: v3.1.0
    """)
    advancedFeatureCount = property(_agorartc.LiveTranscoding_advancedFeatureCount_get, _agorartc.LiveTranscoding_advancedFeatureCount_set, doc=r""" The number of enabled advanced features. The default value is 0.""")

    def __init__(self):
        _agorartc.LiveTranscoding_swiginit(self, _agorartc.new_LiveTranscoding())
    __swig_destroy__ = _agorartc.delete_LiveTranscoding

# Register LiveTranscoding in _agorartc:
_agorartc.LiveTranscoding_swigregister(LiveTranscoding)

class CameraCapturerConfiguration(object):
    r""" Camera capturer configuration."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    preference = property(_agorartc.CameraCapturerConfiguration_preference_get, _agorartc.CameraCapturerConfiguration_preference_set, doc=r""" Camera capturer preference settings. See: #CAPTURER_OUTPUT_PREFERENCE.""")

    def __init__(self):
        _agorartc.CameraCapturerConfiguration_swiginit(self, _agorartc.new_CameraCapturerConfiguration())
    __swig_destroy__ = _agorartc.delete_CameraCapturerConfiguration

# Register CameraCapturerConfiguration in _agorartc:
_agorartc.CameraCapturerConfiguration_swigregister(CameraCapturerConfiguration)

class InjectStreamConfig(object):
    r""" Configuration of the injected media stream."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    width = property(_agorartc.InjectStreamConfig_width_get, _agorartc.InjectStreamConfig_width_set, doc=r""" Width of the injected stream in the live interactive streaming. The default value is 0 (same width as the original stream).""")
    height = property(_agorartc.InjectStreamConfig_height_get, _agorartc.InjectStreamConfig_height_set, doc=r""" Height of the injected stream in the live interactive streaming. The default value is 0 (same height as the original stream).""")
    videoGop = property(_agorartc.InjectStreamConfig_videoGop_get, _agorartc.InjectStreamConfig_videoGop_set, doc=r""" Video GOP (in frames) of the injected stream in the live interactive streaming. The default value is 30 fps.""")
    videoFramerate = property(_agorartc.InjectStreamConfig_videoFramerate_get, _agorartc.InjectStreamConfig_videoFramerate_set, doc=r""" Video frame rate of the injected stream in the live interactive streaming. The default value is 15 fps.""")
    videoBitrate = property(_agorartc.InjectStreamConfig_videoBitrate_get, _agorartc.InjectStreamConfig_videoBitrate_set, doc=r"""
    Video bitrate of the injected stream in the live interactive streaming. The default value is 400 Kbps.

        Notes: The setting of the video bitrate is closely linked to the resolution. If the video bitrate you set is beyond a reasonable range, the SDK sets it within a reasonable range.
    """)
    audioSampleRate = property(_agorartc.InjectStreamConfig_audioSampleRate_get, _agorartc.InjectStreamConfig_audioSampleRate_set, doc=r"""
    Audio-sample rate of the injected stream in the live interactive streaming: #AUDIO_SAMPLE_RATE_TYPE. The default value is 48000 Hz.

        Notes: We recommend setting the default value.
    """)
    audioBitrate = property(_agorartc.InjectStreamConfig_audioBitrate_get, _agorartc.InjectStreamConfig_audioBitrate_set, doc=r"""
    Audio bitrate of the injected stream in the live interactive streaming. The default value is 48.

        Notes: We recommend setting the default value.
    """)
    audioChannels = property(_agorartc.InjectStreamConfig_audioChannels_get, _agorartc.InjectStreamConfig_audioChannels_set, doc=r"""
    Audio channels in the live interactive streaming.

        - 1: (Default) Mono
        - 2: Two-channel stereo

        Notes: We recommend setting the default value.
    """)

    def __init__(self):
        _agorartc.InjectStreamConfig_swiginit(self, _agorartc.new_InjectStreamConfig())
    __swig_destroy__ = _agorartc.delete_InjectStreamConfig

# Register InjectStreamConfig in _agorartc:
_agorartc.InjectStreamConfig_swigregister(InjectStreamConfig)

class ChannelMediaInfo(object):
    r""" The definition of ChannelMediaInfo."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    channelName = property(_agorartc.ChannelMediaInfo_channelName_get, _agorartc.ChannelMediaInfo_channelName_set, doc=r""" The channel name.""")
    token = property(_agorartc.ChannelMediaInfo_token_get, _agorartc.ChannelMediaInfo_token_set, doc=r""" The token that enables the user to join the channel.""")
    uid = property(_agorartc.ChannelMediaInfo_uid_get, _agorartc.ChannelMediaInfo_uid_set, doc=r""" The user ID.""")

    def __init__(self):
        _agorartc.ChannelMediaInfo_swiginit(self, _agorartc.new_ChannelMediaInfo())
    __swig_destroy__ = _agorartc.delete_ChannelMediaInfo

# Register ChannelMediaInfo in _agorartc:
_agorartc.ChannelMediaInfo_swigregister(ChannelMediaInfo)

class ChannelMediaRelayConfiguration(object):
    r""" The definition of ChannelMediaRelayConfiguration."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    srcInfo = property(_agorartc.ChannelMediaRelayConfiguration_srcInfo_get, _agorartc.ChannelMediaRelayConfiguration_srcInfo_set, doc=r"""
     Pointer to the information of the source channel: ChannelMediaInfo. It contains the following members:
    - `channelName`: The name of the source channel. The default value is `NULL`, which means the SDK applies the name of the current channel.
    - `uid`: ID of the host whose media stream you want to relay. The default value is 0, which means the SDK generates a random UID. You must set it as 0.
    - `token`: The token for joining the source channel. It is generated with the `channelName` and `uid` you set in `srcInfo`.
      - If you have not enabled the App Certificate, set this parameter as the default value `NULL`, which means the SDK applies the App ID.
      - If you have enabled the App Certificate, you must use the `token` generated with the `channelName` and `uid`, and the `uid` must be set as 0.
    """)
    destInfos = property(_agorartc.ChannelMediaRelayConfiguration_destInfos_get, _agorartc.ChannelMediaRelayConfiguration_destInfos_set, doc=r"""
     Pointer to the information of the destination channel: ChannelMediaInfo. It contains the following members:
    - `channelName`: The name of the destination channel.
    - `uid`: ID of the host in the destination channel. The value ranges from 0 to (2 32-1). To avoid UID conflicts, this `uid` must be different from any other UIDs in the destination channel. The default value is 0, which means the SDK generates a random UID.
    - `token`: The token for joining the destination channel. It is generated with the `channelName` and `uid` you set in `destInfos`.
      - If you have not enabled the App Certificate, set this parameter as the default value `NULL`, which means the SDK applies the App ID.
      - If you have enabled the App Certificate, you must use the `token` generated with the `channelName` and `uid`.
    """)
    destCount = property(_agorartc.ChannelMediaRelayConfiguration_destCount_get, _agorartc.ChannelMediaRelayConfiguration_destCount_set, doc=r"""
     The number of destination channels. The default value is 0, and the
    value range is [0,4). Ensure that the value of this parameter
    corresponds to the number of ChannelMediaInfo structs you define in
    `destInfos`.
    """)

    def __init__(self):
        _agorartc.ChannelMediaRelayConfiguration_swiginit(self, _agorartc.new_ChannelMediaRelayConfiguration())
    __swig_destroy__ = _agorartc.delete_ChannelMediaRelayConfiguration

# Register ChannelMediaRelayConfiguration in _agorartc:
_agorartc.ChannelMediaRelayConfiguration_swigregister(ChannelMediaRelayConfiguration)

RTMP_STREAM_LIFE_CYCLE_BIND2CHANNEL = _agorartc.RTMP_STREAM_LIFE_CYCLE_BIND2CHANNEL
r""" Bind to the channel lifecycle. If all hosts leave the channel, the CDN live streaming stops after 30 seconds."""
RTMP_STREAM_LIFE_CYCLE_BIND2OWNER = _agorartc.RTMP_STREAM_LIFE_CYCLE_BIND2OWNER
r""" Bind to the owner of the RTMP stream. If the owner leaves the channel, the CDN live streaming stops immediately."""
CONTENT_HINT_NONE = _agorartc.CONTENT_HINT_NONE
r""" (Default) No content hint."""
CONTENT_HINT_MOTION = _agorartc.CONTENT_HINT_MOTION
r""" Motion-intensive content. Choose this option if you prefer smoothness or when you are sharing a video clip, movie, or video game."""
CONTENT_HINT_DETAILS = _agorartc.CONTENT_HINT_DETAILS
r""" Motionless content. Choose this option if you prefer sharpness or when you are sharing a picture, PowerPoint slide, or text."""
class Rectangle(object):
    r""" The relative location of the region to the screen or window."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    x = property(_agorartc.Rectangle_x_get, _agorartc.Rectangle_x_set, doc=r""" The horizontal offset from the top-left corner.""")
    y = property(_agorartc.Rectangle_y_get, _agorartc.Rectangle_y_set, doc=r""" The vertical offset from the top-left corner.""")
    width = property(_agorartc.Rectangle_width_get, _agorartc.Rectangle_width_set, doc=r""" The width of the region.""")
    height = property(_agorartc.Rectangle_height_get, _agorartc.Rectangle_height_set, doc=r""" The height of the region.""")

    def __init__(self, *args):
        _agorartc.Rectangle_swiginit(self, _agorartc.new_Rectangle(*args))
    __swig_destroy__ = _agorartc.delete_Rectangle

# Register Rectangle in _agorartc:
_agorartc.Rectangle_swigregister(Rectangle)

class Rect(object):
    r"""DEPRECATED** Definition of the rectangular region."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    top = property(_agorartc.Rect_top_get, _agorartc.Rect_top_set, doc=r""" Y-axis of the top line.""")
    left = property(_agorartc.Rect_left_get, _agorartc.Rect_left_set, doc=r""" X-axis of the left line.""")
    bottom = property(_agorartc.Rect_bottom_get, _agorartc.Rect_bottom_set, doc=r""" Y-axis of the bottom line.""")
    right = property(_agorartc.Rect_right_get, _agorartc.Rect_right_set, doc=r""" X-axis of the right line.""")

    def __init__(self, *args):
        _agorartc.Rect_swiginit(self, _agorartc.new_Rect(*args))
    __swig_destroy__ = _agorartc.delete_Rect

# Register Rect in _agorartc:
_agorartc.Rect_swigregister(Rect)

class WatermarkOptions(object):
    r""" The options of the watermark image to be added."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    visibleInPreview = property(_agorartc.WatermarkOptions_visibleInPreview_get, _agorartc.WatermarkOptions_visibleInPreview_set, doc=r"""
     Sets whether or not the watermark image is visible in the local video preview:
    - true: (Default) The watermark image is visible in preview.
    - false: The watermark image is not visible in preview.
    """)
    positionInLandscapeMode = property(_agorartc.WatermarkOptions_positionInLandscapeMode_get, _agorartc.WatermarkOptions_positionInLandscapeMode_set, doc=r"""
    The watermark position in the landscape mode. See Rectangle.
    For detailed information on the landscape mode, see the advanced guide *Video Rotation*.
    """)
    positionInPortraitMode = property(_agorartc.WatermarkOptions_positionInPortraitMode_get, _agorartc.WatermarkOptions_positionInPortraitMode_set, doc=r"""
    The watermark position in the portrait mode. See Rectangle.
    For detailed information on the portrait mode, see the advanced guide *Video Rotation*.
    """)

    def __init__(self):
        _agorartc.WatermarkOptions_swiginit(self, _agorartc.new_WatermarkOptions())
    __swig_destroy__ = _agorartc.delete_WatermarkOptions

# Register WatermarkOptions in _agorartc:
_agorartc.WatermarkOptions_swigregister(WatermarkOptions)

class ScreenCaptureParameters(object):
    r""" Screen sharing encoding parameters."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    dimensions = property(_agorartc.ScreenCaptureParameters_dimensions_get, _agorartc.ScreenCaptureParameters_dimensions_set, doc=r"""
    The maximum encoding dimensions of the shared region in terms of width * height.

        The default value is 1920 * 1080 pixels, that is, 2073600 pixels. Agora uses the value of this parameter to calculate the charges.

        If the aspect ratio is different between the encoding dimensions and screen dimensions, Agora applies the following algorithms for encoding. Suppose the encoding dimensions are 1920 x 1080:

        - If the value of the screen dimensions is lower than that of the encoding dimensions, for example, 1000 * 1000, the SDK uses 1000 * 1000 for encoding.
        - If the value of the screen dimensions is higher than that of the encoding dimensions, for example, 2000 * 1500, the SDK uses the maximum value under 1920 * 1080 with the aspect ratio of the screen dimension (4:3) for encoding, that is, 1440 * 1080.
    """)
    frameRate = property(_agorartc.ScreenCaptureParameters_frameRate_get, _agorartc.ScreenCaptureParameters_frameRate_set, doc=r"""
    The frame rate (fps) of the shared region.

       The default value is 5. We do not recommend setting this to a value greater than 15.
    """)
    bitrate = property(_agorartc.ScreenCaptureParameters_bitrate_get, _agorartc.ScreenCaptureParameters_bitrate_set, doc=r"""
    The bitrate (Kbps) of the shared region.

       The default value is 0 (the SDK works out a bitrate according to the dimensions of the current screen).
    """)
    captureMouseCursor = property(_agorartc.ScreenCaptureParameters_captureMouseCursor_get, _agorartc.ScreenCaptureParameters_captureMouseCursor_set, doc=r"""
    Sets whether or not to capture the mouse for screen sharing:

       - true: (Default) Capture the mouse.
       - false: Do not capture the mouse.
    """)
    windowFocus = property(_agorartc.ScreenCaptureParameters_windowFocus_get, _agorartc.ScreenCaptureParameters_windowFocus_set, doc=r"""
     Whether to bring the window to the front when calling 'startScreenCaptureByWindowId' to share the window:
    - true: Bring the window to the front.
    - false: (Default) Do not bring the window to the front.
    """)
    excludeWindowList = property(_agorartc.ScreenCaptureParameters_excludeWindowList_get, _agorartc.ScreenCaptureParameters_excludeWindowList_set, doc=r"""
     A list of IDs of windows to be blocked.

    When calling 'startScreenCaptureByScreenRect' to start screen sharing, you can use this parameter to block the specified windows.
    When calling 'updateScreenCaptureParameters' to update the configuration for screen sharing, you can use this parameter to dynamically block the specified windows during screen sharing.
    """)
    excludeWindowCount = property(_agorartc.ScreenCaptureParameters_excludeWindowCount_get, _agorartc.ScreenCaptureParameters_excludeWindowCount_set, doc=r""" The number of windows to be blocked.""")

    def __init__(self, *args):
        _agorartc.ScreenCaptureParameters_swiginit(self, _agorartc.new_ScreenCaptureParameters(*args))
    __swig_destroy__ = _agorartc.delete_ScreenCaptureParameters

# Register ScreenCaptureParameters in _agorartc:
_agorartc.ScreenCaptureParameters_swigregister(ScreenCaptureParameters)

class VideoCanvas(object):
    r""" Video display settings of the VideoCanvas class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    view = property(_agorartc.VideoCanvas_view_get, _agorartc.VideoCanvas_view_set, doc=r""" Video display window (view).""")
    renderMode = property(_agorartc.VideoCanvas_renderMode_get, _agorartc.VideoCanvas_renderMode_set, doc=r""" The rendering mode of the video view. See RENDER_MODE_TYPE""")
    channelId = property(_agorartc.VideoCanvas_channelId_get, _agorartc.VideoCanvas_channelId_set, doc=r"""
    The unique channel name for the AgoraRTC session in the string format. The string length must be less than 64 bytes. Supported character scopes are:
        - All lowercase English letters: a to z.
        - All uppercase English letters: A to Z.
        - All numeric characters: 0 to 9.
        - The space character.
        - Punctuation characters and other symbols, including: "!", "#", "$", "%", "&", "(", ")", "+", "-", ":", ";", "<", "=", ".", ">", "?", "@", "[", "]", "^", "_", " {", "}", "|", "~", ",".

        Notes: 
        - The default value is the empty string "". Use the default value if the user joins the channel using the 'joinChannel' method in the IRtcEngine class. The `VideoCanvas` struct defines the video canvas of the user in the channel.
        - If the user joins the channel using the 'joinChannel' method in the IChannel class, set this parameter as the `channelId` of the `IChannel` object. The `VideoCanvas` struct defines the video canvas of the user in the channel with the specified channel ID.
    """)
    uid = property(_agorartc.VideoCanvas_uid_get, _agorartc.VideoCanvas_uid_set, doc=r""" The user ID.""")
    priv = property(_agorartc.VideoCanvas_priv_get, _agorartc.VideoCanvas_priv_set)
    mirrorMode = property(_agorartc.VideoCanvas_mirrorMode_get, _agorartc.VideoCanvas_mirrorMode_set, doc=r"""
    The mirror mode of the video view. See VIDEO_MIRROR_MODE_TYPE
        Notes: 
        - For the mirror mode of the local video view: If you use a front camera, the SDK enables the mirror mode by default; if you use a rear camera, the SDK disables the mirror mode by default.
        - For the mirror mode of the remote video view: The SDK disables the mirror mode by default.
    """)

    def __init__(self, *args):
        _agorartc.VideoCanvas_swiginit(self, _agorartc.new_VideoCanvas(*args))
    __swig_destroy__ = _agorartc.delete_VideoCanvas

# Register VideoCanvas in _agorartc:
_agorartc.VideoCanvas_swigregister(VideoCanvas)

class BeautyOptions(object):
    r""" Image enhancement options."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    LIGHTENING_CONTRAST_LOW = _agorartc.BeautyOptions_LIGHTENING_CONTRAST_LOW
    r""" Low contrast level."""
    LIGHTENING_CONTRAST_NORMAL = _agorartc.BeautyOptions_LIGHTENING_CONTRAST_NORMAL
    r""" (Default) Normal contrast level."""
    LIGHTENING_CONTRAST_HIGH = _agorartc.BeautyOptions_LIGHTENING_CONTRAST_HIGH
    r""" High contrast level."""
    lighteningContrastLevel = property(_agorartc.BeautyOptions_lighteningContrastLevel_get, _agorartc.BeautyOptions_lighteningContrastLevel_set, doc=r""" The contrast level, used with the ``lightening`` parameter.""")
    lighteningLevel = property(_agorartc.BeautyOptions_lighteningLevel_get, _agorartc.BeautyOptions_lighteningLevel_set, doc=r""" The brightness level. The value ranges from 0.0 (original) to 1.0.""")
    smoothnessLevel = property(_agorartc.BeautyOptions_smoothnessLevel_get, _agorartc.BeautyOptions_smoothnessLevel_set, doc=r""" The sharpness level. The value ranges between 0 (original) and 1. This parameter is usually used to remove blemishes.""")
    rednessLevel = property(_agorartc.BeautyOptions_rednessLevel_get, _agorartc.BeautyOptions_rednessLevel_set, doc=r""" The redness level. The value ranges between 0 (original) and 1. This parameter adjusts the red saturation level.""")

    def __init__(self, *args):
        _agorartc.BeautyOptions_swiginit(self, _agorartc.new_BeautyOptions(*args))
    __swig_destroy__ = _agorartc.delete_BeautyOptions

# Register BeautyOptions in _agorartc:
_agorartc.BeautyOptions_swigregister(BeautyOptions)

class UserInfo(object):
    r"""The UserInfo struct."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    uid = property(_agorartc.UserInfo_uid_get, _agorartc.UserInfo_uid_set, doc=r"""The user ID.""")
    userAccount = property(_agorartc.UserInfo_userAccount_get, _agorartc.UserInfo_userAccount_set, doc=r"""The user account.""")

    def __init__(self):
        _agorartc.UserInfo_swiginit(self, _agorartc.new_UserInfo())
    __swig_destroy__ = _agorartc.delete_UserInfo

# Register UserInfo in _agorartc:
_agorartc.UserInfo_swigregister(UserInfo)

AREA_CODE_CN = _agorartc.AREA_CODE_CN
r"""Mainland China."""
AREA_CODE_NA = _agorartc.AREA_CODE_NA
r"""North America."""
AREA_CODE_EU = _agorartc.AREA_CODE_EU
r"""Europe."""
AREA_CODE_AS = _agorartc.AREA_CODE_AS
r"""Asia, excluding Mainland China."""
AREA_CODE_JP = _agorartc.AREA_CODE_JP
r"""Japan."""
AREA_CODE_IN = _agorartc.AREA_CODE_IN
r"""India."""
AREA_CODE_GLOB = _agorartc.AREA_CODE_GLOB
r"""(Default) Global."""
class RtcEngineBridge(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def initEventHandler(self, eventHandler: "IRtcEngineEventHandler") -> "int":
        return _agorartc.RtcEngineBridge_initEventHandler(self, eventHandler)

    def release(self, sync: "bool"=False) -> "void":
        r""" Releases all IVideoDeviceManager resources."""
        return _agorartc.RtcEngineBridge_release(self, sync)

    def createChannel(self, channelId: "char const *") -> "agora::common::RtcChannelBridge *":
        return _agorartc.RtcEngineBridge_createChannel(self, channelId)

    def createVideoDeviceManager(self) -> "agora::common::VideoDeviceManager *":
        return _agorartc.RtcEngineBridge_createVideoDeviceManager(self)

    def createAudioPlaybackDeviceManager(self) -> "agora::common::AudioPlaybackDeviceManager *":
        return _agorartc.RtcEngineBridge_createAudioPlaybackDeviceManager(self)

    def createAudioRecordingDeviceManager(self) -> "agora::common::AudioRecordingDeviceManager *":
        return _agorartc.RtcEngineBridge_createAudioRecordingDeviceManager(self)

    def initialize(self, appId: "char const *", context: "void *", areaCode: "unsigned int") -> "int":
        return _agorartc.RtcEngineBridge_initialize(self, appId, context, areaCode)

    def setChannelProfile(self, profile: "agora::rtc::CHANNEL_PROFILE_TYPE") -> "int":
        r"""
         Sets the channel profile of the Agora IRtcEngine.

        The Agora IRtcEngine differentiates channel profiles and applies optimization algorithms accordingly.
        For example, it prioritizes smoothness and low latency for a video call, and prioritizes video quality for the live interactive video streaming.

        Warning: 
        - To ensure the quality of real-time communication, we recommend that all users in a channel use the same channel profile.
        - Call this method before calling 'joinChannel' . You cannot set the channel profile once you have joined the channel.
        - The default audio route and video encoding bitrate are different in different channel profiles. For details, see
        'setDefaultAudioRouteToSpeakerphone' and 'setVideoEncoderConfiguration'.

        :type profile: int
        :param profile: The channel profile of the Agora IRtcEngine. See #CHANNEL_PROFILE_TYPE
        :rtype: int
        :return: 
            - 0(ERR_OK): Success.
            - < 0: Failure.
             - -2 (ERR_INVALID_ARGUMENT): The parameter is invalid.
             - -7(ERR_NOT_INITIALIZED): The SDK is not initialized.
        """
        return _agorartc.RtcEngineBridge_setChannelProfile(self, profile)

    def setClientRole(self, role: "agora::rtc::CLIENT_ROLE_TYPE") -> "int":
        r"""
         Sets the role of the user, such as a host or an audience (default), before joining a channel in the live interactive streaming.

        This method can be used to switch the user role in the live interactive streaming after the user joins a channel.

        In the `LIVE_BROADCASTING` profile, when a user switches user roles after joining a channel, a successful 'setClientRole' method call triggers the following callbacks:
        - The local client: 'onClientRoleChanged'
        - The remote client: 'onUserJoined' or 'onUserOffline' (BECOME_AUDIENCE)

        Notes: 
        This method applies only to the `LIVE_BROADCASTING` profile.

        :type role: int
        :param role: Sets the role of the user. See #CLIENT_ROLE_TYPE.

        :rtype: int
        :return: 
            - 0(ERR_OK): Success.
            - < 0: Failure.
             - -1(ERR_FAILED): A general error occurs (no specified reason).
             - -2(ERR_INALID_ARGUMENT): The parameter is invalid.
             - -7(ERR_NOT_INITIALIZED): The SDK is not initialized.
        """
        return _agorartc.RtcEngineBridge_setClientRole(self, role)

    def joinChannel(self, token: "char const *", channelId: "char const *", info: "char const *", uid: "agora::rtc::uid_t") -> "int":
        r"""
         Joins a channel with the user ID.

        		     Users in the same channel can talk to each other, and multiple users in the same channel can start a group chat. Users with different App IDs cannot call each other.


        		     You must call the 'leaveChannel' method to exit the current call before entering another channel.

        		     A successful 'joinChannel' method call triggers the following callbacks:
        		     - The local client: 'onJoinChannelSuccess'
        		     - The remote client: 'onUserJoined' , if the user joining the channel is in the `COMMUNICATION` profile, or is a host in the `LIVE_BROADCASTING` profile.

        		     When the connection between the client and Agora's server is interrupted due to poor network conditions, the SDK tries reconnecting to the server. When the local client successfully rejoins the channel, the SDK triggers the 'onRejoinChannelSuccess' callback on the local client.

        		     Notes: A channel does not accept duplicate uids, such as two users with the same ``uid``. If you set ``uid`` as 0, the system automatically assigns a ``uid``. If you want to join a channel from different devices, ensure that each device has a different uid.
        		     Warning: Ensure that the App ID used for creating the token is the same App ID used by the 'initialize' method for initializing the RTC engine. Otherwise, the CDN live streaming may fail.

        		     :type token: string
        :param token: Pointer to the token generated by the application server. In most circumstances, a static App ID suffices. For added security, use a Channel Key.
            		     - If the user uses a static App ID, *token* is optional and can be set as NULL.
            		     - If the user uses a Channel Key, Agora issues an additional App Certificate for you to generate a user key based on the algorithm and App Certificate for user authentication on the server.
            		 :type channelId: string
        :param channelId: Pointer to the unique channel name for the Agora RTC session in the string format smaller than 64 bytes. Supported characters:
            		     - All lowercase English letters: a to z.
            		     - All uppercase English letters: A to Z.
            		     - All numeric characters: 0 to 9.
            		     - The space character.
            		     - Punctuation characters and other symbols, including: "!", "#", "$", "%", "&", "(", ")", "+", "-", ":", ";", "<", "=", ".", ">", "?", "@", "[", "]", "^", "_", " {", "}", "|", "~", ",".
            		 :type info: string
        :param info: (Optional) Pointer to additional information about the channel. This parameter can be set to NULL or contain channel related information. Other users in the channel will not receive this message.
            		 :type uid: int
        :param uid: (Optional) User ID. A 32-bit unsigned integer with a value ranging from 1 to 2 32-1. The ``uid`` must be unique. If a ``uid`` is not assigned (or set to 0), the SDK assigns and returns a ``uid`` in the 'onJoinChannelSuccess' callback. Your application must record and maintain the returned *uid* since the SDK does not do so.

        		     :rtype: int
        :return: 
            		     - 0(ERR_OK): Success.
            		     - < 0: Failure.
            		        - -2(ERR_INALID_ARGUMENT): The parameter is invalid.
            		        - -3(ERR_NOT_READY): The SDK fails to be initialized. You can try re-initializing the SDK.
            		        - -5(ERR_REFUSED): The request is rejected. This may be caused by the following:
            		            - You have created an IChannel object with the same channel name.
            		            - You have joined and published a stream in a channel created by the IChannel object.
        """
        return _agorartc.RtcEngineBridge_joinChannel(self, token, channelId, info, uid)

    def switchChannel(self, token: "char const *", channelId: "char const *") -> "int":
        r"""
         Switches to a different channel.

        This method allows the audience of a `LIVE_BROADCASTING` channel to switch
        to a different channel.

        After the user successfully switches to another channel, the
        'onLeaveChannel'
         and 'agora::rtc::IRtcEngineEventHandler::onJoinChannelSuccess'
        "onJoinChannelSuccess" callbacks are triggered to indicate that the
        user has left the original channel and joined a new one.

        Notes: 
        This method applies to the audience role in a `LIVE_BROADCASTING` channel
        only.

        :type token: string
        :param token: The token generated at your server:
            - For low-security requirements: You can use the temporary token
            generated in Console. For details, see
            [Get a temporary token](https://docs.agora.io/en/Agora%20Platform/token?platfor%20*%20m=All%20Platforms#get-a-temporary-token).
            - For high-security requirements: Use the token generated at your
            server. For details, see
            [Get a token](https://docs.agora.io/en/Agora%20Platform/token?platfor%20*%20m=All%20Platforms#get-a-token).
        :type channelId: string
        :param channelId: Unique channel name for the AgoraRTC session in the
            string format. The string length must be less than 64 bytes. Supported
            character scopes are:
            - All lowercase English letters: a to z.
            - All uppercase English letters: A to Z.
            - All numeric characters: 0 to 9.
            - The space character.
            - Punctuation characters and other symbols, including: "!", "#", "$", "%", "&", "(", ")", "+", "-", ":", ";", "<", "=", ".", ">", "?", "@", "[", "]", "^", "_", " {", "}", "|", "~", ",".

        :rtype: int
        :return: 
            - 0(ERR_OK): Success.
            - < 0: Failure.
             - -1(ERR_FAILED): A general error occurs (no specified reason).
             - -2(ERR_INALID_ARGUMENT): The parameter is invalid.
             - -5(ERR_REFUSED): The request is rejected, probably because the user is not an audience.
             - -7(ERR_NOT_INITIALIZED): The SDK is not initialized.
             - -102(ERR_INVALID_CHANNEL_NAME): The channel name is invalid.
             - -113(ERR_NOT_IN_CHANNEL): The user is not in the channel.
        """
        return _agorartc.RtcEngineBridge_switchChannel(self, token, channelId)

    def leaveChannel(self) -> "int":
        r"""
         Allows a user to leave a channel, such as hanging up or exiting a call.

        		     After joining a channel, the user must call the *leaveChannel* method to end the call before joining another channel.

        		     This method returns 0 if the user leaves the channel and releases all resources related to the call.

        		     This method call is asynchronous, and the user has not left the channel when the method call returns. Once the user leaves the channel, the SDK triggers the 'onLeaveChannel' callback.

        		     A successful 'leaveChannel' method call triggers the following callbacks:
        		     - The local client: 'onLeaveChannel'
        		     - The remote client: 'onUserOffline' , if the user leaving the channel is in the `COMMUNICATION` channel, or is a host in the `LIVE_BROADCASTING` profile.

        		     Notes: 
        		     - If you call the 'release' method immediately after the *leaveChannel* method, the *leaveChannel* process interrupts, and the 'onLeaveChannel' callback is not triggered.
        		     - If you call the *leaveChannel* method during a CDN live streaming, the SDK triggers the 'removePublishStreamUrl' method.

        		     :rtype: int
        :return: 
            		     - 0(ERR_OK): Success.
            		     - < 0: Failure.
            		        - -1(ERR_FAILED): A general error occurs (no specified reason).
            		        - -2(ERR_INALID_ARGUMENT): The parameter is invalid.
            		        - -7(ERR_NOT_INITIALIZED): The SDK is not initialized.
        """
        return _agorartc.RtcEngineBridge_leaveChannel(self)

    def renewToken(self, token: "char const *") -> "int":
        r"""
         Gets a new token when the current token expires after a period of time.

        		     The `token` expires after a period of time once the token schema is enabled when:

        		     - The SDK triggers the 'onTokenPrivilegeWillExpire' callback, or
        		     - The 'onConnectionStateChanged' reports CONNECTION_CHANGED_TOKEN_EXPIRED(9).

        		     The application should call this method to get the new `token`. Failure to do so will result in the SDK disconnecting from the server.

        		     :type token: string
        :param token: Pointer to the new token.

        		     :rtype: int
        :return: 
            		     - 0(ERR_OK): Success.
            		     - < 0: Failure.
            		        - -1(ERR_FAILED): A general error occurs (no specified reason).
            		        - -2(ERR_INALID_ARGUMENT): The parameter is invalid.
            		        - -7(ERR_NOT_INITIALIZED): The SDK is not initialized.
        """
        return _agorartc.RtcEngineBridge_renewToken(self, token)

    def registerLocalUserAccount(self, appId: "char const *", userAccount: "char const *") -> "int":
        r"""
         Registers a user account.

        		     Once registered, the user account can be used to identify the local user when the user joins the channel.
        		     After the user successfully registers a user account, the SDK triggers the 'onLocalUserRegistered' callback on the local client,
        		     reporting the user ID and user account of the local user.

        		     To join a channel with a user account, you can choose either of the following:

        		     - Call the 'registerLocalUserAccount' method to create a user account, and then the 'joinChannelWithUserAccount' method to join the channel.
        		     - Call the 'joinChannelWithUserAccount' method to join the channel.

        		     The difference between the two is that for the former, the time elapsed between calling the 'joinChannelWithUserAccount' method
        		     and joining the channel is shorter than the latter.

        		     Notes: 
        		     - Ensure that you set the `userAccount` parameter. Otherwise, this method does not take effect.
        		     - Ensure that the value of the `userAccount` parameter is unique in the channel.
        		     - To ensure smooth communication, use the same parameter type to identify the user. For example, if a user joins the channel with a user ID, then ensure all the other users use the user ID too. The same applies to the user account. If a user joins the channel with the Agora Web SDK, ensure that the uid of the user is set to the same parameter type.

        		     :type appId: string
        :param appId: The App ID of your project.
            		 :type userAccount: string
        :param userAccount: The user account. The maximum length of this parameter is 255 bytes. Ensure that you set this parameter and do not set it as null. Supported character scopes are:
            		     - All lowercase English letters: a to z.
            		     - All uppercase English letters: A to Z.
            		     - All numeric characters: 0 to 9.
            		     - The space character.
            		     - Punctuation characters and other symbols, including: "!", "#", "$", "%", "&", "(", ")", "+", "-", ":", ";", "<", "=", ".", ">", "?", "@", "[", "]", "^", "_", " {", "}", "|", "~", ",".

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_registerLocalUserAccount(self, appId, userAccount)

    def joinChannelWithUserAccount(self, token: "char const *", channelId: "char const *", userAccount: "char const *") -> "int":
        r"""
         Joins the channel with a user account.

        		     After the user successfully joins the channel, the SDK triggers the following callbacks:

        		     - The local client: 'onLocalUserRegistered' and 'onJoinChannelSuccess' .
        		     The remote client: 'onUserJoined' and 'onUserInfoUpdated' , if the user joining the channel is in the `COMMUNICATION` profile, or is a host in the `LIVE_BROADCASTING` profile.

        		     Notes: To ensure smooth communication, use the same parameter type to identify the user. For example, if a user joins the channel with a user ID, then ensure all the other users use the user ID too. The same applies to the user account.
        		     If a user joins the channel with the Agora Web SDK, ensure that the uid of the user is set to the same parameter type.

        		     :type token: string
        :param token: The token generated at your server:
            		     - For low-security requirements: You can use the temporary token generated at Console. For details, see [Get a temporary toke](https://docs.agora.io/en/Voice/token?platform=All%20Platforms#get-a-temporary-token).
            		     - For high-security requirements: Set it as the token generated at your server. For details, see [Get a token](https://docs.agora.io/en/Voice/token?platform=All%20Platforms#get-a-token).
            		 :type channelId: string
        :param channelId: The channel name. The maximum length of this parameter is 64 bytes. Supported character scopes are:
            		     - All lowercase English letters: a to z.
            		     - All uppercase English letters: A to Z.
            		     - All numeric characters: 0 to 9.
            		     - The space character.
            		     - Punctuation characters and other symbols, including: "!", "#", "$", "%", "&", "(", ")", "+", "-", ":", ";", "<", "=", ".", ">", "?", "@", "[", "]", "^", "_", " {", "}", "|", "~", ",".
            		 :type userAccount: string
        :param userAccount: The user account. The maximum length of this parameter is 255 bytes. Ensure that you set this parameter and do not set it as null. Supported character scopes are:
            		     - All lowercase English letters: a to z.
            		     - All uppercase English letters: A to Z.
            		     - All numeric characters: 0 to 9.
            		     - The space character.
            		     - Punctuation characters and other symbols, including: "!", "#", "$", "%", "&", "(", ")", "+", "-", ":", ";", "<", "=", ".", ">", "?", "@", "[", "]", "^", "_", " {", "}", "|", "~", ",".

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
            		        - #ERR_INVALID_ARGUMENT (-2)
            		        - #ERR_NOT_READY (-3)
            		        - #ERR_REFUSED (-5)
        """
        return _agorartc.RtcEngineBridge_joinChannelWithUserAccount(self, token, channelId, userAccount)

    def getUserInfoByUserAccount(self, userAccount: "char const *", userInfo: "UserInfo") -> "int":
        r"""
         Gets the user information by passing in the user account.

        		     After a remote user joins the channel, the SDK gets the user ID and user account of the remote user, caches them
        		     in a mapping table object (`userInfo`), and triggers the 'onUserInfoUpdated' callback on the local client.

        		     After receiving the o'onUserInfoUpdated' callback, you can call this method to get the user ID of the
        		     remote user from the `userInfo` object by passing in the user account.

        		     :type userAccount: string
        :param userAccount: The user account of the user. Ensure that you set this parameter.
            		 :param [in,out]: userInfo  A userInfo object that identifies the user:
            		     - Input: A userInfo object.
            		     - Output: A userInfo object that contains the user account and user ID of the user.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_getUserInfoByUserAccount(self, userAccount, userInfo)

    def getUserInfoByUid(self, uid: "agora::rtc::uid_t", userInfo: "UserInfo") -> "int":
        r"""
         Gets the user information by passing in the user ID.

        		     After a remote user joins the channel, the SDK gets the user ID and user account of the remote user,
        		     caches them in a mapping table object (`userInfo`), and triggers the 'onUserInfoUpdated' callback on the local client.

        		     After receiving the 'onUserInfoUpdated' callback, you can call this method to get the user account of the remote user
        		     from the `userInfo` object by passing in the user ID.

        		     :type uid: int
        :param uid: The user ID of the remote user. Ensure that you set this parameter.
            		 :type userInfo: :py:class:`UserInfo`, in/out
        :param userInfo: A userInfo object that identifies the user:
            		     - Input: A userInfo object.
            		     - Output: A userInfo object that contains the user account and user ID of the user.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_getUserInfoByUid(self, uid, userInfo)

    def startEchoTest(self, *args) -> "int":
        r"""
        *Overload 1:*
        DEPRECATED** Starts an audio call test.

        		     This method is deprecated as of v2.4.0.

        		     This method starts an audio call test to check whether the audio devices (for example, headset and speaker) and the network connection are working properly.

        		     To conduct the test:

        		     - The user speaks and the recording is played back within 10 seconds.
        		     - If the user can hear the recording within 10 seconds, the audio devices and network connection are working properly.

        		     Notes: 
        		     - After calling this method, always call the 'stopEchoTest' method to end the test. Otherwise, the application cannot run the next echo test.
        		     - In the `LIVE_BROADCASTING` profile, only the hosts can call this method. If the user switches from the `COMMUNICATION` to`LIVE_BROADCASTING` profile, the user must call the 'setClientRole' method to change the user role from the audience (default) to the host before calling this method.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.

        |

        *Overload 2:*
         Starts an audio call test.

        		     This method starts an audio call test to determine whether the audio devices (for example, headset and speaker) and the network connection are working properly.

        		     In the audio call test, you record your voice. If the recording plays back within the set time interval, the audio devices and the network connection are working properly.

        		     Notes: 
        		     - Call this method before joining a channel.
        		     - After calling this method, call the 'stopEchoTest' method to end the test. Otherwise, the app cannot run the next echo test, or call the 'joinChannel' method.
        		     - In the `LIVE_BROADCASTING` profile, only a host can call this method.
        		     :type intervalInSeconds: int
        :param intervalInSeconds: The time interval (s) between when you speak and when the recording plays back.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_startEchoTest(self, *args)

    def stopEchoTest(self) -> "int":
        r"""
         Stops the audio call test.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_stopEchoTest(self)

    def enableVideo(self) -> "int":
        r"""
         Enables the video module.

        		     Call this method either before joining a channel or during a call. If this method is called before joining a channel, the call starts in the video mode. If this method is called during an audio call, the audio mode switches to the video mode. To disable the video module, call the 'disableVideo' method.

        		     A successful 'enableVideo' method call triggers the 'onUserEnableVideo' (true) callback on the remote client.
        		     Notes: 
        		     - This method affects the internal engine and can be called after the 'leaveChannel' method.
        		     - This method resets the internal engine and takes some time to take effect. We recommend using the following API methods to control the video engine modules separately:
        		         - 'enableLocalVideo': Whether to enable the camera to create the local video stream.
        		         - 'muteLocalVideoStream': Whether to publish the local video stream.
        		         - 'muteRemoteVideoStream': Whether to subscribe to and play the remote video stream.
        		         - 'muteAllRemoteVideoStreams': Whether to subscribe to and play all remote video streams.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_enableVideo(self)

    def disableVideo(self) -> "int":
        r"""
         Disables the video module.

            		 This method can be called before joining a channel or during a call. If this method is called before joining a channel, the call starts in audio mode. If this method is called during a video call, the video mode switches to the audio mode. To enable the video module, call the 'enableVideo' method.

        		     A successful 'disableVideo' method call triggers the 'onUserEnableVideo' (false) callback on the remote client.
        		     Notes: 
        		     - This method affects the internal engine and can be called after the 'leaveChannel' method.
        		     - This method resets the internal engine and takes some time to take effect. We recommend using the following API methods to control the video engine modules separately:
        		         - 'enableLocalVideo': Whether to enable the camera to create the local video stream.
        		         - 'muteLocalVideoStream': Whether to publish the local video stream.
        		         - 'muteRemoteVideoStream': Whether to subscribe to and play the remote video stream.
        		         - 'muteAllRemoteVideoStreams': Whether to subscribe to and play all remote video streams.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_disableVideo(self)

    def setVideoProfile(self, profile: "agora::rtc::VIDEO_PROFILE_TYPE", swapWidthAndHeight: "bool") -> "int":
        r"""
        DEPRECATED** Sets the video profile.

        		     This method is deprecated as of v2.3. Use the 'setVideoEncoderConfiguration' method instead.

        		     Each video profile includes a set of parameters, such as the resolution, frame rate, and bitrate. If the camera device does not support the specified resolution, the SDK automatically chooses a suitable camera resolution, keeping the encoder resolution specified by the *setVideoProfile* method.

        		     Notes: 
        		     - If you do not need to set the video profile after joining the channel, call this method before the 'enableVideo' method to reduce the render time of the first video frame.
        		     - Always set the video profile before calling the 'joinChannel' or 'startPreview' method.

        		     :type profile: int
        :param profile: Sets the video profile. See #VIDEO_PROFILE_TYPE.
            		 :type swapWidthAndHeight: boolean
        :param swapWidthAndHeight: Sets whether to swap the width and height of the video stream:
            		     - true: Swap the width and height.
            		     - false: (Default) Do not swap the width and height.
            		     The width and height of the output video are consistent with the set video profile.
            		 Since the landscape or portrait mode of the output video can be decided directly by the video profile, We recommend setting *swapWidthAndHeight* to *false* (default).

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_setVideoProfile(self, profile, swapWidthAndHeight)

    def setVideoEncoderConfiguration(self, config: "VideoEncoderConfiguration") -> "int":
        r"""
         Sets the video encoder configuration.

        		     Each video encoder configuration corresponds to a set of video parameters, including the resolution, frame rate, bitrate, and video orientation.

        		     The parameters specified in this method are the maximum values under ideal network conditions. If the video engine cannot render the video using the specified parameters due to poor network conditions, the parameters further down the list are considered until a successful configuration is found.

        		     Notes: If you do not need to set the video encoder configuration after joining the channel, you can call this method before the 'enableVideo' method to reduce the render time of the first video frame.

        		     :type config: :py:class:`VideoEncoderConfiguration`
        :param config: Sets the local video encoder configuration. See VideoEncoderConfiguration.
            		 :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_setVideoEncoderConfiguration(self, config)

    def setCameraCapturerConfiguration(self, config: "CameraCapturerConfiguration") -> "int":
        r"""
         Sets the camera capture configuration.

        		     For a video call or the live interactive video streaming, generally the SDK controls the camera output parameters. When the default camera capturer settings do not meet special requirements or cause performance problems, we recommend using this method to set the camera capturer configuration:

        		     - If the resolution or frame rate of the captured raw video data are higher than those set by 'setVideoEncoderConfiguration', processing video frames requires extra CPU and RAM usage and degrades performance. We recommend setting config as CAPTURER_OUTPUT_PREFERENCE_PERFORMANCE = 1 to avoid such problems.
        		     - If you do not need local video preview or are willing to sacrifice preview quality, we recommend setting config as CAPTURER_OUTPUT_PREFERENCE_PERFORMANCE = 1 to optimize CPU and RAM usage.
        		     - If you want better quality for the local video preview, we recommend setting config as CAPTURER_OUTPUT_PREFERENCE_PREVIEW = 2.

        		     Notes: Call this method before enabling the local camera. That said, you can call this method before calling 'joinChannel', 'enableVideo', or 'enableLocalVideo', depending on which method you use to turn on your local camera.

        		     :type config: :py:class:`CameraCapturerConfiguration`
        :param config: Sets the camera capturer configuration. See CameraCapturerConfiguration.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_setCameraCapturerConfiguration(self, config)

    def setupLocalVideo(self, canvas: "VideoCanvas") -> "int":
        r"""
         Initializes the local video view.

        		     This method initializes the video view of a local stream on the local device. It affects only the video view that the local user sees, not the published local video stream.

        		     Call this method to bind the local video stream to a video view and to set the rendering and mirror modes of the video view.
        		     The binding is still valid after the user leaves the channel, which means that the window still displays. To unbind the view, set the *view* in VideoCanvas to NULL.

        		     Notes: 
        		     - Call this method before joining a channel.
        		     - During a call, you can call this method as many times as necessary to update the display mode of the local video view.
        		     :type canvas: :py:class:`VideoCanvas`
        :param canvas: Pointer to the local video view and settings. See VideoCanvas.
            		 :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_setupLocalVideo(self, canvas)

    def setupRemoteVideo(self, canvas: "VideoCanvas") -> "int":
        r"""
         Initializes the video view of a remote user.

        		     This method initializes the video view of a remote stream on the local device. It affects only the video view that the local user sees.

        		     Call this method to bind the remote video stream to a video view and to set the rendering and mirror modes of the video view.

        		     The application specifies the uid of the remote video in this method before the remote user joins the channel. If the remote uid is unknown to the application, set it after the application receives the 'onUserJoined' callback.
        		     If the Video Recording function is enabled, the Video Recording Service joins the channel as a dummy client, causing other clients to also receive the 'onUserJoined' callback. Do not bind the dummy client to the application view because the dummy client does not send any video streams. If your application does not recognize the dummy client, bind the remote user to the view when the SDK triggers the 'onFirstRemoteVideoDecoded' callback.
        		     To unbind the remote user from the view, set the view in VideoCanvas to NULL. Once the remote user leaves the channel, the SDK unbinds the remote user.

        		     Notes: To update the rendering or mirror mode of the remote video view during a call, use the 'setRemoteRenderMode' method.

        		     :type canvas: :py:class:`VideoCanvas`
        :param canvas: Pointer to the remote video view and settings. See VideoCanvas.
            		 :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_setupRemoteVideo(self, canvas)

    def startPreview(self) -> "int":
        r"""
         Starts the local video preview before joining the channel.

        		     Before calling this method, you must:

        		     - Call the 'setupLocalVideo' method to set up the local preview window and configure the attributes.
        		     - Call the 'enableVideo' method to enable video.

        		     Notes: Once the startPreview method is called to start the local video preview, if you leave the channel by calling the 'leaveChannel' method, the local video preview remains until you call the 'stopPreview' method to disable it.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_startPreview(self)

    def setRemoteUserPriority(self, uid: "agora::rtc::uid_t", userPriority: "agora::rtc::PRIORITY_TYPE") -> "int":
        r"""
         Prioritizes a remote user's stream.

        		    Use this method with the 'setRemoteSubscribeFallbackOption' method. If the fallback function is enabled for a subscribed stream, the SDK ensures the high-priority user gets the best possible stream quality.

        		    Notes: The Agora SDK supports setting ``userPriority`` as high for one user only.

        		    :type uid: int
        :param uid:  The ID of the remote user.
            		:type userPriority: int
        :param userPriority: Sets the priority of the remote user. See #PRIORITY_TYPE.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_setRemoteUserPriority(self, uid, userPriority)

    def stopPreview(self) -> "int":
        r"""
         Stops the local video preview and disables video.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_stopPreview(self)

    def enableAudio(self) -> "int":
        r"""
         Enables the audio module.

        		    The audio mode is enabled by default.

        		     Notes: 
        		     - This method affects the internal engine and can be called after the 'leaveChannel' method. You can call this method either before or after joining a channel.
        		     - This method resets the internal engine and takes some time to take effect. We recommend using the following API methods to control the audio engine modules separately:
        		         - 'enableLocalAudio': Whether to enable the microphone to create the local audio stream.
        		         - 'muteLocalAudioStream': Whether to publish the local audio stream.
        		         - 'muteRemoteAudioStream': Whether to subscribe to and play the remote audio stream.
        		         - 'muteAllRemoteAudioStreams': Whether to subscribe to and play all remote audio streams.

        		    :rtype: int
        :return: 
            		    - 0: Success.
            		    - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_enableAudio(self)

    def enableLocalAudio(self, enabled: "bool") -> "int":
        r"""
         Disables/Re-enables the local audio function.

        		     The audio function is enabled by default. This method disables or re-enables the local audio function, that is, to stop or restart local audio capturing.

        		     This method does not affect receiving or playing the remote audio streams,and enableLocalAudio(false) is applicable to scenarios where the user wants to
        		     receive remote audio streams without sending any audio stream to other users in the channel.

        		     Once the local audio function is disabled or re-enabled, the SDK triggers the 'onLocalAudioStateChanged' callback,
        		     which reports `LOCAL_AUDIO_STREAM_STATE_STOPPED(0)` or `LOCAL_AUDIO_STREAM_STATE_RECORDING(1)`.

        		     Notes: 
        		     This method is different from the 'muteLocalAudioStream' method:
        		        - 'enableLocalAudio': Disables/Re-enables the local audio capturing and processing.
        		        If you disable or re-enable local audio recording using the `enableLocalAudio` method, the local user may hear a pause in the remote audio playback.
        		        - 'muteLocalAudioStream': Sends/Stops sending the local audio streams.

        		     :type enabled: boolean
        :param enabled: Sets whether to disable/re-enable the local audio function:
            		     - true: (Default) Re-enable the local audio function, that is, to start the local audio capturing device (for example, the microphone).
            		     - false: Disable the local audio function, that is, to stop local audio capturing.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_enableLocalAudio(self, enabled)

    def disableAudio(self) -> "int":
        r"""
         Disables the audio module.

        		     Notes: 
        		     - This method affects the internal engine and can be called after the 'leaveChannel' method. You can call this method either before or after joining a channel.
        		     - This method resets the internal engine and takes some time to take effect. We recommend using the 'enableLocalAudio' and 'muteLocalAudioStream' methods to capture, process, and send the local audio streams.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_disableAudio(self)

    def setAudioProfile(self, profile: "agora::rtc::AUDIO_PROFILE_TYPE", scenario: "agora::rtc::AUDIO_SCENARIO_TYPE") -> "int":
        r"""
         Sets the audio parameters and application scenarios.

        		     Notes: 
        		     - The *setAudioProfile* method must be called before the 'joinChannel' method.
        		     - In the `COMMUNICATION` and `LIVE_BROADCASTING` profiles, the bitrate may be different from your settings due to network self-adaptation.
        		     - In scenarios requiring high-quality audio, for example, a music teaching scenario, we recommend setting profile as AUDIO_PROFILE_MUSIC_HIGH_QUALITY (4) and  scenario as AUDIO_SCENARIO_GAME_STREAMING (3).

        		     :type profile: int
        :param profile: Sets the sample rate, bitrate, encoding mode, and the number of channels. See #AUDIO_PROFILE_TYPE.
            		 :type scenario: int
        :param scenario: Sets the audio application scenario. See #AUDIO_SCENARIO_TYPE.
            		     Under different audio scenarios, the device uses different volume tracks,
            		     i.e. either the in-call volume or the media volume. For details, see
            		     [What is the difference between the in-call volume and the media volume?](https://docs.agora.io/en/faq/system_volume).

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_setAudioProfile(self, profile, scenario)

    def muteLocalAudioStream(self, mute: "bool") -> "int":
        r"""
         Stops/Resumes sending the local audio stream.

        		     A successful 'muteLocalAudioStream' method call triggers the 'onUserMuteAudio' callback on the remote client.
        		     Notes: 
        		     - When ``mute`` is set as ``true``, this method does not disable the microphone, which does not affect any ongoing recording.
        		     - If you call 'setChannelProfile' after this method, the SDK resets whether or not to mute the local audio according to the channel profile and user role. Therefore, we recommend calling this method after the `setChannelProfile` method.

        		     :type mute: boolean
        :param mute: Sets whether to send/stop sending the local audio stream:
            		     - true: Stops sending the local audio stream.
            		     - false: (Default) Sends the local audio stream.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_muteLocalAudioStream(self, mute)

    def muteAllRemoteAudioStreams(self, mute: "bool") -> "int":
        r"""
         Stops/Resumes receiving all remote users' audio streams.

        		     :type mute: boolean
        :param mute: Sets whether to receive/stop receiving all remote users' audio streams.
            		     - true: Stops receiving all remote users' audio streams.
            		     - false: (Default) Receives all remote users' audio streams.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_muteAllRemoteAudioStreams(self, mute)

    def setDefaultMuteAllRemoteVideoStreams(self, mute: "bool") -> "int":
        r"""
         Stops/Resumes receiving all remote users' audio streams by default.

        		     You can call this method either before or after joining a channel. If you call `setDefaultMuteAllRemoteAudioStreams (true)` after joining a channel, the remote audio streams of all subsequent users are not received.

        		     Notes: If you want to resume receiving the audio stream, call 'muteRemoteAudioStream (false)',
        		     and specify the ID of the remote user whose audio stream you want to receive.
        		     To receive the audio streams of multiple remote users, call `muteRemoteAudioStream (false)` as many times.
        		     Calling `setDefaultMuteAllRemoteAudioStreams (false)` resumes receiving the audio streams of subsequent users only.

        		     :type mute: boolean
        :param mute: Sets whether to receive/stop receiving all remote users' audio streams by default:
            		     - true:  Stops receiving all remote users' audio streams by default.
            		     - false: (Default) Receives all remote users' audio streams by default.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_setDefaultMuteAllRemoteVideoStreams(self, mute)

    def adjustUserPlaybackSignalVolume(self, uid: "unsigned int", volume: "int") -> "int":
        r"""
         Adjusts the playback volume of a specified remote user.

        		     You can call this method as many times as necessary to adjust the playback volume of different remote users, or to repeatedly adjust the playback volume of the same remote user.

        		     Notes: 
        		     - Call this method after joining a channel.
        		     - The playback volume here refers to the mixed volume of a specified remote user.
        		     - This method can only adjust the playback volume of one specified remote user at a time. To adjust the playback volume of different remote users, call the method as many times, once for each remote user.

        		     :type uid: int
        :param uid: The ID of the remote user.
            		 :type volume: int
        :param volume: The playback volume of the specified remote user. The value ranges from 0 to 100:
            		     - 0: Mute.
            		     - 100: Original volume.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_adjustUserPlaybackSignalVolume(self, uid, volume)

    def muteRemoteAudioStream(self, userId: "agora::rtc::uid_t", mute: "bool") -> "int":
        r"""
         Stops/Resumes receiving a specified remote user's audio stream.

        		     Notes: If you called the 'muteAllRemoteAudioStreams' method and set ``mute`` as ``true`` to stop receiving all remote users' audio streams, call the *muteAllRemoteAudioStreams* method and set ``mute`` as ``false`` before calling this method. The *muteAllRemoteAudioStreams* method sets all remote audio streams, while the *muteRemoteAudioStream* method sets a specified remote audio stream.

        		     :type userId: int
        :param userId: User ID of the specified remote user sending the audio.
            		 :type mute: boolean
        :param mute: Sets whether to receive/stop receiving a specified remote user's audio stream:
            		     - true: Stops receiving the specified remote user's audio stream.
            		     - false: (Default) Receives the specified remote user's audio stream.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_muteRemoteAudioStream(self, userId, mute)

    def muteLocalVideoStream(self, mute: "bool") -> "int":
        r"""
         Stops/Resumes sending the local video stream.

        		     A successful 'muteLocalVideoStream' method call triggers the 'onUserMuteVideo' callback on the remote client.

        		     Notes: 
        		     - When set to *true*, this method does not disable the camera which does not affect the retrieval of the local video streams. This method executes faster than the 'enableLocalVideo' method which controls the sending of the local video stream.
        		     - If you call 'setChannelProfile' after this method, the SDK resets whether or not to mute the local video according to the channel profile and user role. Therefore, we recommend calling this method after the `setChannelProfile` method.

        		     :type mute: boolean
        :param mute: Sets whether to send/stop sending the local video stream:
            		     - true: Stop sending the local video stream.
            		     - false: (Default) Send the local video stream.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_muteLocalVideoStream(self, mute)

    def enableLocalVideo(self, enabled: "bool") -> "int":
        r"""
         Enables/Disables the local video capture.

        		     This method disables or re-enables the local video capturer, and does not affect receiving the remote video stream.

        		     After you call the 'enableVideo' method, the local video capturer is enabled by default. You can call 'enableLocalVideo(false)' to disable the local video capturer. If you want to re-enable it, call 'enableLocalVideo(true)'.

        		     After the local video capturer is successfully disabled or re-enabled, the SDK triggers the 'onUserEnableLocalVideo' callback on the remote client.

        		     Notes: This method affects the internal engine and can be called after the 'leaveChannel' method.

        		     :type enabled: boolean
        :param enabled: Sets whether to disable/re-enable the local video, including the capturer, renderer, and sender:
            		     - true: (Default) Re-enable the local video.
            		     - false: Disable the local video. Once the local video is disabled, the remote users can no longer receive the video stream of this user, while this user can still receive the video streams of the other remote users.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_enableLocalVideo(self, enabled)

    def muteAllRemoteVideoStreams(self, mute: "bool") -> "int":
        r"""
         Stops/Resumes receiving all video stream from a specified remote user.

        		     :type mute: boolean
        :param mute: Sets whether to receive/stop receiving all remote users' video streams:
            		     - true: Stop receiving all remote users' video streams.
            		     - false: (Default) Receive all remote users' video streams.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_muteAllRemoteVideoStreams(self, mute)

    def setDefaultMuteAllRemoteAudioStreams(self, mute: "bool") -> "int":
        r"""
         Stops/Resumes receiving all remote users' video streams by default.

        		     You can call this method either before or after joining a channel. If you call `setDefaultMuteAllRemoteVideoStreams (true)` after joining a channel, the remote video streams of all subsequent users are not received.

        		     Notes: If you want to resume receiving the video stream, call 'muteRemoteVideoStream (false)', and specify the ID of the remote user whose video stream you want to receive. To receive the video streams of multiple remote users, call `muteRemoteVideoStream (false)` as many times. Calling `setDefaultMuteAllRemoteVideoStreams (false)` resumes receiving the video streams of subsequent users only.

        		     :type mute: boolean
        :param mute: Sets whether to receive/stop receiving all remote users' video streams by default:
            		     - true: Stop receiving all remote users' video streams by default.
            		     - false: (Default) Receive all remote users' video streams by default.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_setDefaultMuteAllRemoteAudioStreams(self, mute)

    def muteRemoteVideoStream(self, userId: "agora::rtc::uid_t", mute: "bool") -> "int":
        r"""
         Stops/Resumes receiving the video stream from a specified remote user.

        		     Notes: If you called the 'muteAllRemoteVideoStreams' method and set ``mute`` as ``true`` to stop receiving all remote video streams, call the *muteAllRemoteVideoStreams* method and set ``mute`` as ``false`` before calling this method.

        		     :type userId: int
        :param userId: User ID of the specified remote user.
            		 :type mute: boolean
        :param mute: Sets whether to stop/resume receiving the video stream from a specified remote user:
            		     - true: Stop receiving the specified remote user's video stream.
            		     - false: (Default) Receive the specified remote user's video stream.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_muteRemoteVideoStream(self, userId, mute)

    def setRemoteVideoStreamType(self, userId: "agora::rtc::uid_t", streamType: "agora::rtc::REMOTE_VIDEO_STREAM_TYPE") -> "int":
        r"""
         Sets the stream type of the remote video.

        		     Under limited network conditions, if the publisher has not disabled the dual-stream mode using `enableDualStreamMode(false)`,
        		     the receiver can choose to receive either the high-quality video stream (the high resolution, and high bitrate video stream) or
        		     the low-video stream (the low resolution, and low bitrate video stream).

        		     By default, users receive the high-quality video stream. Call this method if you want to switch to the low-video stream.
        		     This method allows the app to adjust the corresponding video stream type based on the size of the video window to
        		     reduce the bandwidth and resources.

        		     The aspect ratio of the low-video stream is the same as the high-quality video stream. Once the resolution of the high-quality video
        		     stream is set, the system automatically sets the resolution, frame rate, and bitrate of the low-video stream.

        		     The method result returns in the 'onApiCallExecuted' callback.

        		     :type userId: int
        :param userId: ID of the remote user sending the video stream.
            		 :type streamType: int
        :param streamType:  Sets the video-stream type. See #REMOTE_VIDEO_STREAM_TYPE.
            		 :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_setRemoteVideoStreamType(self, userId, streamType)

    def setRemoteDefaultVideoStreamType(self, streamType: "agora::rtc::REMOTE_VIDEO_STREAM_TYPE") -> "int":
        r"""
         Sets the default stream type of remote videos.

        		     Under limited network conditions, if the publisher has not disabled the dual-stream mode using `enableDualStreamMode(false)`,
        		     the receiver can choose to receive either the high-quality video stream (the high resolution, and high bitrate video stream) or
        		     the low-video stream (the low resolution, and low bitrate video stream).

        		     By default, users receive the high-quality video stream. Call this method if you want to switch to the low-video stream.
        		     This method allows the app to adjust the corresponding video stream type based on the size of the video window to
        		     reduce the bandwidth and resources. The aspect ratio of the low-video stream is the same as the high-quality video stream.
        		     Once the resolution of the high-quality video
        		     stream is set, the system automatically sets the resolution, frame rate, and bitrate of the low-video stream.

        		     The method result returns in the 'onApiCallExecuted' callback.

        		     :type streamType: int
        :param streamType: Sets the default video-stream type. See #REMOTE_VIDEO_STREAM_TYPE.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_setRemoteDefaultVideoStreamType(self, streamType)

    def enableAudioVolumeIndication(self, interval: "int", smooth: "int", report_vad: "bool") -> "int":
        r"""
         Enables the 'onAudioVolumeIndication' callback at a set time interval to report on which users are speaking and the speakers' volume.

        		     Once this method is enabled, the SDK returns the volume indication in the 'onAudioVolumeIndication' callback at the set time interval, whether or not any user is speaking in the channel.

        		     :type interval: int
        :param interval: Sets the time interval between two consecutive volume indications:
            		     - <= 0: Disables the volume indication.
            		     - > 0: Time interval (ms) between two consecutive volume indications. We recommend setting ``interval`` > 200 ms. Do not set ``interval`` < 10 ms, or the *onAudioVolumeIndication* callback will not be triggered.
            		 :type smooth: int
        :param smooth:  Smoothing factor sets the sensitivity of the audio volume indicator. The value ranges between 0 and 10. The greater the value, the more sensitive the indicator. The recommended value is 3.
            		 :type report_vad: boolean
        :param report_vad:

        		     - true: Enable the voice activity detection of the local user. Once it is enabled, the `vad` parameter of the `onAudioVolumeIndication` callback reports the voice activity status of the local user.
        		     - false: (Default) Disable the voice activity detection of the local user. Once it is disabled, the `vad` parameter of the `onAudioVolumeIndication` callback does not report the voice activity status of the local user, except for the scenario where the engine automatically detects the voice activity of the local user.
        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_enableAudioVolumeIndication(self, interval, smooth, report_vad)

    def startAudioRecording(self, *args) -> "int":
        r"""
        *Overload 1:*
         Deprecated: Starts an audio recording.

        		     Use 'IRtcEngine::startAudioRecording(const' char* filePath, int sampleRate, AUDIO_RECORDING_QUALITY_TYPE quality) "startAudioRecording"2 instead.

        		     The SDK allows recording during a call. Supported formats:

        		     - .wav: Large file size with high fidelity.
        		     - .aac: Small file size with low fidelity.

        		     This method has a fixed sample rate of 32 kHz.

        		     Ensure that the directory to save the recording file exists and is writable.
        		     This method is usually called after the 'joinChannel' method.
        		     The recording automatically stops when the 'leaveChannel' method is called.

        		     :type filePath: string
        :param filePath: Pointer to the absolute file path of the recording file. The string of the file name is in UTF-8.
            		 :type quality: int
        :param quality: Sets the audio recording quality. See #AUDIO_RECORDING_QUALITY_TYPE.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.

        |

        *Overload 2:*
         Starts an audio recording on the client.

        The SDK allows recording during a call. After successfully calling this method, you can record the audio of all the users in the channel and get an audio recording file.
        Supported formats of the recording file are as follows:
        - .wav: Large file size with high fidelity.
        - .aac: Small file size with low fidelity.

        Notes: 
        - Ensure that the directory you use to save the recording file exists and is writable.
        - This method is usually called after the `joinChannel` method. The recording automatically stops when you call the `leaveChannel` method.
        - For better recording effects, set quality as #AUDIO_RECORDING_QUALITY_MEDIUM or #AUDIO_RECORDING_QUALITY_HIGH when `sampleRate` is 44.1 kHz or 48 kHz.

        :type filePath: string
        :param filePath: Pointer to the absolute file path of the recording file. The string of the file name is in UTF-8, such as c:/music/audio.aac.
        :type sampleRate: int
        :param sampleRate: Sample rate (kHz) of the recording file. Supported values are as follows:
            - 16
            - (Default) 32
            - 44.1
            - 48
        :type quality: int
        :param quality: Sets the audio recording quality. See #AUDIO_RECORDING_QUALITY_TYPE.

        :rtype: int
        :return: 
            - 0: Success.
            - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_startAudioRecording(self, *args)

    def stopAudioRecording(self) -> "int":
        r"""
         Stops an audio recording on the client.

        		     You can call this method before calling the 'leaveChannel' method else, the recording automatically stops when the 'leaveChannel' method is called.

        		     :rtype: int
        :return: 
            		     - 0: Success
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_stopAudioRecording(self)

    def setRemoteVoicePosition(self, uid: "agora::rtc::uid_t", pan: "double", gain: "double") -> "int":
        r"""
         Sets the sound position and gain of a remote user.

        		     When the local user calls this method to set the sound position of a remote user, the sound difference between the left and right channels allows the local user to track the real-time position of the remote user, creating a real sense of space. This method applies to massively multiplayer online games, such as Battle Royale games.

        		     Notes: 
        		     - For this method to work, enable stereo panning for remote users by calling the 'enableSoundPositionIndication' method before joining a channel.
        		     - This method requires hardware support. For the best sound positioning, we recommend using a stereo speaker.

        		     :type uid: int
        :param uid: The ID of the remote user.
            		 :type pan: float
        :param pan: The sound position of the remote user. The value ranges from -1.0 to 1.0:
            		     - 0.0: the remote sound comes from the front.
            		     - -1.0: the remote sound comes from the left.
            		     - 1.0: the remote sound comes from the right.
            		 :type gain: float
        :param gain: Gain of the remote user. The value ranges from 0.0 to 100.0. The default value is 100.0 (the original gain of the remote user). The smaller the value, the less the gain.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_setRemoteVoicePosition(self, uid, pan, gain)

    def setLogFile(self, file: "char const *") -> "int":
        r"""
         Sets the log files that the SDK outputs.

        By default, the SDK outputs five log files, `agorasdk.log`, `agorasdk_1.log`, `agorasdk_2.log`, `agorasdk_3.log`, `agorasdk_4.log`, each with a default size of 1024 KB.
        These log files are encoded in UTF-8. The SDK writes the latest logs in `agorasdk.log`. When `agorasdk.log` is full, the SDK deletes the log file with the earliest
        modification time among the other four, renames `agorasdk.log` to the name of the deleted log file, and create a new `agorasdk.log` to record latest logs.

        Notes: Ensure that you call this method immediately after calling 'initialize' , otherwise the output logs may not be complete.

        See also: 'setLogFileSize'
        See also: 'setLogFilter'

        :param filePath: The absolute path of log files. The default file path is `C: <user_name><process_name>.log`.
            Ensure that the directory for the log files exists and is writable. You can use this parameter to rename the log files.

        :rtype: int
        :return: 
            - 0: Success.
            - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_setLogFile(self, file)

    def setLogFilter(self, filter: "unsigned int") -> "int":
        r"""
         Sets the output log level of the SDK.

        		     You can use one or a combination of the log filter levels. The log level follows the sequence of OFF, CRITICAL, ERROR, WARNING, INFO, and DEBUG. Choose a level to see the logs preceding that level.

        		     If you set the log level to WARNING, you see the logs within levels CRITICAL, ERROR, and WARNING.

        		     See also: 'setLogFile'
        		     See also: 'setLogFileSize'

        		     :type filter: int
        :param filter: Sets the log filter level. See #LOG_FILTER_TYPE.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_setLogFilter(self, filter)

    def setLogFileSize(self, fileSizeInKBytes: "unsigned int") -> "int":
        r"""
         Sets the size of a log file that the SDK outputs.

        By default, the SDK outputs five log files, `agorasdk.log`, `agorasdk_1.log`, `agorasdk_2.log`, `agorasdk_3.log`, `agorasdk_4.log`, each with a default size of 1024 KB.
        These log files are encoded in UTF-8. The SDK writes the latest logs in `agorasdk.log`. When `agorasdk.log` is full, the SDK deletes the log file with the earliest
        modification time among the other four, renames `agorasdk.log` to the name of the deleted log file, and create a new `agorasdk.log` to record latest logs.

        See also: 'setLogFile'
        See also: 'setLogFilter'

        :type fileSizeInKBytes: int
        :param fileSizeInKBytes: The size (KB) of a log file. The default value is 1024 KB. If you set `fileSizeInKByte` to 1024 KB,
            the SDK outputs at most 5 MB log files; if you set it to less than 1024 KB, the maximum size of a log file is still 1024 KB.

        :rtype: int
        :return: 
            - 0: Success.
            - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_setLogFileSize(self, fileSizeInKBytes)

    def setLocalRenderMode(self, *args) -> "int":
        r"""
        *Overload 1:*

        		     Deprecated: This method is deprecated, use the 'IRtcEngine::setLocalRenderMode(RENDER_MODE_TYPE' renderMode, VIDEO_MIRROR_MODE_TYPE mirrorMode) "setLocalRenderMode"2 method instead.
        		     Sets the local video display mode.

        		     This method can be called multiple times during a call to change the display mode.

        		     :type renderMode: int
        :param renderMode:  Sets the local video display mode. See #RENDER_MODE_TYPE.
            		 :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.

        |

        *Overload 2:*
         Updates the display mode of the local video view.

        		     Since: v3.0.0

        		     After initializing the local video view, you can call this method to update its rendering and mirror modes. It affects only the video view that the local user sees, not the published local video stream.

        		     Notes: 
        		     - Ensure that you have called the 'setupLocalVideo' method to initialize the local video view before calling this method.
        		     - During a call, you can call this method as many times as necessary to update the display mode of the local video view.
        		     :type renderMode: int
        :param renderMode: The rendering mode of the local video view. See #RENDER_MODE_TYPE.
            		 :type mirrorMode: int
        :param mirrorMode:
            		     - The mirror mode of the local video view. See #VIDEO_MIRROR_MODE_TYPE.
            		     - **Note**: If you use a front camera, the SDK enables the mirror mode by default; if you use a rear camera, the SDK disables the mirror mode by default.
            		 :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_setLocalRenderMode(self, *args)

    def setRemoteRenderMode(self, *args) -> "int":
        r"""
        *Overload 1:*

        		     Deprecated: This method is deprecated, use the 'IRtcEngine::setRemoteRenderMode(uid_t' userId, RENDER_MODE_TYPE renderMode, VIDEO_MIRROR_MODE_TYPE mirrorMode) "setRemoteRenderMode"2 method instead.
        		     Sets the video display mode of a specified remote user.

        		     This method can be called multiple times during a call to change the display mode.

        		     :type userId: int
        :param userId: ID of the remote user.
            		 :type renderMode: int
        :param renderMode:  Sets the video display mode. See #RENDER_MODE_TYPE.
            		 :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.

        |

        *Overload 2:*
         Updates the display mode of the video view of a remote user.

        		     Since: v3.0.0
        		     After initializing the video view of a remote user, you can call this method to update its rendering and mirror modes. This method affects only the video view that the local user sees.

        		     Notes: 
        		     - Ensure that you have called the 'setupRemoteVideo' method to initialize the remote video view before calling this method.
        		     - During a call, you can call this method as many times as necessary to update the display mode of the video view of a remote user.

        		     :type userId: int
        :param userId: The ID of the remote user.
            		 :type renderMode: int
        :param renderMode: The rendering mode of the remote video view. See #RENDER_MODE_TYPE.
            		 :type mirrorMode: int
        :param mirrorMode:
            		     - The mirror mode of the remote video view. See #VIDEO_MIRROR_MODE_TYPE.
            		     - **Note**: The SDK disables the mirror mode by default.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_setRemoteRenderMode(self, *args)

    def setLocalVideoMirrorMode(self, mirrorMode: "agora::rtc::VIDEO_MIRROR_MODE_TYPE") -> "int":
        r"""
        		     Deprecated: This method is deprecated, use the 'setupLocalVideo'
        		     or 'IRtcEngine::setLocalRenderMode(RENDER_MODE_TYPE' renderMode, VIDEO_MIRROR_MODE_TYPE mirrorMode) "setLocalRenderMode" method instead.

        		     Sets the local video mirror mode.

        		     You must call this method before calling the 'startPreview' method, otherwise the mirror mode will not work.

        		     Warning: 
        		     - Call this method after calling the 'setupLocalVideo' method to initialize the local video view.
        		     - During a call, you can call this method as many times as necessary to update the mirror mode of the local video view.

        		     :type mirrorMode: int
        :param mirrorMode: Sets the local video mirror mode. See #VIDEO_MIRROR_MODE_TYPE.
            		 :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_setLocalVideoMirrorMode(self, mirrorMode)

    def enableDualStreamMode(self, enabled: "bool") -> "int":
        r"""
         Sets the stream mode to the single-stream (default) or dual-stream mode. (`LIVE_BROADCASTING` only.)

        		     If the dual-stream mode is enabled, the receiver can choose to receive the high stream (high-resolution and high-bitrate video stream), or the low stream (low-resolution and low-bitrate video stream).

        		     :type enabled: boolean
        :param enabled: Sets the stream mode:
            		     - true: Dual-stream mode.
            		     - false: Single-stream mode.
        """
        return _agorartc.RtcEngineBridge_enableDualStreamMode(self, enabled)

    def adjustRecordingSignalVolume(self, volume: "int") -> "int":
        r"""
         Adjusts the recording volume.

        		     :type volume: int
        :param volume: Recording volume. To avoid echoes and
            		     improve call quality, Agora recommends setting the value of volume between
            		     0 and 100. If you need to set the value higher than 100, contact
            		     support.io first.
            		     - 0: Mute.
            		     - 100: Original volume.


        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_adjustRecordingSignalVolume(self, volume)

    def adjustPlaybackSignalVolume(self, volume: "int") -> "int":
        r"""
         Adjusts the playback volume of all remote users.

        		     Notes: 
        		     - This method adjusts the playback volume that is the mixed volume of all remote users.
        		     - (Since v2.3.2) To mute the local audio playback, call both the `adjustPlaybackSignalVolume` and 'adjustAudioMixingVolume' methods and set the volume as `0`.

        		     :type volume: int
        :param volume: The playback volume of all remote users. To avoid echoes and
            		     improve call quality, Agora recommends setting the value of volume between
            		     0 and 100. If you need to set the value higher than 100, contact
            		     support.io first.
            		     - 0: Mute.
            		     - 100: Original volume.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_adjustPlaybackSignalVolume(self, volume)

    def enableWebSdkInteroperability(self, enabled: "bool") -> "int":
        r"""
        		     Deprecated: This method is deprecated. As of v3.0.0, the Native SDK automatically enables interoperability with the Web SDK, so you no longer need to call this method.
        		     Enables interoperability with the Agora Web SDK.

        		     Notes: 
        		     - This method applies only to the `LIVE_BROADCASTING` profile. In the `COMMUNICATION` profile, interoperability with the Agora Web SDK is enabled by default.
        		     - If the channel has Web SDK users, ensure that you call this method, or the video of the Native user will be a black screen for the Web user.

        		     :type enabled: boolean
        :param enabled: Sets whether to enable/disable interoperability with the Agora Web SDK:
            		     - true: Enable.
            		     - false: (Default) Disable.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_enableWebSdkInteroperability(self, enabled)

    def setVideoQualityParameters(self, preferFrameRateOverImageQuality: "bool") -> "int":
        r"""
        DEPRECATED** Sets the preferences for the high-quality video. (`LIVE_BROADCASTING` only).

        		     This method is deprecated as of v2.4.0.

        		     :type preferFrameRateOverImageQuality: boolean
        :param preferFrameRateOverImageQuality: Sets the video quality preference:
            		     - true: Frame rate over image quality.
            		     - false: (Default) Image quality over frame rate.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_setVideoQualityParameters(self, preferFrameRateOverImageQuality)

    def setLocalPublishFallbackOption(self, option: "agora::rtc::STREAM_FALLBACK_OPTIONS") -> "int":
        r"""
         Sets the fallback option for the published video stream based on the network conditions.

        		     If `option` is set as #STREAM_FALLBACK_OPTION_AUDIO_ONLY (2), the SDK will:

        		     - Disable the upstream video but enable audio only when the network conditions deteriorate and cannot support both video and audio.
        		     - Re-enable the video when the network conditions improve.

        		     When the published video stream falls back to audio only or when the audio-only stream switches back to the video, the SDK triggers the 'onLocalPublishFallbackToAudioOnly' callback.

        		     Notes: Agora does not recommend using this method for CDN live streaming, because the remote CDN live user will have a noticeable lag when the published video stream falls back to audio only.

        		     :type option: int
        :param option: Sets the fallback option for the published video stream:
            		     - #STREAM_FALLBACK_OPTION_DISABLED (0): (Default) No fallback behavior for the published video stream when the uplink network condition is poor. The stream quality is not guaranteed.
            		     - #STREAM_FALLBACK_OPTION_AUDIO_ONLY (2): The published video stream falls back to audio only when the uplink network condition is poor.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_setLocalPublishFallbackOption(self, option)

    def setRemoteSubscribeFallbackOption(self, option: "agora::rtc::STREAM_FALLBACK_OPTIONS") -> "int":
        r"""
         Sets the fallback option for the remotely subscribed video stream based on the network conditions.

        		     The default setting for `option` is #STREAM_FALLBACK_OPTION_VIDEO_STREAM_LOW (1), where the remotely subscribed video stream falls back to the low-stream video (low resolution and low bitrate) under poor downlink network conditions.

        		     If `option` is set as #STREAM_FALLBACK_OPTION_AUDIO_ONLY (2), the SDK automatically switches the video from a high-stream to a low-stream, or disables the video when the downlink network conditions cannot support both audio and video to guarantee the quality of the audio. The SDK monitors the network quality and restores the video stream when the network conditions improve.

        		     When the remotely subscribed video stream falls back to audio only or when the audio-only stream switches back to the video stream, the SDK triggers the 'onRemoteSubscribeFallbackToAudioOnly' callback.

        		     :type option: int
        :param option:  Sets the fallback option for the remotely subscribed video stream. See #STREAM_FALLBACK_OPTIONS.
            		 :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_setRemoteSubscribeFallbackOption(self, option)

    def rate(self, callId: "char const *", rating: "int", description: "char const *") -> "int":
        r"""
         Allows a user to rate a call after the call ends.

        		     :type callId: string
        :param callId: Pointer to the ID of the call, retrieved from the 'getCallId' method.
            		 :type rating: int
        :param rating:  Rating of the call. The value is between 1 (lowest score) and 5 (highest score). If you set a value out of this range, the #ERR_INVALID_ARGUMENT (2) error returns.
            		 :type description: string
        :param description: (Optional) Pointer to the description of the rating, with a string length of less than 800 bytes.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_rate(self, callId, rating, description)

    def complain(self, callId: "char const *", description: "char const *") -> "int":
        r"""
         Allows a user to complain about the call quality after a call ends.

        		    :type callId: string
        :param callId: Pointer to the ID of the call, retrieved from the 'getCallId' method.
            		:type description: string
        :param description: (Optional) Pointer to the description of the complaint, with a string length of less than 800 bytes.

        		    :rtype: int
        :return: 
            		    - 0: Success.
            		    - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_complain(self, callId, description)

    def getVersion(self) -> "char const *":
        r"""
         Retrieves the SDK version number.

        		     :param build: Pointer to the build number.
            		 :rtype: string
        :return: The version of the current SDK in the string format. For example, 2.3.1.
        """
        return _agorartc.RtcEngineBridge_getVersion(self)

    def enableLastmileTest(self) -> "int":
        r"""
          Enables the network connection quality test.

        		     This method tests the quality of the users' network connections and is disabled by default.

        		     Before a user joins a channel or before an audience switches to a host, call this method to check the uplink network quality.

        		     This method consumes additional network traffic, and hence may affect communication quality.

        		     Call the 'disableLastmileTest' method to disable this test after receiving the 'onLastmileQuality' callback, and before joining a channel.

        		     Notes: 
        		     - Do not call any other methods before receiving the 'onLastmileQuality' callback. Otherwise, the callback may be interrupted by other methods, and hence may not be triggered.
        		     - A host should not call this method after joining a channel (when in a call).
        		     - If you call this method to test the last-mile quality, the SDK consumes the bandwidth of a video stream, whose bitrate corresponds to the bitrate you set in the 'setVideoEncoderConfiguration' method. After you join the channel, whether you have called the `disableLastmileTest` method or not, the SDK automatically stops consuming the bandwidth.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_enableLastmileTest(self)

    def disableLastmileTest(self) -> "int":
        r"""
         Disables the network connection quality test.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_disableLastmileTest(self)

    def startLastmileProbeTest(self, config: "LastmileProbeConfig") -> "int":
        r"""
         Starts the last-mile network probe test.

        		     This method starts the last-mile network probe test before joining a channel to get the uplink and downlink last-mile network statistics, including the bandwidth, packet loss, jitter, and round-trip time (RTT).

        		     Call this method to check the uplink network quality before users join a channel or before an audience switches to a host.
        		     Once this method is enabled, the SDK returns the following callbacks:
        		     - 'onLastmileQuality': the SDK triggers this callback within two seconds depending on the network conditions. This callback rates the network conditions and is more closely linked to the user experience.
        		     - 'onLastmileProbeResult': the SDK triggers this callback within 30 seconds depending on the network conditions. This callback returns the real-time statistics of the network conditions and is more objective.

        		     Notes: 
        		     - This method consumes extra network traffic and may affect communication quality. We do not recommend calling this method together with enableLastmileTest.
        		     - Do not call other methods before receiving the 'onLastmileQuality' and 'onLastmileProbeResult' callbacks. Otherwise, the callbacks may be interrupted.
        		     - In the `LIVE_BROADCASTING` profile, a host should not call this method after joining a channel.

        		     :type config: :py:class:`LastmileProbeConfig`
        :param config: Sets the configurations of the last-mile network probe test. See LastmileProbeConfig.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_startLastmileProbeTest(self, config)

    def stopLastmileProbeTest(self) -> "int":
        r""" Stops the last-mile network probe test."""
        return _agorartc.RtcEngineBridge_stopLastmileProbeTest(self)

    def getErrorDescription(self, code: "int") -> "char const *":
        r"""
         Retrieves the warning or error description.

        		     :type code: int
        :param code: Warning code or error code returned in the 'onWarning' or 'onError' callback.

        		     :rtype: string
        :return: #WARN_CODE_TYPE or #ERROR_CODE_TYPE.
        """
        return _agorartc.RtcEngineBridge_getErrorDescription(self, code)

    def setEncryptionSecret(self, secret: "char const *") -> "int":
        r"""
        DEPRECATED** Enables built-in encryption with an encryption password before users join a channel.

        		     Deprecated as of v3.1.0. Use the 'enableEncryption' instead.

        		     All users in a channel must use the same encryption password. The encryption password is automatically cleared once a user leaves the channel.

        		     If an encryption password is not specified, the encryption functionality will be disabled.

        		     Notes: 
        		     - Do not use this method for CDN live streaming.
        		     - For optimal transmission, ensure that the encrypted data size does not exceed the original data size + 16 bytes. 16 bytes is the maximum padding size for AES encryption.

        		     :type secret: string
        :param secret: Pointer to the encryption password.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_setEncryptionSecret(self, secret)

    def setEncryptionMode(self, encryptionMode: "char const *") -> "int":
        r"""
        DEPRECATED** Sets the built-in encryption mode.

        		     Deprecated: Deprecated as of v3.1.0. Use the 'enableEncryption' instead.

        		     The Agora SDK supports built-in encryption, which is set to the ``aes-128-xts`` mode by default. Call this method to use other encryption modes.

        		     All users in the same channel must use the same encryption mode and password.

        		     Refer to the information related to the AES encryption algorithm on the differences between the encryption modes.

        		     Notes: Call the 'setEncryptionSecret' method to enable the built-in encryption function before calling this method.

        		     :type encryptionMode: string
        :param encryptionMode: Pointer to the set encryption mode:
            		     - "aes-128-xts": (Default) 128-bit AES encryption, XTS mode.
            		     - "aes-128-ecb": 128-bit AES encryption, ECB mode.
            		     - "aes-256-xts": 256-bit AES encryption, XTS mode.
            		     - "": When encryptionMode is set as NULL, the encryption mode is set as "aes-128-xts" by default.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_setEncryptionMode(self, encryptionMode)

    def registerPacketObserver(self, observer: "agora::rtc::IPacketObserver *") -> "int":
        r"""
         Registers a packet observer.

        		     The Agora SDK allows your application to register a packet observer to receive callbacks for voice or video packet transmission.

        		     Notes: 
        		     - The size of the packet sent to the network after processing should not exceed 1200 bytes, otherwise, the packet may fail to be sent.
        		     - Ensure that both receivers and senders call this method, otherwise, you may meet undefined behaviors such as no voice and black screen.
        		     - When you use CDN live streaming, recording or storage functions, Agora doesn't recommend calling this method.

        		     :type observer: agora::rtc::IPacketObserver
        :param observer: Pointer to the registered packet observer. See IPacketObserver.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_registerPacketObserver(self, observer)

    def createDataStream(self, streamId: "int *", reliable: "bool", ordered: "bool") -> "int":
        r"""
         Creates a data stream.

        		     Each user can create up to five data streams during the lifecycle of the IRtcEngine.

        		     Notes: Set both the ``reliable`` and ``ordered`` parameters to true or false. Do not set one as true and the other as false.

        		     :type streamId: int
        :param streamId: Pointer to the ID of the created data stream.
            		 :type reliable: boolean
        :param reliable: Sets whether or not the recipients are guaranteed to receive the data stream from the sender within five seconds:
            		     - true: The recipients receive the data stream from the sender within five seconds. If the recipient does not receive the data stream within five seconds, an error is reported to the application.
            		     - false: There is no guarantee that the recipients receive the data stream within five seconds and no error message is reported for any delay or missing data stream.
            		 :type ordered: boolean
        :param ordered: Sets whether or not the recipients receive the data stream in the sent order:
            		     - true: The recipients receive the data stream in the sent order.
            		     - false: The recipients do not receive the data stream in the sent order.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_createDataStream(self, streamId, reliable, ordered)

    def sendStreamMessage(self, streamId: "int", data: "char const *", length: "size_t") -> "int":
        r"""
         Sends data stream messages to all users in a channel.

        		     The SDK has the following restrictions on this method:
        		     - Up to 30 packets can be sent per second in a channel with each packet having a maximum size of 1 kB.
        		     - Each client can send up to 6 kB of data per second.
        		     - Each user can have up to five data streams simultaneously.

        		     A successful 'sendStreamMessage' method call triggers the
        		     'onStreamMessage' callback on the remote client, from which the remote user gets the stream message.

        		     A failed 'sendStreamMessage' method call triggers the
        		      'onStreamMessage' callback on the remote client.
        		     Notes: This method applies only to the `COMMUNICATION` profile or to the hosts in the `LIVE_BROADCASTING` profile. If an audience in the `LIVE_BROADCASTING` profile calls this method, the audience may be switched to a host.
        		     :type streamId: int
        :param streamId:  ID of the sent data stream, returned in the 'createDataStream' method.
            		 :type data: string
        :param data: Pointer to the sent data.
            		 :type length: int
        :param length: Length of the sent data.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_sendStreamMessage(self, streamId, data, length)

    def addPublishStreamUrl(self, url: "char const *", transcodingEnabled: "bool") -> "int":
        r"""
         Publishes the local stream to a specified CDN live RTMP address.  (CDN live only.)

        		     The SDK returns the result of this method call in the 'onStreamPublished' callback.

        		     The 'addPublishStreamUrl' method call triggers the 'onRtmpStreamingStateChanged' callback on the local client to report the state of adding a local stream to the CDN.
        		     Notes: 
        		     - Ensure that the user joins the channel before calling this method.
        		     - Ensure that you enable the RTMP Converter service before using this function. See  *Prerequisites* in the advanced guide *Push Streams to CDN*.
        		     - This method adds only one stream RTMP URL address each time it is called.
        		     - This method applies to `LIVE_BROADCASTING` only.

        		     :type url: string
        :param url: The CDN streaming URL in the RTMP format. The maximum length of this parameter is 1024 bytes. The RTMP URL address must not contain special characters, such as Chinese language characters.
            		 :type transcodingEnabled: boolean
        :param transcodingEnabled: Sets whether transcoding is enabled/disabled:
            		     - true: Enable transcoding. To [transcode](https://docs.agora.io/en/Agora%20Platform/terms?platform=All%20Platforms#transcoding) the audio or video streams when publishing them to CDN live, often used for combining the audio and video streams of multiple hosts in CDN live. If you set this parameter as `true`, ensure that you call the 'setLiveTranscoding' method before this method.
            		     - false: Disable transcoding.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
            		          - #ERR_INVALID_ARGUMENT (2): The RTMP URL address is NULL or has a string length of 0.
            		          - #ERR_NOT_INITIALIZED (7): You have not initialized the RTC engine when publishing the stream.
        """
        return _agorartc.RtcEngineBridge_addPublishStreamUrl(self, url, transcodingEnabled)

    def removePublishStreamUrl(self, url: "char const *") -> "int":
        r"""
         Removes an RTMP stream from the CDN. (CDN live only.)

        		     This method removes the RTMP URL address (added by the 'addPublishStreamUrl' method) from a CDN live stream. The SDK returns the result of this method call in the 'onStreamUnpublished' callback.

        		     The 'removePublishStreamUrl' method call triggers the 'onRtmpStreamingStateChanged' callback on the local client to report the state of removing an RTMP stream from the CDN.
        		     Notes: 
        		     - This method removes only one RTMP URL address each time it is called.
        		     - The RTMP URL address must not contain special characters, such as Chinese language characters.
        		     - This method applies to `LIVE_BROADCASTING` only.

        		     :type url: string
        :param url: The RTMP URL address to be removed. The maximum length of this parameter is 1024 bytes.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_removePublishStreamUrl(self, url)

    def setLiveTranscoding(self, transcoding: "LiveTranscoding") -> "int":
        r"""
         Sets the video layout and audio settings for CDN live. (CDN live only.)

        		     The SDK triggers the 'onTranscodingUpdated' callback when you call the `setLiveTranscoding` method to update the transcoding setting.

        		     Notes: 
        		     - This method applies to `LIVE_BROADCASTING` only.
        		     - Ensure that you enable the RTMP Converter service before using this function. See *Prerequisites* in the advanced guide *Push Streams to CDN*.
        		     - If you call the `setLiveTranscoding` method to update the transcoding setting for the first time, the SDK does not trigger the `onTranscodingUpdated` callback.

        		     :type transcoding: :py:class:`LiveTranscoding`
        :param transcoding: Sets the CDN live audio/video transcoding settings. See LiveTranscoding.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_setLiveTranscoding(self, transcoding)

    def addVideoWatermark(self, *args) -> "int":
        r"""
        *Overload 1:*
        DEPRECATED** Adds a watermark image to the local video or CDN live stream.

        		     This method is deprecated from v2.9.1. Use 'agora::rtc::IRtcEngine::addVideoWatermark(const' char* watermarkUrl, const WatermarkOptions& options) "addVideoWatermark"2 instead.

        		     This method adds a PNG watermark image to the local video stream for the recording device, channel audience, and CDN live audience to view and capture.

        		     To add the PNG file to the CDN live publishing stream, see the 'setLiveTranscoding' method.

        		     :type watermark: :py:class:`RtcImage`
        :param watermark: Pointer to the watermark image to be added to the local video stream. See RtcImage.

        		     Notes: 
        		     - The URL descriptions are different for the local video and CDN live streams:
        		        - In a local video stream, `url` in RtcImage refers to the absolute path of the added watermark image file in the local video stream.
        		        - In a CDN live stream, `url` in RtcImage refers to the URL address of the added watermark image in the CDN live streaming.
        		     - The source file of the watermark image must be in the PNG file format. If the width and height of the PNG file differ from your settings in this method, the PNG file will be cropped to conform to your settings.
        		     - The Agora SDK supports adding only one watermark image onto a local video or CDN live stream. The newly added watermark image replaces the previous one.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.

        |

        *Overload 2:*
         Adds a watermark image to the local video.

        		     This method adds a PNG watermark image to the local video in the live streaming. Once the watermark image is added, all the audience in the channel (CDN audience included),
        		     and the recording device can see and capture it. Agora supports adding only one watermark image onto the local video, and the newly watermark image replaces the previous one.

        		     The watermark position depends on the settings in the 'setVideoEncoderConfiguration' method:
        		     - If the orientation mode of the encoding video is #ORIENTATION_MODE_FIXED_LANDSCAPE, or the landscape mode in #ORIENTATION_MODE_ADAPTIVE, the watermark uses the landscape orientation.
        		     - If the orientation mode of the encoding video is #ORIENTATION_MODE_FIXED_PORTRAIT, or the portrait mode in #ORIENTATION_MODE_ADAPTIVE, the watermark uses the portrait orientation.
        		     - When setting the watermark position, the region must be less than the dimensions set in the `setVideoEncoderConfiguration` method. Otherwise, the watermark image will be cropped.

        		     Notes: 
        		     - Ensure that you have called the 'enableVideo' method to enable the video module before calling this method.
        		     - If you only want to add a watermark image to the local video for the audience in the CDN live streaming channel to see and capture, you can call this method or the 'setLiveTranscoding' method.
        		     - This method supports adding a watermark image in the PNG file format only. Supported pixel formats of the PNG image are RGBA, RGB, Palette, Gray, and Alpha_gray.
        		     - If the dimensions of the PNG image differ from your settings in this method, the image will be cropped or zoomed to conform to your settings.
        		     - If you have enabled the local video preview by calling the 'startPreview' method, you can use the `visibleInPreview` member in the WatermarkOptions class to set whether or not the watermark is visible in preview.
        		     - If you have enabled the mirror mode for the local video, the watermark on the local video is also mirrored. To avoid mirroring the watermark, Agora recommends that you do not use the mirror and watermark functions for the local video at the same time. You can implement the watermark function in your application layer.

        		     :type watermarkUrl: string
        :param watermarkUrl: The local file path of the watermark image to be added. This method supports adding a watermark image from the local absolute or relative file path.
            		 :type options: :py:class:`WatermarkOptions`
        :param options: Pointer to the watermark's options to be added. See WatermarkOptions for more infomation.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_addVideoWatermark(self, *args)

    def clearVideoWatermarks(self) -> "int":
        r"""
         Removes the watermark image from the video stream added by the 'agora::rtc::IRtcEngine::addVideoWatermark(const' char* watermarkUrl, const WatermarkOptions& options) "addVideoWatermark" method.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_clearVideoWatermarks(self)

    def setBeautyEffectOptions(self, enabled: "bool", options: "BeautyOptions") -> "int":
        r"""
         Since: v3.0.0

        		     Enables/Disables image enhancement and sets the options.

        		    Notes: 
        		    - Call this method after calling the enableVideo method.
        		    - Currently this method does not apply for macOS.

        		    :type enabled: boolean
        :param enabled: Sets whether or not to enable image enhancement:
            		    - true: enables image enhancement.
            		    - false: disables image enhancement.
            		:type options: :py:class:`BeautyOptions`
        :param options: Sets the image enhancement option. See BeautyOptions.
        """
        return _agorartc.RtcEngineBridge_setBeautyEffectOptions(self, enabled, options)

    def addInjectStreamUrl(self, url: "char const *", config: "InjectStreamConfig") -> "int":
        r"""
         Adds a voice or video stream URL address to the live streaming.

        		    The 'onStreamPublished' callback returns the inject status. If this method call is successful, the server pulls the voice or video stream and injects it into a live channel. This is applicable to scenarios where all audience members in the channel can watch a live show and interact with each other.

        		     The 'addInjectStreamUrl' method call triggers the following callbacks:
        		    - The local client:
        		      - 'onStreamInjectedStatus' , with the state of the injecting the online stream.
        		      - 'onUserJoined' (uid: 666), if the method call is successful and the online media stream is injected into the channel.
        		    - The remote client:
        		      - 'onUserJoined' (uid: 666), if the method call is successful and the online media stream is injected into the channel.

        		     Notes: 
        		     - Ensure that you enable the RTMP Converter service before using this function. See *Prerequisites* in the advanced guide *Push Streams to CDN*.
        		     - This method applies to the Native SDK v2.4.1 and later.
        		     - This method applies to the `LIVE_BROADCASTING` profile only.
        		     - You can inject only one media stream into the channel at the same time.

        		     :type url: string
        :param url: Pointer to the URL address to be added to the ongoing streaming. Valid protocols are RTMP, HLS, and HTTP-FLV.
            		     - Supported audio codec type: AAC.
            		     - Supported video codec type: H264 (AVC).
            		 :type config: :py:class:`InjectStreamConfig`
        :param config: Pointer to the InjectStreamConfig object that contains the configuration of the added voice or video stream.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
            		        - #ERR_INVALID_ARGUMENT (2): The injected URL does not exist. Call this method again to inject the stream and ensure that the URL is valid.
            		        - #ERR_NOT_READY (3): The user is not in the channel.
            		        - #ERR_NOT_SUPPORTED (4): The channel profile is not `LIVE_BROADCASTING`. Call the 'setChannelProfile' method and set the channel profile to `LIVE_BROADCASTING` before calling this method.
            		        - #ERR_NOT_INITIALIZED (7): The SDK is not initialized. Ensure that the IRtcEngine object is initialized before calling this method.
        """
        return _agorartc.RtcEngineBridge_addInjectStreamUrl(self, url, config)

    def startChannelMediaRelay(self, configuration: "ChannelMediaRelayConfiguration") -> "int":
        r"""
         Starts to relay media streams across channels.

        After a successful method call, the SDK triggers the
        'agora::rtc::IRtcEngineEventHandler::onChannelMediaRelayStateChanged'
         "onChannelMediaRelayStateChanged" and
        'agora::rtc::IRtcEngineEventHandler::onChannelMediaRelayEvent'
        "onChannelMediaRelayEvent" callbacks, and these callbacks return the
        state and events of the media stream relay.
        - If the
        'agora::rtc::IRtcEngineEventHandler::onChannelMediaRelayStateChanged'
         "onChannelMediaRelayStateChanged" callback returns
        #RELAY_STATE_RUNNING (2) and #RELAY_OK (0), and the
        'agora::rtc::IRtcEngineEventHandler::onChannelMediaRelayEvent'
        "onChannelMediaRelayEvent" callback returns
        #RELAY_EVENT_PACKET_SENT_TO_DEST_CHANNEL (4), the host starts
        sending data to the destination channel.
        - If the
        'agora::rtc::IRtcEngineEventHandler::onChannelMediaRelayStateChanged'
         "onChannelMediaRelayStateChanged" callback returns
        #RELAY_STATE_FAILURE (3), an exception occurs during the media stream
        relay.

        Notes: 
        - Call this method after the 'joinChannel' method.
        - This method takes effect only when you are a host in a
        `LIVE_BROADCASTING` channel.
        - After a successful method call, if you want to call this method
        again, ensure that you call the
        'stopChannelMediaRelay' method to quit the
        current relay.
        - Contact sales-us.io before implementing this function.
        - We do not support string user accounts in this API.

        :type configuration: :py:class:`ChannelMediaRelayConfiguration`
        :param configuration: The configuration of the media stream relay:
            ChannelMediaRelayConfiguration.

        :rtype: int
        :return: 
            - 0: Success.
            - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_startChannelMediaRelay(self, configuration)

    def updateChannelMediaRelay(self, configuration: "ChannelMediaRelayConfiguration") -> "int":
        r"""
         Updates the channels for media stream relay. After a successful
        'startChannelMediaRelay' method call, if
        you want to relay the media stream to more channels, or leave the
        current relay channel, you can call the
        'updateChannelMediaRelay' method.

        After a successful method call, the SDK triggers the
        'agora::rtc::IRtcEngineEventHandler::onChannelMediaRelayEvent'
         "onChannelMediaRelayEvent" callback with the
        #RELAY_EVENT_PACKET_UPDATE_DEST_CHANNEL (7) state code.

        Notes: 
        Call this method after the
        'startChannelMediaRelay' method to update
        the destination channel.

        :type configuration: :py:class:`ChannelMediaRelayConfiguration`
        :param configuration: The media stream relay configuration:
            ChannelMediaRelayConfiguration.

        :rtype: int
        :return: 
            - 0: Success.
            - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_updateChannelMediaRelay(self, configuration)

    def stopChannelMediaRelay(self) -> "int":
        r"""
         Stops the media stream relay.

        Once the relay stops, the host quits all the destination
        channels.

        After a successful method call, the SDK triggers the
        'agora::rtc::IRtcEngineEventHandler::onChannelMediaRelayStateChanged'
         "onChannelMediaRelayStateChanged" callback. If the callback returns
        #RELAY_STATE_IDLE (0) and #RELAY_OK (0), the host successfully
        stops the relay.

        Notes: 
        If the method call fails, the SDK triggers the
        'agora::rtc::IRtcEngineEventHandler::onChannelMediaRelayStateChanged'
         "onChannelMediaRelayStateChanged" callback with the
        #RELAY_ERROR_SERVER_NO_RESPONSE (2) or
        #RELAY_ERROR_SERVER_CONNECTION_LOST (8) state code. You can leave the
        channel by calling the 'leaveChannel' method, and
        the media stream relay automatically stops.

        :rtype: int
        :return: 
            - 0: Success.
            - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_stopChannelMediaRelay(self)

    def removeInjectStreamUrl(self, url: "char const *") -> "int":
        r"""
         Removes the voice or video stream URL address from the live streaming.

        		     This method removes the URL address (added by the 'addInjectStreamUrl' method) from the live streaming.

        		     Notes: If this method is called successfully, the SDK triggers the 'onUserOffline' callback and returns a stream uid of 666.

        		     :type url: string
        :param url: Pointer to the URL address of the injected stream to be removed.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_removeInjectStreamUrl(self, url)

    def getConnectionState(self) -> "agora::rtc::CONNECTION_STATE_TYPE":
        r"""
         Gets the current connection state of the SDK.

        		     :rtype: int
        :return: #CONNECTION_STATE_TYPE.
        """
        return _agorartc.RtcEngineBridge_getConnectionState(self)

    def setParameters(self, parameters: "char const *") -> "int":
        r"""
         Provides technical preview functionalities or special customizations by configuring the SDK with JSON options.

        		     The JSON options are not public by default. Agora is working on making commonly used JSON options public in a standard way.

        		     :type parameters: string
        :param parameters: Sets the parameter as a JSON string in the specified format.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_setParameters(self, parameters)

    def setPlaybackDeviceVolume(self, volume: "int") -> "int":
        r"""
         Sets the volume of the audio playback device.

        		     :type volume: int
        :param volume: Sets the volume of the audio playback device. The value ranges between 0 (lowest volume) and 255 (highest volume).
            		 :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_setPlaybackDeviceVolume(self, volume)

    def startAudioMixing(self, filePath: "char const *", loopback: "bool", replace: "bool", cycle: "int") -> "int":
        r"""
         Starts playing and mixing the music file.

        		     This method mixes the specified local audio file with the audio stream from the microphone, or replaces the microphone's audio stream with the specified local audio file. You can choose whether the other user can hear the local audio playback and specify the number of playback loops. This method also supports online music playback.

        		     When the audio mixing file playback finishes after calling this method, the SDK triggers the 'onAudioMixingFinished' callback.

        		     A successful 'startAudioMixing' method call triggers the 'onAudioMixingStateChanged' (PLAY) callback on the local client.

        		     When the audio mixing file playback finishes, the SDK triggers the 'onAudioMixingStateChanged' (STOPPED) callback on the local client.
        		     Notes: 
        		     - Call this method after joining a channel, otherwise issues may occur.
        		     - If the local audio mixing file does not exist, or if the SDK does not support the file format or cannot access the music file URL, the SDK returns WARN_AUDIO_MIXING_OPEN_ERROR = 701.
        		     - If you want to play an online music file, ensure that the time interval between calling this method is more than 100 ms, or the AUDIO_MIXING_ERROR_TOO_FREQUENT_CALL(702) error code occurs.
        		     :type filePath: string
        :param filePath: Pointer to the absolute path (including the suffixes of the filename) of the local or online audio file to mix, for example, c:/music/audio.mp4. Supported audio formats: 3GP, ASF, ADTS, AVI, MP3, MP4, MPEG-4, SAMI, and WAVE. For more information, see [Supported Media Formats in Media Foundation](https://docs.microsoft.com/en-us/windows/desktop/medfound/supported-media-formats-in-media-foundation).
            		 :type loopback: boolean
        :param loopback: Sets which user can hear the audio mixing:
            		     - true: Only the local user can hear the audio mixing.
            		     - false: Both users can hear the audio mixing.
            		 :type replace: boolean
        :param replace: Sets the audio mixing content:
            		     - true: Only publish the specified audio file. The audio stream from the microphone is not published.
            		     - false: The local audio file is mixed with the audio stream from the microphone.
            		 :type cycle: int
        :param cycle: Sets the number of playback loops:
            		     - Positive integer: Number of playback loops.
            		     - `-1`: Infinite playback loops.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_startAudioMixing(self, filePath, loopback, replace, cycle)

    def stopAudioMixing(self) -> "int":
        r"""
         Stops playing and mixing the music file.

        		     Call this method when you are in a channel.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_stopAudioMixing(self)

    def pauseAudioMixing(self) -> "int":
        r"""
         Pauses playing and mixing the music file.

        		     Call this method when you are in a channel.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_pauseAudioMixing(self)

    def resumeAudioMixing(self) -> "int":
        r"""
         Resumes playing and mixing the music file.

        		     Call this method when you are in a channel.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_resumeAudioMixing(self)

    def setHighQualityAudioParameters(self, fullband: "bool", stereo: "bool", fullBitrate: "bool") -> "int":
        r"""
        DEPRECATED** Agora does not recommend using this method.

        		     Sets the high-quality audio preferences. Call this method and set all parameters before joining a channel.

        		     Do not call this method again after joining a channel.

        		     :type fullband: boolean
        :param fullband: Sets whether to enable/disable full-band codec (48-kHz sample rate). Not compatible with SDK versions before v1.7.4:
            		     - true: Enable full-band codec.
            		     - false: Disable full-band codec.
            		 :type stereo: boolean
        :param stereo: Sets whether to enable/disable stereo codec. Not compatible with SDK versions before v1.7.4:
            		     - true: Enable stereo codec.
            		     - false: Disable stereo codec.
            		 :type fullBitrate: boolean
        :param fullBitrate: Sets whether to enable/disable high-bitrate mode. Recommended in voice-only mode:
            		     - true: Enable high-bitrate mode.
            		     - false: Disable high-bitrate mode.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_setHighQualityAudioParameters(self, fullband, stereo, fullBitrate)

    def adjustAudioMixingVolume(self, volume: "int") -> "int":
        r"""
         Adjusts the volume during audio mixing.

        		     Call this method when you are in a channel.

        		     Notes: Calling this method does not affect the volume of audio effect file playback invoked by the 'playEffect' method.

        		     :type volume: int
        :param volume: Audio mixing volume. The value ranges between 0 and 100 (default).

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_adjustAudioMixingVolume(self, volume)

    def adjustAudioMixingPlayoutVolume(self, volume: "int") -> "int":
        r"""
         Adjusts the audio mixing volume for local playback.

        		     Notes: Call this method when you are in a channel.

        		     :type volume: int
        :param volume: Audio mixing volume for local playback. The value ranges between 0 and 100 (default).

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_adjustAudioMixingPlayoutVolume(self, volume)

    def getAudioMixingPlayoutVolume(self) -> "int":
        r"""
         Retrieves the audio mixing volume for local playback.

        		     This method helps troubleshoot audio volume related issues.

        		     Notes: Call this method when you are in a channel.

        		     :rtype: int
        :return: 
            		     - >= 0: The audio mixing volume, if this method call succeeds. The value range is [0,100].
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_getAudioMixingPlayoutVolume(self)

    def adjustAudioMixingPublishVolume(self, volume: "int") -> "int":
        r"""
         Adjusts the audio mixing volume for publishing (for remote users).

        		     Notes: Call this method when you are in a channel.

        		     :type volume: int
        :param volume: Audio mixing volume for publishing. The value ranges between 0 and 100 (default).

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_adjustAudioMixingPublishVolume(self, volume)

    def getAudioMixingPublishVolume(self) -> "int":
        r"""
         Retrieves the audio mixing volume for publishing.

        		     This method helps troubleshoot audio volume related issues.

        		     Notes: Call this method when you are in a channel.

        		     :rtype: int
        :return: 
            		     - >= 0: The audio mixing volume for publishing, if this method call succeeds. The value range is [0,100].
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_getAudioMixingPublishVolume(self)

    def getAudioMixingDuration(self) -> "int":
        r"""
         Retrieves the duration (ms) of the music file.

        		     Call this method when you are in a channel.

        		     :rtype: int
        :return: 
            		     - >= 0: The audio mixing duration, if this method call succeeds.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_getAudioMixingDuration(self)

    def getAudioMixingCurrentPosition(self) -> "int":
        r"""
         Retrieves the playback position (ms) of the music file.

        		     Call this method when you are in a channel.

        		     :rtype: int
        :return: 
            		     - >= 0: The current playback position of the audio mixing, if this method call succeeds.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_getAudioMixingCurrentPosition(self)

    def setAudioMixingPosition(self, pos: "int") -> "int":
        r"""
         Sets the playback position of the music file to a different starting position (the default plays from the beginning).

        		     :type pos: int
        :param pos: The playback starting position (ms) of the music file.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_setAudioMixingPosition(self, pos)

    def setAudioMixingPitch(self, pitch: "int") -> "int":
        r"""
         Sets the pitch of the local music file.
        Since: v3.0.1

        When a local music file is mixed with a local human voice, call this method to set the pitch of the local music file only.

        Notes: 
        Call this method after calling `startAudioMixing`.

        :type pitch: int
        :param pitch: Sets the pitch of the local music file by chromatic scale. The default value is 0,
            which means keeping the original pitch. The value ranges from -12 to 12, and the pitch value between
            consecutive values is a chromatic value. The greater the absolute value of this parameter, the
            higher or lower the pitch of the local music file.

        :rtype: int
        :return: 
            - 0: Success.
            - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_setAudioMixingPitch(self, pitch)

    def getEffectsVolume(self) -> "int":
        r"""
         Retrieves the volume of the audio effects.

        		     The value ranges between 0.0 and 100.0.

        		     :rtype: int
        :return: 
            		     - >= 0: Volume of the audio effects, if this method call succeeds.

        		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_getEffectsVolume(self)

    def setEffectsVolume(self, volume: "int") -> "int":
        r"""
         Sets the volume of the audio effects.

        		     :type volume: int
        :param volume: Sets the volume of the audio effects. The value ranges between 0 and 100 (default).

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_setEffectsVolume(self, volume)

    def setVolumeOfEffect(self, soundId: "int", volume: "int") -> "int":
        r"""
         Sets the volume of a specified audio effect.

        		     :type soundId: int
        :param soundId: ID of the audio effect. Each audio effect has a unique ID.
            		 :type volume: int
        :param volume: Sets the volume of the specified audio effect. The value ranges between 0 and 100 (default).

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_setVolumeOfEffect(self, soundId, volume)

    def playEffect(self, soundId: "int", filePath: "char const *", loopCount: "int", pitch: "double", pan: "double", gain: "int", publish: "bool"=False) -> "int":
        r"""
         Plays a specified local or online audio effect file.

        		     This method allows you to set the loop count, pitch, pan, and gain of the audio effect file, as well as whether the remote user can hear the audio effect.

        		     To play multiple audio effect files simultaneously, call this method multiple times with different soundIds and filePaths. We recommend playing no more than three audio effect files at the same time.

        		     :type soundId: int
        :param soundId: ID of the specified audio effect. Each audio effect has a unique ID.

        		     Notes: 
        		     - If the audio effect is preloaded into the memory through the 'preloadEffect' method, the value of ``soundID`` must be the same as that in the *preloadEffect* method.
        		     - Playing multiple online audio effect files simultaneously is not supported on macOS and Windows.

        		     :type filePath: string
        :param filePath: Specifies the absolute path (including the suffixes of the filename) to the local audio effect file or the URL of the online audio effect file, for example, c:/music/audio.mp4. Supported audio formats: mp3, mp4, m4a, aac, 3gp, mkv and wav.
            		 :type loopCount: int
        :param loopCount: Sets the number of times the audio effect loops:
            		     - 0: Play the audio effect once.
            		     - 1: Play the audio effect twice.
            		     - -1: Play the audio effect in an indefinite loop until the 'stopEffect' or 'stopAllEffects' method is called.
            		 :type pitch: float
        :param pitch: Sets the pitch of the audio effect. The value ranges between 0.5 and 2. The default value is 1 (no change to the pitch). The lower the value, the lower the pitch.
            		 :type pan: float
        :param pan: Sets the spatial position of the audio effect. The value ranges between -1.0 and 1.0:
            		     - 0.0: The audio effect displays ahead.
            		     - 1.0: The audio effect displays to the right.
            		     - -1.0: The audio effect displays to the left.
            		 :type gain: int
        :param gain:  Sets the volume of the audio effect. The value ranges between 0 and 100 (default). The lower the value, the lower the volume of the audio effect.
            		 :type publish: boolean, optional
        :param publish: Sets whether or not to publish the specified audio effect to the remote stream:
            		     - true: The locally played audio effect is published to the Agora Cloud and the remote users can hear it.
            		     - false: The locally played audio effect is not published to the Agora Cloud and the remote users cannot hear it.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_playEffect(self, soundId, filePath, loopCount, pitch, pan, gain, publish)

    def stopEffect(self, soundId: "int") -> "int":
        r"""
         Stops playing a specified audio effect.

        		     :type soundId: int
        :param soundId: ID of the audio effect to stop playing. Each audio effect has a unique ID.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_stopEffect(self, soundId)

    def stopAllEffects(self) -> "int":
        r"""
         Stops playing all audio effects.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_stopAllEffects(self)

    def preloadEffect(self, soundId: "int", filePath: "char const *") -> "int":
        r"""
         Preloads a specified audio effect file into the memory.

        		     Notes: This method does not support online audio effect files.

        		     To ensure smooth communication, limit the size of the audio effect file. We recommend using this method to preload the audio effect before calling the 'joinChannel' method.

        		     Supported audio formats: mp3, aac, m4a, 3gp, and wav.

        		     :type soundId: int
        :param soundId: ID of the audio effect. Each audio effect has a unique ID.
            		 :type filePath: string
        :param filePath: Pointer to the absolute path of the audio effect file.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_preloadEffect(self, soundId, filePath)

    def unloadEffect(self, soundId: "int") -> "int":
        r"""
         Releases a specified preloaded audio effect from the memory.

        		     :type soundId: int
        :param soundId: ID of the audio effect. Each audio effect has a unique ID.
            		 :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_unloadEffect(self, soundId)

    def pauseEffect(self, soundId: "int") -> "int":
        r"""
         Pauses a specified audio effect.

        		     :type soundId: int
        :param soundId: ID of the audio effect. Each audio effect has a unique ID.
            		 :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_pauseEffect(self, soundId)

    def pauseAllEffects(self) -> "int":
        r"""
         Pauses all audio effects.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_pauseAllEffects(self)

    def resumeEffect(self, soundId: "int") -> "int":
        r"""
         Resumes playing a specified audio effect.

        		     :type soundId: int
        :param soundId: ID of the audio effect. Each audio effect has a unique ID.
            		 :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_resumeEffect(self, soundId)

    def resumeAllEffects(self) -> "int":
        r"""
         Resumes playing all audio effects.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_resumeAllEffects(self)

    def enableSoundPositionIndication(self, enabled: "bool") -> "int":
        r"""
         Enables/Disables stereo panning for remote users.

        		     Ensure that you call this method before joinChannel to enable stereo panning for remote users so that the local user can track the position of a remote user by calling 'setRemoteVoicePosition'.

        		     :type enabled: boolean
        :param enabled: Sets whether or not to enable stereo panning for remote users:
            		     - true: enables stereo panning.
            		     - false: disables stereo panning.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_enableSoundPositionIndication(self, enabled)

    def setLocalVoicePitch(self, pitch: "double") -> "int":
        r"""
         Changes the voice pitch of the local speaker.

        		     :type pitch: float
        :param pitch: Sets the voice pitch. The value ranges between 0.5 and 2.0. The lower the value, the lower the voice pitch. The default value is 1.0 (no change to the local voice pitch).
            		 :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_setLocalVoicePitch(self, pitch)

    def setLocalVoiceEqualization(self, bandFrequency: "agora::rtc::AUDIO_EQUALIZATION_BAND_FREQUENCY", bandGain: "int") -> "int":
        r"""
         Sets the local voice equalization effect.

        		     :type bandFrequency: int
        :param bandFrequency: Sets the band frequency. The value ranges between 0 and 9, representing the respective 10-band center frequencies of the voice effects, including 31, 62, 125, 500, 1k, 2k, 4k, 8k, and 16k Hz. See #AUDIO_EQUALIZATION_BAND_FREQUENCY.
            		 :type bandGain: int
        :param bandGain:  Sets the gain of each band in dB. The value ranges between -15 and 15.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_setLocalVoiceEqualization(self, bandFrequency, bandGain)

    def setLocalVoiceReverb(self, reverbKey: "agora::rtc::AUDIO_REVERB_TYPE", value: "int") -> "int":
        r"""
          Sets the local voice reverberation.

        		     v2.4.0 adds the 'setLocalVoiceReverbPreset' method, a more user-friendly method for setting the local voice reverberation. You can use this method to set the local reverberation effect, such as pop music, R&B, rock music, and hip-hop.

        		     :type reverbKey: int
        :param reverbKey: Sets the reverberation key. See #AUDIO_REVERB_TYPE.
            		 :type value: int
        :param value: Sets the value of the reverberation key.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_setLocalVoiceReverb(self, reverbKey, value)

    def setLocalVoiceChanger(self, voiceChanger: "agora::rtc::VOICE_CHANGER_PRESET") -> "int":
        r"""
         Sets the local voice changer option.

        		     This method can be used to set the local voice effect for users in a `COMMUNICATION` channel or hosts in a `LIVE_BROADCASTING` channel.
        		     Voice changer options include the following voice effects:

        		     - `VOICE_CHANGER_XXX`: Changes the local voice to an old man, a little boy, or the Hulk. Applies to the voice talk scenario.
        		     - `VOICE_BEAUTY_XXX`: Beautifies the local voice by making it sound more vigorous, resounding, or adding spacial resonance. Applies to the voice talk and singing scenario.
        		     - `GENERAL_VOICE_BEAUTY_XXX`: Adds gender-based beautification effect to the local voice. Applies to the voice talk scenario.
        		       - For a male voice: Adds magnetism to the voice.
        		       - For a female voice: Adds freshness or vitality to the voice.

        		     Notes: 
        		     - To achieve better voice effect quality, Agora recommends setting the profile parameter in `setAudioProfile` as `AUDIO_PROFILE_MUSIC_HIGH_QUALITY(4)` or `AUDIO_PROFILE_MUSIC_HIGH_QUALITY_STEREO(5)`.
        		     - This method works best with the human voice, and Agora does not recommend using it for audio containing music and a human voice.
        		     - Do not use this method with `setLocalVoiceReverbPreset`, because the method called later overrides the one called earlier. For detailed considerations, see the advanced guide *Voice Changer and Reverberation*.

        		     :type voiceChanger: int
        :param voiceChanger: Sets the local voice changer option. The default value is `VOICE_CHANGER_OFF`, which means the original voice. See details in #VOICE_CHANGER_PRESET.
            		     Gender-based beatification effect works best only when assigned a proper gender:
            		     - For male: `GENERAL_BEAUTY_VOICE_MALE_MAGNETIC`.
            		     - For female: `GENERAL_BEAUTY_VOICE_FEMALE_FRESH` or `GENERAL_BEAUTY_VOICE_FEMALE_VITALITY`.
            		     Failure to do so can lead to voice distortion.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure. Check if the enumeration is properly set.
        """
        return _agorartc.RtcEngineBridge_setLocalVoiceChanger(self, voiceChanger)

    def setLocalVoiceReverbPreset(self, reverbPreset: "agora::rtc::AUDIO_REVERB_PRESET") -> "int":
        r"""
         Sets the local voice reverberation option, including the virtual stereo.

        This method sets the local voice reverberation for users in a `COMMUNICATION` channel or hosts in a `LIVE_BROADCASTING` channel.
        After successfully calling this method, all users in the channel can hear the voice with reverberation.

        Notes: 
        - When calling this method with enumerations that begin with `AUDIO_REVERB_FX`, ensure that you set profile in `setAudioProfile` as
        `AUDIO_PROFILE_MUSIC_HIGH_QUALITY(4)` or `AUDIO_PROFILE_MUSIC_HIGH_QUALITY_STEREO(5)`; otherwise, this methods cannot set the corresponding voice reverberation option.
        - When calling this method with `AUDIO_VIRTUAL_STEREO`, Agora recommends setting the `profile` parameter in `setAudioProfile` as `AUDIO_PROFILE_MUSIC_HIGH_QUALITY_STEREO(5)`.
        - This method works best with the human voice, and Agora does not recommend using it for audio containing music and a human voice.
        - Do not use this method with `setLocalVoiceChanger`, because the method called later overrides the one called earlier.
        For detailed considerations, see the advanced guide *Voice Changer and Reverberation*.

        		     :type reverbPreset: int
        :param reverbPreset: The local voice reverberation option. The default value is `AUDIO_REVERB_OFF`,
            		     which means the original voice.  See #AUDIO_REVERB_PRESET.
            		     To achieve better voice effects, Agora recommends the enumeration whose name begins with `AUDIO_REVERB_FX`.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_setLocalVoiceReverbPreset(self, reverbPreset)

    def setExternalAudioSource(self, enabled: "bool", sampleRate: "int", channels: "int") -> "int":
        r"""
         Sets the external audio source. Please call this method before 'joinChannel'.

        		     :type enabled: boolean
        :param enabled: Sets whether to enable/disable the external audio source:
            		     - true: Enables the external audio source.
            		     - false: (Default) Disables the external audio source.
            		 :type sampleRate: int
        :param sampleRate: Sets the sample rate (Hz) of the external audio source, which can be set as 8000, 16000, 32000, 44100, or 48000 Hz.
            		 :type channels: int
        :param channels: Sets the number of audio channels of the external audio source:
            		     - 1: Mono.
            		     - 2: Stereo.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_setExternalAudioSource(self, enabled, sampleRate, channels)

    def setExternalAudioSink(self, enabled: "bool", sampleRate: "int", channels: "int") -> "int":
        r"""
         Sets the external audio sink.
        This method applies to scenarios where you want to use external audio
        data for playback. After enabling the external audio sink, you can call
        the 'pullAudioFrame' method to pull the remote audio data, process
        it, and play it with the audio effects that you want.

        Notes: 
        Once you enable the external audio sink, the app will not retrieve any
        audio data from the
        'onPlaybackAudioFrame' callback.

        :type enabled: boolean
        :param enabled:
            - true: Enables the external audio sink.
            - false: (Default) Disables the external audio sink.
        :type sampleRate: int
        :param sampleRate: Sets the sample rate (Hz) of the external audio sink, which can be set as 16000, 32000, 44100 or 48000.
        :type channels: int
        :param channels: Sets the number of audio channels of the external
            audio sink:
            - 1: Mono.
            - 2: Stereo.

        :rtype: int
        :return: 
            - 0: Success.
            - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_setExternalAudioSink(self, enabled, sampleRate, channels)

    def setRecordingAudioFrameParameters(self, sampleRate: "int", channel: "int", mode: "agora::rtc::RAW_AUDIO_FRAME_OP_MODE_TYPE", samplesPerCall: "int") -> "int":
        r"""
         Sets the audio recording format for the 'onRecordAudioFrame' callback.


        		     :type sampleRate: int
        :param sampleRate: Sets the sample rate (``samplesPerSec)`` returned in the *onRecordAudioFrame* callback, which can be set as 8000, 16000, 32000, 44100, or 48000 Hz.
            		 :type channel: int
        :param channel: Sets the number of audio channels (``channels)`` returned in the *onRecordAudioFrame* callback:
            		     - 1: Mono
            		     - 2: Stereo
            		 :type mode: int
        :param mode: Sets the use mode (see #RAW_AUDIO_FRAME_OP_MODE_TYPE) of the *onRecordAudioFrame* callback.
            		 :type samplesPerCall: int
        :param samplesPerCall: Sets the number of samples returned in the *onRecordAudioFrame* callback. `samplesPerCall` is usually set as 1024 for RTMP streaming.


        		     Notes: The SDK triggers the `onRecordAudioFrame` callback according to the sample interval. Ensure that the sample interval ≥ 0.01 (s). And, Sample interval (sec) = `samplePerCall`/(`sampleRate` × `channel`).

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_setRecordingAudioFrameParameters(self, sampleRate, channel, mode, samplesPerCall)

    def setPlaybackAudioFrameParameters(self, sampleRate: "int", channel: "int", mode: "agora::rtc::RAW_AUDIO_FRAME_OP_MODE_TYPE", samplesPerCall: "int") -> "int":
        r"""
         Sets the audio playback format for the 'onPlaybackAudioFrame' callback.


        		     :type sampleRate: int
        :param sampleRate: Sets the sample rate (``samplesPerSec)`` returned in the *onPlaybackAudioFrame* callback, which can be set as 8000, 16000, 32000, 44100, or 48000 Hz.
            		 :type channel: int
        :param channel: Sets the number of channels (``channels)`` returned in the *onPlaybackAudioFrame* callback:
            		     - 1: Mono
            		     - 2: Stereo
            		 :type mode: int
        :param mode: Sets the use mode (see #RAW_AUDIO_FRAME_OP_MODE_TYPE) of the *onPlaybackAudioFrame* callback.
            		 :type samplesPerCall: int
        :param samplesPerCall: Sets the number of samples returned in the *onPlaybackAudioFrame* callback. `samplesPerCall` is usually set as 1024 for RTMP streaming.

        		     Notes: The SDK triggers the `onPlaybackAudioFrame` callback according to the sample interval. Ensure that the sample interval ≥ 0.01 (s). And, Sample interval (sec) = `samplePerCall`/(`sampleRate` × `channel`).

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_setPlaybackAudioFrameParameters(self, sampleRate, channel, mode, samplesPerCall)

    def setMixedAudioFrameParameters(self, sampleRate: "int", samplesPerCall: "int") -> "int":
        r"""
         Sets the mixed audio format for the 'onMixedAudioFrame' callback.


        		     :type sampleRate: int
        :param sampleRate: Sets the sample rate (``samplesPerSec)`` returned in the *onMixedAudioFrame* callback, which can be set as 8000, 16000, 32000, 44100, or 48000 Hz.
            		 :type samplesPerCall: int
        :param samplesPerCall: Sets the number of samples (`samples`) returned in the *onMixedAudioFrame* callback. `samplesPerCall` is usually set as 1024 for RTMP streaming.

        		     Notes: The SDK triggers the `onMixedAudioFrame` callback according to the sample interval. Ensure that the sample interval ≥ 0.01 (s). And, Sample interval (sec) = `samplePerCall`/(`sampleRate` × `channels`).

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_setMixedAudioFrameParameters(self, sampleRate, samplesPerCall)

    def registerMediaMetadataObserver(self, observer: "agora::rtc::IMetadataObserver *", type: "agora::rtc::IMetadataObserver::METADATA_TYPE", useSdkDefault: "bool"=True) -> "int":
        r"""
         Registers the metadata observer.

        		     Registers the metadata observer. You need to implement the IMetadataObserver class and specify the metadata type in this method. A successful call of this method triggers the 'getMaxMetadataSize' callback.
        		     This method enables you to add synchronized metadata in the video stream for more diversified live interactive streaming, such as sending shopping links, digital coupons, and online quizzes.

        		     Notes: 
        		     - Call this method before the joinChannel method.
        		     - This method applies to the `LIVE_BROADCASTING` channel profile.

        		     :type observer: agora::rtc::IMetadataObserver
        :param observer: The IMetadataObserver class. See the definition of IMetadataObserver for details.
            		 :type type: agora::rtc::IMetadataObserver::METADATA_TYPE
        :param type: See 'METADATA_TYPE'. The SDK supports VIDEO_METADATA (0) only for now.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcEngineBridge_registerMediaMetadataObserver(self, observer, type, useSdkDefault)

    def sendMetadata(self, metadata: "agora::rtc::IMetadataObserver::Metadata *") -> "int":
        return _agorartc.RtcEngineBridge_sendMetadata(self, metadata)

    def __init__(self):
        _agorartc.RtcEngineBridge_swiginit(self, _agorartc.new_RtcEngineBridge())
    __swig_destroy__ = _agorartc.delete_RtcEngineBridge

# Register RtcEngineBridge in _agorartc:
_agorartc.RtcEngineBridge_swigregister(RtcEngineBridge)

class IRtcEngineEventHandler(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _agorartc.IRtcEngineEventHandler_swiginit(self, _agorartc.new_IRtcEngineEventHandler())
    __swig_destroy__ = _agorartc.delete_IRtcEngineEventHandler

# Register IRtcEngineEventHandler in _agorartc:
_agorartc.IRtcEngineEventHandler_swigregister(IRtcEngineEventHandler)

class RtcEngineEventHandlerBase(IRtcEngineEventHandler):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _agorartc.delete_RtcEngineEventHandlerBase

    def onJoinChannelSuccess(self, channel: "char const *", uid: "agora::rtc::uid_t", elapsed: "int") -> "void":
        r"""
        Occurs when a user joins a channel.

            This callback notifies the application that a user joins a specified channel when the application calls the 'joinChannel' method.

            The channel name assignment is based on ``channelName`` specified in the 'joinChannel' method.

            If the ``uid`` is not specified in the *joinChannel* method, the server automatically assigns a ``uid``.

            :type channel: string
            :param channel:  Pointer to the channel name.
            :type uid: int
            :param uid: User ID of the user joining the channel.
            :type elapsed: int
            :param elapsed: Time elapsed (ms) from the user calling the 'joinChannel' method until the SDK triggers this callback.
        """
        return _agorartc.RtcEngineEventHandlerBase_onJoinChannelSuccess(self, channel, uid, elapsed)

    def onLeaveChannel(self, stats: "RtcStats") -> "void":
        r"""
        Occurs when a user leaves the channel.

           This callback notifies the application that a user leaves the channel when the application calls the 'leaveChannel' method.

           The application retrieves information, such as the call duration and statistics.

            :type stats: :py:class:`RtcStats`
            :param stats: Pointer to the statistics of the call: RtcStats.
        """
        return _agorartc.RtcEngineEventHandlerBase_onLeaveChannel(self, stats)

    def onRejoinChannelSuccess(self, channel: "char const *", uid: "agora::rtc::uid_t", elapsed: "int") -> "void":
        r"""
        Occurs when a user rejoins the channel after disconnection due to network problems.

           When a user loses connection with the server because of network problems, the SDK automatically tries to reconnect and triggers this callback upon reconnection.

            :type channel: string
            :param channel: Pointer to the channel name.
            :type uid: int
            :param uid: User ID of the user rejoining the channel.
            :type elapsed: int
            :param elapsed: Time elapsed (ms) from starting to reconnect until the SDK triggers this callback.
        """
        return _agorartc.RtcEngineEventHandlerBase_onRejoinChannelSuccess(self, channel, uid, elapsed)

    def onUserJoined(self, uid: "agora::rtc::uid_t", elapsed: "int") -> "void":
        r"""
        Occurs when a remote user (`COMMUNICATION`)/ host (`LIVE_BROADCASTING`) joins the channel.

            - `COMMUNICATION` profile: This callback notifies the application that another user joins the channel. If other users are already in the channel, the SDK also reports to the application on the existing users.
            - `LIVE_BROADCASTING` profile: This callback notifies the application that the host joins the channel. If other hosts are already in the channel, the SDK also reports to the application on the existing hosts. We recommend limiting the number of hosts to 17.

            The SDK triggers this callback under one of the following circumstances:
            - A remote user/host joins the channel by calling the 'joinChannel' method.
            - A remote user switches the user role to the host by calling the 'setClientRole' method after joining the channel.
            - A remote user/host rejoins the channel after a network interruption.
            - The host injects an online media stream into the channel by calling the 'addInjectStreamUrl' method.

            Notes: In the `LIVE_BROADCASTING` profile:
            - The host receives this callback when another host joins the channel.
            - The audience in the channel receives this callback when a new host joins the channel.
            - When a web application joins the channel, the SDK triggers this callback as long as the web application publishes streams.

            :type uid: int
            :param uid: User ID of the user or host joining the channel.
            :type elapsed: int
            :param elapsed: Time delay (ms) from the local user calling the 'joinChannel' method until the SDK triggers this callback.
        """
        return _agorartc.RtcEngineEventHandlerBase_onUserJoined(self, uid, elapsed)

    def onClientRoleChanged(self, oldRole: "agora::rtc::CLIENT_ROLE_TYPE", newRole: "agora::rtc::CLIENT_ROLE_TYPE") -> "void":
        r"""
        Occurs when the user role switches in the live interactive streaming. For example, from a host to an audience or vice versa.

           This callback notifies the application of a user role switch when the application calls the 'setClientRole' method.

           The SDK triggers this callback when the local user switches the user role by calling the 'setClientRole' method after joining the channel.
            :type oldRole: int
            :param oldRole: Role that the user switches from: #CLIENT_ROLE_TYPE.
            :type newRole: int
            :param newRole: Role that the user switches to: #CLIENT_ROLE_TYPE.
        """
        return _agorartc.RtcEngineEventHandlerBase_onClientRoleChanged(self, oldRole, newRole)

    def onUserOffline(self, uid: "agora::rtc::uid_t", reason: "agora::rtc::USER_OFFLINE_REASON_TYPE") -> "void":
        r"""
        Occurs when a remote user (`COMMUNICATION`)/ host (`LIVE_BROADCASTING`) leaves the channel.

           Reasons why the user is offline:

           - Leave the channel: When the user/host leaves the channel, the user/host sends a goodbye message. When the message is received, the SDK assumes that the user/host leaves the channel.
           - Drop offline: When no data packet of the user or host is received for a certain period of time, the SDK assumes that the user/host drops offline. Unreliable network connections may lead to false detections, so we recommend using the Agora RTM SDK for more reliable offline detection.

            :type uid: int
            :param uid: User ID of the user leaving the channel or going offline.
            :type reason: int
            :param reason: Reason why the user is offline: #USER_OFFLINE_REASON_TYPE.
        """
        return _agorartc.RtcEngineEventHandlerBase_onUserOffline(self, uid, reason)

    def onUserMuteAudio(self, uid: "agora::rtc::uid_t", muted: "bool") -> "void":
        r"""
        Deprecated: This method is deprecated from v3.0.0, use the 'onRemoteAudioStateChanged' callback instead.

            Occurs when a remote user's audio stream playback pauses/resumes.

            The SDK triggers this callback when the remote user stops or resumes sending the audio stream by calling the 'muteLocalAudioStream' method.

            Notes: This callback does not work properly when the number of users (in the `COMMUNICATION` profile) or hosts (in the `LIVE_BROADCASTING` profile) in the channel exceeds 17.

            :type uid: int
            :param uid: User ID of the remote user.
            :type muted: boolean
            :param muted: Whether the remote user's audio stream is muted/unmuted:
                - true: Muted.
                - false: Unmuted.
        """
        return _agorartc.RtcEngineEventHandlerBase_onUserMuteAudio(self, uid, muted)

    def onFirstRemoteVideoDecoded(self, uid: "agora::rtc::uid_t", width: "int", height: "int", elapsed: "int") -> "void":
        r"""
         Occurs when the first remote video frame is received and decoded.

        Deprecated: v2.9.0

        This callback is deprecated and replaced by the
        'onRemoteVideoStateChanged' callback
        with the following parameters:
        - #REMOTE_VIDEO_STATE_STARTING (1)
        - #REMOTE_VIDEO_STATE_DECODING (2)

        This callback is triggered in either of the following scenarios:

        - The remote user joins the channel and sends the video stream.
        - The remote user stops sending the video stream and re-sends it after
        15 seconds. Reasons for such an interruption include:
         - The remote user leaves the channel.
         - The remote user drops offline.
         - The remote user calls the
        'muteLocalVideoStream'
         method to stop sending the video stream.
         - The remote user calls the
        'disableVideo' method to
        disable video.

        The application can configure the user view settings in this callback.

        :type uid: int
        :param uid: User ID of the remote user sending the video stream.
        :type width: int
        :param width: Width (px) of the video stream.
        :type height: int
        :param height: Height (px) of the video stream.
        :type elapsed: int
        :param elapsed: Time elapsed (ms) from the local user calling the
            'joinChannel' method until the SDK
            triggers this callback.
        """
        return _agorartc.RtcEngineEventHandlerBase_onFirstRemoteVideoDecoded(self, uid, width, height, elapsed)

    def onUserMuteVideo(self, uid: "agora::rtc::uid_t", muted: "bool") -> "void":
        r"""
         Occurs when a remote user's video stream playback pauses/resumes.

        You can also use the
        'onRemoteVideoStateChanged' callback
        with the following parameters:
        - #REMOTE_VIDEO_STATE_STOPPED (0) and
        #REMOTE_VIDEO_STATE_REASON_REMOTE_MUTED (5).
        - #REMOTE_VIDEO_STATE_DECODING (2) and
        #REMOTE_VIDEO_STATE_REASON_REMOTE_UNMUTED (6).

        The SDK triggers this callback when the remote user stops or resumes
        sending the video stream by calling the
        'agora::rtc::IRtcEngine::muteLocalVideoStream'
        "muteLocalVideoStream" method.

        Notes: This callback does not work properly when the number of users (in the `COMMUNICATION` profile) or hosts (in the `LIVE_BROADCASTING` profile) in the channel exceeds 17.

        :type uid: int
        :param uid: User ID of the remote user.
        :type muted: boolean
        :param muted: Whether the remote user's video stream playback is
            paused/resumed:
            - true: Paused.
            - false: Resumed.
        """
        return _agorartc.RtcEngineEventHandlerBase_onUserMuteVideo(self, uid, muted)

    def onAudioRouteChanged(self, routing: "agora::rtc::AUDIO_ROUTE_TYPE") -> "void":
        r"""
        Occurs when the local audio route changes.

            The SDK triggers this callback when the local audio route switches to an earpiece, speakerphone, headset, or Bluetooth device.

            Notes: This callback is for Android and iOS only.

            :type routing: int
            :param routing: Audio output routing. See: #AUDIO_ROUTE_TYPE.
        """
        return _agorartc.RtcEngineEventHandlerBase_onAudioRouteChanged(self, routing)

    def onConnectionLost(self) -> "void":
        r"""
        Occurs when the SDK cannot reconnect to Agora's edge server 10 seconds after its connection to the server is interrupted.

           The SDK triggers this callback when it cannot connect to the server 10 seconds after calling the 'joinChannel' method, whether or not it is in the channel.

           This callback is different from 'onConnectionInterrupted':

           - The SDK triggers the 'onConnectionInterrupted' callback when it loses connection with the server for more than four seconds after it successfully joins the channel.
           - The SDK triggers the 'onConnectionLost' callback when it loses connection with the server for more than 10 seconds, whether or not it joins the channel.

           If the SDK fails to rejoin the channel 20 minutes after being disconnected from Agora's edge server, the SDK stops rejoining the channel.
        """
        return _agorartc.RtcEngineEventHandlerBase_onConnectionLost(self)

    def onRequestToken(self) -> "void":
        r"""
        Occurs when the token expires.

            After a token is specified by calling the 'joinChannel' method, if the SDK losses connection with the Agora server due to network issues, the token may expire after a certain period of time and a new token may be required to reconnect to the server.

            This callback notifies the app to generate a new token and call joinChannel to rejoin the channel with the new token.
        """
        return _agorartc.RtcEngineEventHandlerBase_onRequestToken(self)

    def onAudioVolumeIndication(self, speakers: "AudioVolumeInfo", speakerNumber: "unsigned int", totalVolume: "int") -> "void":
        r"""
        Reports which users are speaking, the speakers' volume and whether the local user is speaking.

            This callback reports the IDs and volumes of the loudest speakers (at most 3 users) at the moment in the channel, and whether the local user is speaking.

            By default, this callback is disabled. You can enable it by calling the 'IRtcEngine::enableAudioVolumeIndication(int', int, bool) "enableAudioVolumeIndication" method.
            Once enabled, this callback is triggered at the set interval, regardless of whether a user speaks or not.

            The SDK triggers two independent `onAudioVolumeIndication` callbacks at one time, which separately report the volume information of the local user and all the remote speakers.
            For more information, see the detailed parameter descriptions.

            Notes: 
            - To enable the voice activity detection of the local user, ensure that you set `report_vad`(true) in the `enableAudioVolumeIndication` method.
            - Calling the 'muteLocalAudioStream' method affects the SDK's behavior:
               - If the local user calls the 'muteLocalAudioStream' method, the SDK stops triggering the local user's callback.
               - 20 seconds after a remote speaker calls the *muteLocalAudioStream* method, the remote speakers' callback excludes this remote user's information; 20 seconds after all remote users call the *muteLocalAudioStream* method, the SDK stops triggering the remote speakers' callback.
            - An empty ``speakers`` array in the *onAudioVolumeIndication* callback suggests that no remote user is speaking at the moment.

            :type speakers: :py:class:`AudioVolumeInfo`
            :param speakers: A pointer to AudioVolumeInfo:
                - In the local user's callback, this struct contains the following members:
                  - `uid` = 0,
                  - `volume` = `totalVolume`, which reports the sum of the voice volume and audio-mixing volume of the local user, and
                  - `vad`, which reports the voice activity status of the local user.
                - In the remote speakers' callback, this array contains the following members:
                  - `uid` of the remote speaker,
                  - `volume`, which reports the sum of the voice volume and audio-mixing volume of each remote speaker, and
                  - `vad` = 0.

              An empty speakers array in the callback indicates that no remote user is speaking at the moment.
            :type speakerNumber: int
            :param speakerNumber: Total number of speakers. The value range is [0, 3].
                - In the local user’s callback, `speakerNumber` = 1, regardless of whether the local user speaks or not.
                - In the remote speakers' callback, the callback reports the IDs and volumes of the three loudest speakers when there are more than three remote users in the channel, and `speakerNumber` = 3.
            :type totalVolume: int
            :param totalVolume: Total volume after audio mixing. The value ranges between 0 (lowest volume) and 255 (highest volume).
                - In the local user’s callback, `totalVolume` is the sum of the voice volume and audio-mixing volume of the local user.
                - In the remote speakers' callback, `totalVolume` is the sum of the voice volume and audio-mixing volume of all the remote speakers.
        """
        return _agorartc.RtcEngineEventHandlerBase_onAudioVolumeIndication(self, speakers, speakerNumber, totalVolume)

    def onWarning(self, warn: "int", msg: "char const *") -> "void":
        r"""
        Reports a warning during SDK runtime.

            In most cases, the application can ignore the warning reported by the SDK because the SDK can usually fix the issue and resume running. For example, when losing connection with the server, the SDK may report #WARN_LOOKUP_CHANNEL_TIMEOUT and automatically try to reconnect.

            :type warn: int
            :param warn: Warning code: #WARN_CODE_TYPE.
            :type msg: string
            :param msg: Pointer to the warning message.
        """
        return _agorartc.RtcEngineEventHandlerBase_onWarning(self, warn, msg)

    def onError(self, err: "int", msg: "char const *") -> "void":
        r"""
        Reports an error during SDK runtime.

            In most cases, the SDK cannot fix the issue and resume running. The SDK requires the application to take action or informs the user about the issue.

            For example, the SDK reports an #ERR_START_CALL error when failing to initialize a call. The application informs the user that the call initialization failed and invokes the 'leaveChannel' method to leave the channel.

            :type err: int
            :param err: Error code: #ERROR_CODE_TYPE.
            :type msg: string
            :param msg: Pointer to the error message.
        """
        return _agorartc.RtcEngineEventHandlerBase_onError(self, err, msg)

    def onRtcStats(self, stats: "RtcStats") -> "void":
        r"""
        Reports the statistics of the current call.

            The SDK triggers this callback once every two seconds after the user joins the channel.

            :type stats: :py:class:`RtcStats`
            :param stats: Statistics of the IRtcEngine: RtcStats.
        """
        return _agorartc.RtcEngineEventHandlerBase_onRtcStats(self, stats)

    def onAudioMixingFinished(self) -> "void":
        r"""
         Occurs when the audio mixing file playback finishes.

        DEPRECATED**  use onAudioMixingStateChanged instead.

             You can start an audio mixing file playback by calling the 'startAudioMixing' method. The SDK triggers this callback when the audio mixing file playback finishes.

             If the *startAudioMixing* method call fails, an error code returns in the 'onError' callback.
        """
        return _agorartc.RtcEngineEventHandlerBase_onAudioMixingFinished(self)

    def onVideoSizeChanged(self, uid: "agora::rtc::uid_t", width: "int", height: "int", rotation: "int") -> "void":
        r"""
        Occurs when the video size or rotation of a specified user changes.

            :type uid: int
            :param uid: User ID of the remote user or local user (0) whose video size or rotation changes.
            :type width: int
            :param width: New width (pixels) of the video.
            :type height: int
            :param height: New height (pixels) of the video.
            :type rotation: int
            :param rotation: New rotation of the video [0 to 360).
        """
        return _agorartc.RtcEngineEventHandlerBase_onVideoSizeChanged(self, uid, width, height, rotation)

    def onConnectionInterrupted(self) -> "void":
        r"""
        DEPRECATED** Occurs when the connection between the SDK and the server is interrupted.

             Deprecated as of v2.3.2. Replaced by the 'onConnectionStateChanged(CONNECTION_STATE_RECONNECTING, CONNECTION_CHANGED_INTERRUPTED)' callback.

             The SDK triggers this callback when it loses connection with the server for more than four seconds after the connection is established.

             After triggering this callback, the SDK tries reconnecting to the server. You can use this callback to implement pop-up reminders.

             This callback is different from 'onConnectionLost':
             - The SDK triggers the 'onConnectionInterrupted' callback when it loses connection with the server for more than four seconds after it successfully joins the channel.
             - The SDK triggers the 'onConnectionLost' callback when it loses connection with the server for more than 10 seconds, whether or not it joins the channel.

             If the SDK fails to rejoin the channel 20 minutes after being disconnected from Agora's edge server, the SDK stops rejoining the channel.
        """
        return _agorartc.RtcEngineEventHandlerBase_onConnectionInterrupted(self)

    def onMicrophoneEnabled(self, enabled: "bool") -> "void":
        r"""
         Occurs when the microphone is enabled/disabled.

        Deprecated: v2.9.0

        The 'onMicrophoneEnabled' callback is
        deprecated. Use #LOCAL_AUDIO_STREAM_STATE_STOPPED (0) or
        #LOCAL_AUDIO_STREAM_STATE_RECORDING (1) in the
        'onLocalAudioStateChanged' callback
        instead.

        The SDK triggers this callback when the local user resumes or stops
        capturing the local audio stream by calling the
        'enbaleLocalAudio' method.

        :type enabled: boolean
        :param enabled: Whether the microphone is enabled/disabled:
            - true: Enabled.
            - false: Disabled.
        """
        return _agorartc.RtcEngineEventHandlerBase_onMicrophoneEnabled(self, enabled)

    def onAudioQuality(self, uid: "agora::rtc::uid_t", quality: "int", delay: "unsigned short", lost: "unsigned short") -> "void":
        r"""
        DEPRECATED** Reports the statistics of the audio stream from each remote user/host.

            Deprecated as of v2.3.2. Use the 'onRemoteAudioStats' callback instead.

             The SDK triggers this callback once every two seconds to report the audio quality of each remote user/host sending an audio stream. If a channel has multiple users/hosts sending audio streams, the SDK triggers this callback as many times.

             :type uid: int
             :param uid: User ID of the speaker.
             :type quality: int
             :param quality: Audio quality of the user: #QUALITY_TYPE.
             :type delay: int
             :param delay: Time delay (ms) of sending the audio packet from the sender to the receiver, including the time delay of audio sampling pre-processing, transmission, and the jitter buffer.
             :type lost: int
             :param lost: Packet loss rate (%) of the audio packet sent from the sender to the receiver.
        """
        return _agorartc.RtcEngineEventHandlerBase_onAudioQuality(self, uid, quality, delay, lost)

    def onRemoteVideoTransportStats(self, uid: "agora::rtc::uid_t", delay: "unsigned short", lost: "unsigned short", rxKBitRate: "unsigned short") -> "void":
        r"""
         Reports the transport-layer statistics of each remote video stream.

        Deprecated: 
        This callback is deprecated and replaced by the
        'onRemoteVideoStats' callback.

        This callback reports the transport-layer statistics, such as the
        packet loss rate and network time delay, once every two seconds after
        the local user receives a video packet from a remote user.

        :type uid: int
        :param uid: User ID of the remote user sending the video packet.
        :type delay: int
        :param delay: Network time delay (ms) from the remote user sending the
            video packet to the local user.
        :type lost: int
        :param lost: Packet loss rate (%) of the video packet sent from the
            remote user.
        :type rxKBitRate: int
        :param rxKBitRate: Received bitrate (Kbps) of the video packet sent
            from the remote user.
        """
        return _agorartc.RtcEngineEventHandlerBase_onRemoteVideoTransportStats(self, uid, delay, lost, rxKBitRate)

    def onRemoteAudioTransportStats(self, uid: "agora::rtc::uid_t", delay: "unsigned short", lost: "unsigned short", rxKBitRate: "unsigned short") -> "void":
        r"""
         Reports the transport-layer statistics of each remote audio stream.

        Deprecated: 
        This callback is deprecated and replaced by the
        'onRemoteAudioStats' callback.

        This callback reports the transport-layer statistics, such as the
        packet loss rate and network time delay, once every two seconds after
        the local user receives an audio packet from a remote user.

        :type uid: int
        :param uid:  User ID of the remote user sending the audio packet.
        :type delay: int
        :param delay: Network time delay (ms) from the remote user sending the
            audio packet to the local user.
        :type lost: int
        :param lost: Packet loss rate (%) of the audio packet sent from the
            remote user.
        :type rxKBitRate: int
        :param rxKBitRate:  Received bitrate (Kbps) of the audio packet sent
            from the remote user.
        """
        return _agorartc.RtcEngineEventHandlerBase_onRemoteAudioTransportStats(self, uid, delay, lost, rxKBitRate)

    def onStreamInjectedStatus(self, url: "char const *", uid: "agora::rtc::uid_t", status: "int") -> "void":
        r"""
        Occurs when a voice or video stream URL address is added to the live interactive streaming.

           :type url: string
           :param url: Pointer to the URL address of the externally injected stream.
           :type uid: int
           :param uid: User ID.
           :type status: int
           :param status: State of the externally injected stream: #INJECT_STREAM_STATUS.
        """
        return _agorartc.RtcEngineEventHandlerBase_onStreamInjectedStatus(self, url, uid, status)

    def onTranscodingUpdated(self) -> "void":
        r"""
         Occurs when the publisher's transcoding is updated.

        When the `LiveTranscoding` class in the 'setLiveTranscoding' method updates, the SDK triggers the `onTranscodingUpdated` callback to report the update information to the local host.

        Notes: If you call the `setLiveTranscoding` method to set the LiveTranscoding class for the first time, the SDK does not trigger the `onTranscodingUpdated` callback.
        """
        return _agorartc.RtcEngineEventHandlerBase_onTranscodingUpdated(self)

    def onStreamUnpublished(self, url: "char const *") -> "void":
        r"""
        Deprecated: This method is deprecated, use the 'onRtmpStreamingStateChanged' callback instead.

            Reports the result of calling the 'removePublishStreamUrl' method. (CDN live only.)

            This callback indicates whether you have successfully removed an RTMP stream from the CDN.

            :type url: string
            :param url: The RTMP URL address.
        """
        return _agorartc.RtcEngineEventHandlerBase_onStreamUnpublished(self, url)

    def onStreamPublished(self, url: "char const *", error: "int") -> "void":
        r"""
        Deprecated: This method is deprecated, use the 'onRtmpStreamingStateChanged' callback instead.

            Reports the result of calling the 'addPublishStreamUrl' method. (CDN live only.)

            :type url: string
            :param url: The RTMP URL address.
            :type error: int
            :param error: Error code: #ERROR_CODE_TYPE. Main errors include:
                - #ERR_OK (0): The publishing succeeds.
                - #ERR_FAILED (1): The publishing fails.
                - #ERR_INVALID_ARGUMENT (2): Invalid argument used. If, for example, you did not call 'setLiveTranscoding' to configure LiveTranscoding before calling 'addPublishStreamUrl', the SDK reports #ERR_INVALID_ARGUMENT.
                - #ERR_TIMEDOUT (10): The publishing timed out.
                - #ERR_ALREADY_IN_USE (19): The chosen URL address is already in use for CDN live streaming.
                - #ERR_RESOURCE_LIMITED (22): The backend system does not have enough resources for the CDN live streaming.
                - #ERR_ENCRYPTED_STREAM_NOT_ALLOWED_PUBLISH (130): You cannot publish an encrypted stream.
                - #ERR_PUBLISH_STREAM_CDN_ERROR (151)
                - #ERR_PUBLISH_STREAM_NUM_REACH_LIMIT (152)
                - #ERR_PUBLISH_STREAM_NOT_AUTHORIZED (153)
                - #ERR_PUBLISH_STREAM_INTERNAL_SERVER_ERROR (154)
                - #ERR_PUBLISH_STREAM_FORMAT_NOT_SUPPORTED (156)
        """
        return _agorartc.RtcEngineEventHandlerBase_onStreamPublished(self, url, error)

    def onAudioDeviceVolumeChanged(self, deviceType: "agora::rtc::MEDIA_DEVICE_TYPE", volume: "int", muted: "bool") -> "void":
        r"""
        Occurs when the volume of the playback device, microphone, or application changes.

            :type deviceType: int
            :param deviceType: Device type: #MEDIA_DEVICE_TYPE.
            :type volume: int
            :param volume: Volume of the device. The value ranges between 0 and 255.
            :type muted: boolean
            :param muted:
                - true: The audio device is muted.
                - false: The audio device is not muted.
        """
        return _agorartc.RtcEngineEventHandlerBase_onAudioDeviceVolumeChanged(self, deviceType, volume, muted)

    def onActiveSpeaker(self, uid: "agora::rtc::uid_t") -> "void":
        r"""
        Reports which user is the loudest speaker.

           If the user enables the audio volume indication by calling the 'IRtcEngine::enableAudioVolumeIndication(int', int, bool) "enableAudioVolumeIndication" method, this callback returns the ``uid`` of the active speaker detected by the audio volume detection module of the SDK.

           Notes: 
           - To receive this callback, you need to call the 'IRtcEngine::enableAudioVolumeIndication(int', int, bool) "enableAudioVolumeIndication" method.
           - This callback returns the user ID of the user with the highest voice volume during a period of time, instead of at the moment.

           :type uid: int
           :param uid: User ID of the active speaker. A ``uid`` of 0 represents the local user.
        """
        return _agorartc.RtcEngineEventHandlerBase_onActiveSpeaker(self, uid)

    def onFirstRemoteAudioFrame(self, uid: "agora::rtc::uid_t", elapsed: "int") -> "void":
        r"""
        Occurs when the engine receives the first audio frame from a specific remote user.

           Deprecated: v3.0.0

           This callback is deprecated. Use `onRemoteAudioStateChanged` instead.

           :type uid: int
           :param uid: User ID of the remote user.
           :type elapsed: int
           :param elapsed: Time elapsed (ms) from the remote user calling 'joinChannel' until the SDK triggers this callback.
        """
        return _agorartc.RtcEngineEventHandlerBase_onFirstRemoteAudioFrame(self, uid, elapsed)

    def onFirstLocalAudioFrame(self, elapsed: "int") -> "void":
        r"""
        Occurs when the engine sends the first local audio frame.

            Deprecated: Deprecated as of v3.1.0. Use the 'onFirstLocalAudioFramePublished' callback instead.

            :type elapsed: int
            :param elapsed: Time elapsed (ms) from the local user calling 'joinChannel' until the SDK triggers this callback.
        """
        return _agorartc.RtcEngineEventHandlerBase_onFirstLocalAudioFrame(self, elapsed)

    def onMediaEngineStartCallSuccess(self) -> "void":
        r""" Occurs when the media engine call starts."""
        return _agorartc.RtcEngineEventHandlerBase_onMediaEngineStartCallSuccess(self)

    def onMediaEngineLoadSuccess(self) -> "void":
        r""" Occurs when the media engine loads."""
        return _agorartc.RtcEngineEventHandlerBase_onMediaEngineLoadSuccess(self)

    def onStreamMessageError(self, uid: "agora::rtc::uid_t", streamId: "int", code: "int", missed: "int", cached: "int") -> "void":
        r"""
        Occurs when the local user does not receive the data stream from the remote user within five seconds.

            The SDK triggers this callback when the local user fails to receive the stream message that the remote user sends by calling the 'sendStreamMessage' method.
            :type uid: int
            :param uid: User ID of the remote user sending the message.
            :type streamId: int
            :param streamId: Stream ID.
            :type code: int
            :param code: Error code: #ERROR_CODE_TYPE.
            :type missed: int
            :param missed: Number of lost messages.
            :type cached: int
            :param cached: Number of incoming cached messages when the data stream is interrupted.
        """
        return _agorartc.RtcEngineEventHandlerBase_onStreamMessageError(self, uid, streamId, code, missed, cached)

    def onStreamMessage(self, uid: "agora::rtc::uid_t", streamId: "int", data: "char const *", length: "size_t") -> "void":
        r"""
        Occurs when the local user receives the data stream from the remote user within five seconds.

           The SDK triggers this callback when the local user receives the stream message that the remote user sends by calling the 'sendStreamMessage' method.
           :type uid: int
           :param uid: User ID of the remote user sending the message.
           :type streamId: int
           :param streamId: Stream ID.
           :type data: string
           :param data: Pointer to the data received by the local user.
           :type length: int
           :param length: Length of the data in bytes.
        """
        return _agorartc.RtcEngineEventHandlerBase_onStreamMessage(self, uid, streamId, data, length)

    def onConnectionBanned(self) -> "void":
        r"""
        DEPRECATED** Deprecated as of v2.3.2. Replaced by the 'onConnectionStateChanged(CONNECTION_STATE_FAILED, CONNECTION_CHANGED_BANNED_BY_SERVER)' callback.

            Occurs when your connection is banned by the Agora Server.
        """
        return _agorartc.RtcEngineEventHandlerBase_onConnectionBanned(self)

    def onLastmileQuality(self, quality: "int") -> "void":
        r"""
        Reports the last mile network quality of the local user once every two seconds before the user joins the channel.

            Last mile refers to the connection between the local device and Agora's edge server. After the application calls the 'enableLastmileTest' method, this callback reports once every two seconds the uplink and downlink last mile network conditions of the local user before the user joins the channel.

            :type quality: int
            :param quality: The last mile network quality: #QUALITY_TYPE.
        """
        return _agorartc.RtcEngineEventHandlerBase_onLastmileQuality(self, quality)

    def onVideoStopped(self) -> "void":
        r"""
        DEPRECATED** Occurs when the video stops playing.

             The application can use this callback to change the configuration of the view (for example, displaying other pictures in the view) after the video stops playing.

             Deprecated as of v2.4.1. Use LOCAL_VIDEO_STREAM_STATE_STOPPED(0) in the 'onLocalVideoStateChanged' callback instead.
        """
        return _agorartc.RtcEngineEventHandlerBase_onVideoStopped(self)

    def onApiCallExecuted(self, err: "int", api: "char const *", result: "char const *") -> "void":
        r"""
        Occurs when a method is executed by the SDK.

            :type err: int
            :param err: The error code (#ERROR_CODE_TYPE) returned by the SDK when a method call fails. If the SDK returns 0, then the method call is successful.
            :type api: string
            :param api: Pointer to the method executed by the SDK.
            :type result: string
            :param result: Pointer to the result of the method call.
        """
        return _agorartc.RtcEngineEventHandlerBase_onApiCallExecuted(self, err, api, result)

    def onTokenPrivilegeWillExpire(self, token: "char const *") -> "void":
        r"""
        Occurs when the token expires in 30 seconds.

            The user becomes offline if the token used in the 'joinChannel' method expires. The SDK triggers this callback 30 seconds before the token expires to remind the application to get a new token. Upon receiving this callback, generate a new token on the server and call the 'renewToken' method to pass the new token to the SDK.

            :type token: string
            :param token: Pointer to the token that expires in 30 seconds.
        """
        return _agorartc.RtcEngineEventHandlerBase_onTokenPrivilegeWillExpire(self, token)

    def onNetworkQuality(self, uid: "agora::rtc::uid_t", txQuality: "int", rxQuality: "int") -> "void":
        r"""
        Reports the last mile network quality of each user in the channel once every two seconds.

            Last mile refers to the connection between the local device and Agora's edge server. This callback reports once every two seconds the last mile network conditions of each user in the channel. If a channel includes multiple users, the SDK triggers this callback as many times.

            :type uid: int
            :param uid: User ID. The network quality of the user with this ``uid`` is reported. If ``uid`` is 0, the local network quality is reported.
            :type txQuality: int
            :param txQuality: Uplink transmission quality rating of the user in terms of the transmission bitrate, packet loss rate, average RTT (Round-Trip Time), and jitter of the uplink network. ``txQuality`` is a quality rating helping you understand how well the current uplink network conditions can support the selected VideoEncoderConfiguration. For example, a 1000 Kbps uplink network may be adequate for video frames with a resolution of 640 * 480 and a frame rate of 15 fps in the `LIVE_BROADCASTING` profile, but may be inadequate for resolutions higher than 1280 * 720. See #QUALITY_TYPE.
            :type rxQuality: int
            :param rxQuality: Downlink network quality rating of the user in terms of the packet loss rate, average RTT, and jitter of the downlink network. See #QUALITY_TYPE.
        """
        return _agorartc.RtcEngineEventHandlerBase_onNetworkQuality(self, uid, txQuality, rxQuality)

    def onLocalVideoStats(self, stats: "LocalVideoStats") -> "void":
        r"""
         Reports the statistics of the local video stream.

        The SDK triggers this callback once every two seconds for each
        user/host. If there are multiple users/hosts in the channel, the SDK
        triggers this callback as many times.

        Notes: 
        If you have called the
        'enableDualStreamMode'
        method, the 'onLocalVideoStats' callback
        reports the statistics of the high-video
        stream (high bitrate, and high-resolution video stream).

        :type stats: :py:class:`LocalVideoStats`
        :param stats: Statistics of the local video stream. See LocalVideoStats.
        """
        return _agorartc.RtcEngineEventHandlerBase_onLocalVideoStats(self, stats)

    def onLocalAudioStats(self, stats: "LocalAudioStats") -> "void":
        r"""
         Reports the statistics of the local audio stream.

        The SDK triggers this callback once every two seconds.

        :type stats: :py:class:`LocalAudioStats`
        :param stats: The statistics of the local audio stream.
            See LocalAudioStats.
        """
        return _agorartc.RtcEngineEventHandlerBase_onLocalAudioStats(self, stats)

    def onRemoteVideoStats(self, stats: "RemoteVideoStats") -> "void":
        r"""
         Reports the statistics of the video stream from each remote user/host.

        The SDK triggers this callback once every two seconds for each remote
        user/host. If a channel includes multiple remote users, the SDK
        triggers this callback as many times.

        :type stats: :py:class:`RemoteVideoStats`
        :param stats: Statistics of the remote video stream. See
            RemoteVideoStats.
        """
        return _agorartc.RtcEngineEventHandlerBase_onRemoteVideoStats(self, stats)

    def onRemoteAudioStats(self, stats: "RemoteAudioStats") -> "void":
        r"""
        Reports the statistics of the audio stream from each remote user/host.

            This callback replaces the 'onAudioQuality' callback.

            The SDK triggers this callback once every two seconds for each remote user/host. If a channel includes multiple remote users, the SDK triggers this callback as many times.

            :type stats: :py:class:`RemoteAudioStats`
            :param stats: Pointer to the statistics of the received remote audio streams. See RemoteAudioStats.
        """
        return _agorartc.RtcEngineEventHandlerBase_onRemoteAudioStats(self, stats)

    def onFirstLocalVideoFrame(self, width: "int", height: "int", elapsed: "int") -> "void":
        r"""
        Occurs when the first local video frame is displayed/rendered on the local video view.

           :type width: int
           :param width: Width (px) of the first local video frame.
           :type height: int
           :param height: Height (px) of the first local video frame.
           :type elapsed: int
           :param elapsed: Time elapsed (ms) from the local user calling the 'joinChannel' method until the SDK triggers this callback.
               If you call the 'startPreview' method  before calling the *joinChannel* method, then ``elapsed`` is the time elapsed from calling the *startPreview* method until the SDK triggers this callback.
        """
        return _agorartc.RtcEngineEventHandlerBase_onFirstLocalVideoFrame(self, width, height, elapsed)

    def onFirstRemoteVideoFrame(self, uid: "agora::rtc::uid_t", width: "int", height: "int", elapsed: "int") -> "void":
        r"""
        Occurs when the first remote video frame is rendered.

            The SDK triggers this callback when the first frame of the remote video is displayed in the user's video window. The application can retrieve the time elapsed from a user joining the channel until the first video frame is displayed.

            :type uid: int
            :param uid: User ID of the remote user sending the video stream.
            :type width: int
            :param width: Width (px) of the video frame.
            :type height: int
            :param height: Height (px) of the video stream.
            :type elapsed: int
            :param elapsed: Time elapsed (ms) from the local user calling the 'joinChannel' method until the SDK triggers this callback.
        """
        return _agorartc.RtcEngineEventHandlerBase_onFirstRemoteVideoFrame(self, uid, width, height, elapsed)

    def onUserEnableVideo(self, uid: "agora::rtc::uid_t", enabled: "bool") -> "void":
        r"""
         Occurs when a specific remote user enables/disables the video
        module.

        Deprecated: v2.9.0

        This callback is deprecated and replaced by the
        'onRemoteVideoStateChanged' callback
        with the following parameters:
        - #REMOTE_VIDEO_STATE_STOPPED (0) and
        #REMOTE_VIDEO_STATE_REASON_REMOTE_MUTED (5).
        - #REMOTE_VIDEO_STATE_DECODING (2) and
        #REMOTE_VIDEO_STATE_REASON_REMOTE_UNMUTED (6).

        Once the video module is disabled, the remote user can only use a
        voice call. The remote user cannot send or receive any video from
        other users.

        The SDK triggers this callback when the remote user enables or disables
        the video module by calling the
        'enableVideo' or
        'disableVideo' method.

        Notes: This callback returns invalid when the number of users in a
        channel exceeds 20.

        :type uid: int
        :param uid: User ID of the remote user.
        :type enabled: boolean
        :param enabled: Whether the remote user enables/disables the video
            module:
            - true: Enable. The remote user can enter a video session.
            - false: Disable. The remote user can only enter a voice session, and
            cannot send or receive any video stream.
        """
        return _agorartc.RtcEngineEventHandlerBase_onUserEnableVideo(self, uid, enabled)

    def onAudioDeviceStateChanged(self, deviceId: "char const *", deviceType: "int", deviceState: "int") -> "void":
        r"""
        Occurs when the audio device state changes.

            This callback notifies the application that the system's audio device state is changed. For example, a headset is unplugged from the device.

            :type deviceId: string
            :param deviceId: Pointer to the device ID.
            :type deviceType: int
            :param deviceType: Device type: #MEDIA_DEVICE_TYPE.
            :type deviceState: int
            :param deviceState: Device state: #MEDIA_DEVICE_STATE_TYPE.
        """
        return _agorartc.RtcEngineEventHandlerBase_onAudioDeviceStateChanged(self, deviceId, deviceType, deviceState)

    def onCameraReady(self) -> "void":
        r"""
        DEPRECATED** Occurs when the camera turns on and is ready to capture the video.

             If the camera fails to turn on, fix the error reported in the 'onError' callback.

             Deprecated as of v2.4.1. Use #LOCAL_VIDEO_STREAM_STATE_CAPTURING (1) in the 'onLocalVideoStateChanged' callback instead.
        """
        return _agorartc.RtcEngineEventHandlerBase_onCameraReady(self)

    def onCameraFocusAreaChanged(self, x: "int", y: "int", width: "int", height: "int") -> "void":
        r"""
        Occurs when the camera focus area changes.

            The SDK triggers this callback when the local user changes the camera focus position by calling the setCameraFocusPositionInPreview method.

            Notes: This callback is for Android and iOS only.

            :type x: int
            :param x: x coordinate of the changed camera focus area.
            :type y: int
            :param y: y coordinate of the changed camera focus area.
            :type width: int
            :param width: Width of the changed camera focus area.
            :type height: int
            :param height: Height of the changed camera focus area.
        """
        return _agorartc.RtcEngineEventHandlerBase_onCameraFocusAreaChanged(self, x, y, width, height)

    def onCameraExposureAreaChanged(self, x: "int", y: "int", width: "int", height: "int") -> "void":
        r"""
        Occurs when the camera exposure area changes.

           The SDK triggers this callback when the local user changes the camera exposure position by calling the setCameraExposurePosition method.

            Notes: This callback is for Android and iOS only.

            :type x: int
            :param x: x coordinate of the changed camera exposure area.
            :type y: int
            :param y: y coordinate of the changed camera exposure area.
            :type width: int
            :param width: Width of the changed camera exposure area.
            :type height: int
            :param height: Height of the changed camera exposure area.
        """
        return _agorartc.RtcEngineEventHandlerBase_onCameraExposureAreaChanged(self, x, y, width, height)

    def onRemoteAudioMixingBegin(self) -> "void":
        r"""
         Occurs when the audio mixing file playback finishes.

        DEPRECATED**  use onAudioMixingStateChanged instead.

             You can start an audio mixing file playback by calling the 'startAudioMixing' method. The SDK triggers this callback when the audio mixing file playback finishes.

             If the *startAudioMixing* method call fails, an error code returns in the 'onError' callback.
        """
        return _agorartc.RtcEngineEventHandlerBase_onRemoteAudioMixingBegin(self)

    def onRemoteAudioMixingEnd(self) -> "void":
        r""" Occurs when a remote user finishes audio mixing."""
        return _agorartc.RtcEngineEventHandlerBase_onRemoteAudioMixingEnd(self)

    def onAudioEffectFinished(self, soundId: "int") -> "void":
        r"""
        Occurs when the local audio effect playback finishes.

            The SDK triggers this callback when the local audio effect file playback finishes.

            :type soundId: int
            :param soundId: ID of the local audio effect. Each local audio effect has a unique ID.
        """
        return _agorartc.RtcEngineEventHandlerBase_onAudioEffectFinished(self, soundId)

    def onVideoDeviceStateChanged(self, deviceId: "char const *", deviceType: "int", deviceState: "int") -> "void":
        r"""
        Occurs when the video device state changes.

            Notes: On a Windows device with an external camera for video capturing, the video disables once the external camera is unplugged.

            :type deviceId: string
            :param deviceId: Pointer to the device ID of the video device that changes state.
            :type deviceType: int
            :param deviceType: Device type: #MEDIA_DEVICE_TYPE.
            :type deviceState: int
            :param deviceState: Device state: #MEDIA_DEVICE_STATE_TYPE.
        """
        return _agorartc.RtcEngineEventHandlerBase_onVideoDeviceStateChanged(self, deviceId, deviceType, deviceState)

    def onRemoteVideoStateChanged(self, uid: "agora::rtc::uid_t", state: "agora::rtc::REMOTE_VIDEO_STATE", reason: "agora::rtc::REMOTE_VIDEO_STATE_REASON", elapsed: "int") -> "void":
        r"""
        Occurs when the remote video state changes.
            Notes: This callback does not work properly when the number of users (in the `COMMUNICATION` profile) or hosts (in the `LIVE_BROADCASTING` profile) in the channel exceeds 17.

            :type uid: int
            :param uid: ID of the remote user whose video state changes.
            :type state: int
            :param state: State of the remote video. See #REMOTE_VIDEO_STATE.
            :type reason: int
            :param reason: The reason of the remote video state change. See
                #REMOTE_VIDEO_STATE_REASON.
            :type elapsed: int
            :param elapsed: Time elapsed (ms) from the local user calling the
                'joinChannel' method until the
                SDK triggers this callback.
        """
        return _agorartc.RtcEngineEventHandlerBase_onRemoteVideoStateChanged(self, uid, state, reason, elapsed)

    def onUserEnableLocalVideo(self, uid: "agora::rtc::uid_t", enabled: "bool") -> "void":
        r"""
         Occurs when a specified remote user enables/disables the local video
        capturing function.

        Deprecated: v2.9.0

        This callback is deprecated and replaced by the
        'onRemoteVideoStateChanged' callback
        with the following parameters:
        - #REMOTE_VIDEO_STATE_STOPPED (0) and
        #REMOTE_VIDEO_STATE_REASON_REMOTE_MUTED (5).
        - #REMOTE_VIDEO_STATE_DECODING (2) and
        #REMOTE_VIDEO_STATE_REASON_REMOTE_UNMUTED (6).

        This callback is only applicable to the scenario when the user only
        wants to watch the remote video without sending any video stream to the
        other user.

        The SDK triggers this callback when the remote user resumes or stops
        capturing the video stream by calling the
        'enableLocalVideo' method.

        :type uid: int
        :param uid: User ID of the remote user.
        :type enabled: boolean
        :param enabled: Whether the specified remote user enables/disables the
            local video capturing function:
            - true: Enable. Other users in the channel can see the video of this
            remote user.
            - false: Disable. Other users in the channel can no longer receive the
            video stream from this remote user, while this remote user can still
            receive the video streams from other users.
        """
        return _agorartc.RtcEngineEventHandlerBase_onUserEnableLocalVideo(self, uid, enabled)

    def onLocalPublishFallbackToAudioOnly(self, isFallbackOrRecover: "bool") -> "void":
        r"""
        Occurs when the published media stream falls back to an audio-only stream due to poor network conditions or switches back to the video after the network conditions improve.

           If you call 'setLocalPublishFallbackOption' and set *option* as #STREAM_FALLBACK_OPTION_AUDIO_ONLY, the SDK triggers this callback when the
           published stream falls back to audio-only mode due to poor uplink conditions, or when the audio stream switches back to the video after the uplink network condition improves.
           Notes: If the local stream fallbacks to the audio-only stream, the remote user receives the 'onUserMuteVideo' callback.

           :type isFallbackOrRecover: boolean
           :param isFallbackOrRecover: Whether the published stream falls back to audio-only or switches back to the video:
               - true: The published stream falls back to audio-only due to poor network conditions.
               - false: The published stream switches back to the video after the network conditions improve.
        """
        return _agorartc.RtcEngineEventHandlerBase_onLocalPublishFallbackToAudioOnly(self, isFallbackOrRecover)

    def onRemoteSubscribeFallbackToAudioOnly(self, uid: "agora::rtc::uid_t", isFallbackOrRecover: "bool") -> "void":
        r"""
         Occurs when the remote media stream falls back to audio-only stream
        due to poor network conditions or switches back to the video stream
        after the network conditions improve.

        If you call
        'IRtcEngine::setRemoteSubscribeFallbackOption'
        "setRemoteSubscribeFallbackOption" and set
        ``option`` as #STREAM_FALLBACK_OPTION_AUDIO_ONLY, the SDK triggers this
        callback when the remote media stream falls back to audio-only mode due
        to poor uplink conditions, or when the remote media stream switches
        back to the video after the uplink network condition improves.

        Notes: Once the remote media stream switches to the low stream due to
        poor network conditions, you can monitor the stream switch between a
        high and low stream in the RemoteVideoStats callback.

        :type uid: int
        :param uid: ID of the remote user sending the stream.
        :type isFallbackOrRecover: boolean
        :param isFallbackOrRecover: Whether the remotely subscribed media stream
            falls back to audio-only or switches back to the video:
            - true: The remotely subscribed media stream falls back to audio-only
            due to poor network conditions.
            - false: The remotely subscribed media stream switches back to the
            video stream after the network conditions improved.
        """
        return _agorartc.RtcEngineEventHandlerBase_onRemoteSubscribeFallbackToAudioOnly(self, uid, isFallbackOrRecover)

    def onConnectionStateChanged(self, state: "agora::rtc::CONNECTION_STATE_TYPE", reason: "agora::rtc::CONNECTION_CHANGED_REASON_TYPE") -> "void":
        r"""
        Occurs when the connection state between the SDK and the server changes.

            :type state: int
            :param state: See #CONNECTION_STATE_TYPE.
            :type reason: int
            :param reason: See #CONNECTION_CHANGED_REASON_TYPE.
        """
        return _agorartc.RtcEngineEventHandlerBase_onConnectionStateChanged(self, state, reason)

    def onAudioMixingStateChanged(self, state: "agora::rtc::AUDIO_MIXING_STATE_TYPE", errorCode: "agora::rtc::AUDIO_MIXING_ERROR_TYPE") -> "void":
        r"""
        Occurs when the state of the local user's audio mixing file changes.

            When you call the 'startAudioMixing' method and the state of audio mixing file changes, the SDK triggers this callback.
            - When the audio mixing file plays, pauses playing, or stops playing, this callback returns 710, 711, or 713 in ``state``, and 0 in ``errorCode``.
            - When exceptions occur during playback, this callback returns 714 in ``state`` and an error in ``errorCode``.
            - If the local audio mixing file does not exist, or if the SDK does not support the file format or cannot access the music file URL, the SDK returns WARN_AUDIO_MIXING_OPEN_ERROR = 701.

            :type state: int
            :param state: The state code. See #AUDIO_MIXING_STATE_TYPE.
            :type errorCode: int
            :param errorCode: The error code. See #AUDIO_MIXING_ERROR_TYPE.
        """
        return _agorartc.RtcEngineEventHandlerBase_onAudioMixingStateChanged(self, state, errorCode)

    def onFirstRemoteAudioDecoded(self, uid: "agora::rtc::uid_t", elapsed: "int") -> "void":
        r"""
        Occurs when the SDK decodes the first remote audio frame for playback.

        Deprecated: v3.0.0

        This callback is deprecated. Use `onRemoteAudioStateChanged` instead.

        This callback is triggered in either of the following scenarios:

        - The remote user joins the channel and sends the audio stream.
        - The remote user stops sending the audio stream and re-sends it after 15 seconds. Reasons for such an interruption include:
            - The remote user leaves channel.
            - The remote user drops offline.
            - The remote user calls the 'muteLocalAudioStream' method to stop sending the local audio stream.
            - The remote user calls the 'disableAudio' method to disable audio.

        :type uid: int
        :param uid: User ID of the remote user sending the audio stream.
        :type elapsed: int
        :param elapsed: Time elapsed (ms) from the local user calling the 'joinChannel' method until the SDK triggers this callback.
        """
        return _agorartc.RtcEngineEventHandlerBase_onFirstRemoteAudioDecoded(self, uid, elapsed)

    def onLocalVideoStateChanged(self, localVideoState: "agora::rtc::LOCAL_VIDEO_STREAM_STATE", error: "agora::rtc::LOCAL_VIDEO_STREAM_ERROR") -> "void":
        r"""
        Occurs when the local video stream state changes.

            This callback indicates the state of the local video stream, including camera capturing and video encoding, and allows you to troubleshoot issues when exceptions occur.

            Notes: For some device models, the SDK will not trigger this callback when the state of the local video changes while the local video capturing device is in use, so you have to make your own timeout judgment.

            :type localVideoState: int
            :param localVideoState: State type #LOCAL_VIDEO_STREAM_STATE. When the state is LOCAL_VIDEO_STREAM_STATE_FAILED (3), see the `error` parameter for details.
            :type error: int
            :param error: The detailed error information: #LOCAL_VIDEO_STREAM_ERROR.
        """
        return _agorartc.RtcEngineEventHandlerBase_onLocalVideoStateChanged(self, localVideoState, error)

    def onRtmpStreamingStateChanged(self, url: "char const *", state: "agora::rtc::RTMP_STREAM_PUBLISH_STATE", errCode: "agora::rtc::RTMP_STREAM_PUBLISH_ERROR") -> "void":
        r"""
        Occurs when the state of the RTMP streaming changes.

        The SDK triggers this callback to report the result of the local user calling the 'addPublishStreamUrl' or 'removePublishStreamUrl' method.

        This callback indicates the state of the RTMP streaming. When exceptions occur, you can troubleshoot issues by referring to the detailed error descriptions in the *errCode* parameter.

        :type url: string
        :param url: The RTMP URL address.
        :type state: int
        :param state: The RTMP streaming state. See: #RTMP_STREAM_PUBLISH_STATE.
        :type errCode: int
        :param errCode: The detailed error information for streaming. See: #RTMP_STREAM_PUBLISH_ERROR.
        """
        return _agorartc.RtcEngineEventHandlerBase_onRtmpStreamingStateChanged(self, url, state, errCode)

    def onNetworkTypeChanged(self, type: "agora::rtc::NETWORK_TYPE") -> "void":
        r"""
        Occurs when the local network type changes.

            When the network connection is interrupted, this callback indicates whether the interruption is caused by a network type change or poor network conditions.

            :type type: int
            :param type: See #NETWORK_TYPE.
        """
        return _agorartc.RtcEngineEventHandlerBase_onNetworkTypeChanged(self, type)

    def onLastmileProbeResult(self, result: "LastmileProbeResult") -> "void":
        r"""
        Reports the last-mile network probe result.

            The SDK triggers this callback within 30 seconds after the app calls the 'startLastmileProbeTest' method.

            :type result: :py:class:`LastmileProbeResult`
            :param result: The uplink and downlink last-mile network probe test result. See LastmileProbeResult.
        """
        return _agorartc.RtcEngineEventHandlerBase_onLastmileProbeResult(self, result)

    def onLocalUserRegistered(self, uid: "agora::rtc::uid_t", userAccount: "char const *") -> "void":
        r"""
        Occurs when the local user successfully registers a user account by calling the 'registerLocalUserAccount' method or joins a channel by calling the 'joinChannelWithUserAccount' method.This callback reports the user ID and user account of the local user.

            :type uid: int
            :param uid: The ID of the local user.
            :type userAccount: string
            :param userAccount: The user account of the local user.
        """
        return _agorartc.RtcEngineEventHandlerBase_onLocalUserRegistered(self, uid, userAccount)

    def onUserInfoUpdated(self, uid: "agora::rtc::uid_t", info: "UserInfo") -> "void":
        r"""
        Occurs when the SDK gets the user ID and user account of the remote user.

            After a remote user joins the channel, the SDK gets the UID and user account of the remote user,
            caches them in a mapping table object (`userInfo`), and triggers this callback on the local client.

            :type uid: int
            :param uid: The ID of the remote user.
            :type info: :py:class:`UserInfo`
            :param info: The `UserInfo` object that contains the user ID and user account of the remote user.
        """
        return _agorartc.RtcEngineEventHandlerBase_onUserInfoUpdated(self, uid, info)

    def onLocalAudioStateChanged(self, state: "agora::rtc::LOCAL_AUDIO_STREAM_STATE", error: "agora::rtc::LOCAL_AUDIO_STREAM_ERROR") -> "void":
        r"""
         Occurs when the local audio state changes.
        This callback indicates the state change of the local audio stream,
        including the state of the audio recording and encoding, and allows
        you to troubleshoot issues when exceptions occur.

        Notes: 
        When the state is #LOCAL_AUDIO_STREAM_STATE_FAILED (3), see the `error`
        parameter for details.

        :type state: int
        :param state: State of the local audio. See #LOCAL_AUDIO_STREAM_STATE.
        :type error: int
        :param error: The error information of the local audio.
            See #LOCAL_AUDIO_STREAM_ERROR.
        """
        return _agorartc.RtcEngineEventHandlerBase_onLocalAudioStateChanged(self, state, error)

    def onRemoteAudioStateChanged(self, uid: "agora::rtc::uid_t", state: "agora::rtc::REMOTE_AUDIO_STATE", reason: "agora::rtc::REMOTE_AUDIO_STATE_REASON", elapsed: "int") -> "void":
        r"""
        Occurs when the remote audio state changes.

            This callback indicates the state change of the remote audio stream.
            Notes: This callback does not work properly when the number of users (in the `COMMUNICATION` profile) or hosts (in the `LIVE_BROADCASTING` profile) in the channel exceeds 17.

            :type uid: int
            :param uid: ID of the remote user whose audio state changes.
            :type state: int
            :param state: State of the remote audio. See #REMOTE_AUDIO_STATE.
            :type reason: int
            :param reason: The reason of the remote audio state change.
                See #REMOTE_AUDIO_STATE_REASON.
            :type elapsed: int
            :param elapsed: Time elapsed (ms) from the local user calling the
                'joinChannel' method until the SDK
                triggers this callback.
        """
        return _agorartc.RtcEngineEventHandlerBase_onRemoteAudioStateChanged(self, uid, state, reason, elapsed)

    def onChannelMediaRelayStateChanged(self, state: "agora::rtc::CHANNEL_MEDIA_RELAY_STATE", code: "agora::rtc::CHANNEL_MEDIA_RELAY_ERROR") -> "void":
        r"""
         Occurs when the state of the media stream relay changes.

        The SDK returns the state of the current media relay with any error
        message.

        :type state: int
        :param state: The state code in #CHANNEL_MEDIA_RELAY_STATE.
        :type code: int
        :param code: The error code in #CHANNEL_MEDIA_RELAY_ERROR.
        """
        return _agorartc.RtcEngineEventHandlerBase_onChannelMediaRelayStateChanged(self, state, code)

    def onChannelMediaRelayEvent(self, code: "agora::rtc::CHANNEL_MEDIA_RELAY_EVENT") -> "void":
        r"""
         Reports events during the media stream relay.

        :type code: int
        :param code: The event code in #CHANNEL_MEDIA_RELAY_EVENT.
        """
        return _agorartc.RtcEngineEventHandlerBase_onChannelMediaRelayEvent(self, code)

    def onTestEnd(self) -> "void":
        return _agorartc.RtcEngineEventHandlerBase_onTestEnd(self)

    def __init__(self):
        if self.__class__ == RtcEngineEventHandlerBase:
            _self = None
        else:
            _self = self
        _agorartc.RtcEngineEventHandlerBase_swiginit(self, _agorartc.new_RtcEngineEventHandlerBase(_self, ))
    def __disown__(self):
        self.this.disown()
        _agorartc.disown_RtcEngineEventHandlerBase(self)
        return weakref.proxy(self)

# Register RtcEngineEventHandlerBase in _agorartc:
_agorartc.RtcEngineEventHandlerBase_swigregister(RtcEngineEventHandlerBase)

class IChannelEventHandler(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _agorartc.IChannelEventHandler_swiginit(self, _agorartc.new_IChannelEventHandler())
    __swig_destroy__ = _agorartc.delete_IChannelEventHandler

# Register IChannelEventHandler in _agorartc:
_agorartc.IChannelEventHandler_swigregister(IChannelEventHandler)

class RtcChannelEventHandlerBase(IChannelEventHandler):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _agorartc.delete_RtcChannelEventHandlerBase

    def onChannelWarning(self, rtcChannel: "IChannel", warn: "int", msg: "char const *") -> "void":
        r"""
         Reports the warning code of `IChannel`.

        		     :type rtcChannel: :py:class:`IChannel`
        :param rtcChannel: IChannel
            		 :type warn: int
        :param warn: The warning code: #WARN_CODE_TYPE
            		 :type msg: string
        :param msg: The warning message.
        """
        return _agorartc.RtcChannelEventHandlerBase_onChannelWarning(self, rtcChannel, warn, msg)

    def onChannelError(self, rtcChannel: "IChannel", err: "int", msg: "char const *") -> "void":
        r"""
         Reports the error code of `IChannel`.

        		     :type rtcChannel: :py:class:`IChannel`
        :param rtcChannel: IChannel
            		 :type err: int
        :param err: The error code: #ERROR_CODE_TYPE
            		 :type msg: string
        :param msg: The error message.
        """
        return _agorartc.RtcChannelEventHandlerBase_onChannelError(self, rtcChannel, err, msg)

    def onJoinChannelSuccess(self, rtcChannel: "IChannel", uid: "agora::rtc::uid_t", elapsed: "int") -> "void":
        r"""
         Occurs when a user joins a channel.

        		     This callback notifies the application that a user joins a specified channel.

        		     :type rtcChannel: :py:class:`IChannel`
        :param rtcChannel: IChannel
            		 :type uid: int
        :param uid: The user ID. If the `uid` is not specified in the 'joinChannel' method, the server automatically assigns a `uid`.

        		     :type elapsed: int
        :param elapsed: Time elapsed (ms) from the local user calling 'joinChannel' until this callback is triggered.
        """
        return _agorartc.RtcChannelEventHandlerBase_onJoinChannelSuccess(self, rtcChannel, uid, elapsed)

    def onRejoinChannelSuccess(self, rtcChannel: "IChannel", uid: "agora::rtc::uid_t", elapsed: "int") -> "void":
        r"""
         Occurs when a user rejoins the channel after being disconnected due to network problems.

        		     :type rtcChannel: :py:class:`IChannel`
        :param rtcChannel: IChannel
            		 :type uid: int
        :param uid: The user ID.
            		 :type elapsed: int
        :param elapsed: Time elapsed (ms) from the local user starting to reconnect until this callback is triggered.
        """
        return _agorartc.RtcChannelEventHandlerBase_onRejoinChannelSuccess(self, rtcChannel, uid, elapsed)

    def onLeaveChannel(self, rtcChannel: "IChannel", stats: "RtcStats") -> "void":
        r"""
         Occurs when a user leaves the channel.

        		     This callback notifies the application that a user leaves the channel when the application calls the 'leaveChannel' method.

        		     The application retrieves information, such as the call duration and statistics.

        		     :type rtcChannel: :py:class:`IChannel`
        :param rtcChannel: IChannel
            		 :type stats: :py:class:`RtcStats`
        :param stats: The call statistics: RtcStats.
        """
        return _agorartc.RtcChannelEventHandlerBase_onLeaveChannel(self, rtcChannel, stats)

    def onClientRoleChanged(self, rtcChannel: "IChannel", oldRole: "agora::rtc::CLIENT_ROLE_TYPE", newRole: "agora::rtc::CLIENT_ROLE_TYPE") -> "void":
        r"""
         Occurs when the user role switches in the live interactive streaming. For example, from a host to an audience or vice versa.

        		     This callback notifies the application of a user role switch when the application calls the 'setClientRole' method.

        		     The SDK triggers this callback when the local user switches the user role by calling the 'setClientRole' method after joining the channel.

        		     :type rtcChannel: :py:class:`IChannel`
        :param rtcChannel: IChannel
            		 :type oldRole: int
        :param oldRole: Role that the user switches from: #CLIENT_ROLE_TYPE.
            		 :type newRole: int
        :param newRole: Role that the user switches to: #CLIENT_ROLE_TYPE.
        """
        return _agorartc.RtcChannelEventHandlerBase_onClientRoleChanged(self, rtcChannel, oldRole, newRole)

    def onUserJoined(self, rtcChannel: "IChannel", uid: "agora::rtc::uid_t", elapsed: "int") -> "void":
        r"""
         Occurs when a remote user (`COMMUNICATION`)/ host (`LIVE_BROADCASTING`) joins the channel.

        		     - `COMMUNICATION` profile: This callback notifies the application that another user joins the channel. If other users are already in the channel, the SDK also reports to the application on the existing users.
        		     - `LIVE_BROADCASTING` profile: This callback notifies the application that the host joins the channel. If other hosts are already in the channel, the SDK also reports to the application on the existing hosts. We recommend limiting the number of hosts to 17.

        		     The SDK triggers this callback under one of the following circumstances:
        		     - A remote user/host joins the channel by calling the 'joinChannel' method.
        		     - A remote user switches the user role to the host by calling the 'setClientRole' method after joining the channel.
        		     - A remote user/host rejoins the channel after a network interruption.
        		     - The host injects an online media stream into the channel by calling the 'addInjectStreamUrl' method.

        		     Notes: In the `LIVE_BROADCASTING` profile:
        		     - The host receives this callback when another host joins the channel.
        		     - The audience in the channel receives this callback when a new host joins the channel.
        		     - When a web application joins the channel, the SDK triggers this callback as long as the web application publishes streams.

        		     :type rtcChannel: :py:class:`IChannel`
        :param rtcChannel: IChannel
            		 :type uid: int
        :param uid: User ID of the user or host joining the channel.
            		 :type elapsed: int
        :param elapsed: Time delay (ms) from the local user calling the 'joinChannel' method until the SDK triggers this callback.
        """
        return _agorartc.RtcChannelEventHandlerBase_onUserJoined(self, rtcChannel, uid, elapsed)

    def onUserOffline(self, rtcChannel: "IChannel", uid: "agora::rtc::uid_t", reason: "agora::rtc::USER_OFFLINE_REASON_TYPE") -> "void":
        r"""
         Occurs when a remote user ( `COMMUNICATION`)/host (`LIVE_BROADCASTING`) leaves the channel.

        		     Reasons why the user is offline:

        		     - Leave the channel: When the user/host leaves the channel, the user/host sends a goodbye message. When the message is received, the SDK assumes that the user/host leaves the channel.
        		     - Drop offline: When no data packet of the user or host is received for a certain period of time, the SDK assumes that the user/host drops offline. Unreliable network connections may lead to false detections, so we recommend using the Agora RTM SDK for more reliable offline detection.

        		     :type rtcChannel: :py:class:`IChannel`
        :param rtcChannel: IChannel
            		 :type uid: int
        :param uid: User ID of the user leaving the channel or going offline.
            		 :type reason: int
        :param reason: Reason why the user is offline: #USER_OFFLINE_REASON_TYPE.
        """
        return _agorartc.RtcChannelEventHandlerBase_onUserOffline(self, rtcChannel, uid, reason)

    def onConnectionLost(self, rtcChannel: "IChannel") -> "void":
        r"""
         Occurs when the SDK cannot reconnect to Agora's edge server 10 seconds after its connection to the server is interrupted.

        		     The SDK triggers this callback when it cannot connect to the server 10 seconds after calling the 'joinChannel' method, whether or not it is in the channel.

        		     This callback is different from 'onConnectionInterrupted':

        		     - The SDK triggers the `onConnectionInterrupted` callback when it loses connection with the server for more than four seconds after it successfully joins the channel.
        		     - The SDK triggers the `onConnectionLost` callback when it loses connection with the server for more than 10 seconds, whether or not it joins the channel.

        		     If the SDK fails to rejoin the channel 20 minutes after being disconnected from Agora's edge server, the SDK stops rejoining the channel.

        		     :type rtcChannel: :py:class:`IChannel`
        :param rtcChannel: IChannel
        """
        return _agorartc.RtcChannelEventHandlerBase_onConnectionLost(self, rtcChannel)

    def onRequestToken(self, rtcChannel: "IChannel") -> "void":
        r"""
         Occurs when the token expires.

        		     After a token is specified by calling the 'joinChannel' method, if the SDK losses connection with the Agora server due to network issues, the token may expire after a certain period of time and a new token may be required to reconnect to the server.

        		     This callback notifies the app to generate a new token and call `joinChannel` to rejoin the channel with the new token.

        		     :type rtcChannel: :py:class:`IChannel`
        :param rtcChannel: IChannel
        """
        return _agorartc.RtcChannelEventHandlerBase_onRequestToken(self, rtcChannel)

    def onTokenPrivilegeWillExpire(self, rtcChannel: "IChannel", token: "char const *") -> "void":
        r"""
         Occurs when the token expires in 30 seconds.

        		     The user becomes offline if the token used in the 'joinChannel' method expires. The SDK triggers this callback 30 seconds before the token expires to remind the application to get a new token. Upon receiving this callback, generate a new token on the server and call the 'renewToken' method to pass the new token to the SDK.

        		     :type rtcChannel: :py:class:`IChannel`
        :param rtcChannel: IChannel
            		 :type token: string
        :param token: Token that expires in 30 seconds.
        """
        return _agorartc.RtcChannelEventHandlerBase_onTokenPrivilegeWillExpire(self, rtcChannel, token)

    def onRtcStats(self, rtcChannel: "IChannel", stats: "RtcStats") -> "void":
        r"""
         Reports the statistics of the current call.

        		     The SDK triggers this callback once every two seconds after the user joins the channel.

        		     :type rtcChannel: :py:class:`IChannel`
        :param rtcChannel: IChannel
            		 :type stats: :py:class:`RtcStats`
        :param stats: Statistics of the RtcEngine: RtcStats.
        """
        return _agorartc.RtcChannelEventHandlerBase_onRtcStats(self, rtcChannel, stats)

    def onNetworkQuality(self, rtcChannel: "IChannel", uid: "agora::rtc::uid_t", txQuality: "int", rxQuality: "int") -> "void":
        r"""
         Reports the last mile network quality of each user in the channel once every two seconds.

        		     Last mile refers to the connection between the local device and Agora's edge server. This callback reports once every two seconds the last mile network conditions of each user in the channel. If a channel includes multiple users, the SDK triggers this callback as many times.

        		     :type rtcChannel: :py:class:`IChannel`
        :param rtcChannel: IChannel
            		 :type uid: int
        :param uid: User ID. The network quality of the user with this ``uid`` is reported. If ``uid`` is 0, the local network quality is reported.
            		 :type txQuality: int
        :param txQuality: Uplink transmission quality rating of the user in terms of the transmission bitrate, packet loss rate, average RTT (Round-Trip Time), and jitter of the uplink network. ``txQuality`` is a quality rating helping you understand how well the current uplink network conditions can support the selected VideoEncoderConfiguration. For example, a 1000 Kbps uplink network may be adequate for video frames with a resolution of 640 * 480 and a frame rate of 15 fps in the `LIVE_BROADCASTING` profile, but may be inadequate for resolutions higher than 1280 * 720. See #QUALITY_TYPE.
            		 :type rxQuality: int
        :param rxQuality: Downlink network quality rating of the user in terms of the packet loss rate, average RTT, and jitter of the downlink network. See #QUALITY_TYPE.
        """
        return _agorartc.RtcChannelEventHandlerBase_onNetworkQuality(self, rtcChannel, uid, txQuality, rxQuality)

    def onRemoteVideoStats(self, rtcChannel: "IChannel", stats: "RemoteVideoStats") -> "void":
        r"""
         Reports the statistics of the video stream from each remote user/host.

        The SDK triggers this callback once every two seconds for each remote
        user/host. If a channel includes multiple remote users, the SDK
        triggers this callback as many times.

        :type rtcChannel: :py:class:`IChannel`
        :param rtcChannel: IChannel
        :type stats: :py:class:`RemoteVideoStats`
        :param stats: Statistics of the remote video stream. See
            RemoteVideoStats.
        """
        return _agorartc.RtcChannelEventHandlerBase_onRemoteVideoStats(self, rtcChannel, stats)

    def onRemoteAudioStats(self, rtcChannel: "IChannel", stats: "RemoteAudioStats") -> "void":
        r"""
         Reports the statistics of the audio stream from each remote user/host.

        		     This callback replaces the 'onAudioQuality' callback.

        		     The SDK triggers this callback once every two seconds for each remote user/host. If a channel includes multiple remote users, the SDK triggers this callback as many times.

        		     :type rtcChannel: :py:class:`IChannel`
        :param rtcChannel: IChannel
            		 :type stats: :py:class:`RemoteAudioStats`
        :param stats: The statistics of the received remote audio streams. See RemoteAudioStats.
        """
        return _agorartc.RtcChannelEventHandlerBase_onRemoteAudioStats(self, rtcChannel, stats)

    def onRemoteAudioStateChanged(self, rtcChannel: "IChannel", uid: "agora::rtc::uid_t", state: "agora::rtc::REMOTE_AUDIO_STATE", reason: "agora::rtc::REMOTE_AUDIO_STATE_REASON", elapsed: "int") -> "void":
        r"""
         Occurs when the remote audio state changes.

        		      This callback indicates the state change of the remote audio stream.
        		      Notes: This callback does not work properly when the number of users (in the `COMMUNICATION` profile) or hosts (in the `LIVE_BROADCASTING` profile) in the channel exceeds 17.

        		      :type rtcChannel: :py:class:`IChannel`
        :param rtcChannel: IChannel
            		  :type uid: int
        :param uid: ID of the remote user whose audio state changes.
            		  :type state: int
        :param state: State of the remote audio. See #REMOTE_AUDIO_STATE.
            		  :type reason: int
        :param reason: The reason of the remote audio state change.
            		      See #REMOTE_AUDIO_STATE_REASON.
            		  :type elapsed: int
        :param elapsed: Time elapsed (ms) from the local user calling the
            		      'joinChannel' method until the SDK
            		      triggers this callback.
        """
        return _agorartc.RtcChannelEventHandlerBase_onRemoteAudioStateChanged(self, rtcChannel, uid, state, reason, elapsed)

    def onActiveSpeaker(self, rtcChannel: "IChannel", uid: "agora::rtc::uid_t") -> "void":
        r"""
         Reports which user is the loudest speaker.

        		     If the user enables the audio volume indication by calling the 'IRtcEngine::enableAudioVolumeIndication(int', int, bool) "enableAudioVolumeIndication" method, this callback returns the ``uid`` of the active speaker detected by the audio volume detection module of the SDK.

        		     Notes: 
        		     - To receive this callback, you need to call the 'IRtcEngine::enableAudioVolumeIndication(int', int, bool) "enableAudioVolumeIndication" method.
        		     - This callback returns the user ID of the user with the highest voice volume during a period of time, instead of at the moment.

        		     :type rtcChannel: :py:class:`IChannel`
        :param rtcChannel: IChannel
            		 :type uid: int
        :param uid: User ID of the active speaker. A `uid` of 0 represents the local user.
        """
        return _agorartc.RtcChannelEventHandlerBase_onActiveSpeaker(self, rtcChannel, uid)

    def onVideoSizeChanged(self, rtcChannel: "IChannel", uid: "agora::rtc::uid_t", width: "int", height: "int", rotation: "int") -> "void":
        r"""
         Occurs when the video size or rotation of a specified user changes.

        		     :type rtcChannel: :py:class:`IChannel`
        :param rtcChannel: IChannel
            		 :type uid: int
        :param uid: User ID of the remote user or local user (0) whose video size or rotation changes.
            		 :type width: int
        :param width: New width (pixels) of the video.
            		 :type height: int
        :param height: New height (pixels) of the video.
            		 :type rotation: int
        :param rotation: New rotation of the video [0 to 360).
        """
        return _agorartc.RtcChannelEventHandlerBase_onVideoSizeChanged(self, rtcChannel, uid, width, height, rotation)

    def onRemoteVideoStateChanged(self, rtcChannel: "IChannel", uid: "agora::rtc::uid_t", state: "agora::rtc::REMOTE_VIDEO_STATE", reason: "agora::rtc::REMOTE_VIDEO_STATE_REASON", elapsed: "int") -> "void":
        r"""
         Occurs when the remote video state changes.

        		     Notes: This callback does not work properly when the number of users (in the `COMMUNICATION` profile) or hosts (in the `LIVE_BROADCASTING` profile) in the channel exceeds 17.

        		     :type rtcChannel: :py:class:`IChannel`
        :param rtcChannel: IChannel
            		 :type uid: int
        :param uid: ID of the remote user whose video state changes.
            		 :type state: int
        :param state: State of the remote video. See #REMOTE_VIDEO_STATE.
            		 :type reason: int
        :param reason: The reason of the remote video state change. See
            		     #REMOTE_VIDEO_STATE_REASON.
            		 :type elapsed: int
        :param elapsed: Time elapsed (ms) from the local user calling the
            		     'joinChannel' method until the
            		     SDK triggers this callback.
        """
        return _agorartc.RtcChannelEventHandlerBase_onRemoteVideoStateChanged(self, rtcChannel, uid, state, reason, elapsed)

    def onStreamMessage(self, rtcChannel: "IChannel", uid: "agora::rtc::uid_t", streamId: "int", data: "char const *", length: "size_t") -> "void":
        r"""
         Occurs when the local user receives the data stream from the remote user within five seconds.

        		     The SDK triggers this callback when the local user receives the stream message that the remote user sends by calling the 'sendStreamMessage' method.

        		     :type rtcChannel: :py:class:`IChannel`
        :param rtcChannel: IChannel
            		 :type uid: int
        :param uid: User ID of the remote user sending the message.
            		 :type streamId: int
        :param streamId: Stream ID.
            		 :type data: string
        :param data: The data received by the local user.
            		 :type length: int
        :param length: Length of the data in bytes.
        """
        return _agorartc.RtcChannelEventHandlerBase_onStreamMessage(self, rtcChannel, uid, streamId, data, length)

    def onStreamMessageError(self, rtcChannel: "IChannel", uid: "agora::rtc::uid_t", streamId: "int", code: "int", missed: "int", cached: "int") -> "void":
        r"""
         Occurs when the local user does not receive the data stream from the remote user within five seconds.

        		     The SDK triggers this callback when the local user fails to receive the stream message that the remote user sends by calling the 'sendStreamMessage' method.

        		     :type rtcChannel: :py:class:`IChannel`
        :param rtcChannel: IChannel
            		 :type uid: int
        :param uid: User ID of the remote user sending the message.
            		 :type streamId: int
        :param streamId: Stream ID.
            		 :type code: int
        :param code: Error code: #ERROR_CODE_TYPE.
            		 :type missed: int
        :param missed: Number of lost messages.
            		 :type cached: int
        :param cached: Number of incoming cached messages when the data stream is interrupted.
        """
        return _agorartc.RtcChannelEventHandlerBase_onStreamMessageError(self, rtcChannel, uid, streamId, code, missed, cached)

    def onChannelMediaRelayStateChanged(self, rtcChannel: "IChannel", state: "agora::rtc::CHANNEL_MEDIA_RELAY_STATE", code: "agora::rtc::CHANNEL_MEDIA_RELAY_ERROR") -> "void":
        r"""
         Occurs when the state of the media stream relay changes.

        The SDK returns the state of the current media relay with any error
        message.
        :type rtcChannel: :py:class:`IChannel`
        :param rtcChannel: IChannel
        :type state: int
        :param state: The state code in #CHANNEL_MEDIA_RELAY_STATE.
        :type code: int
        :param code: The error code in #CHANNEL_MEDIA_RELAY_ERROR.
        """
        return _agorartc.RtcChannelEventHandlerBase_onChannelMediaRelayStateChanged(self, rtcChannel, state, code)

    def onChannelMediaRelayEvent(self, rtcChannel: "IChannel", code: "agora::rtc::CHANNEL_MEDIA_RELAY_EVENT") -> "void":
        r"""
         Reports events during the media stream relay.
        :type rtcChannel: :py:class:`IChannel`
        :param rtcChannel: IChannel
        :type code: int
        :param code: The event code in #CHANNEL_MEDIA_RELAY_EVENT.
        """
        return _agorartc.RtcChannelEventHandlerBase_onChannelMediaRelayEvent(self, rtcChannel, code)

    def onRtmpStreamingStateChanged(self, rtcChannel: "IChannel", url: "char const *", state: "agora::rtc::RTMP_STREAM_PUBLISH_STATE", errCode: "agora::rtc::RTMP_STREAM_PUBLISH_ERROR") -> "void":
        r"""
        		     Occurs when the state of the RTMP streaming changes.

        		     The SDK triggers this callback to report the result of the local user calling the 'addPublishStreamUrl' or 'removePublishStreamUrl' method.

        		     This callback indicates the state of the RTMP streaming. When exceptions occur, you can troubleshoot issues by referring to the detailed error descriptions in the *errCode* parameter.

        		     :type rtcChannel: :py:class:`IChannel`
        :param rtcChannel: IChannel
            		 :type url: string
        :param url: The RTMP URL address.
            		 :type state: int
        :param state: The RTMP streaming state. See: #RTMP_STREAM_PUBLISH_STATE.
            		 :type errCode: int
        :param errCode: The detailed error information for streaming. See: #RTMP_STREAM_PUBLISH_ERROR.
        """
        return _agorartc.RtcChannelEventHandlerBase_onRtmpStreamingStateChanged(self, rtcChannel, url, state, errCode)

    def onTranscodingUpdated(self, rtcChannel: "IChannel") -> "void":
        r"""
         Reports events during the RTMP streaming.

        Since: v3.1.0

        :type rtcChannel: :py:class:`IChannel`
        :param rtcChannel: IChannel
        :param url: The RTMP streaming URL.
        :param eventCode: The event code. See #RTMP_STREAMING_EVENT
        """
        return _agorartc.RtcChannelEventHandlerBase_onTranscodingUpdated(self, rtcChannel)

    def onStreamInjectedStatus(self, rtcChannel: "IChannel", url: "char const *", uid: "agora::rtc::uid_t", status: "int") -> "void":
        r"""
         Occurs when a voice or video stream URL address is added to the live interactive streaming.

        		     :type rtcChannel: :py:class:`IChannel`
        :param rtcChannel: IChannel
            		 :type url: string
        :param url: The URL address of the externally injected stream.
            		 :type uid: int
        :param uid: User ID.
            		 :type status: int
        :param status: State of the externally injected stream: #INJECT_STREAM_STATUS.
        """
        return _agorartc.RtcChannelEventHandlerBase_onStreamInjectedStatus(self, rtcChannel, url, uid, status)

    def onLocalPublishFallbackToAudioOnly(self, rtcChannel: "IChannel", isFallbackOrRecover: "bool") -> "void":
        r"""
         Occurs when the published media stream falls back to an audio-only stream due to poor network conditions or switches back to the video after the network conditions improve.

        		    If you call 'setLocalPublishFallbackOption' and set *option* as #STREAM_FALLBACK_OPTION_AUDIO_ONLY, the SDK triggers this callback when the published stream falls back to audio-only mode due to poor uplink conditions, or when the audio stream switches back to the video after the uplink network condition improves.

        		    :type rtcChannel: :py:class:`IChannel`
        :param rtcChannel: IChannel
            		:type isFallbackOrRecover: boolean
        :param isFallbackOrRecover: Whether the published stream falls back to audio-only or switches back to the video:
            		    - true: The published stream falls back to audio-only due to poor network conditions.
            		    - false: The published stream switches back to the video after the network conditions improve.
        """
        return _agorartc.RtcChannelEventHandlerBase_onLocalPublishFallbackToAudioOnly(self, rtcChannel, isFallbackOrRecover)

    def onRemoteSubscribeFallbackToAudioOnly(self, rtcChannel: "IChannel", uid: "agora::rtc::uid_t", isFallbackOrRecover: "bool") -> "void":
        r"""
         Occurs when the remote media stream falls back to audio-only stream
        due to poor network conditions or switches back to the video stream
        after the network conditions improve.

        If you call
        'IRtcEngine::setRemoteSubscribeFallbackOption'
        "setRemoteSubscribeFallbackOption" and set
        ``option`` as #STREAM_FALLBACK_OPTION_AUDIO_ONLY, the SDK triggers this
        callback when the remote media stream falls back to audio-only mode due
        to poor uplink conditions, or when the remote media stream switches
        back to the video after the uplink network condition improves.

        Notes: Once the remote media stream switches to the low stream due to
        poor network conditions, you can monitor the stream switch between a
        high and low stream in the RemoteVideoStats callback.
        :type rtcChannel: :py:class:`IChannel`
        :param rtcChannel: IChannel
        :type uid: int
        :param uid: ID of the remote user sending the stream.
        :type isFallbackOrRecover: boolean
        :param isFallbackOrRecover: Whether the remotely subscribed media stream
            falls back to audio-only or switches back to the video:
            - true: The remotely subscribed media stream falls back to audio-only
            due to poor network conditions.
            - false: The remotely subscribed media stream switches back to the
            video stream after the network conditions improved.
        """
        return _agorartc.RtcChannelEventHandlerBase_onRemoteSubscribeFallbackToAudioOnly(self, rtcChannel, uid, isFallbackOrRecover)

    def onConnectionStateChanged(self, rtcChannel: "IChannel", state: "agora::rtc::CONNECTION_STATE_TYPE", reason: "agora::rtc::CONNECTION_CHANGED_REASON_TYPE") -> "void":
        r"""
         Occurs when the connection state between the SDK and the server changes.

        		     :type rtcChannel: :py:class:`IChannel`
        :param rtcChannel: IChannel
            		 :type state: int
        :param state: See #CONNECTION_STATE_TYPE.
            		 :type reason: int
        :param reason: See #CONNECTION_CHANGED_REASON_TYPE.
        """
        return _agorartc.RtcChannelEventHandlerBase_onConnectionStateChanged(self, rtcChannel, state, reason)

    def onTestEnd(self, rtcChannel: "IChannel") -> "void":
        return _agorartc.RtcChannelEventHandlerBase_onTestEnd(self, rtcChannel)

    def __init__(self):
        if self.__class__ == RtcChannelEventHandlerBase:
            _self = None
        else:
            _self = self
        _agorartc.RtcChannelEventHandlerBase_swiginit(self, _agorartc.new_RtcChannelEventHandlerBase(_self, ))
    def __disown__(self):
        self.this.disown()
        _agorartc.disown_RtcChannelEventHandlerBase(self)
        return weakref.proxy(self)

# Register RtcChannelEventHandlerBase in _agorartc:
_agorartc.RtcChannelEventHandlerBase_swigregister(RtcChannelEventHandlerBase)


def createVideoCanvas(ptr: "uint64_t") -> "agora::rtc::VideoCanvas":
    return _agorartc.createVideoCanvas(ptr)

def createRtcEngineBridge() -> "agora::common::RtcEngineBridge *":
    return _agorartc.createRtcEngineBridge()
class VideoFrameObserver(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _agorartc.delete_VideoFrameObserver

    def onCaptureVideoFrame(self, width: "int", height: "int", ybuffer: "uint64_t", ubuffer: "uint64_t", vbuffer: "uint64_t") -> "void":
        return _agorartc.VideoFrameObserver_onCaptureVideoFrame(self, width, height, ybuffer, ubuffer, vbuffer)

    def onRenderVideoFrame(self, uid: "unsigned int", width: "int", height: "int", ybuffer: "uint64_t", ubuffer: "uint64_t", vbuffer: "uint64_t") -> "void":
        return _agorartc.VideoFrameObserver_onRenderVideoFrame(self, uid, width, height, ybuffer, ubuffer, vbuffer)
    privateData = property(_agorartc.VideoFrameObserver_privateData_get, _agorartc.VideoFrameObserver_privateData_set)

    def __init__(self):
        if self.__class__ == VideoFrameObserver:
            _self = None
        else:
            _self = self
        _agorartc.VideoFrameObserver_swiginit(self, _agorartc.new_VideoFrameObserver(_self, ))
    def __disown__(self):
        self.this.disown()
        _agorartc.disown_VideoFrameObserver(self)
        return weakref.proxy(self)

# Register VideoFrameObserver in _agorartc:
_agorartc.VideoFrameObserver_swigregister(VideoFrameObserver)


def registerVideoFrameObserver(rtc: "RtcEngineBridge", frameObserver: "VideoFrameObserver") -> "void":
    return _agorartc.registerVideoFrameObserver(rtc, frameObserver)

def unregisterVideoFrameObserver(rtc: "RtcEngineBridge", frameObserver: "VideoFrameObserver") -> "void":
    return _agorartc.unregisterVideoFrameObserver(rtc, frameObserver)
class AudioFrameObserver(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _agorartc.delete_AudioFrameObserver

    def onRecordAudioFrame(self, type1: "unsigned int", samples: "int", bytesPerSample: "int", channels: "int", samplesPerSec: "int", buffer1: "uint64_t", renderTimeMs: "int64_t", avsync_type: "int") -> "void":
        return _agorartc.AudioFrameObserver_onRecordAudioFrame(self, type1, samples, bytesPerSample, channels, samplesPerSec, buffer1, renderTimeMs, avsync_type)

    def onPlaybackAudioFrame(self, type1: "unsigned int", samples: "int", bytesPerSample: "int", channels: "int", samplesPerSec: "int", buffer1: "uint64_t", renderTimeMs: "int64_t", avsync_type: "int") -> "void":
        return _agorartc.AudioFrameObserver_onPlaybackAudioFrame(self, type1, samples, bytesPerSample, channels, samplesPerSec, buffer1, renderTimeMs, avsync_type)

    def onMixedAudioFrame(self, type1: "unsigned int", samples: "int", bytesPerSample: "int", channels: "int", samplesPerSec: "int", buffer1: "uint64_t", renderTimeMs: "int64_t", avsync_type: "int") -> "void":
        return _agorartc.AudioFrameObserver_onMixedAudioFrame(self, type1, samples, bytesPerSample, channels, samplesPerSec, buffer1, renderTimeMs, avsync_type)

    def onPlaybackAudioFrameBeforeMixing(self, uid: "unsigned int", type1: "unsigned int", samples: "int", bytesPerSample: "int", channels: "int", samplesPerSec: "int", buffer1: "uint64_t", renderTimeMs: "int64_t", avsync_type: "int") -> "void":
        return _agorartc.AudioFrameObserver_onPlaybackAudioFrameBeforeMixing(self, uid, type1, samples, bytesPerSample, channels, samplesPerSec, buffer1, renderTimeMs, avsync_type)
    privateData = property(_agorartc.AudioFrameObserver_privateData_get, _agorartc.AudioFrameObserver_privateData_set)

    def __init__(self):
        if self.__class__ == AudioFrameObserver:
            _self = None
        else:
            _self = self
        _agorartc.AudioFrameObserver_swiginit(self, _agorartc.new_AudioFrameObserver(_self, ))
    def __disown__(self):
        self.this.disown()
        _agorartc.disown_AudioFrameObserver(self)
        return weakref.proxy(self)

# Register AudioFrameObserver in _agorartc:
_agorartc.AudioFrameObserver_swigregister(AudioFrameObserver)


def registerAudioFrameObserver(rtc: "RtcEngineBridge", frameObserver: "AudioFrameObserver") -> "void":
    return _agorartc.registerAudioFrameObserver(rtc, frameObserver)

def unregisterAudioFrameObserver(rtc: "RtcEngineBridge", frameObserver: "AudioFrameObserver") -> "void":
    return _agorartc.unregisterAudioFrameObserver(rtc, frameObserver)
class APICaseHandler(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def handleAPICase(self, apiType: "int", paramter: "char const *") -> "void":
        return _agorartc.APICaseHandler_handleAPICase(self, apiType, paramter)
    __swig_destroy__ = _agorartc.delete_APICaseHandler

    def __init__(self):
        if self.__class__ == APICaseHandler:
            _self = None
        else:
            _self = self
        _agorartc.APICaseHandler_swiginit(self, _agorartc.new_APICaseHandler(_self, ))
    def __disown__(self):
        self.this.disown()
        _agorartc.disown_APICaseHandler(self)
        return weakref.proxy(self)

# Register APICaseHandler in _agorartc:
_agorartc.APICaseHandler_swigregister(APICaseHandler)


def BeginApiTest(caseFilePath: "char const *", apiCaseHandler: "APICaseHandler") -> "void":
    return _agorartc.BeginApiTest(caseFilePath, apiCaseHandler)

def CompareAndDumpApiTestResult(caseFilePath: "char const *", dumpFilePath: "char const *", apiCaseHandler: "APICaseHandler") -> "void":
    return _agorartc.CompareAndDumpApiTestResult(caseFilePath, dumpFilePath, apiCaseHandler)

def BeginRtcEngineEventTest(caseFilePath: "char const *", eventHandler: "RtcEngineEventHandlerBase") -> "void":
    return _agorartc.BeginRtcEngineEventTest(caseFilePath, eventHandler)

def CompareAndDumpRtcEngineEventTestResult(caseFilePath: "char const *", dumpFilePath: "char const *", eventHandler: "RtcEngineEventHandlerBase") -> "void":
    return _agorartc.CompareAndDumpRtcEngineEventTestResult(caseFilePath, dumpFilePath, eventHandler)

def LogEngineEventCase(eventType: "char const *", parameter: "char const *") -> "void":
    return _agorartc.LogEngineEventCase(eventType, parameter)

def BeginChannelEventTest(caseFilePath: "char const *", rtcChannel: "IChannel", eventHandler: "RtcChannelEventHandlerBase") -> "void":
    return _agorartc.BeginChannelEventTest(caseFilePath, rtcChannel, eventHandler)

def CompareAndDumpChannelEventTestResult(caseFilePath: "char const *", dumpFilePath: "char const *", rtcChannel: "IChannel", eventHandler: "RtcChannelEventHandlerBase") -> "void":
    return _agorartc.CompareAndDumpChannelEventTestResult(caseFilePath, dumpFilePath, rtcChannel, eventHandler)

def LogChannelEventCase(eventType: "char const *", parameter: "char const *") -> "void":
    return _agorartc.LogChannelEventCase(eventType, parameter)
class IChannel(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def channelId(self) -> "char const *":
        return _agorartc.IChannel_channelId(self)
    __swig_destroy__ = _agorartc.delete_IChannel

# Register IChannel in _agorartc:
_agorartc.IChannel_swigregister(IChannel)

class ChannelMediaOptions(object):
    r""" The channel media options."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    autoSubscribeAudio = property(_agorartc.ChannelMediaOptions_autoSubscribeAudio_get, _agorartc.ChannelMediaOptions_autoSubscribeAudio_set, doc=r"""
    Determines whether to subscribe to audio streams when the user joins the channel:
        - true: (Default) Subscribe.
        - false: Do not subscribe.

        This member serves a similar function to the 'muteAllRemoteAudioStreams' method. After joining the channel,
        you can call the `muteAllRemoteAudioStreams` method to set whether to subscribe to audio streams in the channel.
    """)
    autoSubscribeVideo = property(_agorartc.ChannelMediaOptions_autoSubscribeVideo_get, _agorartc.ChannelMediaOptions_autoSubscribeVideo_set, doc=r"""
    Determines whether to subscribe to video streams when the user joins the channel:
        - true: (Default) Subscribe.
        - false: Do not subscribe.

        This member serves a similar function to the 'muteAllRemoteVideoStreams' method. After joining the channel,
        you can call the `muteAllRemoteVideoStreams` method to set whether to subscribe to video streams in the channel.
    """)

    def __init__(self):
        _agorartc.ChannelMediaOptions_swiginit(self, _agorartc.new_ChannelMediaOptions())
    __swig_destroy__ = _agorartc.delete_ChannelMediaOptions

# Register ChannelMediaOptions in _agorartc:
_agorartc.ChannelMediaOptions_swigregister(ChannelMediaOptions)

class RtcChannelBridge(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def initChannelEventHandler(self, eventHandler: "IChannelEventHandler") -> "int":
        return _agorartc.RtcChannelBridge_initChannelEventHandler(self, eventHandler)

    def release(self) -> "void":
        r"""
         Releases all IChannel resources.

        		     :rtype: void
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
            		        - `ERR_NOT_INITIALIZED (7)`: The SDK is not initialized before calling this method.
        """
        return _agorartc.RtcChannelBridge_release(self)

    def joinChannel(self, token: "char const *", info: "char const *", uid: "agora::rtc::uid_t", options: "ChannelMediaOptions") -> "int":
        r"""
         Joins the channel with a user ID.

        		     This method differs from the `joinChannel` method in the `IRtcEngine` class in the following aspects:

        		     | IChannel::joinChannel                                                                                                                    | IRtcEngine::joinChannel                                                                                      |
        		     |------------------------------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------|
        		     | Does not contain the `channelId` parameter, because `channelId` is specified when creating the `IChannel` object.                              | Contains the `channelId` parameter, which specifies the channel to join.                                       |
        		     | Contains the `options` parameter, which decides whether to subscribe to all streams before joining the channel.                            | Does not contain the `options` parameter. By default, users subscribe to all streams when joining the channel. |
        		     | Users can join multiple channels simultaneously by creating multiple `IChannel` objects and calling the `joinChannel` method of each object. | Users can join only one channel.                                                                             |
        		     | By default, the SDK does not publish any stream after the user joins the channel. You need to call the publish method to do that.        | By default, the SDK publishes streams once the user joins the channel.                                       |

        		     Notes: 
        		     - If you are already in a channel, you cannot rejoin it with the same `uid`.
        		     - We recommend using different UIDs for different channels.
        		     - If you want to join the same channel from different devices, ensure that the UIDs in all devices are different.
        		     - Ensure that the app ID you use to generate the token is the same with the app ID used when creating the `IRtcEngine` object.

        		     :type token: string
        :param token: The token for authentication:
            		     - In situations not requiring high security: You can use the temporary token generated at Console. For details, see [Get a temporary token](https://docs.agora.io/en/Agora%20Platform/token?platfor%20*%20m=All%20Platforms#get-a-temporary-token).
            		     - In situations requiring high security: Set it as the token generated at your server. For details, see [Generate a token](https://docs.agora.io/en/Agora%20Platform/token?platfor%20*%20m=All%20Platforms#get-a-token).
            		 :type info: string
        :param info: (Optional) Additional information about the channel. This parameter can be set as null. Other users in the channel do not receive this information.
            		 :type uid: int
        :param uid: The user ID. A 32-bit unsigned integer with a value ranging from 1 to (232-1). This parameter must be unique. If `uid` is not assigned (or set as `0`), the SDK assigns a `uid` and reports it in the 'onJoinChannelSuccess' callback. The app must maintain this user ID.
            		 :type options: :py:class:`ChannelMediaOptions`
        :param options: The channel media options: 'ChannelMediaOptions'

        		     :rtype: int
        :return: 
            		     - 0(ERR_OK): Success.
            		     - < 0: Failure.
            		        - -2(ERR_INALID_ARGUMENT): The parameter is invalid.
            		        - -3(ERR_NOT_READY): The SDK fails to be initialized. You can try re-initializing the SDK.
            		        - -5(ERR_REFUSED): The request is rejected. This may be caused by the following:
            		           - You have created an IChannel object with the same channel name.
            		           - You have joined and published a stream in a channel created by the IChannel object.
        """
        return _agorartc.RtcChannelBridge_joinChannel(self, token, info, uid, options)

    def joinChannelWithUserAccount(self, token: "char const *", userAccount: "char const *", options: "ChannelMediaOptions") -> "int":
        r"""
         Joins the channel with a user account.

        		     After the user successfully joins the channel, the SDK triggers the following callbacks:

        		     - The local client: 'onLocalUserRegistered' and 'onJoinChannelSuccess' .
        		     - The remote client: 'onUserJoined' and 'onUserInfoUpdated' , if the user joining the channel is in the `COMMUNICATION` profile, or is a host in the `LIVE_BROADCASTING` profile.

        		     Notes: To ensure smooth communication, use the same parameter type to identify the user. For example, if a user joins the channel with a user ID, then ensure all the other users use the user ID too. The same applies to the user account.
        		     If a user joins the channel with the Agora Web SDK, ensure that the uid of the user is set to the same parameter type.

        		     :type token: string
        :param token: The token generated at your server:
            		     - For low-security requirements: You can use the temporary token generated at Console. For details, see [Get a temporary toke](https://docs.agora.io/en/Voice/token?platform=All%20Platforms#get-a-temporary-token).
            		     - For high-security requirements: Set it as the token generated at your server. For details, see [Get a token](https://docs.agora.io/en/Voice/token?platform=All%20Platforms#get-a-token).
            		 :type userAccount: string
        :param userAccount: The user account. The maximum length of this parameter is 255 bytes. Ensure that you set this parameter and do not set it as null. Supported character scopes are:
            		     - All lowercase English letters: a to z.
            		     - All uppercase English letters: A to Z.
            		     - All numeric characters: 0 to 9.
            		     - The space character.
            		     - Punctuation characters and other symbols, including: "!", "#", "$", "%", "&", "(", ")", "+", "-", ":", ";", "<", "=", ".", ">", "?", "@", "[", "]", "^", "_", " {", "}", "|", "~", ",".
            		 :type options: :py:class:`ChannelMediaOptions`
        :param options: The channel media options: 'agora::rtc::ChannelMediaOptions::ChannelMediaOptions' “ChannelMediaOptions”.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
            		        - #ERR_INVALID_ARGUMENT (-2)
            		        - #ERR_NOT_READY (-3)
            		        - #ERR_REFUSED (-5)
        """
        return _agorartc.RtcChannelBridge_joinChannelWithUserAccount(self, token, userAccount, options)

    def leaveChannel(self) -> "int":
        r"""
         Allows a user to leave a channel, such as hanging up or exiting a call.

        		     After joining a channel, the user must call the *leaveChannel* method to end the call before joining another channel.

        		     This method returns 0 if the user leaves the channel and releases all resources related to the call.

        		     This method call is asynchronous, and the user has not left the channel when the method call returns. Once the user leaves the channel, the SDK triggers the 'onLeaveChannel' callback.

        		     A successful 'leaveChannel' method call triggers the following callbacks:
        		     - The local client: 'onLeaveChannel'
        		     - The remote client: 'onUserOffline' , if the user leaving the channel is in the Communication channel, or is a host in the `LIVE_BROADCASTING` profile.

        		     Notes: 
        		     - If you call the 'release' method immediately after the *leaveChannel* method, the *leaveChannel* process interrupts, and the 'onLeaveChannel' callback is not triggered.
        		     - If you call the *leaveChannel* method during a CDN live streaming, the SDK triggers the 'removePublishStreamUrl' method.

        		     :rtype: int
        :return: 
            		     - 0(ERR_OK): Success.
            		     - < 0: Failure.
            		        - -1(ERR_FAILED): A general error occurs (no specified reason).
            		        - -2(ERR_INALID_ARGUMENT): The parameter is invalid.
            		        - -7(ERR_NOT_INITIALIZED): The SDK is not initialized.
        """
        return _agorartc.RtcChannelBridge_leaveChannel(self)

    def publish(self) -> "int":
        r"""
         Publishes the local stream to the channel.

        		     You must keep the following restrictions in mind when calling this method. Otherwise, the SDK returns the #ERR_REFUSED (5):
        		     - This method publishes one stream only to the channel corresponding to the current `IChannel` object.
        		     - In the live interactive streaming channel, only a host can call this method. To switch the client role, call 'setClientRole' of the current `IChannel` object.
        		     - You can publish a stream to only one channel at a time. For details on joining multiple channels, see the advanced guide *Join Multiple Channels*.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
            		        - #ERR_REFUSED (5): The method call is refused.
        """
        return _agorartc.RtcChannelBridge_publish(self)

    def unpublish(self) -> "int":
        r"""
         Stops publishing a stream to the channel.

        		     If you call this method in a channel where you are not publishing streams, the SDK returns #ERR_REFUSED (5).

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
            		        - #ERR_REFUSED (5): The method call is refused.
        """
        return _agorartc.RtcChannelBridge_unpublish(self)

    def channelId(self) -> "char const *":
        r"""
         Gets the channel ID of the current `IChannel` object.

        		     :rtype: string
        :return: 
            		     - The channel ID of the current `IChannel` object, if the method call succeeds.
            		     - The empty string "", if the method call fails.
        """
        return _agorartc.RtcChannelBridge_channelId(self)

    def getCallId(self, callId: "agora::util::AString &") -> "int":
        r"""
         Retrieves the current call ID.

        		     When a user joins a channel on a client, a `callId` is generated to identify the call from the client.
        		     Feedback methods, such as 'rate' and 'complain', must be called after the call ends to submit feedback to the SDK.

        		     The `rate` and `complain` methods require the `callId` parameter retrieved from the `getCallId` method during a call. `callId` is passed as an argument into the `rate` and `complain` methods after the call ends.

        		     :type callId: agora::util::AString
        :param callId: The current call ID.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcChannelBridge_getCallId(self, callId)

    def renewToken(self, token: "char const *") -> "int":
        r"""
         Gets a new token when the current token expires after a period of time.

        		     The `token` expires after a period of time once the token schema is enabled when:

        		     - The SDK triggers the 'onTokenPrivilegeWillExpire' callback, or
        		     - The 'onConnectionStateChanged' reports CONNECTION_CHANGED_TOKEN_EXPIRED(9).

        		     The application should call this method to get the new `token`. Failure to do so will result in the SDK disconnecting from the server.

        		     :type token: string
        :param token: Pointer to the new token.

        		     :rtype: int
        :return: 
            		     - 0(ERR_OK): Success.
            		     - < 0: Failure.
            		        - -1(ERR_FAILED): A general error occurs (no specified reason).
            		        - -2(ERR_INALID_ARGUMENT): The parameter is invalid.
            		        - -7(ERR_NOT_INITIALIZED): The SDK is not initialized.
        """
        return _agorartc.RtcChannelBridge_renewToken(self, token)

    def setEncryptionSecret(self, secret: "char const *") -> "int":
        r"""
         Enables built-in encryption with an encryption password before users join a channel.

        		     Deprecated: Deprecated as of v3.1.0. Use the 'enableEncryption' instead.

        		     All users in a channel must use the same encryption password. The encryption password is automatically cleared once a user leaves the channel.

        		     If an encryption password is not specified, the encryption functionality will be disabled.

        		     Notes: 
        		     - Do not use this method for CDN live streaming.
        		     - For optimal transmission, ensure that the encrypted data size does not exceed the original data size + 16 bytes. 16 bytes is the maximum padding size for AES encryption.

        		     :type secret: string
        :param secret: Pointer to the encryption password.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcChannelBridge_setEncryptionSecret(self, secret)

    def setEncryptionMode(self, encryptionMode: "char const *") -> "int":
        r"""
         Sets the built-in encryption mode.

        		     Deprecated: Deprecated as of v3.1.0. Use the 'enableEncryption' instead.

        		     The Agora SDK supports built-in encryption, which is set to the `aes-128-xts` mode by default. Call this method to use other encryption modes.

        		     All users in the same channel must use the same encryption mode and password.

        		     Refer to the information related to the AES encryption algorithm on the differences between the encryption modes.

        		     Notes: Call the 'setEncryptionSecret' method to enable the built-in encryption function before calling this method.

        		     :type encryptionMode: string
        :param encryptionMode: The set encryption mode:
            		     - "aes-128-xts": (Default) 128-bit AES encryption, XTS mode.
            		     - "aes-128-ecb": 128-bit AES encryption, ECB mode.
            		     - "aes-256-xts": 256-bit AES encryption, XTS mode.
            		     - "": When encryptionMode is set as NULL, the encryption mode is set as "aes-128-xts" by default.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcChannelBridge_setEncryptionMode(self, encryptionMode)

    def registerPacketObserver(self, observer: "agora::rtc::IPacketObserver *") -> "int":
        r"""
         Registers a packet observer.

        		     The Agora SDK allows your application to register a packet observer to receive callbacks for voice or video packet transmission.

        		     Notes: 
        		     - The size of the packet sent to the network after processing should not exceed 1200 bytes, otherwise, the packet may fail to be sent.
        		     - Ensure that both receivers and senders call this method, otherwise, you may meet undefined behaviors such as no voice and black screen.
        		     - When you use CDN live streaming, recording or storage functions, Agora doesn't recommend calling this method.

        		     :type observer: agora::rtc::IPacketObserver
        :param observer: The registered packet observer. See IPacketObserver.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcChannelBridge_registerPacketObserver(self, observer)

    def setClientRole(self, role: "agora::rtc::CLIENT_ROLE_TYPE") -> "int":
        r"""
         Sets the role of the user, such as a host or an audience (default), before joining a channel in the interactive live streaming.

        		     This method can be used to switch the user role in the interactive live streaming after the user joins a channel.

        		     In the `LIVE_BROADCASTING` profile, when a user switches user roles after joining a channel, a successful 'setClientRole' method call triggers the following callbacks:
        		     - The local client: 'onClientRoleChanged'
        		     - The remote client: 'onUserJoined' or 'onUserOffline' (BECOME_AUDIENCE)

        		     Notes: 
        		     This method applies only to the `LIVE_BROADCASTING` profile.

        		     :type role: int
        :param role: Sets the role of the user. See #CLIENT_ROLE_TYPE.
            		 :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcChannelBridge_setClientRole(self, role)

    def setRemoteUserPriority(self, uid: "agora::rtc::uid_t", userPriority: "agora::rtc::PRIORITY_TYPE") -> "int":
        r"""
         Prioritizes a remote user's stream.

        		     Use this method with the 'setRemoteSubscribeFallbackOption' method.
        		     If the fallback function is enabled for a subscribed stream, the SDK ensures the high-priority user gets the best possible stream quality.

        		     Notes: The Agora SDK supports setting `serPriority` as high for one user only.

        		     :type uid: int
        :param uid:  The ID of the remote user.
            		 :type userPriority: int
        :param userPriority: Sets the priority of the remote user. See #PRIORITY_TYPE.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcChannelBridge_setRemoteUserPriority(self, uid, userPriority)

    def setRemoteVoicePosition(self, uid: "agora::rtc::uid_t", pan: "double", gain: "double") -> "int":
        r"""
         Sets the sound position and gain of a remote user.

        		     When the local user calls this method to set the sound position of a remote user, the sound difference between the left and right channels allows the
        		     local user to track the real-time position of the remote user, creating a real sense of space. This method applies to massively multiplayer online games,
        		     such as Battle Royale games.

        		     Notes: 
        		     - For this method to work, enable stereo panning for remote users by calling the 'enableSoundPositionIndication' method before joining a channel.
        		     - This method requires hardware support. For the best sound positioning, we recommend using a stereo speaker.

        		     :type uid: int
        :param uid: The ID of the remote user.
            		 :type pan: float
        :param pan: The sound position of the remote user. The value ranges from -1.0 to 1.0:
            		     - 0.0: the remote sound comes from the front.
            		     - -1.0: the remote sound comes from the left.
            		     - 1.0: the remote sound comes from the right.
            		 :type gain: float
        :param gain: Gain of the remote user. The value ranges from 0.0 to 100.0. The default value is 100.0 (the original gain of the remote user).
            		     The smaller the value, the less the gain.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcChannelBridge_setRemoteVoicePosition(self, uid, pan, gain)

    def setRemoteRenderMode(self, userId: "agora::rtc::uid_t", renderMode: "agora::rtc::RENDER_MODE_TYPE", mirrorMode: "agora::rtc::VIDEO_MIRROR_MODE_TYPE") -> "int":
        r"""
         Updates the display mode of the video view of a remote user.

        		     After initializing the video view of a remote user, you can call this method to update its rendering and mirror modes.
        		     This method affects only the video view that the local user sees.

        		     Notes: 
        		     - Call this method after calling the 'setupRemoteVideo' method to initialize the remote video view.
        		     - During a call, you can call this method as many times as necessary to update the display mode of the video view of a remote user.

        		     :type userId: int
        :param userId: The ID of the remote user.
            		 :type renderMode: int
        :param renderMode: The rendering mode of the remote video view. See #RENDER_MODE_TYPE.
            		 :type mirrorMode: int
        :param mirrorMode:
            		     - The mirror mode of the remote video view. See #VIDEO_MIRROR_MODE_TYPE.
            		     - **Note**: The SDK disables the mirror mode by default.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcChannelBridge_setRemoteRenderMode(self, userId, renderMode, mirrorMode)

    def setDefaultMuteAllRemoteAudioStreams(self, mute: "bool") -> "int":
        r"""
         Sets whether to receive all remote audio streams by default.

        		     You can call this method either before or after joining a channel. If you call `setDefaultMuteAllRemoteAudioStreams (true)` after joining a channel, the remote audio streams of all subsequent users are not received.

        		     Notes: If you want to resume receiving the audio stream, call 'muteRemoteAudioStream (false)',
        		     and specify the ID of the remote user whose audio stream you want to receive.
        		     To receive the audio streams of multiple remote users, call `muteRemoteAudioStream (false)` as many times.
        		     Calling `setDefaultMuteAllRemoteAudioStreams (false)` resumes receiving the audio streams of subsequent users only.

        		     :type mute: boolean
        :param mute: Sets whether to receive/stop receiving all remote users' audio streams by default:
            		     - true:  Stops receiving all remote users' audio streams by default.
            		     - false: (Default) Receives all remote users' audio streams by default.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcChannelBridge_setDefaultMuteAllRemoteAudioStreams(self, mute)

    def setDefaultMuteAllRemoteVideoStreams(self, mute: "bool") -> "int":
        r"""
         Sets whether to receive all remote video streams by default.

        		     You can call this method either before or after joining a channel. If you
        		     call `setDefaultMuteAllRemoteVideoStreams (true)` after joining a channel,
        		     the remote video streams of all subsequent users are not received.

        		     Notes: If you want to resume receiving the video stream, call
        		     'muteRemoteVideoStream (false)',
        		     and specify the ID of the remote user whose video stream you want to receive.
        		     To receive the video streams of multiple remote users, call `muteRemoteVideoStream (false)`
        		     as many times. Calling `setDefaultMuteAllRemoteVideoStreams (false)` resumes
        		     receiving the video streams of subsequent users only.

        		     :type mute: boolean
        :param mute: Sets whether to receive/stop receiving all remote users' video streams by default:
            		     - true: Stop receiving all remote users' video streams by default.
            		     - false: (Default) Receive all remote users' video streams by default.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcChannelBridge_setDefaultMuteAllRemoteVideoStreams(self, mute)

    def muteAllRemoteAudioStreams(self, mute: "bool") -> "int":
        r"""
         Stops/Resumes receiving all remote users' audio streams.

        		     :type mute: boolean
        :param mute: Sets whether to receive/stop receiving all remote users' audio streams.
            		     - true: Stops receiving all remote users' audio streams.
            		     - false: (Default) Receives all remote users' audio streams.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcChannelBridge_muteAllRemoteAudioStreams(self, mute)

    def adjustUserPlaybackSignalVolume(self, userId: "agora::rtc::uid_t", volume: "int") -> "int":
        r"""
         Adjust the playback volume of the specified remote user.

        		     After joining a channel, call 'adjustPlaybackSignalVolume' to adjust the playback volume of different remote users,
        		     or adjust multiple times for one remote user.

        		     Notes: 
        		     - Call this method after joining a channel.
        		     - This method adjusts the playback volume, which is the mixed volume for the specified remote user.
        		     - This method can only adjust the playback volume of one specified remote user at a time. If you want to adjust the playback volume of several remote users,
        		     call the method multiple times, once for each remote user.

        		     :type userId: int
        :param userId: The user ID, which should be the same as the `uid` of 'joinChannel'
            		 :type volume: int
        :param volume: The playback volume of the voice. The value ranges from 0 to 100:
            		     - 0: Mute.
            		     - 100: Original volume.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            			 - < 0: Failure.
        """
        return _agorartc.RtcChannelBridge_adjustUserPlaybackSignalVolume(self, userId, volume)

    def muteRemoteAudioStream(self, userId: "agora::rtc::uid_t", mute: "bool") -> "int":
        r"""
         Stops/Resumes receiving a specified remote user's audio stream.

        			 Notes: If you called the 'muteAllRemoteAudioStreams' method and set `mute` as `true` to stop
        		     receiving all remote users' audio streams, call the `muteAllRemoteAudioStreams` method and set `mute` as `false` before calling this method.
        		     The `muteAllRemoteAudioStreams` method sets all remote audio streams, while the `muteRemoteAudioStream` method sets a specified remote audio stream.

        			 :type userId: int
        :param userId: The user ID of the specified remote user sending the audio.
            			 :type mute: boolean
        :param mute: Sets whether to receive/stop receiving a specified remote user's audio stream:
            			 - true: Stops receiving the specified remote user's audio stream.
            			 - false: (Default) Receives the specified remote user's audio stream.

        			 :rtype: int
        :return: 
            			 - 0: Success.
            			 - < 0: Failure.
        """
        return _agorartc.RtcChannelBridge_muteRemoteAudioStream(self, userId, mute)

    def muteAllRemoteVideoStreams(self, mute: "bool") -> "int":
        r"""
         Stops/Resumes receiving all video stream from a specified remote user.

        		     :type mute: boolean
        :param mute: Sets whether to receive/stop receiving all remote users' video streams:
            		     - true: Stop receiving all remote users' video streams.
            		     - false: (Default) Receive all remote users' video streams.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcChannelBridge_muteAllRemoteVideoStreams(self, mute)

    def muteRemoteVideoStream(self, userId: "agora::rtc::uid_t", mute: "bool") -> "int":
        r"""
         Stops/Resumes receiving the video stream from a specified remote user.

        		     Notes: If you called the 'muteAllRemoteVideoStreams' method and
        		     set `mute` as `true` to stop receiving all remote video streams, call the `muteAllRemoteVideoStreams` method and
        		     set `mute` as `false` before calling this method.

        		     :type userId: int
        :param userId: The user ID of the specified remote user.
            		 :type mute: boolean
        :param mute: Sets whether to stop/resume receiving the video stream from a specified remote user:
            		     - true: Stop receiving the specified remote user's video stream.
            		     - false: (Default) Receive the specified remote user's video stream.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcChannelBridge_muteRemoteVideoStream(self, userId, mute)

    def setRemoteVideoStreamType(self, userId: "agora::rtc::uid_t", streamType: "agora::rtc::REMOTE_VIDEO_STREAM_TYPE") -> "int":
        r"""
         Sets the stream type of the remote video.

        		     Under limited network conditions, if the publisher has not disabled the dual-stream mode using
        		     'enableDualStreamMode' (false),
        		     the receiver can choose to receive either the high-quality video stream (the high resolution, and high bitrate video stream) or
        		     the low-video stream (the low resolution, and low bitrate video stream).

        		     By default, users receive the high-quality video stream. Call this method if you want to switch to the low-video stream.
        		     This method allows the app to adjust the corresponding video stream type based on the size of the video window to
        		     reduce the bandwidth and resources.

        		     The aspect ratio of the low-video stream is the same as the high-quality video stream. Once the resolution of the high-quality video
        		     stream is set, the system automatically sets the resolution, frame rate, and bitrate of the low-video stream.

        		     The method result returns in the 'onApiCallExecuted' callback.

        		     :type userId: int
        :param userId: The ID of the remote user sending the video stream.
            		 :type streamType: int
        :param streamType:  Sets the video-stream type. See #REMOTE_VIDEO_STREAM_TYPE.
            		 :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcChannelBridge_setRemoteVideoStreamType(self, userId, streamType)

    def setRemoteDefaultVideoStreamType(self, streamType: "agora::rtc::REMOTE_VIDEO_STREAM_TYPE") -> "int":
        r"""
         Sets the default stream type of remote videos.

        		     Under limited network conditions, if the publisher has not disabled the dual-stream mode using
        		     'enableDualStreamMode' (false),
        		     the receiver can choose to receive either the high-quality video stream (the high resolution, and high bitrate video stream) or
        		     the low-video stream (the low resolution, and low bitrate video stream).

        		     By default, users receive the high-quality video stream. Call this method if you want to switch to the low-video stream.
        		     This method allows the app to adjust the corresponding video stream type based on the size of the video window to
        		     reduce the bandwidth and resources. The aspect ratio of the low-video stream is the same as the high-quality video stream.
        		      Once the resolution of the high-quality video
        		     stream is set, the system automatically sets the resolution, frame rate, and bitrate of the low-video stream.

        		     The method result returns in the 'onApiCallExecuted' callback.

        		     :type streamType: int
        :param streamType: Sets the default video-stream type. See #REMOTE_VIDEO_STREAM_TYPE.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcChannelBridge_setRemoteDefaultVideoStreamType(self, streamType)

    def addPublishStreamUrl(self, url: "char const *", transcodingEnabled: "bool") -> "int":
        r"""
         Publishes the local stream to a specified CDN live RTMP address.  (CDN live only.)

        		     The SDK returns the result of this method call in the 'onStreamPublished' callback.

        		     The 'addPublishStreamUrl' method call triggers
        		     the 'onRtmpStreamingStateChanged' callback on the local client
        		     to report the state of adding a local stream to the CDN.

        		     Notes: 
        		     - Ensure that the user joins the channel before calling this method.
        		     - Ensure that you enable the RTMP Converter service before using this function. See Prerequisites in the advanced guide *Push Streams to CDN*.
        		     - This method adds only one stream RTMP URL address each time it is called.

        		     :type url: string
        :param url: The CDN streaming URL in the RTMP format. The maximum length of this parameter is 1024 bytes. The RTMP URL address must not contain special characters, such as Chinese language characters.
            		 :type transcodingEnabled: boolean
        :param transcodingEnabled: Sets whether transcoding is enabled/disabled:
            		     - true: Enable transcoding. To [transcode](https://docs.agora.io/en/Agora%20Platform/terms?platform=All%20Platforms#transcoding) the audio or video streams when publishing them to CDN live, often used for combining the audio and video streams of multiple hosts in CDN live. If you set this parameter as `true`, ensure that you call the 'setLiveTranscoding' method before this method.
            		     - false: Disable transcoding.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
            		          - #ERR_INVALID_ARGUMENT (2): The RTMP URL address is NULL or has a string length of 0.
            		          - #ERR_NOT_INITIALIZED (7): You have not initialized `IChannel` when publishing the stream.
        """
        return _agorartc.RtcChannelBridge_addPublishStreamUrl(self, url, transcodingEnabled)

    def removePublishStreamUrl(self, url: "char const *") -> "int":
        r"""
         Removes an RTMP stream from the CDN.

        		     This method removes the RTMP URL address (added by the 'addPublishStreamUrl' method) from a CDN live stream.

        		     The SDK returns the result of this method call in the 'onStreamUnpublished' callback.

        		     The 'removePublishStreamUrl' method call triggers
        		     the 'onRtmpStreamingStateChanged' callback on the local client to report the state of removing an RTMP stream from the CDN.

        		     Notes: 
        		     - This method removes only one RTMP URL address each time it is called.
        		     - The RTMP URL address must not contain special characters, such as Chinese language characters.

        		     :type url: string
        :param url: The RTMP URL address to be removed. The maximum length of this parameter is 1024 bytes.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcChannelBridge_removePublishStreamUrl(self, url)

    def setLiveTranscoding(self, transcoding: "LiveTranscoding") -> "int":
        r"""
         Sets the video layout and audio settings for CDN live. (CDN live only.)

        		     The SDK triggers the 'onTranscodingUpdated' callback when you
        		     call the `setLiveTranscoding` method to update the transcoding setting.

        		     Notes: 
        		     - Ensure that you enable the RTMP Converter service before using this function. See Prerequisites in the advanced guide *Push Streams to CDN*..
        		     - If you call the `setLiveTranscoding` method to set the transcoding setting for the first time, the SDK does not trigger the `onTranscodingUpdated` callback.

        		     :type transcoding: :py:class:`LiveTranscoding`
        :param transcoding: Sets the CDN live audio/video transcoding settings. See LiveTranscoding.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcChannelBridge_setLiveTranscoding(self, transcoding)

    def addInjectStreamUrl(self, url: "char const *", config: "InjectStreamConfig") -> "int":
        r"""
         Adds a voice or video stream URL address to the interactive live streaming.

        		    The 'onStreamPublished' callback returns the inject status.
        		    If this method call is successful, the server pulls the voice or video stream and injects it into a live channel.
        		    This is applicable to scenarios where all audience members in the channel can watch a live show and interact with each other.

        		     The 'addInjectStreamUrl' method call triggers the following callbacks:
        		    - The local client:
        		      - 'onStreamInjectedStatus' , with the state of the injecting the online stream.
        		      - 'onUserJoined' (uid: 666), if the method call is successful and the online media stream is injected into the channel.
        		    - The remote client:
        		      - 'onUserJoined' (uid: 666), if the method call is successful and the online media stream is injected into the channel.

        		     Notes: 
        		     - Ensure that you enable the RTMP Converter service before using this function. See Prerequisites in the advanced guide *Push Streams to CDN*.
        		     - This method applies to the Native SDK v2.4.1 and later.
        		     - This method applies to the `LIVE_BROADCASTING` profile only.
        		     - You can inject only one media stream into the channel at the same time.

        		     :type url: string
        :param url: The URL address to be added to the ongoing live streaming. Valid protocols are RTMP, HLS, and HTTP-FLV.
            		     - Supported audio codec type: AAC.
            		     - Supported video codec type: H264 (AVC).
            		 :type config: :py:class:`InjectStreamConfig`
        :param config: The InjectStreamConfig object that contains the configuration of the added voice or video stream.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
            		        - #ERR_INVALID_ARGUMENT (2): The injected URL does not exist. Call this method again to inject the stream and ensure that the URL is valid.
            		        - #ERR_NOT_READY (3): The user is not in the channel.
            		        - #ERR_NOT_SUPPORTED (4): The channel profile is not `LIVE_BROADCASTING`. Call the 'setChannelProfile' method and set the channel profile to `LIVE_BROADCASTING` before calling this method.
            		        - #ERR_NOT_INITIALIZED (7): The SDK is not initialized. Ensure that the IChannel object is initialized before calling this method.
        """
        return _agorartc.RtcChannelBridge_addInjectStreamUrl(self, url, config)

    def removeInjectStreamUrl(self, url: "char const *") -> "int":
        r"""
         Removes the voice or video stream URL address from a live streaming.

        		     This method removes the URL address (added by the 'addInjectStreamUrl' method) from the live streaming.

        		     Notes: If this method is called successfully, the SDK triggers the 'onUserOffline' callback and returns a stream uid of 666.

        		     :type url: string
        :param url: Pointer to the URL address of the added stream to be removed.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcChannelBridge_removeInjectStreamUrl(self, url)

    def startChannelMediaRelay(self, configuration: "ChannelMediaRelayConfiguration") -> "int":
        r"""
         Starts to relay media streams across channels.

        After a successful method call, the SDK triggers the
        'agora::rtc::IChannelEventHandler::onChannelMediaRelayStateChanged'
         "onChannelMediaRelayStateChanged" and
        'agora::rtc::IChannelEventHandler::onChannelMediaRelayEvent'
        "onChannelMediaRelayEvent" callbacks, and these callbacks return the
        state and events of the media stream relay.
        - If the
        'agora::rtc::IChannelEventHandler::onChannelMediaRelayStateChanged'
         "onChannelMediaRelayStateChanged" callback returns
        #RELAY_STATE_RUNNING (2) and #RELAY_OK (0), and the
        'agora::rtc::IChannelEventHandler::onChannelMediaRelayEvent'
        "onChannelMediaRelayEvent" callback returns
        #RELAY_EVENT_PACKET_SENT_TO_DEST_CHANNEL (4), the host starts
        sending data to the destination channel.
        - If the
        'agora::rtc::IChannelEventHandler::onChannelMediaRelayStateChanged'
         "onChannelMediaRelayStateChanged" callback returns
        #RELAY_STATE_FAILURE (3), an exception occurs during the media stream
        relay.

        Notes: 
        - Call this method after the 'joinChannel' method.
        - This method takes effect only when you are a host in a
        `LIVE_BROADCASTING` channel.
        - After a successful method call, if you want to call this method
        again, ensure that you call the
        'stopChannelMediaRelay' method to quit the
        current relay.
        - Contact sales-us.io before implementing this function.
        - We do not support string user accounts in this API.

        :type configuration: :py:class:`ChannelMediaRelayConfiguration`
        :param configuration: The configuration of the media stream relay:
            ChannelMediaRelayConfiguration.

        :rtype: int
        :return: 
            - 0: Success.
            - < 0: Failure.
        """
        return _agorartc.RtcChannelBridge_startChannelMediaRelay(self, configuration)

    def updateChannelMediaRelay(self, configuration: "ChannelMediaRelayConfiguration") -> "int":
        r"""
         Updates the channels for media stream relay.

        After a successful
        'startChannelMediaRelay' method call, if
        you want to relay the media stream to more channels, or leave the
        current relay channel, you can call the
        'updateChannelMediaRelay' method.

        After a successful method call, the SDK triggers the
        'agora::rtc::IChannelEventHandler::onChannelMediaRelayEvent'
         "onChannelMediaRelayEvent" callback with the
        #RELAY_EVENT_PACKET_UPDATE_DEST_CHANNEL (7) state code.

        Notes: 
        Call this method after the
        'startChannelMediaRelay' method to update
        the destination channel.

        :type configuration: :py:class:`ChannelMediaRelayConfiguration`
        :param configuration: The media stream relay configuration:
            ChannelMediaRelayConfiguration.

        :rtype: int
        :return: 
            - 0: Success.
            - < 0: Failure.
        """
        return _agorartc.RtcChannelBridge_updateChannelMediaRelay(self, configuration)

    def stopChannelMediaRelay(self) -> "int":
        r"""
         Stops the media stream relay.

        Once the relay stops, the host quits all the destination
        channels.

        After a successful method call, the SDK triggers the
        'agora::rtc::IChannelEventHandler::onChannelMediaRelayStateChanged'
         "onChannelMediaRelayStateChanged" callback. If the callback returns
        #RELAY_STATE_IDLE (0) and #RELAY_OK (0), the host successfully
        stops the relay.

        Notes: 
        If the method call fails, the SDK triggers the
        'agora::rtc::IChannelEventHandler::onChannelMediaRelayStateChanged'
         "onChannelMediaRelayStateChanged" callback with the
        #RELAY_ERROR_SERVER_NO_RESPONSE (2) or
        #RELAY_ERROR_SERVER_CONNECTION_LOST (8) state code. You can leave the
        channel by calling the 'leaveChannel' method, and
        the media stream relay automatically stops.

        :rtype: int
        :return: 
            - 0: Success.
            - < 0: Failure.
        """
        return _agorartc.RtcChannelBridge_stopChannelMediaRelay(self)

    def createDataStream(self, streamId: "int *", reliable: "bool", ordered: "bool") -> "int":
        r"""
         Creates a data stream.

        		     Each user can create up to five data streams during the lifecycle of the IChannel.

        		     Notes: Set both the `reliable` and `ordered` parameters to `true` or `false`. Do not set one as `true` and the other as `false`.

        		     :type streamId: int
        :param streamId: The ID of the created data stream.
            		 :type reliable: boolean
        :param reliable: Sets whether or not the recipients are guaranteed to receive the data stream from the sender within five seconds:
            		     - true: The recipients receive the data stream from the sender within five seconds. If the recipient does not receive the data stream within five seconds,
            		     an error is reported to the application.
            		     - false: There is no guarantee that the recipients receive the data stream within five seconds and no error message is reported for
            		     any delay or missing data stream.
            		 :type ordered: boolean
        :param ordered: Sets whether or not the recipients receive the data stream in the sent order:
            		     - true: The recipients receive the data stream in the sent order.
            		     - false: The recipients do not receive the data stream in the sent order.

        		     :rtype: int
        :return: 
            		     - Returns 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcChannelBridge_createDataStream(self, streamId, reliable, ordered)

    def sendStreamMessage(self, streamId: "int", data: "char const *", length: "size_t") -> "int":
        r"""
         Sends data stream messages to all users in a channel.

        		     The SDK has the following restrictions on this method:
        		     - Up to 30 packets can be sent per second in a channel with each packet having a maximum size of 1 kB.
        		     - Each client can send up to 6 kB of data per second.
        		     - Each user can have up to five data streams simultaneously.

        		     A successful 'sendStreamMessage' method call triggers
        		     the 'onStreamMessage' callback on the remote client, from which the remote user gets the stream message.

        		     A failed 'sendStreamMessage' method call triggers
        		     the 'onStreamMessage' callback on the remote client.

        		     Notes: 
        		     - This method applies only to the `COMMUNICATION` profile or to the hosts in the `LIVE_BROADCASTING` profile. If an audience in the `LIVE_BROADCASTING` profile calls this method, the audience may be switched to a host.
        		     - Ensure that you have created the data stream using 'createDataStream' before calling this method.

        		     :type streamId: int
        :param streamId:  The ID of the sent data stream, returned in the 'createDataStream' method.
            		 :type data: string
        :param data: The sent data.
            		 :type length: int
        :param length: The length of the sent data.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcChannelBridge_sendStreamMessage(self, streamId, data, length)

    def getConnectionState(self) -> "agora::rtc::CONNECTION_STATE_TYPE":
        r"""
         Gets the current connection state of the SDK.

        		     :rtype: int
        :return: #CONNECTION_STATE_TYPE.
        """
        return _agorartc.RtcChannelBridge_getConnectionState(self)

    def registerMediaMetadataObserver(self, observer: "agora::rtc::IMetadataObserver *", type: "agora::rtc::IMetadataObserver::METADATA_TYPE", useSdkDefault: "bool"=True) -> "int":
        r"""
         Registers the metadata observer.

        		     Registers the metadata observer. You need to implement the IMetadataObserver class and specify the metadata type in this method. A successful call of this method triggers the 'getMaxMetadataSize' callback.
        		     This method enables you to add synchronized metadata in the video stream for more diversified interactive live streaming, such as sending shopping links, digital coupons, and online quizzes.

        		     Notes: 
        		     - Call this method before the joinChannel method.
        		     - This method applies to the `LIVE_BROADCASTING` channel profile.

        		     :type observer: agora::rtc::IMetadataObserver
        :param observer: The IMetadataObserver class. See the definition of IMetadataObserver for details.
            		 :type type: agora::rtc::IMetadataObserver::METADATA_TYPE
        :param type: See 'METADATA_TYPE'. The SDK supports VIDEO_METADATA (0) only for now.

        		     :rtype: int
        :return: 
            		     - 0: Success.
            		     - < 0: Failure.
        """
        return _agorartc.RtcChannelBridge_registerMediaMetadataObserver(self, observer, type, useSdkDefault)

    def sendMetadata(self, metadata: "agora::rtc::IMetadataObserver::Metadata *") -> "int":
        return _agorartc.RtcChannelBridge_sendMetadata(self, metadata)

    def setMaxMetadataSize(self, size: "int") -> "int":
        return _agorartc.RtcChannelBridge_setMaxMetadataSize(self, size)

    def getChannel(self) -> "agora::rtc::IChannel *":
        return _agorartc.RtcChannelBridge_getChannel(self)
    __swig_destroy__ = _agorartc.delete_RtcChannelBridge

# Register RtcChannelBridge in _agorartc:
_agorartc.RtcChannelBridge_swigregister(RtcChannelBridge)

class VideoDeviceManager(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def startDeviceTest(self, hwnd: "uint64_t") -> "int":
        return _agorartc.VideoDeviceManager_startDeviceTest(self, hwnd)

    def stopDeviceTest(self) -> "int":
        return _agorartc.VideoDeviceManager_stopDeviceTest(self)

    def getDeviceCount(self) -> "int":
        return _agorartc.VideoDeviceManager_getDeviceCount(self)

    def setDevice(self, deviceId: "char const [512]") -> "int":
        return _agorartc.VideoDeviceManager_setDevice(self, deviceId)

    def getCurrentDevice(self, deviceId_output: "char [512]") -> "int":
        return _agorartc.VideoDeviceManager_getCurrentDevice(self, deviceId_output)

    def getDevice(self, index: "int", deviceName_output: "char [512]", deviceId_output: "char [512]") -> "int":
        return _agorartc.VideoDeviceManager_getDevice(self, index, deviceName_output, deviceId_output)

    def release(self) -> "void":
        return _agorartc.VideoDeviceManager_release(self)
    __swig_destroy__ = _agorartc.delete_VideoDeviceManager

# Register VideoDeviceManager in _agorartc:
_agorartc.VideoDeviceManager_swigregister(VideoDeviceManager)

class AudioPlaybackDeviceManager(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def release(self) -> "void":
        return _agorartc.AudioPlaybackDeviceManager_release(self)

    def getCount(self) -> "int":
        return _agorartc.AudioPlaybackDeviceManager_getCount(self)

    def getDevice(self, index: "int", deviceName_output: "char [512]", deviceId_output: "char [512]") -> "int":
        return _agorartc.AudioPlaybackDeviceManager_getDevice(self, index, deviceName_output, deviceId_output)

    def getCurrentDevice(self, deviceId_output: "char [512]") -> "int":
        return _agorartc.AudioPlaybackDeviceManager_getCurrentDevice(self, deviceId_output)

    def getCurrentDeviceInfo(self, deviceId_output: "char [512]", deviceName_output: "char [512]") -> "int":
        return _agorartc.AudioPlaybackDeviceManager_getCurrentDeviceInfo(self, deviceId_output, deviceName_output)

    def setDevice(self, deviceId_output: "char const [512]") -> "int":
        return _agorartc.AudioPlaybackDeviceManager_setDevice(self, deviceId_output)

    def setDeviceVolume(self, volume: "int") -> "int":
        return _agorartc.AudioPlaybackDeviceManager_setDeviceVolume(self, volume)

    def getDeviceVolume(self) -> "int":
        return _agorartc.AudioPlaybackDeviceManager_getDeviceVolume(self)

    def setDeviceMute(self, mute: "bool") -> "int":
        return _agorartc.AudioPlaybackDeviceManager_setDeviceMute(self, mute)

    def getDeviceMute(self) -> "int":
        return _agorartc.AudioPlaybackDeviceManager_getDeviceMute(self)

    def startDeviceTest(self, testAudioFilePath: "char const *") -> "int":
        return _agorartc.AudioPlaybackDeviceManager_startDeviceTest(self, testAudioFilePath)

    def stopDeviceTest(self) -> "int":
        return _agorartc.AudioPlaybackDeviceManager_stopDeviceTest(self)

    def startAudioDeviceLoopbackTest(self, indicationInterval: "int") -> "int":
        return _agorartc.AudioPlaybackDeviceManager_startAudioDeviceLoopbackTest(self, indicationInterval)

    def stopAudioDeviceLoopbackTest(self) -> "int":
        return _agorartc.AudioPlaybackDeviceManager_stopAudioDeviceLoopbackTest(self)
    __swig_destroy__ = _agorartc.delete_AudioPlaybackDeviceManager

# Register AudioPlaybackDeviceManager in _agorartc:
_agorartc.AudioPlaybackDeviceManager_swigregister(AudioPlaybackDeviceManager)

class AudioRecordingDeviceManager(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def release(self) -> "void":
        return _agorartc.AudioRecordingDeviceManager_release(self)

    def getCount(self) -> "int":
        return _agorartc.AudioRecordingDeviceManager_getCount(self)

    def getDevice(self, index: "int", deviceName_output: "char [512]", deviceId_output: "char [512]") -> "int":
        return _agorartc.AudioRecordingDeviceManager_getDevice(self, index, deviceName_output, deviceId_output)

    def getCurrentDevice(self, deviceId_output: "char [512]") -> "int":
        return _agorartc.AudioRecordingDeviceManager_getCurrentDevice(self, deviceId_output)

    def getCurrentDeviceInfo(self, deviceId_output: "char [512]", deviceName_output: "char [512]") -> "int":
        return _agorartc.AudioRecordingDeviceManager_getCurrentDeviceInfo(self, deviceId_output, deviceName_output)

    def setDevice(self, deviceId_output: "char const [512]") -> "int":
        return _agorartc.AudioRecordingDeviceManager_setDevice(self, deviceId_output)

    def setDeviceVolume(self, volume: "int") -> "int":
        return _agorartc.AudioRecordingDeviceManager_setDeviceVolume(self, volume)

    def getDeviceVolume(self) -> "int":
        return _agorartc.AudioRecordingDeviceManager_getDeviceVolume(self)

    def setDeviceMute(self, mute: "bool") -> "int":
        return _agorartc.AudioRecordingDeviceManager_setDeviceMute(self, mute)

    def getDeviceMute(self) -> "int":
        return _agorartc.AudioRecordingDeviceManager_getDeviceMute(self)

    def startDeviceTest(self, indicationInterval: "int") -> "int":
        return _agorartc.AudioRecordingDeviceManager_startDeviceTest(self, indicationInterval)

    def stopDeviceTest(self) -> "int":
        return _agorartc.AudioRecordingDeviceManager_stopDeviceTest(self)

    def startAudioDeviceLoopbackTest(self, indicationInterval: "int") -> "int":
        return _agorartc.AudioRecordingDeviceManager_startAudioDeviceLoopbackTest(self, indicationInterval)

    def stopAudioDeviceLoopbackTest(self) -> "int":
        return _agorartc.AudioRecordingDeviceManager_stopAudioDeviceLoopbackTest(self)
    __swig_destroy__ = _agorartc.delete_AudioRecordingDeviceManager

# Register AudioRecordingDeviceManager in _agorartc:
_agorartc.AudioRecordingDeviceManager_swigregister(AudioRecordingDeviceManager)