Merge pull request #90 from syanbo/chore/2.9.0-sdk-integrate

upgrade to 2.9.0 sdk

CHANGELOG

 
 #### 2.9.0-alpha.1
   - fix typo: rename `methodisSpeakerphoneEnabled` to `isSpeakerphoneEnabled`
+  - events deprecated & instead:
+    * `microphoneEnabled` instead `localAudioStateChanged`
+    * `audioTransportStatsOfUid` instead `remoteAudioStats`
+    * `videoTransportStatsOfUid` instead `remoteVideoStats`
+    * `userMuteVideo`, `userEnableVideo`, `userEnableLocalVideo` & `firstRemoteVideoDecoded` instead `remoteVideoStateChanged`
+  - events enhancement:
+    * `rtcStats`, `leaveChannel` add channel stats `txAudioBytes`, `txVideoBytes`, `rxAudioBytes`, `rxVideoBytes`, `txPacketLossRate`, `rxPacketLossRate`
+  - new events:
+    * `remoteAudioStateChanged` subscribe for remote audio state
+    * `localAudioStateChanged` subscribe for local audio state
+    * `localAudioStats` subscribe for local audio stats
+    * `mediaRelayStateChanged`, `receivedChannelMediaRelay`
+  - new apis:
+    * `switchChannel` switch to specified channel
+    * `startChannelMediaRelay`, `updateChannelMediaRelay`, `stopChannelMediaRelay`, `removeChannelMediaRelay` relay media streams operation for across channels.
 
 #### 2.8.0-alpha.1
   - add `string uid` api support

android/CMakeLists.txt

+# For more information about using CMake with Android Studio, read the
+# documentation: https://d.android.com/studio/projects/add-native-code.html
+
+# Sets the minimum version of CMake required to build the native library.
+
+cmake_minimum_required(VERSION 3.4.1)
+
+# Creates and names a library, sets it as either STATIC
+# or SHARED, and provides the relative paths to its source code.
+# You can define multiple libraries, and CMake builds them for you.
+# Gradle automatically packages shared libraries with your APK.
+
+add_library( # Sets the name of the library.
+             apm-plugin-raw-data-api-java
+
+             # Sets the library as a shared library.
+             SHARED
+
+             # Provides a relative path to your source file(s).
+             src/main/cpp/src/agora_media_pre_processing.cpp )
+
+# Searches for a specified prebuilt library and stores the path as a
+# variable. Because CMake includes system libraries in the search path by
+# default, you only need to specify the name of the public NDK library
+# you want to add. CMake verifies that the library exists before
+# completing its build.
+
+find_library( # Sets the name of the path variable.
+              log-lib
+
+              # Specifies the name of the NDK library that
+              # you want CMake to locate.
+              log )
+
+# Specifies libraries CMake should link to your target library. You
+# can link multiple libraries, such as libraries you define in this
+# build script, prebuilt third-party libraries, or system libraries.
+
+target_link_libraries( # Specifies the target library.
+                       apm-plugin-raw-data-api-java
+
+                       # Links the target library to the log library
+                       # included in the NDK.
+                       ${log-lib} )

android/build.gradle

     def androidSupportVersion = rootProject.hasProperty("androidSupportVersion")  ? rootProject.androidSupportVersion : DEFAULT_ANDROID_SUPPORT_VERSION
     // from internet
     implementation "com.android.support:appcompat-v7:$androidSupportVersion"
-    implementation "io.agora.rtc:full-sdk:2.8.2"
+    implementation "io.agora.rtc:full-sdk:2.9.0"
     // from node_modules
     implementation "com.facebook.react:react-native:+"
 }

android/src/main/cpp/include/AgoraBase.h

+//  Agora Engine SDK
+//
+//  Copyright (c) 2019 Agora.io. All rights reserved.
+//
+
+#ifndef AGORA_BASE_H
+#define AGORA_BASE_H
+
+#include <stddef.h>
+#include <stdio.h>
+#include <stdarg.h>
+
+#if defined(_WIN32)
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#define AGORA_CALL __cdecl
+#if defined(AGORARTC_EXPORT)
+#define AGORA_API extern "C" __declspec(dllexport)
+#else
+#define AGORA_API extern "C" __declspec(dllimport)
+#endif
+#elif defined(__APPLE__)
+#include <TargetConditionals.h>
+#define AGORA_API __attribute__((visibility("default"))) extern "C"
+#define AGORA_CALL
+#elif defined(__ANDROID__) || defined(__linux__)
+#define AGORA_API extern "C" __attribute__((visibility("default")))
+#define AGORA_CALL
+#else
+#define AGORA_API extern "C"
+#define AGORA_CALL
+#endif
+
+namespace agora {
+namespace util {
+
+template<class T>
+class AutoPtr {
+    typedef T value_type;
+    typedef T* pointer_type;
+public:
+    AutoPtr(pointer_type p=0)
+        :ptr_(p)
+    {}
+    ~AutoPtr() {
+        if (ptr_)
+            ptr_->release();
+    }
+    operator bool() const { return ptr_ != (pointer_type)0; }
+    value_type& operator*() const {
+        return *get();
+    }
+
+    pointer_type operator->() const {
+        return get();
+    }
+
+    pointer_type get() const {
+        return ptr_;
+    }
+
+    pointer_type release() {
+        pointer_type tmp = ptr_;
+        ptr_ = 0;
+        return tmp;
+    }
+
+    void reset(pointer_type ptr = 0) {
+        if (ptr != ptr_ && ptr_)
+            ptr_->release();
+        ptr_ = ptr;
+    }
+    template<class C1, class C2>
+    bool queryInterface(C1* c, C2 iid) {
+        pointer_type p = NULL;
+        if (c && !c->queryInterface(iid, (void**)&p))
+        {
+            reset(p);
+        }
+        return p != NULL;
+	}
+private:
+    AutoPtr(const AutoPtr&);
+    AutoPtr& operator=(const AutoPtr&);
+private:
+    pointer_type ptr_;
+};
+class IString {
+protected:
+    virtual ~IString(){}
+public:
+    virtual bool empty() const = 0;
+    virtual const char* c_str() = 0;
+    virtual const char* data() = 0;
+    virtual size_t length() = 0;
+    virtual void release() = 0;
+};
+typedef AutoPtr<IString> AString;
+
+}//namespace util
+
+enum INTERFACE_ID_TYPE
+{
+    AGORA_IID_AUDIO_DEVICE_MANAGER = 1,
+    AGORA_IID_VIDEO_DEVICE_MANAGER = 2,
+    AGORA_IID_RTC_ENGINE_PARAMETER = 3,
+    AGORA_IID_MEDIA_ENGINE = 4,
+    AGORA_IID_SIGNALING_ENGINE = 8,
+};
+
+    /** Warning code.
+     */
+enum WARN_CODE_TYPE
+{
+  /** 8: The specified view is invalid. Specify a view when using the video call function.
+  */
+    WARN_INVALID_VIEW = 8,
+    /** 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_INIT_VIDEO = 16,
+    /** 20: The request is pending, usually due to some module not being ready, and the SDK postponed processing the request.
+    */
+    WARN_PENDING = 20,
+    /** 103: No channel resources are available. Maybe because the server cannot allocate any channel resource.
+    */
+    WARN_NO_AVAILABLE_CHANNEL = 103,
+    /** 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_TIMEOUT = 104,
+    /** **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 \ref agora::rtc::IRtcEngineEventHandler::onConnectionStateChanged "onConnectionStateChanged" callback instead.
+    */
+    WARN_LOOKUP_CHANNEL_REJECTED = 105,
+    /** 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_TIMEOUT = 106,
+    /** 107: The server rejects the request to open the channel. The server cannot process this request or the request is illegal.
+    */
+    WARN_OPEN_CHANNEL_REJECTED = 107,
+
+    // sdk: 100~1000
+    /** 111: A timeout occurs when switching to the live video.
+    */
+    WARN_SWITCH_LIVE_VIDEO_TIMEOUT = 111,
+    /** 118: A timeout occurs when setting the client role in the live broadcast profile.
+    */
+    WARN_SET_CLIENT_ROLE_TIMEOUT = 118,
+    /** 121: The ticket to open the channel is invalid.
+    */
+    WARN_OPEN_CHANNEL_INVALID_TICKET = 121,
+    /** 122: Try connecting to another server.
+    */
+    WARN_OPEN_CHANNEL_TRY_NEXT_VOS = 122,
+    WARN_CHANNEL_CONNECTION_UNRECOVERABLE = 131,
+    WARN_CHANNEL_CONNECTION_IP_CHANGED = 132,
+    WARN_CHANNEL_CONNECTION_PORT_CHANGED = 133,
+    /** 701: An error occurs in opening the audio mixing file.
+    */
+    WARN_AUDIO_MIXING_OPEN_ERROR = 701,
+    /** 1014: Audio Device Module: a warning occurs in the playback device.
+    */
+    WARN_ADM_RUNTIME_PLAYOUT_WARNING = 1014,
+    /** 1016: Audio Device Module: a warning occurs in the recording device.
+    */
+    WARN_ADM_RUNTIME_RECORDING_WARNING = 1016,
+    /** 1019: Audio Device Module: no valid audio data is collected.
+    */
+    WARN_ADM_RECORD_AUDIO_SILENCE = 1019,
+    /** 1020: Audio Device Module: the playback device fails.
+    */
+    WARN_ADM_PLAYOUT_MALFUNCTION = 1020,
+    /** 1021: Audio Device Module: the recording device fails.
+    */
+    WARN_ADM_RECORD_MALFUNCTION = 1021,
+    /** 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_IOS_CATEGORY_NOT_PLAYANDRECORD = 1029,
+    /** 
+     */
+    WARN_ADM_IOS_SAMPLERATE_CHANGE = 1030,
+    /** 1031: Audio Device Module: the recorded audio voice is too low.
+    */
+    WARN_ADM_RECORD_AUDIO_LOWLEVEL = 1031,
+    /** 1032: Audio Device Module: the playback audio voice is too low.
+    */
+    WARN_ADM_PLAYOUT_AUDIO_LOWLEVEL = 1032,
+    /** 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_WINDOWS_NO_DATA_READY_EVENT = 1040,
+    /** 1051: Audio Device Module: howling is detected.
+    */
+    WARN_APM_HOWLING = 1051,
+    /** 1052: Audio Device Module: the device is in the glitch state.
+    */
+    WARN_ADM_GLITCH_STATE = 1052,
+    /** 1053: Audio Device Module: the underlying audio settings have changed.
+    */
+    WARN_ADM_IMPROPER_SETTINGS = 1053,
+    /**
+        */
+    WARN_ADM_WIN_CORE_NO_RECORDING_DEVICE = 1322,
+    /** 1323: Audio device module: No available playback device. 
+     * Solution: Plug in the audio device.
+    */
+    WARN_ADM_WIN_CORE_NO_PLAYOUT_DEVICE = 1323,
+    /** 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_ADM_WIN_CORE_IMPROPER_CAPTURE_RELEASE = 1324,
+    /** 1610: Super-resolution warning: the original video dimensions of the remote user exceed 640 &times; 480.
+    */
+    WARN_SUPER_RESOLUTION_STREAM_OVER_LIMITATION = 1610,
+    /** 1611: Super-resolution warning: another user is using super resolution.
+    */
+    WARN_SUPER_RESOLUTION_USER_COUNT_OVER_LIMITATION = 1611,
+    /** 1612: The device is not supported.
+    */
+    WARN_SUPER_RESOLUTION_DEVICE_NOT_SUPPORTED = 1612,
+
+    WARN_RTM_LOGIN_TIMEOUT = 2005,
+    WARN_RTM_KEEP_ALIVE_TIMEOUT = 2009
+};
+
+/** Error code.
+*/
+enum ERROR_CODE_TYPE
+{
+  /** 0: No error occurs.
+  */
+    ERR_OK = 0,
+    //1~1000
+    /** 1: A general error occurs (no specified reason).
+    */
+    ERR_FAILED = 1,
+    /** 2: An invalid parameter is used. For example, the specific channel name includes illegal characters.
+    */
+    ERR_INVALID_ARGUMENT = 2,
+    /** 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_READY = 3,
+    /** 4: The SDK does not support this function.
+     */
+    ERR_NOT_SUPPORTED = 4,
+    /** 5: The request is rejected. This is for internal SDK use only, and it does not return to the application through any method or callback.
+     */
+    ERR_REFUSED = 5,
+    /** 6: The buffer size is not big enough to store the returned data.
+     */
+    ERR_BUFFER_TOO_SMALL = 6,
+    /** 7: The SDK is not initialized before calling this method.
+     */
+    ERR_NOT_INITIALIZED = 7,
+    /** 9: No permission exists. This is for internal SDK use only, and it does not return to the application through any method or callback.
+     */
+    ERR_NO_PERMISSION = 9,
+    /** 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_TIMEDOUT = 10,
+    /** 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_CANCELED = 11,
+    /** 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_TOO_OFTEN = 12,
+    /** 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_BIND_SOCKET = 13,
+    /** 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_DOWN = 14,
+    /** 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_NET_NOBUFS = 15,
+    /** 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, \ref agora::rtc::IRtcEngine::joinChannel "joinChannel".
+     */
+    ERR_JOIN_CHANNEL_REJECTED = 17,
+    /** 18: The request to leave the channel is rejected.
+
+     This error usually occurs:
+
+     - When the user has left the channel and still calls \ref agora::rtc::IRtcEngine::leaveChannel "leaveChannel" to leave the channel. In this case, stop calling \ref agora::rtc::IRtcEngine::leaveChannel "leaveChannel".
+     - When the user has not joined the channel and still calls \ref agora::rtc::IRtcEngine::leaveChannel "leaveChannel" to leave the channel. In this case, no extra operation is needed.
+     */
+    ERR_LEAVE_CHANNEL_REJECTED = 18,
+    /** 19: Resources are occupied and cannot be reused.
+     */
+    ERR_ALREADY_IN_USE = 19,
+    /** 20: The SDK gives up the request due to too many requests.
+     */
+    ERR_ABORTED = 20,
+    /** 21: In Windows, specific firewall settings can cause the SDK to fail to initialize and crash.
+     */
+    ERR_INIT_NET_ENGINE = 21,
+    /** 22: The application uses too much of the system resources and the SDK fails to allocate the resources.
+     */
+    ERR_RESOURCE_LIMITED = 22,
+    /** 101: The specified App ID is invalid. Please try to rejoin the channel with a valid App ID.
+     */
+    ERR_INVALID_APP_ID = 101,
+    /** 102: The specified channel name is invalid. Please try to rejoin the channel with a valid channel name.
+     */
+    ERR_INVALID_CHANNEL_NAME = 102,
+    /** **DEPRECATED** 109: Deprecated as of v2.4.1. Use CONNECTION_CHANGED_TOKEN_EXPIRED(9) in the \ref agora::rtc::IRtcEngineEventHandler::onConnectionStateChanged "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 five minutes after the Token is generated. If the user does not access the Agora service after five minutes, 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_TOKEN_EXPIRED = 109,
+    /** **DEPRECATED** 110: Deprecated as of v2.4.1. Use CONNECTION_CHANGED_INVALID_TOKEN(8) in the \ref agora::rtc::IRtcEngineEventHandler::onConnectionStateChanged "onConnectionStateChanged" callback instead.
+     
+     The token is invalid due to one of the following reasons:
+     
+     - The App Certificate for the project is enabled in Dashboard, 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 \ref agora::rtc::IRtcEngine::joinChannel "joinChannel" method.
+     */
+    ERR_INVALID_TOKEN = 110,
+    /** 111: The internet connection is interrupted. This applies to the Agora Web SDK only.
+     */
+    ERR_CONNECTION_INTERRUPTED = 111, // only used in web sdk
+    /** 112: The internet connection is lost. This applies to the Agora Web SDK only.
+     */
+    ERR_CONNECTION_LOST = 112, // only used in web sdk
+    /** 113: The user is not in the channel when calling the \ref agora::rtc::IRtcEngine::sendStreamMessage "sendStreamMessage" or \ref agora::rtc::IRtcEngine::getUserInfoByUserAccount "getUserInfoByUserAccount" method.
+     */
+    ERR_NOT_IN_CHANNEL = 113,
+    /** 114: The size of the sent data is over 1024 bytes when the user calls the \ref agora::rtc::IRtcEngine::sendStreamMessage "sendStreamMessage" method.
+     */
+    ERR_SIZE_TOO_LARGE = 114,
+    /** 115: The bitrate of the sent data exceeds the limit of 6 Kbps when the user calls the \ref agora::rtc::IRtcEngine::sendStreamMessage "sendStreamMessage" method.
+     */
+    ERR_BITRATE_LIMIT = 115,
+    /** 116: Too many data streams (over 5 streams) are created when the user calls the \ref agora::rtc::IRtcEngine::createDataStream "createDataStream" method.
+     */
+    ERR_TOO_MANY_DATA_STREAMS = 116,
+    /** 117: The data stream transmission timed out.
+     */
+    ERR_STREAM_MESSAGE_TIMEOUT = 117,
+    /** 119: Switching roles fail. Please try to rejoin the channel.
+     */
+    ERR_SET_CLIENT_ROLE_NOT_AUTHORIZED = 119,
+    /** 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_DECRYPTION_FAILED = 120,
+    /** 123: The client is banned by the server.
+     */
+    ERR_CLIENT_IS_BANNED_BY_SERVER = 123,
+    /** 124: Incorrect watermark file parameter.
+     */
+    ERR_WATERMARK_PARAM = 124,
+    /** 125: Incorrect watermark file path.
+     */
+    ERR_WATERMARK_PATH = 125,
+    /** 126: Incorrect watermark file format.
+     */
+    ERR_WATERMARK_PNG = 126,
+    /** 127: Incorrect watermark file information.
+     */
+    ERR_WATERMARKR_INFO = 127,
+    /** 128: Incorrect watermark file data format.
+     */
+    ERR_WATERMARK_ARGB = 128,
+    /** 129: An error occurs in reading the watermark file.
+     */
+    ERR_WATERMARK_READ = 129,
+    /** 130: Encryption is enabled when the user calls the \ref agora::rtc::IRtcEngine::addPublishStreamUrl "addPublishStreamUrl" method (CDN live streaming does not support encrypted streams).
+     */
+    ERR_ENCRYPTED_STREAM_NOT_ALLOWED_PUBLISH = 130,
+    /** 134: The user account is invalid. */
+    ERR_INVALID_USER_ACCOUNT = 134,
+
+    /** 151: CDN related errors. Remove the original URL address and add a new one by calling the \ref agora::rtc::IRtcEngine::removePublishStreamUrl "removePublishStreamUrl" and \ref agora::rtc::IRtcEngine::addPublishStreamUrl "addPublishStreamUrl" methods.
+     */
+    ERR_PUBLISH_STREAM_CDN_ERROR = 151,
+    /** 152: The host publishes more than 10 URLs. Delete the unnecessary URLs before adding new ones.
+     */
+    ERR_PUBLISH_STREAM_NUM_REACH_LIMIT = 152,
+    /** 153: The host manipulates other hosts' URLs. Check your app logic.
+     */
+    ERR_PUBLISH_STREAM_NOT_AUTHORIZED = 153,
+    /** 154: An error occurs in Agora's streaming server. Call the addPublishStreamUrl method to publish the streaming again.
+     */
+    ERR_PUBLISH_STREAM_INTERNAL_SERVER_ERROR = 154,
+    /** 155: The server fails to find the stream.
+     */
+    ERR_PUBLISH_STREAM_NOT_FOUND = 155,
+    /** 156: The format of the RTMP stream URL is not supported. Check whether the URL format is correct.
+     */
+    ERR_PUBLISH_STREAM_FORMAT_NOT_SUPPORTED = 156,
+
+    //signaling: 400~600
+    /**
+    */
+    ERR_LOGOUT_OTHER = 400,  //
+    /** 401: The user logged out.
+     */
+    ERR_LOGOUT_USER = 401,  // logout by user
+    /** 402: Network failure.
+     */
+    ERR_LOGOUT_NET = 402,  // network failure
+    /** 403: Logged in another device.
+     */
+    ERR_LOGOUT_KICKED = 403,  // login in other device
+    /**
+     */
+    ERR_LOGOUT_PACKET = 404,  //
+    /** 405: The token expired.
+     */
+    ERR_LOGOUT_TOKEN_EXPIRED = 405,  // token expired
+    /**
+     */
+    ERR_LOGOUT_OLDVERSION = 406,  //
+    /**
+     */
+    ERR_LOGOUT_TOKEN_WRONG = 407,
+    /**
+    */
+    ERR_LOGOUT_ALREADY_LOGOUT = 408,
+    /**
+     */
+    ERR_LOGIN_OTHER = 420,
+    /**
+    */
+    ERR_LOGIN_NET = 421,
+    /**
+     */
+    ERR_LOGIN_FAILED = 422,
+    /**
+     */
+    ERR_LOGIN_CANCELED = 423,
+    /**
+     */
+    ERR_LOGIN_TOKEN_EXPIRED = 424,
+    /**
+     */
+    ERR_LOGIN_OLD_VERSION = 425,
+    /**
+     */
+    ERR_LOGIN_TOKEN_WRONG = 426,
+    /**
+     */
+    ERR_LOGIN_TOKEN_KICKED = 427,
+    /**
+     */
+    ERR_LOGIN_ALREADY_LOGIN = 428,
+    /**
+    */
+    ERR_JOIN_CHANNEL_OTHER = 440,
+    /**
+     */
+    ERR_SEND_MESSAGE_OTHER = 440,
+    /**
+     */
+    ERR_SEND_MESSAGE_TIMEOUT = 441,
+    /**
+     */
+    ERR_QUERY_USERNUM_OTHER = 450,
+    /**
+     */
+    ERR_QUERY_USERNUM_TIMEOUT = 451,
+    /**
+     */
+    ERR_QUERY_USERNUM_BYUSER = 452,
+    /**
+     */
+    ERR_LEAVE_CHANNEL_OTHER = 460,
+    /**
+     */
+    ERR_LEAVE_CHANNEL_KICKED = 461,
+    /**
+     */
+    ERR_LEAVE_CHANNEL_BYUSER = 462,
+    /**
+     */
+    ERR_LEAVE_CHANNEL_LOGOUT = 463,
+    /**
+     */
+    ERR_LEAVE_CHANNEL_DISCONNECTED = 464,
+    /**
+     */
+    ERR_INVITE_OTHER = 470,
+    /**
+     */
+    ERR_INVITE_REINVITE = 471,
+    /**
+     */
+    ERR_INVITE_NET = 472,
+    /**
+     */
+    ERR_INVITE_PEER_OFFLINE = 473,
+    ERR_INVITE_TIMEOUT = 474,
+    ERR_INVITE_CANT_RECV = 475,
+
+
+    //1001~2000
+    /** 1001: Fails to load the media engine.
+     */
+    ERR_LOAD_MEDIA_ENGINE = 1001,
+    /** 1002: Fails to start the call after enabling the media engine.
+     */
+    ERR_START_CALL = 1002,
+    /** **DEPRECATED** 1003: Fails to start the camera.
+     
+    Deprecated as of v2.4.1. Use LOCAL_VIDEO_STREAM_ERROR_CAPTURE_FAILURE(4) in the \ref agora::rtc::IRtcEngineEventHandler::onConnectionStateChanged "onConnectionStateChanged" callback instead.
+     */
+    ERR_START_CAMERA = 1003,
+    /** 1004: Fails to start the video rendering module.
+     */
+    ERR_START_VIDEO_RENDER = 1004,
+    /** 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_GENERAL_ERROR = 1005,
+    /** 1006: Audio Device Module: An error occurs in using the Java resources.
+     */
+    ERR_ADM_JAVA_RESOURCE = 1006,
+    /** 1007: Audio Device Module: An error occurs in setting the sampling frequency.
+     */
+    ERR_ADM_SAMPLE_RATE = 1007,
+    /** 1008: Audio Device Module: An error occurs in initializing the playback device.
+     */
+    ERR_ADM_INIT_PLAYOUT = 1008,
+    /** 1009: Audio Device Module: An error occurs in starting the playback device.
+     */
+    ERR_ADM_START_PLAYOUT = 1009,
+    /** 1010: Audio Device Module: An error occurs in stopping the playback device.
+     */
+    ERR_ADM_STOP_PLAYOUT = 1010,
+    /** 1011: Audio Device Module: An error occurs in initializing the recording device.
+     */
+    ERR_ADM_INIT_RECORDING = 1011,
+    /** 1012: Audio Device Module: An error occurs in starting the recording device.
+     */
+    ERR_ADM_START_RECORDING = 1012,
+    /** 1013: Audio Device Module: An error occurs in stopping the recording device.
+     */
+    ERR_ADM_STOP_RECORDING = 1013,
+    /** 1015: Audio Device Module: A playback error occurs. Check your playback device and try rejoining the channel.
+     */
+    ERR_ADM_RUNTIME_PLAYOUT_ERROR = 1015,
+    /** 1017: Audio Device Module: A recording error occurs.
+     */
+    ERR_ADM_RUNTIME_RECORDING_ERROR = 1017,
+    /** 1018: Audio Device Module: Fails to record.
+     */
+    ERR_ADM_RECORD_AUDIO_FAILED = 1018,
+    /** 1022: Audio Device Module: An error occurs in initializing the 
+     * loopback device.
+     */
+    ERR_ADM_INIT_LOOPBACK = 1022,
+    /** 1023: Audio Device Module: An error occurs in starting the loopback 
+     * device.
+     */
+    ERR_ADM_START_LOOPBACK = 1023,
+    /** 1027: Audio Device Module: No recording permission exists. Check if the
+     *  recording permission is granted.
+     */
+    ERR_ADM_NO_PERMISSION = 1027,
+    /** 1033: Audio device module: The device is occupied. 
+    */
+    ERR_ADM_RECORD_AUDIO_IS_ACTIVE = 1033,
+    /** 1101: Audio device module: A fatal exception occurs.
+    */
+    ERR_ADM_ANDROID_JNI_JAVA_RESOURCE = 1101,
+    /** 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_RECORD_FREQUENCY = 1108,
+    /** 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_NO_PLAYBACK_FREQUENCY = 1109,
+    /** 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_RECORD = 1111,
+    /** 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_START_PLAYBACK = 1112,
+    /** 1115: Audio device module: AudioRecord returns error. The SDK will 
+     * automatically restart AudioRecord. */
+    ERR_ADM_ANDROID_JNI_JAVA_RECORD_ERROR = 1115,
+    /** **DEPRECATED** */
+    ERR_ADM_ANDROID_OPENSL_CREATE_ENGINE = 1151,
+    /** **DEPRECATED** */
+    ERR_ADM_ANDROID_OPENSL_CREATE_AUDIO_RECORDER = 1153,
+    /** **DEPRECATED** */
+    ERR_ADM_ANDROID_OPENSL_START_RECORDER_THREAD = 1156,
+    /** **DEPRECATED** */
+    ERR_ADM_ANDROID_OPENSL_CREATE_AUDIO_PLAYER = 1157,
+    /** **DEPRECATED** */
+    ERR_ADM_ANDROID_OPENSL_START_PLAYER_THREAD = 1160,
+    /** 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_INPUT_NOT_AVAILABLE = 1201,
+    /** 1206: Audio device module: Cannot activate the Audio Session.*/
+    ERR_ADM_IOS_ACTIVATE_SESSION_FAIL = 1206,
+    /** 1210: Audio device module: Fails to initialize the audio device, 
+     * normally because the audio device parameters are wrongly set.*/
+    ERR_ADM_IOS_VPIO_INIT_FAIL = 1210,
+    /** 1213: Audio device module: Fails to re-initialize the audio device, 
+     * normally because the audio device parameters are wrongly set.*/
+    ERR_ADM_IOS_VPIO_REINIT_FAIL = 1213,
+    /** 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_VPIO_RESTART_FAIL = 1214,
+    ERR_ADM_IOS_SET_RENDER_CALLBACK_FAIL = 1219,
+    /** **DEPRECATED** */
+    ERR_ADM_IOS_SESSION_SAMPLERATR_ZERO = 1221,
+    /** 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 = 1301,
+    /** 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_RECORDING = 1303,
+    /** 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 = 1306,
+    /** 1307: Audio device module: No audio device is available. Solutions: 
+     * Plug in a proper audio device. */
+    ERR_ADM_WIN_CORE_INIT_PLAYOUT_NULL = 1307,
+    /** 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_START_RECORDING = 1309,
+    /** 1311: Audio device module: Insufficient system memory or poor device 
+     * performance. Solutions: Reboot the system or replace the device.
+    */
+    ERR_ADM_WIN_CORE_CREATE_REC_THREAD = 1311,
+    /** 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_CAPTURE_NOT_STARTUP = 1314,
+    /** 1319: Audio device module: Insufficient system memory or poor device 
+     * performance. Solutions: Reboot the system or replace the device. */
+    ERR_ADM_WIN_CORE_CREATE_RENDER_THREAD = 1319,
+    /** 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_RENDER_NOT_STARTUP = 1320,
+    /** 1322: Audio device module: No audio sampling device is available. 
+     * Solutions: Plug in a proper recording device. */
+    ERR_ADM_WIN_CORE_NO_RECORDING_DEVICE = 1322,
+    /** 1323: Audio device module: No audio playout device is available. 
+     * Solutions: Plug in a proper playback device.*/
+    ERR_ADM_WIN_CORE_NO_PLAYOUT_DEVICE = 1323,
+    /** 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 = 1351,
+    /** 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_RECORDING = 1353,
+    /** 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_MICROPHONE = 1354,
+    /** 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_PLAYOUT = 1355,
+    /** 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_INIT_SPEAKER = 1356,
+    /** 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_RECORDING = 1357,
+    /** 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_WIN_WAVE_START_PLAYOUT = 1358,
+    /** 1359: Audio Device Module: No recording device exists.
+     */
+    ERR_ADM_NO_RECORDING_DEVICE = 1359,
+    /** 1360: Audio Device Module: No playback device exists.
+     */
+    ERR_ADM_NO_PLAYOUT_DEVICE = 1360,
+
+    // VDM error code starts from 1500
+    /** 1501: Video Device Module: The camera is unauthorized.
+     */
+    ERR_VDM_CAMERA_NOT_AUTHORIZED = 1501,
+
+	// VDM error code starts from 1500
+	/** **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 \ref agora::rtc::IRtcEngineEventHandler::onConnectionStateChanged "onConnectionStateChanged" callback instead.
+	 */
+	ERR_VDM_WIN_DEVICE_IN_USE = 1502,
+
+    // VCM error code starts from 1600
+    /** 1600: Video Device Module: An unknown error occurs.
+     */
+    ERR_VCM_UNKNOWN_ERROR = 1600,
+    /** 1601: Video Device Module: An error occurs in initializing the video encoder.
+    */
+    ERR_VCM_ENCODER_INIT_ERROR = 1601,
+    /** 1602: Video Device Module: An error occurs in encoding.
+     */
+    ERR_VCM_ENCODER_ENCODE_ERROR = 1602,
+    /** 1603: Video Device Module: An error occurs in setting the video encoder.
+     */
+    ERR_VCM_ENCODER_SET_ERROR = 1603,
+};
+
+    /** Output log filter level. */
+enum LOG_FILTER_TYPE
+{
+/** 0: Do not output any log information. */
+    LOG_FILTER_OFF = 0,
+     /** 0x080f: Output all log information.
+      Set your log filter as debug if you want to get the most complete log file.      */
+    LOG_FILTER_DEBUG = 0x080f,
+     /** 0x000f: Output CRITICAL, ERROR, WARNING, and INFO level log information.
+      We recommend setting your log filter as this level.
+      */
+    LOG_FILTER_INFO = 0x000f,
+     /** 0x000e: Outputs CRITICAL, ERROR, and WARNING level log information.
+      */
+    LOG_FILTER_WARN = 0x000e,
+     /** 0x000c: Outputs CRITICAL and ERROR level log information. */
+    LOG_FILTER_ERROR = 0x000c,
+     /** 0x0008: Outputs CRITICAL level log information. */
+    LOG_FILTER_CRITICAL = 0x0008,
+    LOG_FILTER_MASK = 0x80f,
+};
+} // namespace agora
+
+#endif

android/src/main/cpp/include/IAgoraMediaEngine.h

+#ifndef AGORA_MEDIA_ENGINE_H
+#define AGORA_MEDIA_ENGINE_H
+#if defined _WIN32 || defined __CYGWIN__
+typedef __int64 int64_t;
+typedef unsigned __int64 uint64_t;
+#else
+#include <stdint.h>
+#endif
+
+namespace agora
+{
+namespace media
+{
+
+enum MEDIA_SOURCE_TYPE {
+    AUDIO_PLAYOUT_SOURCE = 0,
+    AUDIO_RECORDING_SOURCE = 1,
+};
+
+class IAudioFrameObserver
+{
+public:
+  enum AUDIO_FRAME_TYPE {
+    FRAME_TYPE_PCM16 = 0,  //PCM 16bit little endian
+  };
+  struct AudioFrame {
+    AUDIO_FRAME_TYPE type;
+    int samples;  //number of samples in this frame
+    int bytesPerSample;  //number of bytes per sample: 2 for PCM16
+    int channels;  //number of channels (data are interleaved if stereo)
+    int samplesPerSec;  //sampling rate
+    void* buffer;  //data buffer
+    int64_t renderTimeMs;
+    int avsync_type;
+  };
+public:
+  virtual bool onRecordAudioFrame(AudioFrame& audioFrame) = 0;
+  virtual bool onPlaybackAudioFrame(AudioFrame& audioFrame) = 0;
+  virtual bool onMixedAudioFrame(AudioFrame& audioFrame) = 0;
+  virtual bool onPlaybackAudioFrameBeforeMixing(unsigned int uid, AudioFrame& audioFrame) = 0;
+};
+
+class IVideoFrameObserver
+{
+public:
+  enum VIDEO_FRAME_TYPE {
+    FRAME_TYPE_YUV420 = 0,  //YUV 420 format
+  };
+  struct VideoFrame {
+    VIDEO_FRAME_TYPE type;
+    int width;  //width of video frame
+    int height;  //height of video frame
+    int yStride;  //stride of Y data buffer
+    int uStride;  //stride of U data buffer
+    int vStride;  //stride of V data buffer
+    void* yBuffer;  //Y data buffer
+    void* uBuffer;  //U data buffer
+    void* vBuffer;  //V data buffer
+    int rotation; // rotation of this frame (0, 90, 180, 270)
+    int64_t renderTimeMs;
+    int avsync_type;
+  };
+public:
+  virtual bool onCaptureVideoFrame(VideoFrame& videoFrame) = 0;
+  virtual bool onRenderVideoFrame(unsigned int uid, VideoFrame& videoFrame) = 0;
+};
+
+class IVideoFrame
+{
+public:
+  enum PLANE_TYPE {
+    Y_PLANE = 0,
+    U_PLANE = 1,
+    V_PLANE = 2,
+    NUM_OF_PLANES = 3
+  };
+  enum VIDEO_TYPE {
+    VIDEO_TYPE_UNKNOWN = 0,
+    VIDEO_TYPE_I420 = 1,
+    VIDEO_TYPE_IYUV = 2,
+    VIDEO_TYPE_RGB24 = 3,
+    VIDEO_TYPE_ABGR = 4,
+    VIDEO_TYPE_ARGB = 5,
+    VIDEO_TYPE_ARGB4444 = 6,
+    VIDEO_TYPE_RGB565 = 7,
+    VIDEO_TYPE_ARGB1555 = 8,
+    VIDEO_TYPE_YUY2 = 9,
+    VIDEO_TYPE_YV12 = 10,
+    VIDEO_TYPE_UYVY = 11,
+    VIDEO_TYPE_MJPG = 12,
+    VIDEO_TYPE_NV21 = 13,
+    VIDEO_TYPE_NV12 = 14,
+    VIDEO_TYPE_BGRA = 15,
+    VIDEO_TYPE_RGBA = 16,
+  };
+  virtual void release() = 0;
+  virtual const unsigned char* buffer(PLANE_TYPE type) const = 0;
+
+  // Copy frame: If required size is bigger than allocated one, new buffers of
+  // adequate size will be allocated.
+  // Return value: 0 on success ,-1 on error.
+  virtual int copyFrame(IVideoFrame** dest_frame) const = 0;
+
+  // Convert frame
+  // Input:
+  //   - src_frame        : Reference to a source frame.
+  //   - dst_video_type   : Type of output video.
+  //   - dst_sample_size  : Required only for the parsing of MJPG.
+  //   - dst_frame        : Pointer to a destination frame.
+  // Return value: 0 if OK, < 0 otherwise.
+  // It is assumed that source and destination have equal height.
+  virtual int convertFrame(VIDEO_TYPE dst_video_type, int dst_sample_size, unsigned char* dst_frame) const = 0;
+
+  // Get allocated size per plane.
+  virtual int allocated_size(PLANE_TYPE type) const = 0;
+
+  // Get allocated stride per plane.
+  virtual int stride(PLANE_TYPE type) const = 0;
+
+  // Get frame width.
+  virtual int width() const = 0;
+
+  // Get frame height.
+  virtual int height() const = 0;
+
+  // Get frame timestamp (90kHz).
+  virtual unsigned int timestamp() const = 0;
+
+  // Get render time in milliseconds.
+  virtual int64_t render_time_ms() const = 0;
+
+  // Return true if underlying plane buffers are of zero size, false if not.
+  virtual bool IsZeroSize() const = 0;
+};
+
+class IExternalVideoRenderCallback
+{
+public:
+  virtual void onViewSizeChanged(int width, int height) = 0;
+  virtual void onViewDestroyed() = 0;
+};
+
+struct ExternalVideoRenerContext
+{
+  IExternalVideoRenderCallback* renderCallback;
+  void* view;
+  int renderMode;
+  int zOrder;
+  float left;
+  float top;
+  float right;
+  float bottom;
+};
+
+class IExternalVideoRender
+{
+public:
+  virtual void release() = 0;
+  virtual int initialize() = 0;
+  virtual int deliverFrame(const IVideoFrame& videoFrame, int rotation, bool mirrored) = 0;
+};
+
+class IExternalVideoRenderFactory
+{
+public:
+  virtual IExternalVideoRender* createRenderInstance(const ExternalVideoRenerContext& context) = 0;
+};
+
+struct ExternalVideoFrame
+{
+  enum VIDEO_BUFFER_TYPE
+  {
+    VIDEO_BUFFER_RAW_DATA = 1,
+  };
+
+  enum VIDEO_PIXEL_FORMAT
+  {
+    VIDEO_PIXEL_UNKNOWN = 0,
+    VIDEO_PIXEL_I420 = 1,
+    VIDEO_PIXEL_BGRA = 2,
+    VIDEO_PIXEL_NV12 = 8,
+  };
+
+  VIDEO_BUFFER_TYPE type;
+  VIDEO_PIXEL_FORMAT format;
+  void* buffer;
+  int stride;
+  int height;
+  int cropLeft;
+  int cropTop;
+  int cropRight;
+  int cropBottom;
+  int rotation;
+  long long timestamp;
+};
+
+class IMediaEngine {
+public:
+  virtual void release() = 0;
+  virtual int registerAudioFrameObserver(IAudioFrameObserver* observer) = 0;
+  virtual int registerVideoFrameObserver(IVideoFrameObserver* observer) = 0;
+  virtual int registerVideoRenderFactory(IExternalVideoRenderFactory* factory) = 0;
+  virtual int pushAudioFrame(MEDIA_SOURCE_TYPE type, IAudioFrameObserver::AudioFrame *frame, bool wrap) = 0;
+  virtual int pushAudioFrame(IAudioFrameObserver::AudioFrame *frame) = 0;
+  virtual int pullAudioFrame(IAudioFrameObserver::AudioFrame *frame) = 0;
+
+  virtual int setExternalVideoSource(bool enable, bool useTexture) = 0;
+  virtual int pushVideoFrame(ExternalVideoFrame *frame) = 0;
+};
+
+} //media
+
+} //agora
+
+#endif //AGORA_MEDIA_ENGINE_H

android/src/main/cpp/include/IAgoraService.h

+//  Agora SDK
+//
+//  Copyright (c) 2019 Agora.io. All rights reserved.
+//
+
+#ifndef AGORA_SERVICE_H
+#define AGORA_SERVICE_H
+#include "AgoraBase.h"
+
+namespace agora {
+    namespace rtc {
+        class IRtcEngine;
+    }
+    namespace rtm {
+        class IRtmService;
+    }
+namespace base {
+
+struct AgoraServiceContext
+{
+};
+
+
+class IAgoraService
+{
+protected:
+    virtual ~IAgoraService(){}
+public:
+    virtual void release() = 0;
+
+	/** Initializes the engine.
+     
+    @param context RtcEngine context.
+    @return
+     - 0: Success.
+     - < 0: Failure.
+    */
+    virtual int initialize(const AgoraServiceContext& context) = 0;
+
+    /** Retrieves the SDK version number.
+    * @param build Build number.
+    * @return The current SDK version in the string format. For example, 2.4.0
+    */
+    virtual const char* getVersion(int* build) = 0;
+
+    virtual rtm::IRtmService* createRtmService() = 0;
+};
+
+} //namespace base
+} // namespace agora
+
+/** Gets the SDK version number.
+ 
+ @param build Build number of the Agora SDK.
+ @return
+ - 0: Success.
+ - < 0: Failure.
+*/
+AGORA_API const char* AGORA_CALL getAgoraSdkVersion(int* build);
+
+/**
+* Creates the RtcEngine object and returns the pointer.
+* @param err Error code
+* @return returns Description of the error code
+*/
+AGORA_API const char* AGORA_CALL getAgoraSdkErrorDescription(int err);
+
+/**
+* Creates the Agora Service object and returns the pointer.
+* @return returns Pointer of the Agora Service object
+*/
+AGORA_API agora::base::IAgoraService* AGORA_CALL createAgoraService();
+
+AGORA_API int AGORA_CALL setAgoraSdkExternalSymbolLoader(void* (*func)(const char* symname));
+
+#endif

android/src/main/cpp/include/VMUtil.h

+#ifndef __VM_UTIL_H__
+#define __VM_UTIL_H__
+
+#include <jni.h>
+#include <stddef.h>
+
+#include <assert.h>
+
+#include <pthread.h>
+#include <android/log.h>
+
+#define LOGD(...) __android_log_print(ANDROID_LOG_DEBUG, "AG_EX_AV", __VA_ARGS__)
+#define LOGV(...) __android_log_print(ANDROID_LOG_VERBOSE, "AG_EX_AV", __VA_ARGS__)
+#define LOGI(...) __android_log_print(ANDROID_LOG_INFO, "AG_EX_AV", __VA_ARGS__)
+#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, "AG_EX_AV", __VA_ARGS__)
+
+#define TRUE true
+#define FALSE false
+
+#define CHECK_POINTER(pValue, rValue, ...) 	if (NULL == pValue) {  \
+					                           LOGE(__VA_ARGS__); \
+					                           return rValue; }
+
+class AttachThreadScoped
+{
+public:
+    explicit AttachThreadScoped(JavaVM* jvm)
+        : attached_(false), jvm_(jvm), env_(nullptr) {
+        jint ret_val = jvm->GetEnv(reinterpret_cast<void**>(&env_),
+            JNI_VERSION_1_6);
+        if (ret_val == JNI_EDETACHED) {
+            // Attach the thread to the Java VM.
+            ret_val = jvm_->AttachCurrentThread(&env_, nullptr);
+            attached_ = ret_val >= 0;
+            assert(attached_);
+        }
+	}
+
+    ~AttachThreadScoped() {
+        if (attached_ && (jvm_->DetachCurrentThread() < 0)) {
+            assert(false);
+        }
+    }
+
+    JNIEnv* env() { return env_; }
+
+private:
+    bool attached_;
+    JavaVM* jvm_;
+    JNIEnv* env_;
+};
+
+#endif  // __VM_UTIL_H__

android/src/main/cpp/src/agora_media_pre_processing.cpp

+//
+// Created by LY on 2019-08-21.
+//
+
+#include <jni.h>
+#include <android/log.h>
+#include <cstring>
+#include "../include/IAgoraMediaEngine.h"
+
+#include "../include/IAgoraRtcEngine.h"
+#include <string.h>
+#include "agora_media_pre_processing.h"
+#include "../include/VMUtil.h"
+
+#include <map>
+
+using namespace std;
+
+jobject gCallBack = nullptr;
+jclass gCallbackClass = nullptr;
+jmethodID recordAudioMethodId = nullptr;
+jmethodID playbackAudioMethodId = nullptr;
+jmethodID playBeforeMixAudioMethodId = nullptr;
+jmethodID mixAudioMethodId = nullptr;
+jmethodID captureVideoMethodId = nullptr;
+jmethodID renderVideoMethodId = nullptr;
+void *_javaDirectPlayBufferCapture = nullptr;
+void *_javaDirectPlayBufferRecordAudio = nullptr;
+void *_javaDirectPlayBufferPlayAudio = nullptr;
+void *_javaDirectPlayBufferBeforeMixAudio = nullptr;
+void *_javaDirectPlayBufferMixAudio = nullptr;
+map<int, void *> decodeBufferMap;
+
+static JavaVM *gJVM = nullptr;
+
+class AgoraVideoFrameObserver : public agora::media::IVideoFrameObserver {
+
+public:
+    AgoraVideoFrameObserver() {
+
+    }
+
+    ~AgoraVideoFrameObserver() {
+
+    }
+
+    void
+    getVideoFrame(VideoFrame &videoFrame, _jmethodID *jmethodID, void *_byteBufferObject, unsigned int uid) {
+
+        if (_byteBufferObject) {
+            int width = videoFrame.width;
+            int height = videoFrame.height;
+            size_t widthAndHeight = (size_t) videoFrame.yStride * height;
+            size_t length = widthAndHeight * 3 / 2;
+
+            AttachThreadScoped ats(gJVM);
+            JNIEnv *env = ats.env();
+
+            memcpy(_byteBufferObject, videoFrame.yBuffer, widthAndHeight);
+            memcpy((uint8_t *) _byteBufferObject + widthAndHeight, videoFrame.uBuffer,
+                   widthAndHeight / 4);
+            memcpy((uint8_t *) _byteBufferObject + widthAndHeight * 5 / 4, videoFrame.vBuffer,
+                   widthAndHeight / 4);
+
+            if (uid == 0) {
+                env->CallVoidMethod(gCallBack, jmethodID, videoFrame.type, width, height, length,
+                                    videoFrame.yStride, videoFrame.uStride,
+                                    videoFrame.vStride, videoFrame.rotation,
+                                    videoFrame.renderTimeMs);
+            } else {
+                env->CallVoidMethod(gCallBack, jmethodID, uid, videoFrame.type, width, height,
+                                    length,
+                                    videoFrame.yStride, videoFrame.uStride,
+                                    videoFrame.vStride, videoFrame.rotation,
+                                    videoFrame.renderTimeMs);
+            }
+        }
+
+    }
+
+    void writebackVideoFrame(VideoFrame &videoFrame, void *byteBuffer) {
+        if (byteBuffer == nullptr) {
+            return;
+        }
+
+        int width = videoFrame.width;
+        int height = videoFrame.height;
+        size_t widthAndHeight = (size_t) videoFrame.yStride * height;
+
+        memcpy(videoFrame.yBuffer, byteBuffer, widthAndHeight);
+        memcpy(videoFrame.uBuffer, (uint8_t *) byteBuffer + widthAndHeight, widthAndHeight / 4);
+        memcpy(videoFrame.vBuffer, (uint8_t *) byteBuffer + widthAndHeight * 5 / 4,
+               widthAndHeight / 4);
+    }
+
+public:
+    virtual bool onCaptureVideoFrame(VideoFrame &videoFrame) override {
+        getVideoFrame(videoFrame, captureVideoMethodId, _javaDirectPlayBufferCapture, 0);
+        writebackVideoFrame(videoFrame, _javaDirectPlayBufferCapture);
+        return true;
+    }
+
+    virtual bool onRenderVideoFrame(unsigned int uid, VideoFrame &videoFrame) override {
+        map<int, void *>::iterator it_find;
+        it_find = decodeBufferMap.find(uid);
+
+        if (it_find != decodeBufferMap.end()) {
+            if (it_find->second != nullptr) {
+                getVideoFrame(videoFrame, renderVideoMethodId, it_find->second, uid);
+                writebackVideoFrame(videoFrame, it_find->second);
+            }
+        }
+
+        return true;
+    }
+
+};
+
+
+class AgoraAudioFrameObserver : public agora::media::IAudioFrameObserver {
+
+public:
+    AgoraAudioFrameObserver() {
+        gCallBack = nullptr;
+    }
+
+    ~AgoraAudioFrameObserver() {
+    }
+
+    void getAudioFrame(AudioFrame &audioFrame, _jmethodID *jmethodID, void *_byteBufferObject, unsigned int uid) {
+        if (_byteBufferObject) {
+            AttachThreadScoped ats(gJVM);
+            JNIEnv *env = ats.env();
+            if (env == nullptr) {
+                return;
+            }
+            int len = audioFrame.samples * audioFrame.bytesPerSample;
+            memcpy(_byteBufferObject, audioFrame.buffer, (size_t) len); // * sizeof(int16_t)
+
+            if (uid == 0) {
+                env->CallVoidMethod(gCallBack, jmethodID, audioFrame.type, audioFrame.samples,
+                                    audioFrame.bytesPerSample,
+                                    audioFrame.channels, audioFrame.samplesPerSec,
+                                    audioFrame.renderTimeMs, len);
+            } else {
+                env->CallVoidMethod(gCallBack, jmethodID, uid, audioFrame.type, audioFrame.samples,
+                                    audioFrame.bytesPerSample,
+                                    audioFrame.channels, audioFrame.samplesPerSec,
+                                    audioFrame.renderTimeMs, len);
+            }
+        }
+
+    }
+
+    void writebackAudioFrame(AudioFrame &audioFrame, void *byteBuffer) {
+        if (byteBuffer == nullptr) {
+            return;
+        }
+
+        int len = audioFrame.samples * audioFrame.bytesPerSample;
+        memcpy(audioFrame.buffer, byteBuffer, (size_t) len);
+    }
+
+public:
+    virtual bool onRecordAudioFrame(AudioFrame &audioFrame) override {
+        getAudioFrame(audioFrame, recordAudioMethodId, _javaDirectPlayBufferRecordAudio, 0);
+        writebackAudioFrame(audioFrame, _javaDirectPlayBufferRecordAudio);
+        return true;
+    }
+
+    virtual bool onPlaybackAudioFrame(AudioFrame &audioFrame) override {
+        getAudioFrame(audioFrame, playbackAudioMethodId, _javaDirectPlayBufferPlayAudio, 0);
+        writebackAudioFrame(audioFrame, _javaDirectPlayBufferPlayAudio);
+        return true;
+    }
+
+    virtual bool
+    onPlaybackAudioFrameBeforeMixing(unsigned int uid, AudioFrame &audioFrame) override {
+        getAudioFrame(audioFrame, playBeforeMixAudioMethodId, _javaDirectPlayBufferBeforeMixAudio, uid);
+        writebackAudioFrame(audioFrame, _javaDirectPlayBufferBeforeMixAudio);
+        return true;
+    }
+
+    virtual bool onMixedAudioFrame(AudioFrame &audioFrame) override {
+        getAudioFrame(audioFrame, mixAudioMethodId, _javaDirectPlayBufferMixAudio, 0);
+        writebackAudioFrame(audioFrame, _javaDirectPlayBufferMixAudio);
+        return true;
+    }
+};
+
+
+static AgoraAudioFrameObserver s_audioFrameObserver;
+
+static AgoraVideoFrameObserver s_videoFrameObserver;
+static agora::rtc::IRtcEngine *rtcEngine = nullptr;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int __attribute__((visibility("default")))
+loadAgoraRtcEnginePlugin(agora::rtc::IRtcEngine *engine) {
+    __android_log_print(ANDROID_LOG_DEBUG, "agora-raw-data-plugin", "loadAgoraRtcEnginePlugin");
+    rtcEngine = engine;
+    return 0;
+}
+
+void __attribute__((visibility("default")))
+unloadAgoraRtcEnginePlugin(agora::rtc::IRtcEngine *engine) {
+    __android_log_print(ANDROID_LOG_DEBUG, "agora-raw-data-plugin", "unloadAgoraRtcEnginePlugin");
+
+    rtcEngine = nullptr;
+}
+
+JNIEXPORT void JNICALL
+Java_com_syan_agora_media_MediaPreProcessing_setCallback(JNIEnv *env, jclass obj,
+                                                                jobject callback) {
+    if (!rtcEngine) return;
+
+    env->GetJavaVM(&gJVM);
+
+    agora::util::AutoPtr<agora::media::IMediaEngine> mediaEngine;
+    mediaEngine.queryInterface(rtcEngine, agora::INTERFACE_ID_TYPE::AGORA_IID_MEDIA_ENGINE);
+    if (mediaEngine) {
+        mediaEngine->registerVideoFrameObserver(&s_videoFrameObserver);
+        mediaEngine->registerAudioFrameObserver(&s_audioFrameObserver);
+    }
+
+    if (gCallBack == nullptr) {
+        gCallBack = env->NewGlobalRef(callback);
+        gCallbackClass = env->GetObjectClass(gCallBack);
+
+        recordAudioMethodId = env->GetMethodID(gCallbackClass, "onRecordAudioFrame", "(IIIIIJI)V");
+        playbackAudioMethodId = env->GetMethodID(gCallbackClass, "onPlaybackAudioFrame",
+                                                 "(IIIIIJI)V");
+        playBeforeMixAudioMethodId = env->GetMethodID(gCallbackClass,
+                                                      "onPlaybackAudioFrameBeforeMixing",
+                                                      "(IIIIIIJI)V");
+        mixAudioMethodId = env->GetMethodID(gCallbackClass, "onMixedAudioFrame", "(IIIIIJI)V");
+
+        captureVideoMethodId = env->GetMethodID(gCallbackClass, "onCaptureVideoFrame",
+                                                "(IIIIIIIIJ)V");
+        renderVideoMethodId = env->GetMethodID(gCallbackClass, "onRenderVideoFrame",
+                                               "(IIIIIIIIIJ)V");
+
+        __android_log_print(ANDROID_LOG_DEBUG, "setCallback", "setCallback done successfully");
+    }
+}
+
+JNIEXPORT void JNICALL Java_com_syan_agora_media_MediaPreProcessing_setVideoCaptureByteBuffer
+        (JNIEnv *env, jclass obj, jobject bytebuffer) {
+    _javaDirectPlayBufferCapture = env->GetDirectBufferAddress(bytebuffer);
+}
+
+JNIEXPORT void JNICALL Java_com_syan_agora_media_MediaPreProcessing_setAudioRecordByteBuffer
+        (JNIEnv *env, jclass obj, jobject bytebuffer) {
+    _javaDirectPlayBufferRecordAudio = env->GetDirectBufferAddress(bytebuffer);
+}
+
+JNIEXPORT void JNICALL Java_com_syan_agora_media_MediaPreProcessing_setAudioPlayByteBuffer
+        (JNIEnv *env, jclass obj, jobject bytebuffer) {
+    _javaDirectPlayBufferPlayAudio = env->GetDirectBufferAddress(bytebuffer);
+}
+
+JNIEXPORT void JNICALL
+Java_com_syan_agora_media_MediaPreProcessing_setBeforeAudioMixByteBuffer
+        (JNIEnv *env, jclass obj, jobject bytebuffer) {
+    _javaDirectPlayBufferBeforeMixAudio = env->GetDirectBufferAddress(bytebuffer);
+}
+
+JNIEXPORT void JNICALL Java_com_syan_agora_media_MediaPreProcessing_setAudioMixByteBuffer
+        (JNIEnv *env, jclass obj, jobject bytebuffer) {
+    _javaDirectPlayBufferMixAudio = env->GetDirectBufferAddress(bytebuffer);
+}
+
+JNIEXPORT void JNICALL
+Java_com_syan_agora_media_MediaPreProcessing_setVideoDecodeByteBuffer(JNIEnv *env,
+                                                                             jclass type,
+                                                                             jint uid,
+                                                                             jobject byteBuffer) {
+    if (byteBuffer == nullptr) {
+        decodeBufferMap.erase(uid);
+    } else {
+        void *_javaDirectDecodeBuffer = env->GetDirectBufferAddress(byteBuffer);
+        decodeBufferMap.insert(make_pair(uid, _javaDirectDecodeBuffer));
+        __android_log_print(ANDROID_LOG_DEBUG, "agora-raw-data-plugin",
+                            "setVideoDecodeByteBuffer uid: %u, _javaDirectDecodeBuffer: %p",
+                            uid, _javaDirectDecodeBuffer);
+    }
+}
+
+JNIEXPORT void JNICALL
+Java_com_syan_agora_media_MediaPreProcessing_releasePoint(JNIEnv *env, jclass type) {
+    agora::util::AutoPtr<agora::media::IMediaEngine> mediaEngine;
+    mediaEngine.queryInterface(rtcEngine, agora::INTERFACE_ID_TYPE::AGORA_IID_MEDIA_ENGINE);
+
+    if (mediaEngine) {
+        mediaEngine->registerVideoFrameObserver(NULL);
+        mediaEngine->registerAudioFrameObserver(NULL);
+    }
+
+    if (gCallBack != nullptr) {
+        env->DeleteGlobalRef(gCallBack);
+        gCallBack = nullptr;
+    }
+    gCallbackClass = nullptr;
+
+    recordAudioMethodId = nullptr;
+    playbackAudioMethodId = nullptr;
+    playBeforeMixAudioMethodId = nullptr;
+    mixAudioMethodId = nullptr;
+    captureVideoMethodId = nullptr;
+    renderVideoMethodId = nullptr;
+
+    _javaDirectPlayBufferCapture = nullptr;
+    _javaDirectPlayBufferRecordAudio = nullptr;
+    _javaDirectPlayBufferPlayAudio = nullptr;
+    _javaDirectPlayBufferBeforeMixAudio = nullptr;
+    _javaDirectPlayBufferMixAudio = nullptr;
+
+    decodeBufferMap.clear();
+}
+
+
+#ifdef __cplusplus
+}
+#endif

android/src/main/cpp/src/agora_media_pre_processing.h

+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class com_syan_agora_media_MediaPreProcessing */
+
+#ifndef _Included_com_syan_agora_media_MediaPreProcessing
+#define _Included_com_syan_agora_media_MediaPreProcessing
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     com_syan_agora_media_MediaPreProcessing
+ * Method:    setCallback
+ * Signature: (Lcom/syan/agora/media/MediaPreProcessing/ProgressCallback;)V
+ */
+JNIEXPORT void JNICALL Java_com_syan_agora_media_MediaPreProcessing_setCallback
+  (JNIEnv *, jclass, jobject);
+
+/*
+ * Class:     com_syan_agora_media_MediaPreProcessing
+ * Method:    setVideoCaptureByteBuffer
+ * Signature: (Ljava/nio/ByteBuffer;)V
+ */
+JNIEXPORT void JNICALL Java_com_syan_agora_media_MediaPreProcessing_setVideoCaptureByteBuffer
+  (JNIEnv *, jclass, jobject);
+
+/*
+ * Class:     com_syan_agora_media_MediaPreProcessing
+ * Method:    setAudioRecordByteBuffer
+ * Signature: (Ljava/nio/ByteBuffer;)V
+ */
+JNIEXPORT void JNICALL Java_com_syan_agora_media_MediaPreProcessing_setAudioRecordByteBuffer
+  (JNIEnv *, jclass, jobject);
+
+/*
+ * Class:     com_syan_agora_media_MediaPreProcessing
+ * Method:    setAudioPlayByteBuffer
+ * Signature: (Ljava/nio/ByteBuffer;)V
+ */
+JNIEXPORT void JNICALL Java_com_syan_agora_media_MediaPreProcessing_setAudioPlayByteBuffer
+  (JNIEnv *, jclass, jobject);
+
+/*
+ * Class:     com_syan_agora_media_MediaPreProcessing
+ * Method:    setBeforeAudioMixByteBuffer
+ * Signature: (Ljava/nio/ByteBuffer;)V
+ */
+JNIEXPORT void JNICALL Java_com_syan_agora_media_MediaPreProcessing_setBeforeAudioMixByteBuffer
+  (JNIEnv *, jclass, jobject);
+
+/*
+ * Class:     com_syan_agora_media_MediaPreProcessing
+ * Method:    setAudioMixByteBuffer
+ * Signature: (Ljava/nio/ByteBuffer;)V
+ */
+JNIEXPORT void JNICALL Java_com_syan_agora_media_MediaPreProcessing_setAudioMixByteBuffer
+  (JNIEnv *, jclass, jobject);
+
+/*
+ * Class:     com_syan_agora_media_MediaPreProcessing
+ * Method:    setVideoDecodeByteBuffer
+ * Signature: (ILjava/nio/ByteBuffer;)V
+ */
+JNIEXPORT void JNICALL Java_com_syan_agora_media_MediaPreProcessing_setVideoDecodeByteBuffer
+  (JNIEnv *, jclass, jint, jobject);
+
+/*
+ * Class:     com_syan_agora_media_MediaPreProcessing
+ * Method:    releasePoint
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_com_syan_agora_media_MediaPreProcessing_releasePoint
+  (JNIEnv *, jclass);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

android/src/main/java/com/syan/agora/AgoraConst.java

     public final static String AGTokenPrivilegeWillExpire = "tokenPrivilegeWillExpire";
     public final static String AGRequestToken = "requestToken";
 
-    public final static String AGMicrophoneEnabled = "microphoneEnabled";
     public final static String AGAudioVolumeIndication = "audioVolumeIndication";
     public final static String AGActiveSpeaker = "activeSpeaker";
     public final static String AGFirstLocalAudioFrame = "firstLocalAudioFrame";
     public final static String AGFirstRemoteAudioFrame = "firstRemoteAudioFrame";
     public final static String AGFirstLocalVideoFrame = "firstLocalVideoFrame";
-    public final static String AGFirstRemoteVideoDecoded = "firstRemoteVideoDecoded";
     public final static String AGFirstRemoteVideoFrame = "firstRemoteVideoFrame";
     public final static String AGUserMuteAudio = "userMuteAudio";
-    public final static String AGUserMuteVideo = "userMuteVideo";
-    public final static String AGUserEnableVideo = "userEnableVideo";
-    public final static String AGUserEnableLocalVideo = "userEnableLocalVideo";
     public final static String AGVideoSizeChanged = "videoSizeChanged";
     public final static String AGRtmpStreamingStateChanged = "rtmpStreamingStateChanged";
     public final static String AGNetworkTypeChanged = "networkTypeChanged";
     public final static String AGAudioRouteChanged = "audioRouteChanged";
     public final static String AGCameraFocusAreaChanged = "cameraFocusAreaChanged";
     public final static String AGCameraExposureAreaChanged = "cameraExposureAreaChanged";
+    public final static String AGRemoteAudioStateChanged = "remoteAudioStateChanged";
+    public final static String AGLocalAudioStateChanged = "localAudioStateChanged";
+    public final static String AGLocalAudioStats = "localAudioStats";
+    public final static String AGMediaRelayStateChanged = "mediaRelayStateChanged";
+    public final static String AGReceivedChannelMediaRelay = "receivedChannelMediaRelay";
 
     public final static String AGRtcStats = "rtcStats";
     public final static String AGLastmileQuality = "lastmileQuality";
     public final static String AGLocalVideoStats = "localVideoStats";
     public final static String AGRemoteVideoStats = "remoteVideoStats";
     public final static String AGRemoteAudioStats = "remoteAudioStats";
-    public final static String AGAudioTransportStatsOfUid = "audioTransportStatsOfUid";
-    public final static String AGVideoTransportStatsOfUid = "videoTransportStatsOfUid";
 
     public final static String AGRemoteAudioMixingStart = "remoteAudioMixingStart";
     public final static String AGRemoteAudioMixingFinish = "remoteAudioMixingFinish";

android/src/main/java/com/syan/agora/AgoraModule.java

 
 import android.graphics.Rect;
 import android.support.annotation.Nullable;
+import android.view.SurfaceView;
 
 import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.Callback;
 import io.agora.rtc.video.AgoraImage;
 import io.agora.rtc.video.BeautyOptions;
 import io.agora.rtc.video.CameraCapturerConfiguration;
+import io.agora.rtc.video.ChannelMediaInfo;
+import io.agora.rtc.video.ChannelMediaRelayConfiguration;
 import io.agora.rtc.video.VideoEncoderConfiguration;
 
 import static com.facebook.react.bridge.UiThreadUtil.runOnUiThread;
                 public void run() {
                     WritableMap map = Arguments.createMap();
                     map.putString("message", "AgoraWarning");
-                    map.putInt("code", code);
+                    map.putInt("errorCode", code);
                     sendEvent(getReactApplicationContext(), AGWarning, map);
                 }
             });
                 public void run() {
                     WritableMap map = Arguments.createMap();
                     map.putString("message", "AgoraError");
-                    map.putInt("code", code);
+                    map.putInt("errorCode", code);
                     sendEvent(getReactApplicationContext(), AGError, map);
                 }
             });
                 @Override
                 public void run() {
                     WritableMap map = Arguments.createMap();
-                    map.putInt("error", code);
+                    map.putInt("errorCode", code);
                     map.putString("api", api);
                     map.putString("result", result);
                     if (code != 0) {
                     statsMap.putInt("duration", stats.totalDuration);
                     statsMap.putInt("txBytes", stats.txBytes);
                     statsMap.putInt("rxBytes", stats.rxBytes);
-                    // statsMap.putInt("txKBitRate", stats.txKBitRate);
-                    // statsMap.putInt("rxKBitRate", stats.rxKBitRate);
+                    statsMap.putInt("txAudioBytes", stats.txAudioBytes);
+                    statsMap.putInt("txVideoBytes", stats.txVideoBytes);
+                    statsMap.putInt("rxAudioBytes", stats.rxAudioBytes);
+                    statsMap.putInt("rxVideoBytes", stats.rxVideoBytes);
+                    statsMap.putInt("txKBitRate", stats.txKBitRate);
+                    statsMap.putInt("rxKBitRate", stats.rxKBitRate);
                     statsMap.putInt("txAudioKBitRate", stats.txAudioKBitRate);
                     statsMap.putInt("rxAudioKBitRate", stats.rxAudioKBitRate);
                     statsMap.putInt("txVideoKBitRate", stats.txVideoKBitRate);
             });
         }
 
-        @Override
-        public void onMicrophoneEnabled(final boolean enabled) {
-            runOnUiThread(new Runnable() {
-                @Override
-                public void run() {
-                    WritableMap map = Arguments.createMap();
-                    map.putBoolean("enabled", enabled);
-                    sendEvent(getReactApplicationContext(), AGMicrophoneEnabled, map);
-                }
-
-            });
-        }
-
         @Override
         public void onAudioVolumeIndication(final AudioVolumeInfo [] speakers, final int totalVolume) {
             runOnUiThread(new Runnable() {
             });
         }
 
-        /**
-         * onFirstRemoteVideoDecoded
-         */
-        @Override
-        public void onFirstRemoteVideoDecoded(final int uid, final int width, final int height, final int elapsed) {
-            runOnUiThread(new Runnable() {
-                @Override
-                public void run() {
-                    WritableMap map = Arguments.createMap();
-                    map.putInt("uid", uid);
-                    map.putInt("width", width);
-                    map.putInt("height", height);
-                    map.putInt("elapsed", elapsed);
-                    sendEvent(getReactApplicationContext(), AGFirstRemoteVideoDecoded, map);
-                }
-            });
-        }
-
         @Override
         public void onFirstRemoteVideoFrame(final int uid, final int width, final int height, final int elapsed) {
             runOnUiThread(new Runnable() {
         }
 
         @Override
-        public void onUserMuteVideo(final int uid, final boolean muted) {
+        public void onVideoSizeChanged(final int uid, final int width, final int height, final int rotation) {
             runOnUiThread(new Runnable() {
                 @Override
                 public void run() {
                     WritableMap map = Arguments.createMap();
-                    map.putBoolean("muted", muted);
                     map.putInt("uid", uid);
-                    sendEvent(getReactApplicationContext(), AGUserMuteVideo, map);
+                    map.putInt("width", width);
+                    map.putInt("height", height);
+                    map.putInt("rotation", rotation);
+                    sendEvent(getReactApplicationContext(), AGVideoSizeChanged, map);
                 }
             });
         }
 
         @Override
-        public void onUserEnableVideo(final int uid, final boolean enabled) {
+        public void onRtmpStreamingStateChanged(final String url, final int state, final int errCode) {
             runOnUiThread(new Runnable() {
                 @Override
                 public void run() {
                     WritableMap map = Arguments.createMap();
-                    map.putBoolean("enabled", enabled);
-                    map.putInt("uid", uid);
-                    sendEvent(getReactApplicationContext(), AGUserEnableVideo, map);
+                    map.putString("url", url);
+                    map.putInt("state", state);
+                    map.putInt("errorCode", errCode);
+                    sendEvent(getReactApplicationContext(), AGRtmpStreamingStateChanged, map);
                 }
             });
         }
 
         @Override
-        public void onUserEnableLocalVideo(final int uid, final boolean enabled) {
+        public void onNetworkTypeChanged(final int type) {
             runOnUiThread(new Runnable() {
                 @Override
                 public void run() {
                     WritableMap map = Arguments.createMap();
-                    map.putBoolean("enabled", enabled);
-                    map.putInt("uid", uid);
-                    sendEvent(getReactApplicationContext(), AGUserEnableLocalVideo, map);
+                    map.putInt("type", type);
+                    sendEvent(getReactApplicationContext(), AGNetworkTypeChanged, map);
                 }
             });
         }
 
-        @Override
-        public void onVideoSizeChanged(final int uid, final int width, final int height, final int rotation) {
-            runOnUiThread(new Runnable() {
-                @Override
-                public void run() {
-                    WritableMap map = Arguments.createMap();
-                    map.putInt("uid", uid);
-                    map.putInt("width", width);
-                    map.putInt("height", height);
-                    map.putInt("rotation", rotation);
-                    sendEvent(getReactApplicationContext(), AGVideoSizeChanged, map);
-                }
-            });
-        }
 
         @Override
-        public void onRtmpStreamingStateChanged(final String url, final int state, final int errCode) {
+        public void onLocalAudioStateChanged(final int state, final int errCode) {
             runOnUiThread(new Runnable() {
                 @Override
                 public void run() {
                     WritableMap map = Arguments.createMap();
-                    map.putString("url", url);
                     map.putInt("state", state);
                     map.putInt("errorCode", errCode);
-                    sendEvent(getReactApplicationContext(), AGRtmpStreamingStateChanged, map);
+                    sendEvent(getReactApplicationContext(), AGLocalAudioStateChanged, map);
                 }
             });
         }
-
         @Override
-        public void onNetworkTypeChanged(final int type) {
+        public void onRemoteAudioStateChanged(final int uid,
+                                              final int state,
+                                              final int reason,
+                                              final int elapsed) {
             runOnUiThread(new Runnable() {
                 @Override
                 public void run() {
                     WritableMap map = Arguments.createMap();
-                    map.putInt("type", type);
-                    sendEvent(getReactApplicationContext(), AGNetworkTypeChanged, map);
+                    map.putInt("uid", uid);
+                    map.putInt("state", state);
+                    map.putInt("uid", reason);
+                    map.putInt("elapsed", elapsed);
+                    sendEvent(getReactApplicationContext(), AGRemoteAudioStateChanged, map);
                 }
             });
         }
         }
 
         @Override
-        public void onRemoteVideoStateChanged(final int uid, final int state) {
+        public void onRemoteVideoStateChanged(final int uid,
+                                              final int state,
+                                              final int reason,
+                                              final int elapsed)  {
             runOnUiThread(new Runnable() {
                 @Override
                 public void run() {
                     WritableMap map = Arguments.createMap();
                     map.putInt("uid", uid);
                     map.putInt("state", state);
+                    map.putInt("reason", reason);
+                    map.putInt("elapsed", elapsed);
                     sendEvent(getReactApplicationContext(), AGRemoteVideoStateChanged, map);
                 }
             });
                     statsMap.putInt("duration", stats.totalDuration);
                     statsMap.putInt("txBytes", stats.txBytes);
                     statsMap.putInt("rxBytes", stats.rxBytes);
-                    statsMap.putInt("txAudioKBitRate", stats.txAudioKBitRate);
+                    statsMap.putInt("txAudioBytes", stats.txAudioBytes);
+                    statsMap.putInt("txVideoBytes", stats.txVideoBytes);
+                    statsMap.putInt("rxAudioBytes", stats.rxAudioBytes);
+                    statsMap.putInt("rxVideoBytes", stats.rxVideoBytes);
+                    statsMap.putInt("txKBitRate", stats.txKBitRate);
+                    statsMap.putInt("rxKBitRate", stats.rxKBitRate);
+                    statsMap.putInt("rxVideoKBitRate", stats.rxVideoKBitRate);
                     statsMap.putInt("rxAudioKBitRate", stats.rxAudioKBitRate);
                     statsMap.putInt("txVideoKBitRate", stats.txVideoKBitRate);
                     statsMap.putInt("rxVideoKBitRate", stats.rxVideoKBitRate);
                     statsMap.putInt("sentFrameRate", stats.sentFrameRate);
                     statsMap.putInt("encoderOutputFrameRate", stats.encoderOutputFrameRate);
                     statsMap.putInt("rendererOutputFrameRate", stats.rendererOutputFrameRate);
+                    statsMap.putInt("targetBitrate", stats.targetBitrate);
+                    statsMap.putInt("targetFrameRate", stats.targetFrameRate);
+                    statsMap.putInt("qualityAdaptIndication", stats.qualityAdaptIndication);
+                    statsMap.putInt("encodedBitrate", stats.encodedBitrate);
+                    statsMap.putInt("encodedFrameWidth", stats.encodedFrameWidth);
+                    statsMap.putInt("encodedFrameHeight", stats.encodedFrameHeight);
+                    statsMap.putInt("encodedFrameCount", stats.encodedFrameCount);
+                    statsMap.putInt("codecType", stats.codecType);
                     WritableMap map = Arguments.createMap();
                     map.putMap("stats", statsMap);
                     sendEvent(getReactApplicationContext(), AGLocalVideoStats, map);
                     statsMap.putInt("width", stats.width);
                     statsMap.putInt("height", stats.height);
                     statsMap.putInt("receivedBitrate", stats.receivedBitrate);
+                    statsMap.putInt("decoderOutputFrameRate", stats.decoderOutputFrameRate);
                     statsMap.putInt("rendererOutputFrameRate", stats.rendererOutputFrameRate);
+                    statsMap.putInt("packetLossRate", stats.packetLossRate);
                     statsMap.putInt("rxStreamType", stats.rxStreamType);
                     statsMap.putInt("totalFrozenTime", stats.totalFrozenTime);
                     statsMap.putInt("frozenRate", stats.frozenRate);
             });
         }
 
-        @Override
-        public void onRemoteAudioTransportStats(final int uid,
-                                                final int delay,
-                                                final int lost,
-                                                final int rxKBitRate) {
-            runOnUiThread(new Runnable() {
-                @Override
-                public void run() {
-                    WritableMap statsMap = Arguments.createMap();
-                    statsMap.putInt("uid", uid);
-                    statsMap.putInt("delay", delay);
-                    statsMap.putInt("lost", lost);
-                    statsMap.putInt("rxKBitRate", rxKBitRate);
-                    WritableMap map = Arguments.createMap();
-                    map.putMap("stats", statsMap);
-                    sendEvent(getReactApplicationContext(), AGAudioTransportStatsOfUid, map);
-                }
-            });
-        }
-
-        @Override
-        public void onRemoteVideoTransportStats(final int uid,
-                                                final int delay,
-                                                final int lost,
-                                                final int rxKBitRate) {
-            runOnUiThread(new Runnable() {
-                @Override
-                public void run() {
-                    WritableMap statsMap = Arguments.createMap();
-                    statsMap.putInt("uid", uid);
-                    statsMap.putInt("delay", delay);
-                    statsMap.putInt("lost", lost);
-                    statsMap.putInt("rxKBitRate", rxKBitRate);
-                    WritableMap map = Arguments.createMap();
-                    map.putMap("stats", statsMap);
-                    sendEvent(getReactApplicationContext(), AGVideoTransportStatsOfUid, map);
-                }
-            });
-        }
-
         @Override
         public void onAudioMixingStateChanged(final int state, final int errorCode) {
             runOnUiThread(new Runnable() {
                 public void run() {
                     WritableMap map = Arguments.createMap();
                     map.putString("url", url);
-                    map.putInt("code", errorCode);
+                    map.putInt("errorCode", errorCode);
                     sendEvent(getReactApplicationContext(), AGStreamPublished, map);
                 }
             });
                     WritableMap map = Arguments.createMap();
                     map.putInt("uid", uid);
                     map.putInt("streamId", streamId);
-                    map.putInt("error", error);
+                    map.putInt("errorCode", error);
                     map.putInt("missed", missed);
                     map.putInt("cached", cached);
                     sendEvent(getReactApplicationContext(), AGOccurStreamMessageError, map);
                 }
             });
         }
+
+        @Override
+        public void onChannelMediaRelayEvent(final int code) {
+            super.onChannelMediaRelayEvent(code);
+            runOnUiThread(new Runnable() {
+                @Override
+                public void run() {
+                    WritableMap map = Arguments.createMap();
+                    map.putInt("errorCode", code);
+                    sendEvent(getReactApplicationContext(), AGReceivedChannelMediaRelay, map);
+                }
+            });
+        }
+
+        @Override
+        public void onChannelMediaRelayStateChanged(final int state, final int code) {
+            super.onChannelMediaRelayStateChanged(state, code);
+            runOnUiThread(new Runnable() {
+                @Override
+                public void run() {
+                    WritableMap map = Arguments.createMap();
+                    map.putInt("state", state);
+                    map.putInt("errorCode", code);
+                    sendEvent(getReactApplicationContext(), AGMediaRelayStateChanged, map);
+                }
+            });
+        }
+
+        @Override
+        public void onLocalAudioStats(final LocalAudioStats rtcStats) {
+            super.onLocalAudioStats(rtcStats);
+            runOnUiThread(new Runnable() {
+                @Override
+                public void run() {
+                    WritableMap map = Arguments.createMap();
+                    map.putInt("numChannels", rtcStats.numChannels);
+                    map.putInt("sentSampleRate", rtcStats.sentSampleRate);
+                    map.putInt("sentBitrate", rtcStats.sentBitrate);
+                    sendEvent(getReactApplicationContext(), AGLocalAudioStats, map);
+                }
+            });
+        }
     };
 
     @ReactMethod
         }
     }
 
+    private String channelName = null;
+
     @ReactMethod
     public void joinChannel(ReadableMap options, Promise promise) {
         Integer res = AgoraManager.getInstance().joinChannel(options);
         if (res == 0) {
+            String channelName = options.getString("channelName");
+            this.channelName = channelName;
             promise.resolve(null);
         } else {
             promise.reject("-1", res.toString());
         if (options.hasKey("token")) {
             token = options.getString("token");
         }
+        String channelName = options.getString("channelName");
         Integer res = rtcEngine.joinChannelWithUserAccount(token, options.getString("channelName"), options.getString("userAccount"));
         if (res == 0) {
+            this.channelName = channelName;
             promise.resolve(null);
         } else {
             promise.reject("-1", res.toString());
         }
     }
 
+    @ReactMethod
+    public void switchChannel(ReadableMap options, Promise promise) {
+        String token = null;
+        String channel = null;
+        if (options.hasKey("token")) {
+            token = options.getString("token");
+        }
+        if (options.hasKey("channelName")) {
+            channel = options.getString("channelName");
+        }
+        Integer res = AgoraManager.getInstance().mRtcEngine.switchChannel(token, channel);
+        if (res == 0) {
+            promise.resolve(null);
+        } else {
+            promise.reject("-1", res.toString());
+        }
+    }
+
     @ReactMethod
     public void leaveChannel(Promise promise) {
         Integer res = AgoraManager.getInstance().leaveChannel();
         RtcEngine.destroy();
     }
 
+    @ReactMethod
+    public void startChannelMediaRelay(ReadableMap options, Promise promise) {
+        ChannelMediaRelayConfiguration config = new ChannelMediaRelayConfiguration();
+        ChannelMediaInfo src = config.getSrcChannelMediaInfo();
+        if (options.hasKey("src")) {
+            ReadableMap srcOption = options.getMap("src");
+            if (srcOption.hasKey("token")) {
+                src.token = srcOption.getString("token");
+            }
+            if (srcOption.hasKey("channelName")) {
+                src.channelName = srcOption.getString("channelName");
+            }
+        }
+        ReadableArray dstMediaInfo = options.getArray("channels");
+        for (int i = 0; i < dstMediaInfo.size(); i++) {
+            ReadableMap dst = dstMediaInfo.getMap(i);
+            String channelName = null;
+            String token = null;
+            Integer uid = 0;
+            if (dst.hasKey("token")) {
+                token = token;
+            }
+            if (dst.hasKey("channelName")) {
+                channelName = dst.getString("channelName");
+            }
+            if (dst.hasKey("uid")) {
+                uid = dst.getInt("uid");
+            }
+            config.setDestChannelInfo(channelName, new ChannelMediaInfo(channelName, token, uid));
+        }
+        Integer res = AgoraManager.getInstance().mRtcEngine.startChannelMediaRelay(config);
+        if (res == 0) {
+            promise.resolve(null);
+        } else {
+            promise.reject("-1", res.toString());
+        }
+    }
+
+    @ReactMethod
+    public void removeChannelMediaRelay(ReadableMap options, Promise promise) {
+        ChannelMediaRelayConfiguration config = new ChannelMediaRelayConfiguration();
+        ChannelMediaInfo src = config.getSrcChannelMediaInfo();
+        if (options.hasKey("src")) {
+            ReadableMap srcOption = options.getMap("src");
+            if (srcOption.hasKey("token")) {
+                src.token = srcOption.getString("token");
+            }
+            if (srcOption.hasKey("channelName")) {
+                src.channelName = srcOption.getString("channelName");
+            }
+        }
+        ReadableArray dstMediaInfo = options.getArray("channels");
+        for (int i = 0; i < dstMediaInfo.size(); i++) {
+            ReadableMap dst = dstMediaInfo.getMap(i);
+            if (dst.hasKey("channelName")) {
+                channelName = dst.getString("channelName");
+                config.removeDestChannelInfo(channelName);
+            }
+        }
+        Integer res = AgoraManager.getInstance().mRtcEngine.updateChannelMediaRelay(config);
+        if (res == 0) {
+            promise.resolve(null);
+        } else {
+            promise.reject("-1", res.toString());
+        }
+    }
+
+    @ReactMethod
+    public void updateChannelMediaRelay(ReadableMap options, Promise promise) {
+        ChannelMediaRelayConfiguration config = new ChannelMediaRelayConfiguration();
+        ChannelMediaInfo src = config.getSrcChannelMediaInfo();
+        if (options.hasKey("src")) {
+            ReadableMap srcOption = options.getMap("src");
+            if (srcOption.hasKey("token")) {
+                src.token = srcOption.getString("token");
+            }
+            if (srcOption.hasKey("channelName")) {
+                src.channelName = srcOption.getString("channelName");
+            }
+        }
+        ReadableArray dstMediaInfo = options.getArray("channels");
+        for (int i = 0; i < dstMediaInfo.size(); i++) {
+            ReadableMap dst = dstMediaInfo.getMap(i);
+            String channelName = null;
+            String token = null;
+            Integer uid = 0;
+            if (dst.hasKey("token")) {
+                token = token;
+            }
+            if (dst.hasKey("channelName")) {
+                channelName = dst.getString("channelName");
+            }
+            if (dst.hasKey("uid")) {
+                uid = dst.getInt("uid");
+            }
+            config.setDestChannelInfo(src.channelName, new ChannelMediaInfo(channelName, token, uid));
+        }
+        Integer res = AgoraManager.getInstance().mRtcEngine.updateChannelMediaRelay(config);
+        if (res == 0) {
+            promise.resolve(null);
+        } else {
+            promise.reject("-1", res.toString());
+        }
+    }
+
+    @ReactMethod
+    public void stopChannelMediaRelay(Promise promise) {
+        Integer res = AgoraManager.getInstance().mRtcEngine.stopChannelMediaRelay();
+        if (res == 0) {
+            promise.resolve(null);
+        } else {
+            promise.reject("-1", res.toString());
+        }
+    }
+
     @ReactMethod
     public void startPreview(Promise promise) {
         Integer res = AgoraManager.getInstance().startPreview();
     @ReactMethod
     public void setCameraFocusPositionInPreview(ReadableMap options, Promise promise) {
         Integer res = AgoraManager.getInstance().mRtcEngine.setCameraFocusPositionInPreview(
-                    (float)options.getDouble("x"),
-                    (float)options.getDouble("y")
-            );
+                (float)options.getDouble("x"),
+                (float)options.getDouble("y")
+        );
         if (res == 0) {
             promise.resolve(null);
         } else {
     @ReactMethod
     public void createDataStream(ReadableMap options, Promise promise) {
         Integer res = AgoraManager.getInstance().mRtcEngine
-                    .createDataStream(
-                            options.getBoolean("ordered"),
-                            options.getBoolean("reliable")
-                            );
+                .createDataStream(
+                        options.getBoolean("ordered"),
+                        options.getBoolean("reliable")
+                );
         if (res == 0) {
             promise.resolve(null);
         } else {
     @ReactMethod
     public void startAudioMixing(ReadableMap options, Promise promise) {
         Integer res = AgoraManager.getInstance().mRtcEngine.startAudioMixing(
-                    options.getString("filepath"),
-                    options.getBoolean("loopback"),
-                    options.getBoolean("replace"),
-                    options.getInt("cycle")
+                options.getString("filepath"),
+                options.getBoolean("loopback"),
+                options.getBoolean("replace"),
+                options.getInt("cycle")
         );
         if (res == 0) {
             promise.resolve(null);
     @ReactMethod
     public void startAudioRecording(ReadableMap options, Promise promise) {
         Integer res = AgoraManager.getInstance().mRtcEngine
-                    .startAudioRecording(
-                            options.getString("filepath"),
-                            options.getInt("quality")
-        );
+                .startAudioRecording(
+                        options.getString("filepath"),
+                        options.getInt("quality")
+                );
         if (res == 0) {
             promise.resolve(null);
         } else {
     @ReactMethod
     public void stopAudioRecording(Promise promise) {
         Integer res = AgoraManager.getInstance().mRtcEngine
-                    .stopAudioRecording();
+                .stopAudioRecording();
         if (res == 0) {
             promise.resolve(null);
         } else {
     @ReactMethod
     public void stopEchoTest(Promise promise) {
         Integer res = AgoraManager.getInstance().mRtcEngine
-                    .stopEchoTest();
+                .stopEchoTest();
         if (res == 0) {
             promise.resolve(null);
         } else {
     @ReactMethod
     public void enableLastmileTest(Promise promise) {
         Integer res = AgoraManager.getInstance().mRtcEngine
-                    .enableLastmileTest();
+                .enableLastmileTest();
         if (res == 0) {
             promise.resolve(null);
         } else {
     @ReactMethod
     public void disableLastmileTest(Promise promise) {
         Integer res = AgoraManager.getInstance().mRtcEngine
-                    .disableLastmileTest();
+                .disableLastmileTest();
         if (res == 0) {
             promise.resolve(null);
         } else {
     @ReactMethod
     public void setRecordingAudioFrameParameters(ReadableMap options, Promise promise) {
         Integer res = AgoraManager.getInstance().mRtcEngine
-                    .setRecordingAudioFrameParameters(
-                            options.getInt("sampleRate"),
-                            options.getInt("channel"),
-                            options.getInt("mode"),
-                            options.getInt("samplesPerCall")
-        );
+                .setRecordingAudioFrameParameters(
+                        options.getInt("sampleRate"),
+                        options.getInt("channel"),
+                        options.getInt("mode"),
+                        options.getInt("samplesPerCall")
+                );
         if (res == 0) {
             promise.resolve(null);
         } else {
     @ReactMethod
     public void setPlaybackAudioFrameParameters(ReadableMap options, Promise promise) {
         Integer res = AgoraManager.getInstance().mRtcEngine
-                    .setPlaybackAudioFrameParameters(
-                            options.getInt("sampleRate"),
-                            options.getInt("channel"),
-                            options.getInt("mode"),
-                            options.getInt("samplesPerCall")
-        );
+                .setPlaybackAudioFrameParameters(
+                        options.getInt("sampleRate"),
+                        options.getInt("channel"),
+                        options.getInt("mode"),
+                        options.getInt("samplesPerCall")
+                );
         if (res == 0) {
             promise.resolve(null);
         } else {
     @ReactMethod
     public void setMixedAudioFrameParameters(WritableMap options, Promise promise) {
         Integer res = AgoraManager.getInstance().mRtcEngine
-                    .setMixedAudioFrameParameters(
-                            options.getInt("sampleRate"),
-                            options.getInt("samplesPerCall")
-                    );
+                .setMixedAudioFrameParameters(
+                        options.getInt("sampleRate"),
+                        options.getInt("samplesPerCall")
+                );
         if (res == 0) {
             promise.resolve(null);
         } else {
     @ReactMethod
     public void addVideoWatermark(ReadableMap options, Promise promise) {
         Integer res = AgoraManager.getInstance().mRtcEngine
-                    .addVideoWatermark(createAgoraImage(options));
+                .addVideoWatermark(createAgoraImage(options));
         if (res == 0) {
             promise.resolve(null);
         } else {
     @ReactMethod
     public void clearVideoWatermarks(Promise promise) {
         Integer res = AgoraManager.getInstance().mRtcEngine
-                    .clearVideoWatermarks();
+                .clearVideoWatermarks();
         if (res == 0) {
             promise.resolve(null);
         } else {
     @ReactMethod
     public void setLocalPublishFallbackOption(int option, Promise promise) {
         Integer res = AgoraManager.getInstance().mRtcEngine
-                    .setLocalPublishFallbackOption(option);
+                .setLocalPublishFallbackOption(option);
         if (res == 0) {
             promise.resolve(null);
         } else {
     @ReactMethod
     public void setRemoteSubscribeFallbackOption(int option, Promise promise) {
         Integer res = AgoraManager.getInstance().mRtcEngine
-                    .setRemoteSubscribeFallbackOption(option);
+                .setRemoteSubscribeFallbackOption(option);
         if (res == 0) {
             promise.resolve(null);
         } else {
     @ReactMethod
     public void enableDualStreamMode(boolean enabled, Promise promise) {
         Integer res = AgoraManager.getInstance().mRtcEngine
-                    .enableDualStreamMode(enabled);
+                .enableDualStreamMode(enabled);
         if (res == 0) {
             promise.resolve(null);
         } else {
     @ReactMethod
     public void setRemoteVideoStreamType(ReadableMap options, Promise promise) {
         Integer res = AgoraManager.getInstance().mRtcEngine
-                    .setRemoteVideoStreamType(
-                            options.getInt("uid"),
-                            options.getInt("streamType")
-                        );
+                .setRemoteVideoStreamType(
+                        options.getInt("uid"),
+                        options.getInt("streamType")
+                );
         if (res == 0) {
             promise.resolve(null);
         } else {
     @ReactMethod
     public void setRemoteDefaultVideoStreamType(ReadableMap options, Promise promise) {
         Integer res = AgoraManager.getInstance().mRtcEngine
-                    .setRemoteDefaultVideoStreamType(
-                            options.getInt("streamType")
-                    );
+                .setRemoteDefaultVideoStreamType(
+                        options.getInt("streamType")
+                );
         if (res == 0) {
             promise.resolve(null);
         } else {
         }
     }
 
+    private static boolean recording = false;
+
+    // TODO: need implementation
+    @ReactMethod
+    public void startAVRecording(final ReadableMap option, final Promise promise) {
+        String path = option.getString("path");
+        Integer uid = option.getInt("uid");
+        String format = option.getString("format");
+        if (true == recording) {
+            promise.reject("-1", "recording already started");
+        }
+        SurfaceView view = AgoraManager.getInstance().getSurfaceView(uid);
+        if (null == view) {
+            promise.reject("-1", "recording already started");
+        }
+    }
+
+    // TODO: need implementation
+    @ReactMethod
+    public void stopAVRecording(final Promise promise) {
+        if (false == recording) {
+            promise.reject("-1", "recording didn't start");
+        } else {
+            promise.resolve(null);
+        }
+    }
+
     public LiveInjectStreamConfig.AudioSampleRateType getAudioSampleRateEnum (int val) {
         LiveInjectStreamConfig.AudioSampleRateType type = LiveInjectStreamConfig.AudioSampleRateType.TYPE_32000;
         switch (Integer.valueOf(val)) {
     @ReactMethod
     public void removeInjectStreamUrl(ReadableMap options, Promise promise) {
         Integer res = AgoraManager.getInstance().mRtcEngine
-                    .removeInjectStreamUrl(options.getString("url"));
+                .removeInjectStreamUrl(options.getString("url"));
         if (res == 0) {
             promise.resolve(null);
         } else {
     @ReactMethod
     public void addPublishStreamUrl(ReadableMap options, Promise promise) {
         Integer res = AgoraManager.getInstance().mRtcEngine
-                    .addPublishStreamUrl(
-                            options.getString("url"),
-                            options.getBoolean("enable")
-                    );
+                .addPublishStreamUrl(
+                        options.getString("url"),
+                        options.getBoolean("enable")
+                );
         if (res == 0) {
             promise.resolve(null);
         } else {
     @ReactMethod
     public void removePublishStreamUrl(ReadableMap options, Promise promise) {
         Integer res = AgoraManager.getInstance().mRtcEngine
-                    .removePublishStreamUrl(options.getString("url"));
+                .removePublishStreamUrl(options.getString("url"));
         if (res == 0) {
             promise.resolve(null);
         } else {
     public void playEffect(ReadableMap options, Promise promise) {
         IAudioEffectManager manager = AgoraManager.getInstance().mRtcEngine.getAudioEffectManager();
         Integer res = manager.playEffect(
-            options.getInt("soundid"),
-            options.getString("filepath"),
-            options.getInt("loopcount"),
-            options.getDouble("pitch"),
-            options.getDouble("pan"),
-            options.getDouble("gain"),
-            options.getBoolean("publish")
+                options.getInt("soundid"),
+                options.getString("filepath"),
+                options.getInt("loopcount"),
+                options.getDouble("pitch"),
+                options.getDouble("pan"),
+                options.getDouble("gain"),
+                options.getBoolean("publish")
         );
         if (res == 0) {
             promise.resolve(null);

android/src/main/java/com/syan/agora/AgoraVideoView.java

 package com.syan.agora;
 
 import android.content.Context;
+import android.media.MediaCodec;
+import android.media.MediaCodecInfo;
+import android.media.MediaCodecList;
+import android.media.MediaFormat;
+import android.media.MediaMuxer;
+import android.os.Build;
+import android.support.annotation.RequiresApi;
 import android.util.AttributeSet;
-import android.view.SurfaceView;
+import android.util.Log;
 import android.view.View;
 import android.widget.LinearLayout;
 
-import io.agora.rtc.mediaio.AgoraSurfaceView;
+import com.syan.agora.media.MediaDataAudioObserver;
+import com.syan.agora.media.MediaDataVideoObserver;
+
+import java.io.IOException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+
+import static android.media.MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420SemiPlanar;
+import static android.media.MediaFormat.KEY_BIT_RATE;
+import static android.media.MediaFormat.KEY_COLOR_FORMAT;
+import static android.media.MediaFormat.KEY_FRAME_RATE;
+import static android.media.MediaFormat.KEY_I_FRAME_INTERVAL;
 
 /**
  * Created by DB on 2017/6/27.
  */
 
-public class AgoraVideoView extends LinearLayout {
+public class AgoraVideoView extends LinearLayout implements MediaDataAudioObserver, MediaDataVideoObserver {
+
     public boolean isShowLocalVideo() {
         return showLocalVideo;
     }
 
     public void setRenderMode(Integer renderMode) {
         this.renderMode = renderMode;
-
     }
 
     public Integer getRemoteUid() {
     private Integer renderMode = 1;
     private Integer remoteUid;
     private boolean zOrderMediaOverlay;
-    private SurfaceView surfaceView;
 
     public AgoraVideoView(Context context) {
         super(context);
             }
         }
     }
+
+    @Override
+    public void onRecordAudioFrame(byte[] data, int audioFrameType, int samples, int bytesPerSample, int channels, int samplesPerSec, long renderTimeMs, int bufferLength) {
+
+    }
+
+    @Override
+    public void onPlaybackAudioFrame(byte[] data, int audioFrameType, int samples, int bytesPerSample, int channels, int samplesPerSec, long renderTimeMs, int bufferLength) {
+
+    }
+
+    @Override
+    public void onPlaybackAudioFrameBeforeMixing(int uid, byte[] data, int audioFrameType, int samples, int bytesPerSample, int channels, int samplesPerSec, long renderTimeMs, int bufferLength) {
+
+    }
+
+    @Override
+    public void onMixedAudioFrame(byte[] data, int audioFrameType, int samples, int bytesPerSample, int channels, int samplesPerSec, long renderTimeMs, int bufferLength) {
+
+    }
+
+    @Override
+    public void onCaptureVideoFrame(byte[] data, int frameType, int width, int height, int bufferLength, int yStride, int uStride, int vStride, int rotation, long renderTimeMs) {
+
+    }
+
+    @Override
+    public void onRenderVideoFrame(int uid, byte[] data, int frameType, int width, int height, int bufferLength, int yStride, int uStride, int vStride, int rotation, long renderTimeMs) {
+
+    }
 }

android/src/main/java/com/syan/agora/media/DecodeDataBuffer.java

+package com.syan.agora.media;
+
+import java.nio.ByteBuffer;
+
+public class DecodeDataBuffer {
+    private int uid;
+    private ByteBuffer byteBuffer;
+
+    public DecodeDataBuffer(int uid, ByteBuffer byteBuffer) {
+        this.uid = uid;
+        this.byteBuffer = byteBuffer;
+    }
+
+    public int getUid() {
+        return uid;
+    }
+
+    public void setUid(int uid) {
+        this.uid = uid;
+    }
+
+    public ByteBuffer getByteBuffer() {
+        return byteBuffer;
+    }
+
+    public void setByteBuffer(ByteBuffer byteBuffer) {
+        this.byteBuffer = byteBuffer;
+    }
+}

android/src/main/java/com/syan/agora/media/MediaDataAudioObserver.java

+
+package com.syan.agora.media;
+
+public interface MediaDataAudioObserver {
+
+    void onRecordAudioFrame(byte[] data, int audioFrameType, int samples, int bytesPerSample, int channels, int samplesPerSec, long renderTimeMs, int bufferLength);
+
+    void onPlaybackAudioFrame(byte[] data, int audioFrameType, int samples, int bytesPerSample, int channels, int samplesPerSec, long renderTimeMs, int bufferLength);
+
+    void onPlaybackAudioFrameBeforeMixing(int uid, byte[] data,int audioFrameType, int samples, int bytesPerSample, int channels, int samplesPerSec, long renderTimeMs, int bufferLength);
+
+    void onMixedAudioFrame(byte[] data,int audioFrameType, int samples, int bytesPerSample, int channels, int samplesPerSec, long renderTimeMs, int bufferLength);
+}

android/src/main/java/com/syan/agora/media/MediaDataObserverPlugin.java

+package com.syan.agora.media;
+
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.graphics.ImageFormat;
+import android.graphics.Matrix;
+import android.graphics.Rect;
+import android.graphics.YuvImage;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+public class MediaDataObserverPlugin implements MediaPreProcessing.ProgressCallback {
+
+    private final CopyOnWriteArrayList<MediaDataVideoObserver> videoObserverList = new CopyOnWriteArrayList<>();
+    private final CopyOnWriteArrayList<MediaDataAudioObserver> audioObserverList = new CopyOnWriteArrayList<>();
+
+    private static final int VIDEO_DEFAULT_BUFFER_SIZE = 3240 * 1080; // default maximum video size Full HD+
+    private static final int AUDIO_DEFAULT_BUFFER_SIZE = 2048;
+
+    public ByteBuffer byteBufferCapture = ByteBuffer.allocateDirect(VIDEO_DEFAULT_BUFFER_SIZE);
+    public ByteBuffer byteBufferRender = ByteBuffer.allocateDirect(VIDEO_DEFAULT_BUFFER_SIZE);
+    public ByteBuffer byteBufferAudioRecord = ByteBuffer.allocateDirect(AUDIO_DEFAULT_BUFFER_SIZE);
+    public ByteBuffer byteBufferAudioPlay = ByteBuffer.allocateDirect(AUDIO_DEFAULT_BUFFER_SIZE);
+    public ByteBuffer byteBufferBeforeAudioMix = ByteBuffer.allocateDirect(AUDIO_DEFAULT_BUFFER_SIZE);
+    public ByteBuffer byteBufferAudioMix = ByteBuffer.allocateDirect(AUDIO_DEFAULT_BUFFER_SIZE);
+
+    private final ArrayList<DecodeDataBuffer> decodeBufferList = new ArrayList<>();
+
+    private static MediaDataObserverPlugin myAgent = null;
+
+    private boolean beCaptureVideoShot = false;
+    private boolean beRenderVideoShot = false;
+    private String captureFilePath = null;
+    private String renderFilePath = null;
+    private int renderVideoShotUid;
+
+    public static MediaDataObserverPlugin the() {
+        if (myAgent == null) {
+            synchronized (MediaDataObserverPlugin.class) {
+                if (myAgent == null)
+                    myAgent = new MediaDataObserverPlugin();
+            }
+        }
+        return myAgent;
+    }
+
+    public void addVideoObserver(MediaDataVideoObserver observer) {
+        videoObserverList.add(observer);
+    }
+
+    public void removeVideoObserver(MediaDataVideoObserver observer) {
+        videoObserverList.remove(observer);
+    }
+
+    public void addAudioObserver(MediaDataAudioObserver observer) {
+        audioObserverList.add(observer);
+    }
+
+    public void removeAudioObserver(MediaDataAudioObserver observer) {
+        audioObserverList.remove(observer);
+    }
+
+    public void saveCaptureVideoSnapshot(String filePath) {
+        beCaptureVideoShot = true;
+        captureFilePath = filePath;
+    }
+
+    public void saveRenderVideoSnapshot(String filePath, int uid) {
+        beRenderVideoShot = true;
+        renderFilePath = filePath;
+        renderVideoShotUid = uid;
+    }
+
+    public void addDecodeBuffer(int uid) {
+        ByteBuffer byteBuffer = ByteBuffer.allocateDirect(VIDEO_DEFAULT_BUFFER_SIZE);
+        decodeBufferList.add(new DecodeDataBuffer(uid, byteBuffer));
+        MediaPreProcessing.setVideoDecodeByteBuffer(uid, byteBuffer);
+    }
+
+    public void removeDecodeBuffer(int uid) {
+        Iterator<DecodeDataBuffer> it = decodeBufferList.iterator();
+        while (it.hasNext()) {
+            DecodeDataBuffer buffer = it.next();
+            if (buffer.getUid() == uid) {
+                it.remove();
+            }
+        }
+
+        MediaPreProcessing.setVideoDecodeByteBuffer(uid, null);
+    }
+
+    public void removeAllBuffer() {
+        decodeBufferList.removeAll(decodeBufferList);
+        releaseBuffer();
+    }
+
+    @Override
+    public void onCaptureVideoFrame(int videoFrameType, int width, int height, int bufferLength, int yStride, int uStride, int vStride, int rotation, long renderTimeMs) {
+
+        byte[] buf = new byte[bufferLength];
+        byteBufferCapture.limit(bufferLength);
+        byteBufferCapture.get(buf);
+        byteBufferCapture.flip();
+
+        for (MediaDataVideoObserver observer : videoObserverList) {
+            observer.onCaptureVideoFrame(buf, videoFrameType, width, height, bufferLength, yStride, uStride, vStride, rotation, renderTimeMs);
+        }
+
+        byteBufferCapture.put(buf);
+        byteBufferCapture.flip();
+
+        if (beCaptureVideoShot) {
+            beCaptureVideoShot = false;
+
+            getVideoSnapshot(width, height, rotation, bufferLength, buf, captureFilePath, yStride, uStride, vStride);
+        }
+    }
+
+    @Override
+    public void onRenderVideoFrame(int uid, int videoFrameType, int width, int height, int bufferLength, int yStride, int uStride, int vStride, int rotation, long renderTimeMs) {
+
+        for (MediaDataVideoObserver observer : videoObserverList) {
+            Iterator<DecodeDataBuffer> it = decodeBufferList.iterator();
+            while (it.hasNext()) {
+                DecodeDataBuffer tmp = it.next();
+                if (tmp.getUid() == uid) {
+                    byte[] buf = new byte[bufferLength];
+                    tmp.getByteBuffer().limit(bufferLength);
+                    tmp.getByteBuffer().get(buf);
+                    tmp.getByteBuffer().flip();
+
+                    observer.onRenderVideoFrame(uid, buf, videoFrameType, width, height, bufferLength, yStride, uStride, vStride, rotation, renderTimeMs);
+
+                    tmp.getByteBuffer().put(buf);
+                    tmp.getByteBuffer().flip();
+
+                    if (beRenderVideoShot) {
+                        if (uid == renderVideoShotUid) {
+                            beRenderVideoShot = false;
+
+                            getVideoSnapshot(width, height, rotation, bufferLength, buf, renderFilePath, yStride, uStride, vStride);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    @Override
+    public void onRecordAudioFrame(int audioFrameType, int samples, int bytesPerSample, int channels, int samplesPerSec, long renderTimeMs, int bufferLength) {
+        byte[] buf = new byte[bufferLength];
+        byteBufferAudioRecord.limit(bufferLength);
+        byteBufferAudioRecord.get(buf);
+        byteBufferAudioRecord.flip();
+
+        for (MediaDataAudioObserver observer : audioObserverList) {
+            observer.onRecordAudioFrame(buf, audioFrameType, samples, bytesPerSample, channels, samplesPerSec, renderTimeMs, bufferLength);
+        }
+
+        byteBufferAudioRecord.put(buf);
+        byteBufferAudioRecord.flip();
+    }
+
+    @Override
+    public void onPlaybackAudioFrame(int audioFrameType, int samples, int bytesPerSample, int channels, int samplesPerSec, long renderTimeMs, int bufferLength) {
+        byte[] buf = new byte[bufferLength];
+        byteBufferAudioPlay.limit(bufferLength);
+        byteBufferAudioPlay.get(buf);
+        byteBufferAudioPlay.flip();
+
+        for (MediaDataAudioObserver observer : audioObserverList) {
+            observer.onPlaybackAudioFrame(buf, audioFrameType, samples, bytesPerSample, channels, samplesPerSec, renderTimeMs, bufferLength);
+        }
+
+        byteBufferAudioPlay.put(buf);
+        byteBufferAudioPlay.flip();
+    }
+
+    @Override
+    public void onPlaybackAudioFrameBeforeMixing(int uid, int audioFrameType, int samples, int bytesPerSample, int channels, int samplesPerSec, long renderTimeMs, int bufferLength) {
+        byte[] buf = new byte[bufferLength];
+        byteBufferBeforeAudioMix.limit(bufferLength);
+        byteBufferBeforeAudioMix.get(buf);
+        byteBufferBeforeAudioMix.flip();
+
+        for (MediaDataAudioObserver observer : audioObserverList) {
+            observer.onPlaybackAudioFrameBeforeMixing(uid, buf, audioFrameType, samples, bytesPerSample, channels, samplesPerSec, renderTimeMs, bufferLength);
+        }
+
+        byteBufferBeforeAudioMix.put(buf);
+        byteBufferBeforeAudioMix.flip();
+    }
+
+    @Override
+    public void onMixedAudioFrame(int audioFrameType, int samples, int bytesPerSample, int channels, int samplesPerSec, long renderTimeMs, int bufferLength) {
+        byte[] buf = new byte[bufferLength];
+        byteBufferAudioMix.limit(bufferLength);
+        byteBufferAudioMix.get(buf);
+        byteBufferAudioMix.flip();
+
+        for (MediaDataAudioObserver observer : audioObserverList) {
+            observer.onMixedAudioFrame(buf, audioFrameType, samples, bytesPerSample, channels, samplesPerSec, renderTimeMs, bufferLength);
+        }
+
+        byteBufferAudioMix.put(buf);
+        byteBufferAudioMix.flip();
+    }
+
+    private void getVideoSnapshot(int width, int height, int rotation, int bufferLength, byte[] buffer, String filePath, int yStride, int uStride, int vStride) {
+        File file = new File(filePath);
+
+        byte[] NV21 = new byte[bufferLength];
+        swapYU12toYUV420SemiPlanar(buffer, NV21, width, height, yStride, uStride, vStride);
+
+        ByteArrayOutputStream baos = new ByteArrayOutputStream();
+
+        int[] strides = {yStride, yStride};
+        YuvImage image = new YuvImage(NV21, ImageFormat.NV21, width, height, strides);
+
+        image.compressToJpeg(
+                new Rect(0, 0, image.getWidth(), image.getHeight()),
+                100, baos);
+
+        // rotate picture when saving to file
+        Matrix matrix = new Matrix();
+        matrix.postRotate(rotation);
+        byte[] bytes = baos.toByteArray();
+        try {
+            baos.close();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        Bitmap bitmap = BitmapFactory.decodeByteArray(bytes, 0, bytes.length);
+        Bitmap target = Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix, true);
+
+        File fileParent = file.getParentFile();
+        if (!fileParent.exists()) {
+            fileParent.mkdirs();
+        }
+        if (file.exists()) {
+            file.delete();
+        }
+
+        try {
+            file.createNewFile();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+
+        FileOutputStream fos = null;
+        try {
+            fos = new FileOutputStream(file);
+        } catch (FileNotFoundException e) {
+            e.printStackTrace();
+        }
+
+        target.compress(Bitmap.CompressFormat.JPEG, 100, fos);
+
+        target.recycle();
+        bitmap.recycle();
+
+        try {
+            fos.close();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    private void swapYU12toYUV420SemiPlanar(byte[] yu12bytes, byte[] i420bytes, int width, int height, int yStride, int uStride, int vStride) {
+        System.arraycopy(yu12bytes, 0, i420bytes, 0, yStride * height);
+        int startPos = yStride * height;
+        int yv_start_pos_u = startPos;
+        int yv_start_pos_v = startPos + startPos / 4;
+        for (int i = 0; i < startPos / 4; i++) {
+            i420bytes[startPos + 2 * i + 0] = yu12bytes[yv_start_pos_v + i];
+            i420bytes[startPos + 2 * i + 1] = yu12bytes[yv_start_pos_u + i];
+        }
+    }
+
+    public void releaseBuffer() {
+        byteBufferCapture.clear();
+        byteBufferRender.clear();
+        byteBufferAudioRecord.clear();
+        byteBufferAudioPlay.clear();
+        byteBufferBeforeAudioMix.clear();
+        byteBufferAudioMix.clear();
+    }
+
+}

android/src/main/java/com/syan/agora/media/MediaDataVideoObserver.java

+package com.syan.agora.media;
+
+public interface MediaDataVideoObserver {
+
+    void onCaptureVideoFrame(byte[] data, int frameType, int width, int height, int bufferLength, int yStride, int uStride, int vStride, int rotation, long renderTimeMs);
+
+    void onRenderVideoFrame(int uid, byte[] data, int frameType, int width, int height, int bufferLength, int yStride, int uStride, int vStride, int rotation, long renderTimeMs);
+}

android/src/main/java/com/syan/agora/media/MediaPreProcessing.java

+package com.syan.agora.media;
+
+import java.nio.ByteBuffer;
+
+public class MediaPreProcessing {
+    static {
+        System.loadLibrary("apm-plugin-raw-data-api-java");
+    }
+
+    public interface ProgressCallback {
+        void onCaptureVideoFrame(int videoFrameType, int width, int height, int bufferLength, int yStride, int uStride, int vStride, int rotation, long renderTimeMs);
+
+        void onRenderVideoFrame(int uid, int videoFrameType, int width, int height, int bufferLength, int yStride, int uStride, int vStride, int rotation, long renderTimeMs);
+
+        void onRecordAudioFrame(int audioFrameType, int samples, int bytesPerSample, int channels, int samplesPerSec, long renderTimeMs, int bufferLength);
+
+        void onPlaybackAudioFrame(int audioFrameType, int samples, int bytesPerSample, int channels, int samplesPerSec, long renderTimeMs, int bufferLength);
+
+        void onPlaybackAudioFrameBeforeMixing(int uid, int audioFrameType, int samples, int bytesPerSample, int channels, int samplesPerSec, long renderTimeMs, int bufferLength);
+
+        void onMixedAudioFrame(int audioFrameType, int samples, int bytesPerSample, int channels, int samplesPerSec, long renderTimeMs, int bufferLength);
+    }
+
+    public static native void setCallback(ProgressCallback callback);
+
+    public static native void setVideoCaptureByteBuffer(ByteBuffer byteBuffer);
+
+    public static native void setAudioRecordByteBuffer(ByteBuffer byteBuffer);
+
+    public static native void setAudioPlayByteBuffer(ByteBuffer byteBuffer);
+
+    public static native void setBeforeAudioMixByteBuffer(ByteBuffer byteBuffer);
+
+    public static native void setAudioMixByteBuffer(ByteBuffer byteBuffer);
+
+    public static native void setVideoDecodeByteBuffer(int uid, ByteBuffer byteBuffer);
+
+    public static native void releasePoint();
+}

ios/RCTAgora/AgoraConst.h

 static NSString *AGTokenPrivilegeWillExpire = @"tokenPrivilegeWillExpire";
 static NSString *AGRequestToken = @"requestToken";
 
-static NSString *AGMicrophoneEnabled = @"microphoneEnabled";
+static NSString *AGLocalAudioStateChanged = @"localAudioStateChanged";
+static NSString *AGRemoteAudioStateChanged = @"remoteAudioStateChanged";
+static NSString *AGLocalAudioStats = @"localAudioStats";
 static NSString *AGAudioVolumeIndication = @"audioVolumeIndication";
 static NSString *AGActiveSpeaker = @"activeSpeaker";
 static NSString *AGFirstLocalAudioFrame = @"firstLocalAudioFrame";
 static NSString *AGFirstRemoteAudioFrame = @"firstRemoteAudioFrame";
 static NSString *AGFirstRemoteAudioDecoded = @"firstRemoteAudioDecoded";
 static NSString *AGFirstLocalVideoFrame = @"firstLocalVideoFrame";
-static NSString *AGFirstRemoteVideoDecoded = @"firstRemoteVideoDecoded";
 static NSString *AGFirstRemoteVideoFrame = @"firstRemoteVideoFrame";
 static NSString *AGUserMuteAudio = @"userMuteAudio";
-static NSString *AGUserMuteVideo = @"userMuteVideo";
-static NSString *AGUserEnableVideo = @"userEnableVideo";
-static NSString *AGUserEnableLocalVideo = @"userEnableLocalVideo";
 static NSString *AGVideoSizeChanged = @"videoSizeChanged";
 static NSString *AGRemoteVideoStateChanged = @"remoteVideoStateChanged";
 static NSString *AGLocalPublishFallbackToAudioOnly = @"localPublishFallbackToAudioOnly";
 static NSString *AGLocalVideoStats = @"localVideoStats";
 static NSString *AGRemoteVideoStats = @"remoteVideoStats";
 static NSString *AGRemoteAudioStats = @"remoteAudioStats";
-static NSString *AGAudioTransportStatsOfUid = @"audioTransportStatsOfUid";
-static NSString *AGVideoTransportStatsOfUid = @"videoTransportStatsOfUid";
 
 static NSString *AGRemoteAudioMixingStart = @"remoteAudioMixingStart";
 static NSString *AGRemoteAudioMixingFinish = @"remoteAudioMixingFinish";
 static NSString *AGReceiveStreamMessage = @"receiveStreamMessage";
 static NSString *AGOccurStreamMessageError = @"occurStreamMessageError";
 
+static NSString *AGReceivedChannelMediaRelay = @"receivedChannelMediaRelay";
+static NSString *AGMediaRelayStateChanged = @"mediaRelayStateChanged";
+
 static NSString *AGMediaEngineLoaded = @"mediaEngineLoaded";
 static NSString *AGMediaEngineStartCall = @"mediaEngineStartCall";
 

ios/RCTAgora/AgoraConst.m

                                   AGTokenPrivilegeWillExpire,
                                   AGRequestToken,
                                   
-                                  AGMicrophoneEnabled,
                                   AGAudioVolumeIndication,
                                   AGActiveSpeaker,
                                   AGFirstLocalAudioFrame,
                                   AGFirstRemoteAudioFrame,
                                   AGFirstRemoteAudioDecoded,
                                   AGFirstLocalVideoFrame,
-                                  AGFirstRemoteVideoDecoded,
                                   AGFirstRemoteVideoFrame,
                                   AGUserMuteAudio,
-                                  AGUserMuteVideo,
-                                  AGUserEnableVideo,
-                                  AGUserEnableLocalVideo,
                                   AGVideoSizeChanged,
                                   AGRemoteVideoStateChanged,
                                   AGLocalPublishFallbackToAudioOnly,
                                   AGLocalVideoStats,
                                   AGRemoteVideoStats,
                                   AGRemoteAudioStats,
-                                  AGAudioTransportStatsOfUid,
-                                  AGVideoTransportStatsOfUid,
+                                  AGLocalAudioStateChanged,
+                                  AGRemoteAudioStateChanged,
+                                  AGLocalAudioStats,
+                                  AGMediaRelayStateChanged,
+                                  AGReceivedChannelMediaRelay,
                                   
                                   AGAudioMixingStateChanged,
                                   AGRemoteAudioMixingStart,

ios/RCTAgora/RCTAgora.m

   return toSend;
 }
 
-- (void)receiveMetadata:(NSData *_Nonnull)data fromUser:(NSUInteger)uid atTimestamp:(NSTimeInterval)timestamp {
+- (void)receiveMetadata:(NSData *_Nonnull)data fromUser:(NSInteger)uid atTimestamp:(NSTimeInterval)timestamp {
   NSString *dataStr = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
   [self sendEvent:AGMediaMetaDataReceived params:@{
                                                    @"uid": @(uid),
   }
 }
 
+// switch channel
+RCT_EXPORT_METHOD(switchChannel:(NSDictionary *)options
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject) {
+  NSInteger res = [self.rtcEngine switchChannelByToken:options[@"token"] channelId:options[@"channelName"] joinSuccess:nil];
+  if (res == 0) {
+    resolve(nil);
+  } else {
+    reject(@(-1).stringValue, @(res).stringValue, nil);
+  }
+}
+
+// startChannelMediaRelay
+RCT_EXPORT_METHOD(startChannelMediaRelay:(NSDictionary *)options
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject) {
+  AgoraChannelMediaRelayConfiguration *config = [[AgoraChannelMediaRelayConfiguration alloc] init];
+  AgoraChannelMediaRelayInfo *src = [config sourceInfo];
+  NSDictionary *srcOption = options[@"src"];
+  if (srcOption != nil) {
+    src.channelName = srcOption[@"channelName"];
+    src.uid = [srcOption[@"uid"] integerValue];
+    src.token = srcOption[@"token"];
+  }
+  NSArray *channels = options[@"channels"];
+  for (NSDictionary *channel in channels) {
+    AgoraChannelMediaRelayInfo *dst = [[AgoraChannelMediaRelayInfo alloc] init];
+    dst.channelName = channel[@"channelName"];
+    dst.uid = [channel[@"uid"] integerValue];
+    dst.token = channel[@"token"];
+    [config setDestinationInfo:dst forChannelName:dst.channelName];
+  }
+  NSInteger res = [self.rtcEngine startChannelMediaRelay:config];
+  if (res == 0) {
+    resolve(nil);
+  } else {
+    reject(@(-1).stringValue, @(res).stringValue, nil);
+  }
+}
+
+// updateChannelMediaRelay
+RCT_EXPORT_METHOD(updateChannelMediaRelay:(NSDictionary *)options
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject) {
+  AgoraChannelMediaRelayConfiguration *config = [[AgoraChannelMediaRelayConfiguration alloc] init];
+  AgoraChannelMediaRelayInfo *src = [config sourceInfo];
+  NSDictionary *srcOption = options[@"src"];
+  if (srcOption != nil) {
+    src.channelName = srcOption[@"channelName"];
+    src.uid = [srcOption[@"uid"] integerValue];
+    src.token = srcOption[@"token"];
+  }
+  NSArray *channels = options[@"channels"];
+  for (NSDictionary *channel in channels) {
+    AgoraChannelMediaRelayInfo *dst = [[AgoraChannelMediaRelayInfo alloc] init];
+    dst.channelName = channel[@"channelName"];
+    dst.uid = [channel[@"uid"] integerValue];
+    dst.token = channel[@"token"];
+    [config setDestinationInfo:dst forChannelName:dst.channelName];
+  }
+  NSInteger res = [self.rtcEngine updateChannelMediaRelay:config];
+  if (res == 0) {
+    resolve(nil);
+  } else {
+    reject(@(-1).stringValue, @(res).stringValue, nil);
+  }
+}
+
+// removeChannelMediaRelay
+RCT_EXPORT_METHOD(removeChannelMediaRelay:(NSDictionary *)options
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject) {
+  AgoraChannelMediaRelayConfiguration *config = [[AgoraChannelMediaRelayConfiguration alloc] init];
+  AgoraChannelMediaRelayInfo *src = [config sourceInfo];
+  NSDictionary *srcOption = options[@"src"];
+  if (srcOption != nil) {
+    src.channelName = srcOption[@"channelName"];
+    src.uid = [srcOption[@"uid"] integerValue];
+    src.token = srcOption[@"token"];
+  }
+  NSArray *channels = options[@"channels"];
+  for (NSDictionary *channel in channels) {
+    if (channel[@"channelName"] != nil) {
+      [config removeDestinationInfoForChannelName:channel[@"channelName"]];
+    }
+  }
+  NSInteger res = [self.rtcEngine updateChannelMediaRelay:config];
+  if (res == 0) {
+    resolve(nil);
+  } else {
+    reject(@(-1).stringValue, @(res).stringValue, nil);
+  }
+}
+
+// stopChannelMediaRelay
+RCT_EXPORT_METHOD(stopChannelMediaRelay:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject) {
+  NSInteger res = [self.rtcEngine stopChannelMediaRelay];
+  if (res == 0) {
+    resolve(nil);
+  } else {
+    reject(@(-1).stringValue, @(res).stringValue, nil);
+  }
+}
+
 // register user account
 RCT_EXPORT_METHOD(registerLocalUserAccount:(NSDictionary *)options
                   resolve:(RCTPromiseResolveBlock)resolve
   AgoraUserInfo *info = [self.rtcEngine getUserInfoByUid:uid withError:&code];
   if ((int)code == 0) {
     resolve(@{
-        @"uid": @(info.uid),
-        @"userAccount": info.userAccount
-    });
+              @"uid": @(info.uid),
+              @"userAccount": info.userAccount
+              });
   } else {
     reject(@(-1).stringValue, @((int)code).stringValue, nil);
   }
 RCT_EXPORT_METHOD(leaveChannel
                   :(RCTPromiseResolveBlock) resolve
                   reject:(RCTPromiseRejectBlock) reject) {
-  NSInteger res = [self.rtcEngine leaveChannel:^(AgoraChannelStats * _Nonnull stat) {
+  NSInteger res = [self.rtcEngine leaveChannel:^(AgoraChannelStats * _Nonnull stats) {
     [self sendEvent:AGLeaveChannel params:@{
                                             @"message": @"leaveChannel",
-                                            @"duration": @(stat.duration),
-                                            @"txBytes": @(stat.txBytes),
-                                            @"rxBytes": @(stat.rxBytes),
-                                            @"txAudioKBitrate": @(stat.txAudioKBitrate),
-                                            @"rxAudioKBitrate": @(stat.rxAudioKBitrate),
-                                            @"txVideoKBitrate": @(stat.txVideoKBitrate),
-                                            @"rxVideoKBitrate": @(stat.rxVideoKBitrate),
-                                            @"lastmileDelay": @(stat.lastmileDelay),
-                                            @"userCount": @(stat.userCount),
-                                            @"cpuAppUsage": @(stat.cpuAppUsage),
-                                            @"cpuTotalUsage": @(stat.cpuTotalUsage)
+                                            @"duration": @(stats.duration),
+                                            @"txBytes": @(stats.txBytes),
+                                            @"rxBytes": @(stats.rxBytes),
+                                            @"txAudioBytes": @(stats.txAudioBytes),
+                                            @"txVideoBytes": @(stats.txVideoBytes),
+                                            @"rxAudioBytes": @(stats.rxAudioBytes),
+                                            @"rxVideoBytes": @(stats.rxVideoBytes),
+                                            @"txPacketLossRate": @(stats.txPacketLossRate),
+                                            @"rxPacketLossRate": @(stats.rxPacketLossRate),
+                                            @"txAudioKBitrate": @(stats.txAudioKBitrate),
+                                            @"rxAudioKBitrate": @(stats.rxAudioKBitrate),
+                                            @"txVideoKBitrate": @(stats.txVideoKBitrate),
+                                            @"rxVideoKBitrate": @(stats.rxVideoKBitrate),
+                                            @"lastmileDelay": @(stats.lastmileDelay),
+                                            @"userCount": @(stats.userCount),
+                                            @"cpuAppUsage": @(stats.cpuAppUsage),
+                                            @"cpuTotalUsage": @(stats.cpuTotalUsage)
                                             }];
   }];
   if (res == 0) {
 
 // set volume of effect
 RCT_EXPORT_METHOD(setVolumeOfEffect
-                  :(NSInteger) soundId
+                  :(int) soundId
                   volume:(double)volume
                   resolve:(RCTPromiseResolveBlock)resolve
                   reject:(RCTPromiseRejectBlock)reject) {
 #pragma mark - <AgoraRtcEngineDelegate>
 // EVENT CALLBACKS
 - (void)rtcEngine:(AgoraRtcEngineKit *_Nonnull)engine didOccurWarning:(AgoraWarningCode)warningCode {
-  [self sendEvent:AGWarning params:@{@"message": @"AgoraWarning", @"code": @(warningCode)}];
+  [self sendEvent:AGWarning params:@{@"message": @"AgoraWarning", @"errorCode": @(warningCode)}];
 }
 
 - (void)rtcEngine:(AgoraRtcEngineKit *_Nonnull)engine didOccurError:(AgoraErrorCode)errorCode {
-  [self sendEvent:AGError params:@{@"message": @"AgoraError", @"code": @(errorCode)}];
+  [self sendEvent:AGError params:@{@"message": @"AgoraError", @"errorCode": @(errorCode)}];
 }
 
 - (void)rtcEngine:(AgoraRtcEngineKit *_Nonnull)engine didApiCallExecute:(NSInteger)error api:(NSString *_Nonnull)api result:(NSString *_Nonnull)result {
     [self sendEvent:AGError  params:@{
                                       @"api": api,
                                       @"result": result,
-                                      @"error": @(error)
+                                      @"errorCode": @(error)
                                       }];
   } else {
     [self sendEvent:AGApiCallExecute  params:@{
                                                @"api": api,
                                                @"result": result,
-                                               @"error": @(error)
+                                               @"errorCode": @(error)
                                                }];
   }
 }
                                               @"duration": @(stats.duration),
                                               @"txBytes": @(stats.txBytes),
                                               @"rxBytes": @(stats.rxBytes),
+                                              @"txAudioBytes": @(stats.txAudioBytes),
+                                              @"txVideoBytes": @(stats.txVideoBytes),
+                                              @"rxAudioBytes": @(stats.rxAudioBytes),
+                                              @"rxVideoBytes": @(stats.rxVideoBytes),
+                                              @"txPacketLossRate": @(stats.txPacketLossRate),
+                                              @"rxPacketLossRate": @(stats.rxPacketLossRate),
                                               @"txAudioKBitrate": @(stats.txAudioKBitrate),
                                               @"rxAudioKBitrate": @(stats.rxVideoKBitrate),
                                               @"txVideoKBitrate": @(stats.txVideoKBitrate),
 
 - (void)rtcEngine:(AgoraRtcEngineKit *_Nonnull)engine didUpdatedUserInfo:(AgoraUserInfo *_Nonnull)userInfo withUid:(NSUInteger)uid {
   [self sendEvent:AGUserInfoUpdated params:@{
-                                                 @"uid": @(uid),
-                                                 @"peer": @{
-                                                     @"uid": @(userInfo.uid),
-                                                     @"userAccount": userInfo.userAccount
+                                             @"uid": @(uid),
+                                             @"peer": @{
+                                                 @"uid": @(userInfo.uid),
+                                                 @"userAccount": userInfo.userAccount
                                                  }}];
 }
 
                                           }];
 }
 
-- (void)rtcEngine:(AgoraRtcEngineKit *_Nonnull)engine didMicrophoneEnabled:(BOOL)enabled {
-  [self sendEvent:AGMicrophoneEnabled params:@{
-                                               @"enabled": @(enabled)
-                                               }];
+- (void)rtcEngine:(AgoraRtcEngineKit *_Nonnull)engine localAudioStateChange:(AgoraAudioLocalState)state error:(AgoraAudioLocalError)error {
+  [self sendEvent:AGLocalAudioStateChanged params:@{
+                                                    @"state": @(state),
+                                                    @"errorCode": @(error)
+                                                    }];
+}
+
+- (void)rtcEngine:(AgoraRtcEngineKit *_Nonnull)engine remoteAudioStateChangedOfUid:(NSUInteger)uid state:(AgoraAudioRemoteState)state reason:(AgoraAudioRemoteStateReason)reason elapsed:(NSInteger)elapsed {
+  [self sendEvent:AGRemoteAudioStateChanged params:@{
+                                                     @"uid": @(uid),
+                                                     @"state": @(state),
+                                                     @"reason": @(reason),
+                                                     @"elapsed": @(elapsed)
+                                                     }];
+}
+
+- (void)rtcEngine:(AgoraRtcEngineKit *_Nonnull)engine localAudioStats:(AgoraRtcLocalAudioStats *_Nonnull)stats {
+  [self sendEvent:AGLocalAudioStats params:@{
+                                             @"numChannels": @(stats.numChannels),
+                                             @"sentSampleRate": @(stats.sentSampleRate),
+                                             @"sentBitrate": @(stats.sentBitrate),
+                                             }];
 }
 
 - (void)rtcEngine:(AgoraRtcEngineKit *_Nonnull)engine reportAudioVolumeIndicationOfSpeakers:(NSArray<AgoraRtcAudioVolumeInfo*> *_Nonnull)speakers totalVolume:(NSInteger)totalVolume {
                                                   }];
 }
 
-- (void)rtcEngine:(AgoraRtcEngineKit *_Nonnull)engine firstRemoteVideoDecodedOfUid:(NSUInteger)uid size:(CGSize)size elapsed:(NSInteger)elapsed {
-  [self sendEvent:AGFirstRemoteVideoDecoded params:@{
-                                                     @"uid": @(uid),
-                                                     @"width": @(size.width),
-                                                     @"height": @(size.height),
-                                                     @"elapsed": @(elapsed)
-                                                     }];
-}
-
 - (void)rtcEngine:(AgoraRtcEngineKit *_Nonnull)engine firstRemoteVideoFrameOfUid:(NSUInteger)uid size:(CGSize)size elapsed:(NSInteger)elapsed {
   [self sendEvent:AGFirstRemoteVideoFrame params:@{
                                                    @"uid": @(uid),
                                            }];
 }
 
-- (void)rtcEngine:(AgoraRtcEngineKit *_Nonnull)engine didVideoMuted:(BOOL)muted byUid:(NSUInteger)uid {
-  [self sendEvent:AGUserMuteVideo params:@{
-                                           @"muted": @(muted),
-                                           @"uid": @(uid)
-                                           }];
-}
-
-- (void)rtcEngine:(AgoraRtcEngineKit *_Nonnull)engine didVideoEnabled:(BOOL)enabled byUid:(NSUInteger)uid {
-  [self sendEvent:AGUserEnableVideo params:@{
-                                             @"enabled": @(enabled),
-                                             @"uid": @(uid)
-                                             }];
-}
-
-- (void)rtcEngine:(AgoraRtcEngineKit *_Nonnull)engine didLocalVideoEnabled:(BOOL)enabled byUid:(NSUInteger)uid {
-  [self sendEvent:AGUserEnableLocalVideo params:@{
-                                                  @"enabled": @(enabled),
-                                                  @"uid": @(uid)
-                                                  }];
-}
-
 - (void)rtcEngine:(AgoraRtcEngineKit *_Nonnull)engine videoSizeChangedOfUid:(NSUInteger)uid size:(CGSize)size rotation:(NSInteger)rotation {
   [self sendEvent:AGVideoSizeChanged params:@{
                                               @"uid": @(uid),
                                               }];
 }
 
-- (void)rtcEngine:(AgoraRtcEngineKit *_Nonnull)engine remoteVideoStateChangedOfUid:(NSUInteger)uid state:(AgoraVideoRemoteState)state {
+- (void)rtcEngine:(AgoraRtcEngineKit *_Nonnull)engine remoteVideoStateChangedOfUid:(NSUInteger)uid state:(AgoraVideoRemoteState)state reason:(AgoraVideoRemoteStateReason)reason elapsed:(NSInteger)elapsed {
   [self sendEvent:AGRemoteVideoStateChanged params:@{
                                                      @"uid": @(uid),
-                                                     @"state": @(state)
+                                                     @"state": @(state),
+                                                     @"reason": @(reason),
+                                                     @"elapsed": @(elapsed)
                                                      }];
 }
 
   [self sendEvent:AGRtcStats params:@{
                                       @"stats": @{
                                           @"duration": @(stats.duration),
-                                          @"txPacketLossRate": @(stats.txPacketLossRate),
-                                          @"rxPacketLossRate": @(stats.rxPacketLossRate),
                                           @"txBytes": @(stats.txBytes),
                                           @"rxBytes": @(stats.rxBytes),
+                                          @"txAudioBytes": @(stats.txAudioBytes),
+                                          @"txVideoBytes": @(stats.txVideoBytes),
+                                          @"rxAudioBytes": @(stats.rxAudioBytes),
+                                          @"rxVideoBytes": @(stats.rxVideoBytes),
+                                          @"txPacketLossRate": @(stats.txPacketLossRate),
+                                          @"rxPacketLossRate": @(stats.rxPacketLossRate),
                                           @"txAudioKBitrate": @(stats.txAudioKBitrate),
                                           @"rxAudioKBitrate": @(stats.rxAudioKBitrate),
                                           @"txVideoKBitrate": @(stats.txVideoKBitrate),
                                               }];
 }
 
-- (void)rtcEngine:(AgoraRtcEngineKit *_Nonnull)engine audioTransportStatsOfUid:(NSUInteger)uid delay:(NSUInteger)delay lost:(NSUInteger)lost rxKBitRate:(NSUInteger)rxKBitRate {
-  [self sendEvent:AGAudioTransportStatsOfUid params:@{
-                                                      @"uid": @(uid),
-                                                      @"delay": @(delay),
-                                                      @"lost": @(lost),
-                                                      @"rxKBitrate": @(rxKBitRate)
-                                                      }];
-}
-
-- (void)rtcEngine:(AgoraRtcEngineKit *_Nonnull)engine videoTransportStatsOfUid:(NSUInteger)uid delay:(NSUInteger)delay lost:(NSUInteger)lost rxKBitRate:(NSUInteger)rxKBitRate {
-  [self sendEvent:AGVideoTransportStatsOfUid params:@{
-                                                      @"uid": @(uid),
-                                                      @"delay": @(delay),
-                                                      @"lost": @(lost),
-                                                      @"rxKBitrate": @(rxKBitRate)
-                                                      }];
-}
-
 - (void)rtcEngineRemoteAudioMixingDidStart:(AgoraRtcEngineKit *_Nonnull)engine {
   [self sendEvent:AGRemoteAudioMixingStart params:@{
                                                     @"message": @"RemoteAudioMixingStarted"
 - (void)rtcEngine:(AgoraRtcEngineKit *_Nonnull)engine streamPublishedWithUrl:(NSString *_Nonnull)url errorCode:(AgoraErrorCode)errorCode {
   [self sendEvent:AGStreamPublished params:@{
                                              @"url": url,
-                                             @"code": @(errorCode)
+                                             @"errorCode": @(errorCode)
                                              }];
 }
 
                                                   }];
 }
 
+- (void)rtcEngine:(AgoraRtcEngineKit *_Nonnull)engine channelMediaRelayStateDidChange:(AgoraChannelMediaRelayState)state error:(AgoraChannelMediaRelayError)error {
+  [self sendEvent:AGMediaRelayStateChanged params:@{
+                                                    @"state": @(state),
+                                                    @"errorCode": @(error),
+                                                    }];
+}
+
+- (void)rtcEngine:(AgoraRtcEngineKit *_Nonnull)engine didReceiveChannelMediaRelayEvent:(AgoraChannelMediaRelayEvent)event {
+  [self sendEvent:AGReceivedChannelMediaRelay params:@{
+                                                       @"event": @(event),
+                                                       }];
+}
+
 - (void)rtcEngine:(AgoraRtcEngineKit *_Nonnull)engine receiveStreamMessageFromUid:(NSUInteger)uid streamId:(NSInteger)streamId data:(NSData *_Nonnull)data {
   NSString *_data = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
   [self sendEvent:AGReceiveStreamMessage params:@{
   [self sendEvent:AGOccurStreamMessageError params:@{
                                                      @"uid": @(uid),
                                                      @"streamId": @(streamId),
-                                                     @"error": @(error),
+                                                     @"errorCode": @(error),
                                                      @"missed": @(missed),
                                                      @"cached": @(cached)
                                                      }];

lib/RtcEngine.native.d.ts

-import { Option, Callback, AgoraUserInfo, AudioMixingOption, PlayEffectOption, AudioRecordingOption, AudioFrameOption, MixedAudioFrameOption, ImageOption, VideoStreamOption, DefaultVideoStreamOption, InjectStreamOption, RemoveInjectStreamOption, PublishStreamOption, RemovePublishStreamOption, LiveTranscodingOption, PositionOption, BeautyOption, LastmileProbeConfig, CameraCapturerConfiguration } from "./types";
+import { Option, Callback, AgoraUserInfo, AudioMixingOption, PlayEffectOption, AudioRecordingOption, AudioFrameOption, MixedAudioFrameOption, ImageOption, VideoStreamOption, DefaultVideoStreamOption, InjectStreamOption, RemoveInjectStreamOption, PublishStreamOption, RemovePublishStreamOption, LiveTranscodingOption, PositionOption, BeautyOption, LastmileProbeConfig, CameraCapturerConfiguration, ChannelMediaConfiguration } from "./types";
 /**
  * RtcEngine is the javascript object for control agora native sdk through react native bridge.
  *
      * @param info
      */
     static joinChannel(channelName: string, uid?: number, token?: string, info?: Object): Promise<any>;
+    /**
+     * switch to specified channel
+     *
+     * This method will switch channel smoothly than you invoke leaveChannel & joinChannel.
+     * Otherwise, it will invoke error by the event
+     * It will occurs two events:
+     * Occurs leaveChannel when achieve leaving stage
+     * Occurs joinChannelSuccess when achieve joining stage
+     * @param channelName
+     * @param token
+     */
+    static switchChannel(channelName: string, token?: string): Promise<any>;
+    /**
+     * Starts to relay media streams across channels.
+     *
+     * This method will start relay media stream across specified channels. (maximum support 4 channels)
+     * It will occurs event:
+     *  Occurs onChannelMediaRelayStateChanged
+     * @param config
+     */
+    static startChannelMediaRelay(config: ChannelMediaConfiguration): Promise<any>;
+    /**
+     * Remove to relay media streams across channels.
+     *
+     * This method will remove & update relay media stream across specified channels. (maximum support relay 4 channels)
+     * It will occurs event:
+     *  Occurs onChannelMediaRelayStateChanged
+     * @param config
+     */
+    static removeChannelMediaRelay(config: ChannelMediaConfiguration): Promise<any>;
+    /**
+     * Updates to relay media streams across channels.
+     *
+     * This method will update relay media stream across specified channels. (maximum support 4 channels)
+     * It will occurs event:
+     *  Occurs onChannelMediaRelayStateChanged
+     * @param config
+     */
+    static updateChannelMediaRelay(config: ChannelMediaConfiguration): Promise<any>;
+    /**
+     * Stop to relay media streams across channels.
+     *
+     * This method will stop relay media stream across specified channels.
+     * It will occurs event:
+     *  Occurs onChannelMediaRelayStateChanged
+     * @param config
+     */
+    static stopChannelMediaRelay(): Promise<any>;
     /**
      * Registers a user account.
      *
      * connectionLost | occurs when sdk connection lost | on("connectionLost", evt) |
      * tokenPrivilegeWillExpire | occurs when token will expire | on("tokenPrivilegeWillExpire", evt) |
      * requestToken | occurs when token expired | on("requestToken") |
-     * microphoneEnabled | occurs when microphone enable state changed | on("microphoneEnabled", evt) |
+     * localAudioStateChanged | occurs when local audio device state changed | on("localAudioStateChanged", (state, errorCode) => {}) |
      * audioVolumeIndication | occurs when audio volume indication changed | on("audioVolumeIndication", evt) |
      * activeSpeaker | occurs when detect active speaker | on("activeSpeaker", evt) |
      * firstLocalAudioFrame | occurs when sent first audio frame on local | on("firstLocalAudioFrame", evt) |
      * firstRemoteAudioFrame | occurs when received first audio frame from remote side | on("firstRemoteAudioFrame", evt) |
      * firstRemoteAudioDecoded | occurs when first remote audio decoded | on("firstRemoteAudioDecoded", evt) |
      * firstLocalVideoFrame | occurs when sent first video frame on local | on("firstLocalVideoFrame", evt) |
-     * firstRemoteVideoDecoded | occurs when received first video frame from remote side decoded | on("firstRemoteVideoDecoded", evt) |
      * firstRemoteVideoFrame | occurs when received first video frame from remote side | on("firstRemoteVideoFrame", evt) |
      * userMuteAudio | occurs when user mute audio | on("userMuteAudio", evt) |
-     * userMuteVideo | occurs when user mute video | on("userMuteVideo", evt) |
-     * userEnableVideo | occurs when remote side's user change video enable state | on("userEnableVideo", evt) |
-     * userEnableLocalVideo | occurs when user change video enable state on local | on("userEnableLocalVideo", evt) |
      * videoSizeChanged | occurs when change local or remote side video size or rotation | on("videoSizeChanged", evt) |
      * remoteVideoStateChanged | occurs when remote video state has any changed | on("remoteVideoStateChanged", evt) |
+     * remoteAudioStateChanged | occurs when remote audio state has any changed | on("remoteAudioStateChanged", evt) |
+     * localAudioStats | occurs when engine start to report local audio stats | on("localAudioStats", evt) |
      * localPublishFallbackToAudioOnly | occurs when published stream from local side fallback to audio stream | on("localPublishFallbackToAudioOnly", evt) |
      * remoteSubscribeFallbackToAudioOnly | occurs when subscribed side's stream fallback to audio stream | on("remoteSubscribeFallbackToAudioOnly", evt) |
      * audioRouteChanged | occurs when local audio route changed | on("audioRouteChanged", evt) |
      * localVideoStats | occurs when reports local video statistics | on("localVideoStats", evt) |
      * remoteVideoStats | occurs when reports remote video statistics| on("remoteVideoStats", evt) |
      * remoteAudioStats | occurs when reports remote audio statistics| on("remoteAudioStats", evt) |
-     * audioTransportStatsOfUid | occurs when reports  transport-layer statistics of each remote audio stream. | on("audioTransportStatsOfUid", evt) |
-     * videoTransportStatsOfUid | occurs when reports  transport-layer statistics of each remote video stream.| on("videoTransportStatsOfUid", evt) |
      * audioEffectFinish | occurs when the local audio effect playback finishes. | on("audioEffectFinish", evt) |
      * streamPublished | occurs when addPublishStreamUrl success| on("streamPublished", evt) |
      * streamUnpublish | occurs when removePublishStreamUrl success| on("streamUnpublish", evt) |
      * mediaMetaDataReceived | occurs when you received media meta data from the remote side through sendMediaData | on("mediaMetaDataReceived", evt) |
      * localUserRegistered | occurs when you register user account success | on("localUserRegistered", evt) |
      * userInfoUpdated | occurs when you peer side using user account join channel | on("userInfoUpdated", evt) |
+     * receivedChannelMediaRelay | occurs when you received channel media relay | on('receivedChannelMediaRelay", evt)|
+     * mediaRelayStateChanged | occurs when you received remote media relay state changed | on('mediaRelayStateChanged", evt)|
      * ---
      *
      * @param eventType

lib/RtcEngine.native.js

     static joinChannel(channelName, uid, token, info) {
         return Agora.joinChannel({ channelName, uid, token, info });
     }
+    /**
+     * switch to specified channel
+     *
+     * This method will switch channel smoothly than you invoke leaveChannel & joinChannel.
+     * Otherwise, it will invoke error by the event
+     * It will occurs two events:
+     * Occurs leaveChannel when achieve leaving stage
+     * Occurs joinChannelSuccess when achieve joining stage
+     * @param channelName
+     * @param token
+     */
+    static switchChannel(channelName, token) {
+        return Agora.switchChannel({ channelName, token });
+    }
+    /**
+     * Starts to relay media streams across channels.
+     *
+     * This method will start relay media stream across specified channels. (maximum support 4 channels)
+     * It will occurs event:
+     *  Occurs onChannelMediaRelayStateChanged
+     * @param config
+     */
+    static startChannelMediaRelay(config) {
+        return Agora.startChannelMediaRelay(config);
+    }
+    /**
+     * Remove to relay media streams across channels.
+     *
+     * This method will remove & update relay media stream across specified channels. (maximum support relay 4 channels)
+     * It will occurs event:
+     *  Occurs onChannelMediaRelayStateChanged
+     * @param config
+     */
+    static removeChannelMediaRelay(config) {
+        return Agora.removeChannelMediaRelay(config);
+    }
+    /**
+     * Updates to relay media streams across channels.
+     *
+     * This method will update relay media stream across specified channels. (maximum support 4 channels)
+     * It will occurs event:
+     *  Occurs onChannelMediaRelayStateChanged
+     * @param config
+     */
+    static updateChannelMediaRelay(config) {
+        return Agora.updateChannelMediaRelay(config);
+    }
+    /**
+     * Stop to relay media streams across channels.
+     *
+     * This method will stop relay media stream across specified channels.
+     * It will occurs event:
+     *  Occurs onChannelMediaRelayStateChanged
+     * @param config
+     */
+    static stopChannelMediaRelay() {
+        return Agora.stopChannelMediaRelay();
+    }
     /**
      * Registers a user account.
      *
      * connectionLost | occurs when sdk connection lost | on("connectionLost", evt) |
      * tokenPrivilegeWillExpire | occurs when token will expire | on("tokenPrivilegeWillExpire", evt) |
      * requestToken | occurs when token expired | on("requestToken") |
-     * microphoneEnabled | occurs when microphone enable state changed | on("microphoneEnabled", evt) |
+     * localAudioStateChanged | occurs when local audio device state changed | on("localAudioStateChanged", (state, errorCode) => {}) |
      * audioVolumeIndication | occurs when audio volume indication changed | on("audioVolumeIndication", evt) |
      * activeSpeaker | occurs when detect active speaker | on("activeSpeaker", evt) |
      * firstLocalAudioFrame | occurs when sent first audio frame on local | on("firstLocalAudioFrame", evt) |
      * firstRemoteAudioFrame | occurs when received first audio frame from remote side | on("firstRemoteAudioFrame", evt) |
      * firstRemoteAudioDecoded | occurs when first remote audio decoded | on("firstRemoteAudioDecoded", evt) |
      * firstLocalVideoFrame | occurs when sent first video frame on local | on("firstLocalVideoFrame", evt) |
-     * firstRemoteVideoDecoded | occurs when received first video frame from remote side decoded | on("firstRemoteVideoDecoded", evt) |
      * firstRemoteVideoFrame | occurs when received first video frame from remote side | on("firstRemoteVideoFrame", evt) |
      * userMuteAudio | occurs when user mute audio | on("userMuteAudio", evt) |
-     * userMuteVideo | occurs when user mute video | on("userMuteVideo", evt) |
-     * userEnableVideo | occurs when remote side's user change video enable state | on("userEnableVideo", evt) |
-     * userEnableLocalVideo | occurs when user change video enable state on local | on("userEnableLocalVideo", evt) |
      * videoSizeChanged | occurs when change local or remote side video size or rotation | on("videoSizeChanged", evt) |
      * remoteVideoStateChanged | occurs when remote video state has any changed | on("remoteVideoStateChanged", evt) |
+     * remoteAudioStateChanged | occurs when remote audio state has any changed | on("remoteAudioStateChanged", evt) |
+     * localAudioStats | occurs when engine start to report local audio stats | on("localAudioStats", evt) |
      * localPublishFallbackToAudioOnly | occurs when published stream from local side fallback to audio stream | on("localPublishFallbackToAudioOnly", evt) |
      * remoteSubscribeFallbackToAudioOnly | occurs when subscribed side's stream fallback to audio stream | on("remoteSubscribeFallbackToAudioOnly", evt) |
      * audioRouteChanged | occurs when local audio route changed | on("audioRouteChanged", evt) |
      * localVideoStats | occurs when reports local video statistics | on("localVideoStats", evt) |
      * remoteVideoStats | occurs when reports remote video statistics| on("remoteVideoStats", evt) |
      * remoteAudioStats | occurs when reports remote audio statistics| on("remoteAudioStats", evt) |
-     * audioTransportStatsOfUid | occurs when reports  transport-layer statistics of each remote audio stream. | on("audioTransportStatsOfUid", evt) |
-     * videoTransportStatsOfUid | occurs when reports  transport-layer statistics of each remote video stream.| on("videoTransportStatsOfUid", evt) |
      * audioEffectFinish | occurs when the local audio effect playback finishes. | on("audioEffectFinish", evt) |
      * streamPublished | occurs when addPublishStreamUrl success| on("streamPublished", evt) |
      * streamUnpublish | occurs when removePublishStreamUrl success| on("streamUnpublish", evt) |
      * mediaMetaDataReceived | occurs when you received media meta data from the remote side through sendMediaData | on("mediaMetaDataReceived", evt) |
      * localUserRegistered | occurs when you register user account success | on("localUserRegistered", evt) |
      * userInfoUpdated | occurs when you peer side using user account join channel | on("userInfoUpdated", evt) |
+     * receivedChannelMediaRelay | occurs when you received channel media relay | on('receivedChannelMediaRelay", evt)|
+     * mediaRelayStateChanged | occurs when you received remote media relay state changed | on('mediaRelayStateChanged", evt)|
      * ---
      *
      * @param eventType
             'receiveStreamMessage',
             'activeSpeaker',
             'firstRemoteAudioFrame',
-            'firstRemoteVideoDecoded',
             'firstRemoteVideoFrame',
             'userMuteAudio',
-            'userMuteVideo',
-            'userEnableVideo',
-            'userEnableLocalVideo',
             'videoSizeChanged',
-            'firstRemoteAudioDecoded',
             'remoteVideoStateChanged',
+            'remoteAudioStateChanged',
             'remoteSubscribeFallbackToAudioOnly',
             'networkQuality',
             'streamInjectedStatus',
         if ([
             'remoteAudioStats',
             'remoteVideoStats',
-            'audioTransportStatsOfUid',
-            'videoTransportStatsOfUid',
         ].indexOf(eventType) != -1) {
             AgoraEventEmitter.addListener(`${RtcEngine.AG_PREFIX}${eventType}`, (args) => {
                 args.stats.uid = this.Int32ToUint32(args.stats.uid);

lib/types.d.ts

 import { ViewProps } from 'react-native';
+/**
+ * ChannelMediaInfo
+ * @property channelName: string
+ * @property token: string
+ * @property uid: number
+ */
+export interface ChannelMediaInfo {
+    channelName: string;
+    token?: string;
+    uid?: number;
+}
+/**
+ * ChannelMediaConfiguration
+ * @property src: {
+ *    @member channelName,
+ *    @member token,
+ *    @member uid,
+ * }
+ * @property channels: {@link Array<ChannelMediaInfo>}
+ */
+export interface ChannelMediaConfiguration {
+    src?: {
+        channelName: string;
+        token?: string;
+        uid?: number;
+    };
+    channels: Array<ChannelMediaInfo>;
+}
 /**
  * AgoraViewMode
  * @mode hidden Uniformly scale the video until it fills the visible boundaries (cropped). One dimension of the video may have clipped contents.

lib/types.js.map

-{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":";;AAEA;;;;GAIG;AACH,IAAY,aAGX;AAHD,WAAY,aAAa;IACvB,qDAAU,CAAA;IACV,+CAAO,CAAA;AACT,CAAC,EAHW,aAAa,GAAb,qBAAa,KAAb,qBAAa,QAGxB;AAUA,CAAC;AAuGF,IAAY,iBAIX;AAJD,WAAY,iBAAiB;IAC3B,kEAAa,CAAA;IACb,0DAAS,CAAA;IACT,2DAAU,CAAA;AACZ,CAAC,EAJW,iBAAiB,GAAjB,yBAAiB,KAAjB,yBAAiB,QAI5B;AAED,IAAY,iBAGX;AAHD,WAAY,iBAAiB;IAC3B,6DAAU,CAAA;IACV,6DAAU,CAAA;AACZ,CAAC,EAHW,iBAAiB,GAAjB,yBAAiB,KAAjB,yBAAiB,QAG5B;AAED,IAAY,eAIX;AAJD,WAAY,eAAe;IACzB,qEAAkB,CAAA;IAClB,qEAAkB,CAAA;IAClB,qEAAkB,CAAA;AACpB,CAAC,EAJW,eAAe,GAAf,uBAAe,KAAf,uBAAe,QAI1B;AAED;;;GAGG;AACH,IAAY,kBAMX;AAND,WAAY,kBAAkB;IAC5B,yDAAO,CAAA;IACP,yDAAO,CAAA;IACP,6DAAS,CAAA;IACT,2DAAQ,CAAA;IACR,2DAAQ,CAAA;AACV,CAAC,EANW,kBAAkB,GAAlB,0BAAkB,KAAlB,0BAAkB,QAM7B"}
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":";;AA+BA;;;;GAIG;AACH,IAAY,aAGX;AAHD,WAAY,aAAa;IACvB,qDAAU,CAAA;IACV,+CAAO,CAAA;AACT,CAAC,EAHW,aAAa,GAAb,qBAAa,KAAb,qBAAa,QAGxB;AAUA,CAAC;AAuGF,IAAY,iBAIX;AAJD,WAAY,iBAAiB;IAC3B,kEAAa,CAAA;IACb,0DAAS,CAAA;IACT,2DAAU,CAAA;AACZ,CAAC,EAJW,iBAAiB,GAAjB,yBAAiB,KAAjB,yBAAiB,QAI5B;AAED,IAAY,iBAGX;AAHD,WAAY,iBAAiB;IAC3B,6DAAU,CAAA;IACV,6DAAU,CAAA;AACZ,CAAC,EAHW,iBAAiB,GAAjB,yBAAiB,KAAjB,yBAAiB,QAG5B;AAED,IAAY,eAIX;AAJD,WAAY,eAAe;IACzB,qEAAkB,CAAA;IAClB,qEAAkB,CAAA;IAClB,qEAAkB,CAAA;AACpB,CAAC,EAJW,eAAe,GAAf,uBAAe,KAAf,uBAAe,QAI1B;AAED;;;GAGG;AACH,IAAY,kBAMX;AAND,WAAY,kBAAkB;IAC5B,yDAAO,CAAA;IACP,yDAAO,CAAA;IACP,6DAAS,CAAA;IACT,2DAAQ,CAAA;IACR,2DAAQ,CAAA;AACV,CAAC,EANW,kBAAkB,GAAlB,0BAAkB,KAAlB,0BAAkB,QAM7B"}

package.json

 {
   "name": "react-native-agora",
-  "version": "2.8.0-alpha.2",
+  "version": "2.9.0-alpha.1",
   "description": "React Native around the Agora RTC SDKs for Android and iOS agora",
   "summary": "agora native sdk for react-native",
   "main": "lib/index.js",

react-native-agora.podspec

     end
 
     s.dependency 'React'
-    s.dependency "AgoraRtcEngine_iOS", "2.8"
+    s.dependency "AgoraRtcEngine_iOS", "2.9"
 end

src/RtcEngine.native.ts

     PositionOption,
     BeautyOption,
     LastmileProbeConfig,
-    CameraCapturerConfiguration
+    CameraCapturerConfiguration,
+    ChannelMediaConfiguration
 } from "./types";
 
 
         return Agora.joinChannel({channelName, uid, token, info});
     }
 
+    /**
+     * switch to specified channel
+     *
+     * This method will switch channel smoothly than you invoke leaveChannel & joinChannel.
+     * Otherwise, it will invoke error by the event
+     * It will occurs two events:
+     * Occurs leaveChannel when achieve leaving stage
+     * Occurs joinChannelSuccess when achieve joining stage
+     * @param channelName
+     * @param token
+     */
+    public static switchChannel(channelName: string, token?: string): Promise<any> {
+        return Agora.switchChannel({channelName, token});
+    }
+    
+    /**
+     * Starts to relay media streams across channels.
+     * 
+     * This method will start relay media stream across specified channels. (maximum support 4 channels)
+     * It will occurs event:
+     *  Occurs onChannelMediaRelayStateChanged
+     * @param config
+     */
+    public static startChannelMediaRelay(config: ChannelMediaConfiguration): Promise<any> {
+        return Agora.startChannelMediaRelay(config);
+    }
+
+    /**
+     * Remove to relay media streams across channels.
+     * 
+     * This method will remove & update relay media stream across specified channels. (maximum support relay 4 channels)
+     * It will occurs event:
+     *  Occurs onChannelMediaRelayStateChanged
+     * @param config
+     */
+    public static removeChannelMediaRelay(config: ChannelMediaConfiguration): Promise<any> {
+        return Agora.removeChannelMediaRelay(config);
+    }
+
+    /**
+     * Updates to relay media streams across channels.
+     * 
+     * This method will update relay media stream across specified channels. (maximum support 4 channels)
+     * It will occurs event:
+     *  Occurs onChannelMediaRelayStateChanged
+     * @param config
+     */
+    public static updateChannelMediaRelay(config: ChannelMediaConfiguration): Promise<any> {
+        return Agora.updateChannelMediaRelay(config);
+    }
+
+    /**
+     * Stop to relay media streams across channels.
+     * 
+     * This method will stop relay media stream across specified channels.
+     * It will occurs event:
+     *  Occurs onChannelMediaRelayStateChanged
+     * @param config
+     */
+    public static stopChannelMediaRelay(): Promise<any> {
+        return Agora.stopChannelMediaRelay();
+    }
+
     /**
      * Registers a user account.
      * 
      * connectionLost | occurs when sdk connection lost | on("connectionLost", evt) |
      * tokenPrivilegeWillExpire | occurs when token will expire | on("tokenPrivilegeWillExpire", evt) |
      * requestToken | occurs when token expired | on("requestToken") |
-     * microphoneEnabled | occurs when microphone enable state changed | on("microphoneEnabled", evt) |
+     * localAudioStateChanged | occurs when local audio device state changed | on("localAudioStateChanged", (state, errorCode) => {}) |
      * audioVolumeIndication | occurs when audio volume indication changed | on("audioVolumeIndication", evt) |
      * activeSpeaker | occurs when detect active speaker | on("activeSpeaker", evt) |
      * firstLocalAudioFrame | occurs when sent first audio frame on local | on("firstLocalAudioFrame", evt) |
      * firstRemoteAudioFrame | occurs when received first audio frame from remote side | on("firstRemoteAudioFrame", evt) |
      * firstRemoteAudioDecoded | occurs when first remote audio decoded | on("firstRemoteAudioDecoded", evt) |
      * firstLocalVideoFrame | occurs when sent first video frame on local | on("firstLocalVideoFrame", evt) |
-     * firstRemoteVideoDecoded | occurs when received first video frame from remote side decoded | on("firstRemoteVideoDecoded", evt) |
      * firstRemoteVideoFrame | occurs when received first video frame from remote side | on("firstRemoteVideoFrame", evt) |
      * userMuteAudio | occurs when user mute audio | on("userMuteAudio", evt) |
-     * userMuteVideo | occurs when user mute video | on("userMuteVideo", evt) |
-     * userEnableVideo | occurs when remote side's user change video enable state | on("userEnableVideo", evt) |
-     * userEnableLocalVideo | occurs when user change video enable state on local | on("userEnableLocalVideo", evt) |
      * videoSizeChanged | occurs when change local or remote side video size or rotation | on("videoSizeChanged", evt) |
      * remoteVideoStateChanged | occurs when remote video state has any changed | on("remoteVideoStateChanged", evt) |
+     * remoteAudioStateChanged | occurs when remote audio state has any changed | on("remoteAudioStateChanged", evt) |
+     * localAudioStats | occurs when engine start to report local audio stats | on("localAudioStats", evt) |
      * localPublishFallbackToAudioOnly | occurs when published stream from local side fallback to audio stream | on("localPublishFallbackToAudioOnly", evt) |
      * remoteSubscribeFallbackToAudioOnly | occurs when subscribed side's stream fallback to audio stream | on("remoteSubscribeFallbackToAudioOnly", evt) |
      * audioRouteChanged | occurs when local audio route changed | on("audioRouteChanged", evt) |
      * localVideoStats | occurs when reports local video statistics | on("localVideoStats", evt) | 
      * remoteVideoStats | occurs when reports remote video statistics| on("remoteVideoStats", evt) | 
      * remoteAudioStats | occurs when reports remote audio statistics| on("remoteAudioStats", evt) | 
-     * audioTransportStatsOfUid | occurs when reports  transport-layer statistics of each remote audio stream. | on("audioTransportStatsOfUid", evt) | 
-     * videoTransportStatsOfUid | occurs when reports  transport-layer statistics of each remote video stream.| on("videoTransportStatsOfUid", evt) | 
      * audioEffectFinish | occurs when the local audio effect playback finishes. | on("audioEffectFinish", evt) | 
      * streamPublished | occurs when addPublishStreamUrl success| on("streamPublished", evt) | 
      * streamUnpublish | occurs when removePublishStreamUrl success| on("streamUnpublish", evt) | 
      * mediaMetaDataReceived | occurs when you received media meta data from the remote side through sendMediaData | on("mediaMetaDataReceived", evt) | 
      * localUserRegistered | occurs when you register user account success | on("localUserRegistered", evt) |
      * userInfoUpdated | occurs when you peer side using user account join channel | on("userInfoUpdated", evt) |
+     * receivedChannelMediaRelay | occurs when you received channel media relay | on('receivedChannelMediaRelay", evt)|
+     * mediaRelayStateChanged | occurs when you received remote media relay state changed | on('mediaRelayStateChanged", evt)|
      * ---
      * 
      * @param eventType
             'receiveStreamMessage',
             'activeSpeaker',
             'firstRemoteAudioFrame',
-            'firstRemoteVideoDecoded',
             'firstRemoteVideoFrame',
             'userMuteAudio',
-            'userMuteVideo',
-            'userEnableVideo',
-            'userEnableLocalVideo',
             'videoSizeChanged',
-            'firstRemoteAudioDecoded',
             'remoteVideoStateChanged',
+            'remoteAudioStateChanged',
             'remoteSubscribeFallbackToAudioOnly',
             'networkQuality',
             'streamInjectedStatus',
         if ([
             'remoteAudioStats',
             'remoteVideoStats',
-            'audioTransportStatsOfUid',
-            'videoTransportStatsOfUid',   
         ].indexOf(eventType) != -1) {
             AgoraEventEmitter.addListener(`${RtcEngine.AG_PREFIX}${eventType}`, (args) => {
                 args.stats.uid = this.Int32ToUint32(args.stats.uid);
             for (let eventType of this._eventTypes) {
                 AgoraEventEmitter.removeAllListeners(eventType);
             }
-            this._eventTypes.clear()
+            this._eventTypes.clear();
         }
         return Agora.destroy();
     }

src/types.ts

 import { ViewProps } from 'react-native';
 
+/**
+ * ChannelMediaInfo
+ * @property channelName: string
+ * @property token: string
+ * @property uid: number
+ */
+export interface ChannelMediaInfo {
+  channelName: string
+  token?: string
+  uid?: number
+}
+/**
+ * ChannelMediaConfiguration
+ * @property src: {
+ *    @member channelName,
+ *    @member token,
+ *    @member uid,
+ * }
+ * @property channels: {@link Array<ChannelMediaInfo>}
+ */
+export interface ChannelMediaConfiguration {
+  src?: {
+    channelName: string
+    token?: string
+    uid?: number
+  }
+  channels: Array<ChannelMediaInfo>
+}
+
 /**
  * AgoraViewMode
  * @mode hidden Uniformly scale the video until it fills the visible boundaries (cropped). One dimension of the video may have clipped contents.