support. android custom raw data api

CHANGELOG

@@ -2,6 +2,21 @@
 
 #### 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` relay media streams operation for across channels.
 
 #### 2.8.0-alpha.1
   - add `string uid` api support

android/src/cpp/include/AgoraBase.h

@@ -0,0 +1,781 @@
+//  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/cpp/include/IAgoraMediaEngine.h

@@ -0,0 +1,215 @@
+#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/cpp/include/IAgoraService.h

@@ -0,0 +1,76 @@
+//  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/cpp/include/VMUtil.h

@@ -0,0 +1,53 @@
+#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/cpp/src/agora_media_pre_processing.cpp

@@ -0,0 +1,327 @@
+//
+// 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/cpp/src/agora_media_pre_processing.h

@@ -0,0 +1,77 @@
+/* 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

@@ -19,7 +19,6 @@ public class AgoraConst {
     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";

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

@@ -2,6 +2,7 @@ package com.syan.agora;
 
 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;
@@ -494,19 +495,6 @@ public class AgoraModule extends ReactContextBaseJavaModule {
             });
         }
 
-        @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() {
@@ -2074,6 +2062,33 @@ public class AgoraModule extends ReactContextBaseJavaModule {
         }
     }
 
+    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)) {

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

@@ -1,18 +1,38 @@
 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;
     }
@@ -27,7 +47,6 @@ public class AgoraVideoView extends LinearLayout {
 
     public void setRenderMode(Integer renderMode) {
         this.renderMode = renderMode;
-
     }
 
     public Integer getRemoteUid() {
@@ -74,4 +93,151 @@ public class AgoraVideoView extends LinearLayout {
             }
         }
     }
+
+    @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) {
+
+    }
+
+    private static final String VCODEC_MIME = "video/avc";
+
+    private String audioFilePath;
+    private String videoFilePath;
+
+    private Future<Void> audioFuture = null;
+    private Future<Void> videoFuture = null;
+    private int colorFormat;
+    private MediaCodec vencoder;
+
+    private ExecutorService executor = Executors.newSingleThreadExecutor();
+
+    public void setAudioFilePath(String path) {
+        audioFilePath = path;
+    }
+
+    public void setVideoFilePath(String path) {
+        videoFilePath = path;
+    }
+
+    private static MediaCodecInfo selectCodec(String mimeType) {
+        int numCodecs = MediaCodecList.getCodecCount();
+        for (int i = 0; i < numCodecs; i++) {
+            MediaCodecInfo codecInfo = MediaCodecList.getCodecInfoAt(i);
+
+            if (!codecInfo.isEncoder()) {
+                continue;
+            }
+            String[] types = codecInfo.getSupportedTypes();
+            for (int j = 0; j < types.length; j++) {
+                if (types[j].equalsIgnoreCase(mimeType)) {
+                    return codecInfo;
+                }
+            }
+        }
+        return null;
+    }
+
+    private void logColorFormatName(int format) {
+        switch (format) {
+            case MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420Flexible:
+                Log.d("video", "COLOR_FormatYUV420Flexible");
+                break;
+            case MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420PackedPlanar:
+                Log.d("video", "COLOR_FormatYUV420PackedPlanar");
+                break;
+            case MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420Planar:
+                Log.d("video", "COLOR_FormatYUV420Planar");
+                break;
+            case MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420PackedSemiPlanar:
+                Log.d("video", "COLOR_FormatYUV420PackedSemiPlanar");
+                break;
+            case COLOR_FormatYUV420SemiPlanar:
+                Log.d("video", "COLOR_FormatYUV420SemiPlanar");
+                break;
+        }
+    }
+
+
+    private int getColorFormat(MediaCodecInfo mediaCodecInfo) {
+        int matchedFormat = 0;
+        MediaCodecInfo.CodecCapabilities codecCapabilities =
+                mediaCodecInfo.getCapabilitiesForType(VCODEC_MIME);
+        for (int i = 0; i < codecCapabilities.colorFormats.length; i++) {
+            int format = codecCapabilities.colorFormats[i];
+            if (format >= codecCapabilities.COLOR_FormatYUV420Planar &&
+                    format <= codecCapabilities.COLOR_FormatYUV420PackedSemiPlanar) {
+                if (format >= matchedFormat) {
+                    matchedFormat = format;
+                    logColorFormatName(format);
+                    break;
+                }
+            }
+        }
+        return matchedFormat;
+    }
+
+
+    private void initVideoEncoder() {
+        MediaCodecInfo mediaCodecInfo = selectCodec(VCODEC_MIME);
+        colorFormat = getColorFormat(mediaCodecInfo);
+
+        String TAG = remoteUid.toString();
+        try {
+            vencoder = MediaCodec.createByCodecName(mediaCodecInfo.getName());
+            Log.d(TAG, "编码器:" + mediaCodecInfo.getName() + "创建完成!");
+        } catch (IOException e) {
+            e.printStackTrace();
+            throw new RuntimeException("vencodec初始化失败！", e);
+        }
+        MediaFormat mediaFormat = MediaFormat
+                .createVideoFormat(MediaFormat.MIMETYPE_VIDEO_AVC, this.getWidth(), this.getHeight());
+        mediaFormat.setInteger(MediaFormat.KEY_MAX_INPUT_SIZE, 0);
+        mediaFormat.setInteger(KEY_BIT_RATE, 300 * 1000);
+        mediaFormat.setInteger(KEY_COLOR_FORMAT, colorFormat);
+        mediaFormat.setInteger(KEY_FRAME_RATE, 30);
+        mediaFormat.setInteger(KEY_I_FRAME_INTERVAL, 5);
+        vencoder.configure(mediaFormat, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);
+        vencoder.start();
+    }
+
+    private MediaMuxer vmuxer = null;
+
+    private int videoTrackIndex;
+
+    @RequiresApi(api = Build.VERSION_CODES.JELLY_BEAN_MR2)
+    public void startMuxerVideo () {
+        try {
+            vmuxer = new MediaMuxer(videoFilePath,
+                    MediaMuxer.OutputFormat.MUXER_OUTPUT_MPEG_4);
+            videoTrackIndex = vmuxer.addTrack(vencoder.getOutputFormat());
+            vmuxer.start();
+        } catch (IOException ex) {
+            ex.printStackTrace();
+        }
+    }
 }

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

@@ -0,0 +1,29 @@
+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

@@ -0,0 +1,13 @@
+
+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

@@ -0,0 +1,297 @@
+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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,39 @@
+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();
+}

src/RtcEngine.native.ts

@@ -50,7 +50,7 @@ class RtcEngine {
      * @ignore AG_PREFIX
      */ 
     private static readonly AG_PREFIX: string = 'ag_rtc';
-
+    
     /**
      * Creates a RtcEngine Object internal.
      *
@@ -406,7 +406,7 @@ class RtcEngine {
             for (let eventType of this._eventTypes) {
                 AgoraEventEmitter.removeAllListeners(eventType);
             }
-            this._eventTypes.clear()
+            this._eventTypes.clear();
         }
         return Agora.destroy();
     }