upgrade iOS agora sdk

.gitignore

@@ -63,3 +63,4 @@ xcuserdata
 *.pbxproj
 lib
 *.xcworkspace
+*.zip

ios/RCTAgora/AgoraConst.h

@@ -8,6 +8,76 @@
 
 #import <AgoraRtcEngineKit/AgoraRtcEngineKit.h>
 
+static NSString *RCTAgoraErrorDomain = @"RCTAgoraErrorDomain";
+
+static NSString *DidOccurWarning = @"DidOccurWarning";
+static NSString *DidOccurError = @"DidOccurError";
+static NSString *DidApiCallExecute = @"DidApiCallExecute";
+static NSString *DidJoinChannel = @"DidJoinChannel";
+static NSString *DidRejoinChannel = @"DidRejoinChannel";
+static NSString *DidLeaveChannel = @"DidLeaveChannel";
+static NSString *DidClientRoleChanged = @"DidClientRoleChanged";
+static NSString *DidJoinedOfUid = @"DidJoinedOfUid";
+static NSString *DidOfflineOfUid = @"DidOfflineOfUid";
+static NSString *ConnectionChangedToState = @"ConnectionChangedToState";
+static NSString *ConnectionDidLost = @"ConnectionDidLost";
+static NSString *TokenPrivilegeWillExpire = @"T=okenPrivilegeWillExpire";
+static NSString *RequestToken = @"RequestToken";
+
+static NSString *DidMicrophoneEnabled = @"DidMicrophoneEnabled";
+static NSString *ReportAudioVolumeIndicationOfSpeakers = @"ReportAudioVolumeIndicationOfSpeakers";
+static NSString *ActiveSpeaker = @"ActiveSpeaker";
+static NSString *FirstLocalAudioFrame = @"FirstLocalAudioFrame";
+static NSString *FirstRemoteAudioFrameOfUid = @"FirstRemoteAudioFrameOfUid";
+static NSString *VideoDidStop = @"VideoDidStop";
+static NSString *FirstLocalVideoFrameWithSize = @"FirstLocalVideoFrameWithSize";
+static NSString *FirstRemoteVideoDecodedOfUid = @"FirstRemoteVideoDecodedOfUid";
+static NSString *FirstRemoteVideoFrameOfUid = @"FirstRemoteVideoFrameOfUid";
+static NSString *DidAudioMuted = @"DidAudioMuted";
+static NSString *DidVideoMuted = @"DidVideoMuted";
+static NSString *DidVideoEnabled = @"DidVideoEnabled";
+static NSString *DidLocalVideoEnabled = @"DidLocalVideoEnabled";
+static NSString *VideoSizeChangedOfUid = @"VideoSizeChangedOfUid";
+static NSString *RemoteVideoStateChangedOfUid = @"RemoteVideoStateChangedOfUid";
+static NSString *DidLocalPublishFallbackToAudioOnly = @"DidLocalPublishFallbackToAudioOnly";
+static NSString *DidRemoteSubscribeFallbackToAudioOnly = @"DidRemoteSubscribeFallbackToAudioOnly";
+
+static NSString *DeviceTypeStateChanged = @"DeviceTypeStateChanged";
+static NSString *DidAudioRouteChanged = @"DidAudioRouteChanged";
+static NSString *CameraDidReady = @"CameraDidReady";
+static NSString *CameraFocusDidChangedToRect = @"CameraFocusDidChangedToRect";
+static NSString *CameraExposureDidChangedToRect = @"CameraExposureDidChangedToRect";
+
+static NSString *ReportRtcStats = @"ReportRtcStats";
+static NSString *LastmileQuality = @"LastmileQuality";
+static NSString *NetworkQuality = @"NetworkQuality";
+static NSString *LocalVideoStats = @"LocalVideoStats";
+static NSString *RemoteVideoStats = @"RemoteVideoStats";
+static NSString *RemoteAudioStats = @"RemoteAudioStats";
+static NSString *AudioTransportStatsOfUid = @"AudioTransportStatsOfUid";
+static NSString *VideoTransportStatsOfUid = @"VideoTransportStatsOfUid";
+
+static NSString *LocalAudioMixingDidFinish = @"LocalAudioMixingDidFinish";
+static NSString *RemoteAudioMixingDidStart = @"RemoteAudioMixingDidStart";
+static NSString *RemoteAudioMixingDidFinish = @"RemoteAudioMixingDidFinish";
+static NSString *DidAudioEffectFinish = @"DidAudioEffectFinish";
+
+static NSString *StreamPublished = @"StreamPublished";
+static NSString *StreamUnpublish = @"StreamUnpublish";
+static NSString *TranscodingUpdated = @"TranscodingUpdated";
+
+static NSString *StreamInjectedStatus = @"StreamInjectedStatus";
+
+static NSString *ReceiveStreamMessage = @"ReceiveStreamMessage";
+static NSString *DidOccurStreamMessageError = @"DidOccurStreamMessageError";
+
+static NSString *MediaEngineDidLoaded = @"MediaEngineDidLoaded";
+static NSString *MediaEngineDidStartCall = @"MediaEngineDidStartCall";
+
+static NSString *ConnectionDidInterrupted = @"ConnectionDidInterrupted";
+static NSString *ConnectionDidBanned = @"ConnectionDidBanned";
+static NSString *AudioQualityOfUid = @"AudioQualityOfUid";
+
 @interface AgoraConst : NSObject
 
 @property (nonatomic, copy) NSString *appid;

ios/RCTAgora/AgoraConst.m

@@ -31,6 +31,4 @@ static AgoraConst *_person;
     return _person;
 }
 
-
-
 @end

ios/RCTAgora/RCTAgora.h

@@ -9,8 +9,8 @@
 #import <Foundation/Foundation.h>
 #import <UIKit/UIKit.h>
 #import <React/RCTBridgeModule.h>
-#import <AgoraRtcEngineKit/AgoraRtcEngineKit.h>
+#import <React/RCTEventEmitter.h>
 
-@interface RCTAgora : NSObject<RCTBridgeModule, AgoraRtcEngineDelegate>
+@interface RCTAgora : RCTEventEmitter<RCTBridgeModule>
 
 @end

ios/RCTAgora/RCTAgoraVideoView.m

@@ -24,7 +24,7 @@
         AgoraRtcVideoCanvas *canvas = [[AgoraRtcVideoCanvas alloc] init];
         canvas.uid = [AgoraConst share].localUid;
         canvas.view = self;
-        canvas.renderMode = AgoraRtc_Render_Hidden;
+        canvas.renderMode = AgoraVideoRenderModeHidden;
         [_rtcEngine setupLocalVideo:canvas];
     }
 }
@@ -34,7 +34,7 @@
         AgoraRtcVideoCanvas *canvas = [[AgoraRtcVideoCanvas alloc] init];
         canvas.uid = remoteUid;
         canvas.view = self;
-        canvas.renderMode = AgoraRtc_Render_Hidden;
+        canvas.renderMode = AgoraVideoRenderModeHidden;
         [_rtcEngine setupRemoteVideo:canvas];
     }
 }

ios/RCTAgora/libs/AgoraRtcCryptoLoader.framework/Headers/AgoraRtcCryptoLoader.h

@@ -2,8 +2,7 @@
 //  AgoraRtcCryptoLoader.h
 //  AgoraRtcCryptoLoader
 //
-//  Created by junhao wang on 1/5/17.
-//  Copyright © 2017 Agora. All rights reserved.
+//  Copyright © 2018 Agora. All rights reserved.
 //
 
 #import <Foundation/Foundation.h>

ios/RCTAgora/libs/AgoraRtcEngineKit.framework/Headers/AgoraBase.h

@@ -0,0 +1,597 @@
+//  Agora Engine SDK
+//
+//  Copyright (c) 2018 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__)
+#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 to connect to the server.
+    */
+    WARN_LOOKUP_CHANNEL_TIMEOUT = 104,
+    /** 105: The server rejects the request to look up the channel. The server cannot process this request or the request is illegal.
+    */
+    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 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,
+    /** 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. This warning does not affect the ongoing call.
+    */
+    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,
+    /**
+    */
+    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,
+    /**
+    */
+    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 changed.
+    */
+    WARN_ADM_IMPROPER_SETTINGS = 1053,
+    /**
+        */
+    WARN_ADM_WIN_CORE_NO_RECORDING_DEVICE = 1322,
+    /**
+    */
+    WARN_ADM_WIN_CORE_NO_PLAYOUT_DEVICE = 1323,
+    /**
+    */
+    WARN_ADM_WIN_CORE_IMPROPER_CAPTURE_RELEASE = 1324,
+};
+
+/** 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,
+    /** 109: 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,
+    /** 110: 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" 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: An error occurs in the watermark file parameter.
+     */
+    ERR_WATERMARK_PARAM = 124,
+    /** 125: An error occurs in the watermark file path.
+     */
+    ERR_WATERMARK_PATH = 125,
+    /** 126: An error occurs in the watermark file format.
+     */
+    ERR_WATERMARK_PNG = 126,
+    /** 127: An error occurs in the watermark file information.
+     */
+    ERR_WATERMARKR_INFO = 127,
+    /** 128: An error occurs in the 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,
+
+    //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,
+    /** 1003: Fails to start the camera.
+     */
+    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,
+    ERR_ADM_RECORD_AUDIO_IS_ACTIVE = 1033,
+    ERR_ADM_ANDROID_JNI_JAVA_RESOURCE = 1101,
+    ERR_ADM_ANDROID_JNI_NO_RECORD_FREQUENCY = 1108,
+    ERR_ADM_ANDROID_JNI_NO_PLAYBACK_FREQUENCY = 1109,
+    ERR_ADM_ANDROID_JNI_JAVA_START_RECORD = 1111,
+    ERR_ADM_ANDROID_JNI_JAVA_START_PLAYBACK = 1112,
+    ERR_ADM_ANDROID_JNI_JAVA_RECORD_ERROR = 1115,
+    ERR_ADM_ANDROID_OPENSL_CREATE_ENGINE = 1151,
+    ERR_ADM_ANDROID_OPENSL_CREATE_AUDIO_RECORDER = 1153,
+    ERR_ADM_ANDROID_OPENSL_START_RECORDER_THREAD = 1156,
+    ERR_ADM_ANDROID_OPENSL_CREATE_AUDIO_PLAYER = 1157,
+    ERR_ADM_ANDROID_OPENSL_START_PLAYER_THREAD = 1160,
+    ERR_ADM_IOS_INPUT_NOT_AVAILABLE = 1201,
+    ERR_ADM_IOS_ACTIVATE_SESSION_FAIL = 1206,
+    ERR_ADM_IOS_VPIO_INIT_FAIL = 1210,
+    ERR_ADM_IOS_VPIO_REINIT_FAIL = 1213,
+    ERR_ADM_IOS_VPIO_RESTART_FAIL = 1214,
+    ERR_ADM_IOS_SET_RENDER_CALLBACK_FAIL = 1219,
+    ERR_ADM_IOS_SESSION_SAMPLERATR_ZERO = 1221,
+    ERR_ADM_WIN_CORE_INIT = 1301,
+    ERR_ADM_WIN_CORE_INIT_RECORDING = 1303,
+    ERR_ADM_WIN_CORE_INIT_PLAYOUT = 1306,
+    ERR_ADM_WIN_CORE_INIT_PLAYOUT_NULL = 1307,
+    ERR_ADM_WIN_CORE_START_RECORDING = 1309,
+    ERR_ADM_WIN_CORE_CREATE_REC_THREAD = 1311,
+    ERR_ADM_WIN_CORE_CAPTURE_NOT_STARTUP = 1314,
+    ERR_ADM_WIN_CORE_CREATE_RENDER_THREAD = 1319,
+    ERR_ADM_WIN_CORE_RENDER_NOT_STARTUP = 1320,
+    ERR_ADM_WIN_CORE_NO_RECORDING_DEVICE = 1322,
+    ERR_ADM_WIN_CORE_NO_PLAYOUT_DEVICE = 1323,
+    ERR_ADM_WIN_WAVE_INIT = 1351,
+    ERR_ADM_WIN_WAVE_INIT_RECORDING = 1353,
+    ERR_ADM_WIN_WAVE_INIT_MICROPHONE = 1354,
+    ERR_ADM_WIN_WAVE_INIT_PLAYOUT = 1355,
+    ERR_ADM_WIN_WAVE_INIT_SPEAKER = 1356,
+    ERR_ADM_WIN_WAVE_START_RECORDING = 1357,
+    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,
+
+    // 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. */
+    LOG_FILTER_DEBUG = 0x080f,
+     /** 0x000f: Output CRITICAL, ERROR, WARNING, and INFO level log information. */
+    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

ios/RCTAgora/libs/AgoraRtcEngineKit.framework/Headers/AgoraConstants.h

@@ -0,0 +1,91 @@
+//
+//  AgoraConstants.h
+//  AgoraRtcEngineKit
+//
+//  Copyright (c) 2018 Agora. All rights reserved.
+//
+#import <Foundation/Foundation.h>
+#if TARGET_OS_IPHONE
+#import <UIKit/UIKit.h>
+#elif TARGET_OS_MAC
+#import <AppKit/AppKit.h>
+#endif
+
+/** The standard bitrate set in [setVideoEncoderConfiguration]([AgoraRtcEngineKit setVideoEncoderConfiguration:]).
+
+(Recommended) The standard bitrate mode. In this mode, the bitrate under the live broadcast and communication profiles differs:
+
+    - Communication profile: The video bitrate is the same as the base bitrate.
+    - Live broadcast profile: The video bitrate is twice the base bitrate.
+ */
+extern NSInteger const AgoraVideoBitrateStandard;
+
+/** The compatible bitrate set in [setVideoEncoderConfiguration]([AgoraRtcEngineKit setVideoEncoderConfiguration:]).
+
+The compatible bitrate mode. In this mode, the bitrate stays the same regardless of the channel profile. In a live broadcast channel, if you choose this mode, the video frame rate may be lower than the set value.
+ */
+extern NSInteger const AgoraVideoBitrateCompatible;
+
+/** Use default minimum bitrate.
+ */
+extern NSInteger const AgoraVideoBitrateDefaultMin;
+
+/** 120 &times; 120
+ */
+extern CGSize const AgoraVideoDimension120x120;
+/** 160 &times; 120
+ */
+extern CGSize const AgoraVideoDimension160x120;
+/** 180 &times; 180
+ */
+extern CGSize const AgoraVideoDimension180x180;
+/** 240 &times; 180
+ */
+extern CGSize const AgoraVideoDimension240x180;
+/** 320 &times; 180
+ */
+extern CGSize const AgoraVideoDimension320x180;
+/** 240 &times; 240
+ */
+extern CGSize const AgoraVideoDimension240x240;
+/** 320 &times; 240
+ */
+extern CGSize const AgoraVideoDimension320x240;
+/** 424 &times; 240
+ */
+extern CGSize const AgoraVideoDimension424x240;
+/** 360 &times; 360
+ */
+extern CGSize const AgoraVideoDimension360x360;
+/** 480 &times; 360
+ */
+extern CGSize const AgoraVideoDimension480x360;
+/** 640 &times; 360
+ */
+extern CGSize const AgoraVideoDimension640x360;
+/** 480 &times; 480
+ */
+extern CGSize const AgoraVideoDimension480x480;
+/** 640 &times; 480
+ */
+extern CGSize const AgoraVideoDimension640x480;
+/** 840 &times; 480
+ */
+extern CGSize const AgoraVideoDimension840x480;
+/** 960 &times; 720 (Depends on the hardware)
+ */
+extern CGSize const AgoraVideoDimension960x720;
+/** 1280 &times; 720 (Depends on the hardware)
+ */
+extern CGSize const AgoraVideoDimension1280x720;
+#if TARGET_OS_MAC
+/** 1920 &times; 1080 (Depends on the hardware, macOS only)
+ */
+extern CGSize const AgoraVideoDimension1920x1080;
+/** 25400 &times; 1440 (Depends on the hardware, macOS only)
+ */
+extern CGSize const AgoraVideoDimension2540x1440;
+/** 3840 &times; 2160 (Depends on the hardware, macOS only)
+ */
+extern CGSize const AgoraVideoDimension3840x2160;
+#endif

ios/RCTAgora/libs/AgoraRtcEngineKit.framework/Headers/AgoraEnumerates.h

@@ -0,0 +1,833 @@
+//
+// AgoraEnumerates.h
+// AgoraRtcEngineKit
+//
+// Copyright (c) 2018 Agora. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+
+/** Warning code.
+
+Warning codes occur when the SDK encounters an error that may be recovered automatically. These are only notifications, and can generally be ignored. For example, when the SDK loses connection to the server, the SDK reports the AgoraWarningCodeOpenChannelTimeout(106) code and tries to reconnect automatically.
+*/
+typedef NS_ENUM(NSInteger, AgoraWarningCode) {
+    /** 8: The specified view is invalid. Specify a view when using the video call function. */
+    AgoraWarningCodeInvalidView = 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. */
+    AgoraWarningCodeInitVideo = 16,
+     /** 20: The request is pending, usually due to some module not being ready, and the SDK postpones processing the request. */
+    AgoraWarningCodePending = 20,
+    /** 103: No channel resources are available. Maybe because the server cannot allocate any channel resource. */
+    AgoraWarningCodeNoAvailableChannel = 103,
+    /** 104: A timeout occurs when looking up the channel. When joining a channel, the SDK looks up the specified channel. The warning usually occurs when the network condition is too poor to connect to the server. */
+    AgoraWarningCodeLookupChannelTimeout = 104,
+    /** 105: The server rejects the request to look up the channel. The server cannot process this request or the request is illegal. */
+    AgoraWarningCodeLookupChannelRejected = 105,
+    /** 106: The server rejects the request to look up the channel. The server cannot process this request or the request is illegal. */
+    AgoraWarningCodeOpenChannelTimeout = 106,
+    /** 107: The server rejects the request to open the channel. The server cannot process this request or the request is illegal. */
+    AgoraWarningCodeOpenChannelRejected = 107,
+    /** 111: A timeout occurs when switching to the live video. */
+    AgoraWarningCodeSwitchLiveVideoTimeout = 111,
+    /** 118: A timeout occurs when setting the client role in the live broadcast profile. */
+    AgoraWarningCodeSetClientRoleTimeout = 118,
+    /** 119: The client role is unauthorized. */
+    AgoraWarningCodeSetClientRoleNotAuthorized = 119,
+    /** 121: The ticket to open the channel is invalid. */
+    AgoraWarningCodeOpenChannelInvalidTicket = 121,
+    /** 122: Try connecting to another server. */
+    AgoraWarningCodeOpenChannelTryNextVos = 122,
+    /** 701: An error occurs in opening the audio mixing file. */
+    AgoraWarningCodeAudioMixingOpenError = 701,
+    /** 1014: Audio Device Module: A warning occurs in the playback device. */
+    AgoraWarningCodeAdmRuntimePlayoutWarning = 1014,
+    /** 1016: Audio Device Module: A warning occurs in the recording device. */
+    AgoraWarningCodeAdmRuntimeRecordingWarning = 1016,
+    /** 1019: Audio Device Module: No valid audio data is collected. */
+    AgoraWarningCodeAdmRecordAudioSilence = 1019,
+    /** 1020: Audio Device Module: A playback device fails. */
+    AgoraWarningCodeAdmPlaybackMalfunction = 1020,
+    /** 1021: Audio Device Module: A recording device fails. */
+    AgoraWarningCodeAdmRecordMalfunction = 1021,
+    /** 1025: The system interrupts the audio session, and the session is no longer active. */
+    AgoraWarningCodeAdmInterruption = 1025,
+    /** 1031: Audio Device Module: The recorded audio voice is too low. */
+    AgoraWarningCodeAdmRecordAudioLowlevel = 1031,
+    /** 1032: Audio Device Module: The playback audio voice is too low. */
+    AgoraWarningCodeAdmPlayoutAudioLowlevel = 1032,
+    /** 1051: Audio Device Module: Howling is detected. */
+    AgoraWarningCodeApmHowling = 1051,
+    /** 1052: Audio Device Module: The device is in the glitch state. */
+    AgoraWarningCodeAdmGlitchState = 1052,
+    /** 1053: Audio Device Module: The underlying audio settings have changed. */
+    AgoraWarningCodeAdmImproperSettings = 1053,
+};
+
+/** Error code.
+
+Error codes occur when the SDK encounters an error that cannot be recovered automatically without any app intervention. For example, the SDK reports the AgoraErrorCodeStartCall = 1002 error if it fails to start a call, and reminds the user to call the [leaveChannel]([AgoraRtcEngineKit leaveChannel:]) method.
+*/
+typedef NS_ENUM(NSInteger, AgoraErrorCode) {
+    /** 0: No error occurs. */
+    AgoraErrorCodeNoError = 0,
+    /** 1: A general error occurs (no specified reason). */
+    AgoraErrorCodeFailed = 1,
+    /** 2: An invalid parameter is used. For example, the specific channel name includes illegal characters. */
+    AgoraErrorCodeInvalidArgument = 2,
+    /** 3: The SDK module is not ready.
+     <p>Possible solutions：
+     <ul><li>Check the audio device.</li>
+     <li>Check the completeness of the app.</li>
+     <li>Re-initialize the SDK.</li></ul></p>
+    */
+    AgoraErrorCodeNotReady = 3,
+    /** 4: The current state of the SDK does not support this function. */
+    AgoraErrorCodeNotSupported = 4,
+    /** 5: The request is rejected. This is for internal SDK use only, and is not returned to the app through any method or callback. */
+    AgoraErrorCodeRefused = 5,
+    /** 6: The buffer size is not big enough to store the returned data. */
+    AgoraErrorCodeBufferTooSmall = 6,
+    /** 7: The SDK is not initialized before calling this method. */
+    AgoraErrorCodeNotInitialized = 7,
+    /** 9: No permission exists. This is for internal SDK use only, and is not returned to the app through any method or callback. */
+    AgoraErrorCodeNoPermission = 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 (over 10 seconds) for the SDK to process. */
+    AgoraErrorCodeTimedOut = 10,
+    /** 11: The request is canceled. This is for internal SDK use only, and is not returned to the app through any method or callback. */
+    AgoraErrorCodeCanceled = 11,
+    /** 12: The method is called too often. This is for internal SDK use only, and is not returned to the app through any method or callback. */
+    AgoraErrorCodeTooOften = 12,
+    /** 13: The SDK fails to bind to the network socket. This is for internal SDK use only, and is not returned to the app through any method or callback. */
+    AgoraErrorCodeBindSocket = 13,
+    /** 14: The network is unavailable. This is for internal SDK use only, and is not returned to the app through any method or callback. */
+    AgoraErrorCodeNetDown = 14,
+    /** 15: No network buffers are available. This is for internal SDK use only, and is not returned to the app through any method or callback. */
+    AgoraErrorCodeNoBufs = 15,
+    /** 17: The request to join the channel is rejected.
+     <p>The possible reasons are:
+     <ul><li>The user is already in the channel, and still calls the API method to join the channel, for example, [joinChannelByToken]([AgoraRtcEngineKit joinChannelByToken:channelId:info:uid:joinSuccess:]).</li>
+     <li>The user tries joining the channel during the echo test. Please join the channel after the echo test.</li></ul></p>
+    */
+    AgoraErrorCodeJoinChannelRejected = 17,
+    /** 18: The request to leave the channel is rejected.
+     <p>The possible reasons are:
+     <ul><li>The user left the channel and still calls the API method to leave the channel, for example, [leaveChannel]([AgoraRtcEngineKit leaveChannel:]).</li>
+     <li>The user has not joined the channel and calls the API method to leave the channel.</li></ul></p>
+    */
+    AgoraErrorCodeLeaveChannelRejected = 18,
+    /** 19: The resources are occupied and cannot be used. */
+    AgoraErrorCodeAlreadyInUse = 19,
+    /** 20: The SDK gave up the request due to too many requests.  */
+    AgoraErrorCodeAbort = 20,
+    /** 21: In Windows, specific firewall settings can cause the SDK to fail to initialize and crash. */
+    AgoraErrorCodeInitNetEngine = 21,
+    /** 22: The app uses too much of the system resources and the SDK fails to allocate the resources. */
+    AgoraErrorCodeResourceLimited = 22,
+    /** 101: The specified App ID is invalid. Please try to rejoin the channel with a valid App ID.*/
+    AgoraErrorCodeInvalidAppId = 101,
+    /** 102: The specified channel name is invalid. Please try to rejoin the channel with a valid channel name. */
+    AgoraErrorCodeInvalidChannelId = 102,
+    /** 109: The token expired.
+     <p>The possible reasons are:
+     <ul><li>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.</li>
+     <li>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.</li></ul></p>
+     */
+    AgoraErrorCodeTokenExpired = 109,
+    /** 110: The token is invalid.
+     <p>The possible reasons are:
+     <ul><li>The App Certificate for the project is enabled in Dashboard, but the user is  using the App ID. Once the App Certificate is enabled, the user must use a token.</li>
+     <li>The uid is mandatory, and users must set the same uid as the one set in the [joinChannelByToken]([AgoraRtcEngineKit joinChannelByToken:channelId:info:uid:joinSuccess:]) method.</li></ul></p>
+     */
+    AgoraErrorCodeInvalidToken = 110,
+    /** 111: The Internet connection is interrupted. This applies to the Agora Web SDK only. */
+    AgoraErrorCodeConnectionInterrupted = 111,
+    /** 112: The Internet connection is lost. This applies to the Agora Web SDK only. */
+    AgoraErrorCodeConnectionLost = 112,
+    /** 113: The user is not in the channel when calling the [sendStreamMessage]([AgoraRtcEngineKit sendStreamMessage:data:]) method. */
+    AgoraErrorCodeNotInChannel = 113,
+    /** 114: The size of the sent data is over 1024 bytes when the user calls the [sendStreamMessage]([AgoraRtcEngineKit sendStreamMessage:data:]) method. */
+    AgoraErrorCodeSizeTooLarge = 114,
+    /** 115: The bitrate of the sent data exceeds the limit of 6 Kbps when the user calls the [sendStreamMessage]([AgoraRtcEngineKit sendStreamMessage:data:]) method. */
+    AgoraErrorCodeBitrateLimit = 115,
+    /** 116: Too many data streams (over five streams) are created when the user calls the [createDataStream]([AgoraRtcEngineKit createDataStream:reliable:ordered:]) method. */
+    AgoraErrorCodeTooManyDataStreams = 116,
+    /** 120: Decryption fails. The user may have used a different encryption password to join the channel. Check your settings or try rejoining the channel. */
+    AgoraErrorCodeDecryptionFailed = 120,
+    /** 124: An error occurs in the watermark file parameter. */
+    AgoraErrorCodeWatermarkParam = 124,
+    /** 125: An error occurs in the watermark file path. */
+    AgoraErrorCodeWatermarkPath = 125,
+    /** 126: An error occurs in the watermark file format. */
+    AgoraErrorCodeWatermarkPng = 126,
+    /** 127: An error occurs in the watermark file information. */
+    AgoraErrorCodeWatermarkInfo = 127,
+    /** 128: An error occurs in the watermark file data format. */
+    AgoraErrorCodeWatermarkAGRB = 128,
+    /** 129: An error occurs in reading the watermark file. */
+    AgoraErrorCodeWatermarkRead = 129,
+    /** 130: The encrypted stream is not allowed to publish. */
+    AgoraErrorCodeEncryptedStreamNotAllowedPublish = 130,
+    /** 150: Stream publishing fails. */
+    AgoraErrorCodePublishFailed = 150,
+    /** 1001: Fails to load the media engine. */
+    AgoraErrorCodeLoadMediaEngine = 1001,
+    /** 1002: Fails to start the call after enabling the media engine. */
+    AgoraErrorCodeStartCall = 1002,
+    /** 1003: Fails to start the camera. */
+    AgoraErrorCodeStartCamera = 1003,
+    /** 1004: Fails to start the video rendering module. */
+    AgoraErrorCodeStartVideoRender = 1004,
+    /** 1005: A general error occurs in the Audio Device Module (the reason is not classified specifically). Check if the audio device is used by another app, or try rejoining the channel. */
+    AgoraErrorCodeAdmGeneralError = 1005,
+    /** 1006: Audio Device Module: An error occurs in using the Java resources. */
+    AgoraErrorCodeAdmJavaResource = 1006,
+    /** 1007: Audio Device Module: An error occurs in setting the sampling frequency. */
+    AgoraErrorCodeAdmSampleRate = 1007,
+    /** 1008: Audio Device Module: An error occurs in initializing the playback device. */
+    AgoraErrorCodeAdmInitPlayout = 1008,
+    /** 1009: Audio Device Module: An error occurs in starting the playback device. */
+    AgoraErrorCodeAdmStartPlayout = 1009,
+    /** 1010: Audio Device Module: An error occurs in stopping the playback device. */
+    AgoraErrorCodeAdmStopPlayout = 1010,
+    /** 1011: Audio Device Module: An error occurs in initializing the recording device. */
+    AgoraErrorCodeAdmInitRecording = 1011,
+    /** 1012: Audio Device Module: An error occurs in starting the recording device. */
+    AgoraErrorCodeAdmStartRecording = 1012,
+    /** 1013: Audio Device Module: An error occurs in stopping the recording device. */
+    AgoraErrorCodeAdmStopRecording = 1013,
+    /** 1015: Audio Device Module: A playback error occurs. Check your playback device, or try rejoining the channel. */
+    AgoraErrorCodeAdmRuntimePlayoutError = 1015,
+    /** 1017: Audio Device Module: A recording error occurs. */
+    AgoraErrorCodeAdmRuntimeRecordingError = 1017,
+    /** 1018: Audio Device Module: Fails to record. */
+    AgoraErrorCodeAdmRecordAudioFailed = 1018,
+    /** 1020: Audio Device Module: Abnormal audio playback frequency. */
+    AgoraErrorCodeAdmPlayAbnormalFrequency = 1020,
+    /** 1021: Audio Device Module: Abnormal audio recording frequency. */
+    AgoraErrorCodeAdmRecordAbnormalFrequency = 1021,
+    /** 1022: Audio Device Module: An error occurs in initializing the loopback device. */
+    AgoraErrorCodeAdmInitLoopback  = 1022,
+    /** 1023: Audio Device Module: An error occurs in starting the loopback device. */
+    AgoraErrorCodeAdmStartLoopback = 1023,
+    /** 1359: No recording device exists. */
+    AgoraErrorCodeAdmNoRecordingDevice = 1359,
+    /** 1360: No playback device exists. */
+    AgoraErrorCodeAdmNoPlayoutDevice = 1360,
+    /** 1501: Video Device Module: The camera is unauthorized. */
+    AgoraErrorCodeVdmCameraNotAuthorized = 1501,
+    /** 1600: Video Device Module: An unknown error occurs. */
+    AgoraErrorCodeVcmUnknownError = 1600,
+    /** 1601: Video Device Module: An error occurs in initializing the video encoder. */
+    AgoraErrorCodeVcmEncoderInitError = 1601,
+    /** 1602: Video Device Module: An error occurs in video encoding. */
+    AgoraErrorCodeVcmEncoderEncodeError = 1602,
+    /** 1603: Video Device Module: An error occurs in setting the video encoder.
+    <p><b>DEPRECATED</b></p>
+    */
+    AgoraErrorCodeVcmEncoderSetError = 1603,
+};
+
+/** Video profile.
+
+**DEPRECATED**
+
+Please use AgoraVideoEncoderConfiguration.
+
+iPhone does not support resolutions above 720p.
+*/
+typedef NS_ENUM(NSInteger, AgoraVideoProfile) {
+    /** Invalid profile. */
+    AgoraVideoProfileInvalid = -1,
+    /** Resolution 160 &times; 120, frame rate 15 fps, bitrate 65 Kbps. */
+    AgoraVideoProfileLandscape120P = 0,
+    /** Resolution 120 &times; 120, frame rate 15 fps, bitrate 50 Kbps. */
+    AgoraVideoProfileLandscape120P_3 = 2, // iOS
+    /** Resolution 320 &times; 180, frame rate 15 fps, bitrate 140 Kbps. */
+    AgoraVideoProfileLandscape180P = 10, // iOS
+    /** Resolution 180 &times; 180, frame rate 15 fps, bitrate 100 Kbps. */
+    AgoraVideoProfileLandscape180P_3 = 12, // iOS
+    /** Resolution 240 &times; 180, frame rate 15 fps, bitrate 120 Kbps. */
+    AgoraVideoProfileLandscape180P_4 = 13, // iOS
+    /** Resolution 320 &times; 240, frame rate 15 fps, bitrate 200 Kbps. */
+    AgoraVideoProfileLandscape240P = 20,
+    /** Resolution 240 &times; 240, frame rate 15 fps, bitrate 140 Kbps. */
+    AgoraVideoProfileLandscape240P_3 = 22, //iOS
+    /** Resolution 424 &times; 240, frame rate 15 fps, bitrate 220 Kbps. */
+    AgoraVideoProfileLandscape240P_4 = 23, // iOS
+    /** Resolution 640 &times; 360, frame rate 15 fps, bitrate 400 Kbps. */
+    AgoraVideoProfileLandscape360P = 30,
+    /** Resolution 360 &times; 360, frame rate 15 fps, bitrate 260 Kbps. */
+    AgoraVideoProfileLandscape360P_3 = 32, // iOS
+    /** Resolution 640 &times; 360, frame rate 30 fps, bitrate 600 Kbps. */
+    AgoraVideoProfileLandscape360P_4 = 33,
+    /** Resolution 360 &times; 360, frame rate 30 fps, bitrate 400 Kbps. */
+    AgoraVideoProfileLandscape360P_6 = 35,
+    /** Resolution 480 &times; 360, frame rate 15 fps, bitrate 320 Kbps. */
+    AgoraVideoProfileLandscape360P_7 = 36,
+    /** Resolution 480 &times; 360, frame rate 30 fps, bitrate 490 Kbps. */
+    AgoraVideoProfileLandscape360P_8 = 37,
+    /** Resolution 640 &times; 360, frame rate 15 fps, bitrate 800 Kbps.
+
+     Note: This profile applies to the live broadcast channel profile only.
+     */
+    AgoraVideoProfileLandscape360P_9 = 38,
+    /** Resolution 640 &times; 360, frame rate 24 fps, bitrate 800 Kbps.
+
+     Note: This profile applies to the live broadcast channel profile only.
+     */
+    AgoraVideoProfileLandscape360P_10 = 39,
+    /** Resolution 640 &times; 360, frame rate 24 fps, bitrate 1000 Kbps.
+
+     Note: This profile applies to the live broadcast channel profile only.
+     */
+    AgoraVideoProfileLandscape360P_11 = 100,
+    /** Resolution 640 &times; 480, frame rate 15 fps, bitrate 500 Kbps. */
+    AgoraVideoProfileLandscape480P = 40,
+    /** Resolution 480 &times; 480, frame rate 15 fps, bitrate 400 Kbps. */
+    AgoraVideoProfileLandscape480P_3 = 42, // iOS
+    /** Resolution 640 &times; 480, frame rate 30 fps, bitrate 750 Kbps. */
+    AgoraVideoProfileLandscape480P_4 = 43,
+    /** Resolution 480 &times; 480, frame rate 30 fps, bitrate 600 Kbps. */
+    AgoraVideoProfileLandscape480P_6 = 45,
+    /** Resolution 848 &times; 480, frame rate 15 fps, bitrate 610 Kbps. */
+    AgoraVideoProfileLandscape480P_8 = 47,
+    /** Resolution 848 &times; 480, frame rate 30 fps, bitrate 930 Kbps. */
+    AgoraVideoProfileLandscape480P_9 = 48,
+    /** Resolution 640 &times; 480, frame rate 10 fps, bitrate 400 Kbps. */
+    AgoraVideoProfileLandscape480P_10 = 49,
+    /** Resolution 1280 &times; 720, frame rate 15 fps, bitrate 1130 Kbps. */
+    AgoraVideoProfileLandscape720P = 50,
+    /** Resolution 1280 &times; 720, frame rate 30 fps, bitrate 1710 Kbps. */
+    AgoraVideoProfileLandscape720P_3 = 52,
+    /** Resolution 960 &times; 720, frame rate 15 fps, bitrate 910 Kbps. */
+    AgoraVideoProfileLandscape720P_5 = 54,
+    /** Resolution 960 &times; 720, frame rate 30 fps, bitrate 1380 Kbps. */
+    AgoraVideoProfileLandscape720P_6 = 55,
+    /** Resolution 1920 &times; 1080, frame rate 15 fps, bitrate 2080 Kbps. */
+    AgoraVideoProfileLandscape1080P = 60,
+    /** Resolution 1920 &times; 1080, frame rate 30 fps, bitrate 3150 Kbps. */
+    AgoraVideoProfileLandscape1080P_3 = 62,
+    /** Resolution 1920 &times; 1080, frame rate 60 fps, bitrate 4780 Kbps. */
+    AgoraVideoProfileLandscape1080P_5 = 64,
+    /** Resolution 2560 &times; 1440, frame rate 30 fps, bitrate 4850 Kbps. */
+    AgoraVideoProfileLandscape1440P = 66,
+    /** Resolution 2560 &times; 1440, frame rate 60 fps, bitrate 6500 Kbps. */
+    AgoraVideoProfileLandscape1440P_2 = 67,
+    /** Resolution 3840 &times; 2160, frame rate 30 fps, bitrate 6500 Kbps. */
+    AgoraVideoProfileLandscape4K = 70,
+    /** Resolution 3840 &times; 2160, frame rate 60 fps, bitrate 6500 Kbps. */
+    AgoraVideoProfileLandscape4K_3 = 72,
+
+    /** Resolution 120 &times; 160, frame rate 15 fps, bitrate 65 Kbps. */
+    AgoraVideoProfilePortrait120P = 1000,
+    /** Resolution 120 &times; 120, frame rate 15 fps, bitrate 50 Kbps. */
+    AgoraVideoProfilePortrait120P_3 = 1002, //iOS
+    /** Resolution 180 &times; 320, frame rate 15 fps, bitrate 140 Kbps. */
+    AgoraVideoProfilePortrait180P = 1010, // iOS
+    /** Resolution 180 &times; 180, frame rate 15 fps, bitrate 100 Kbps. */
+    AgoraVideoProfilePortrait180P_3 = 1012, // iOS
+    /** Resolution 180 &times; 240, frame rate 15 fps, bitrate 120 Kbps. */
+    AgoraVideoProfilePortrait180P_4 = 1013, // iOS
+    /** Resolution 240 &times; 320, frame rate 15 fps, bitrate 200 Kbps. */
+    AgoraVideoProfilePortrait240P = 1020,
+    /** Resolution 240 &times; 240, frame rate 15 fps, bitrate 140 Kbps. */
+    AgoraVideoProfilePortrait240P_3 = 1022, // iOS
+    /** Resolution 240 &times; 424, frame rate 15 fps, bitrate 220 Kbps. */
+    AgoraVideoProfilePortrait240P_4 = 1023,
+    /** Resolution 360 &times; 640, frame rate 15 fps, bitrate 400 Kbps. */
+    AgoraVideoProfilePortrait360P = 1030, // iOS
+    /** Resolution 360 &times; 360, frame rate 15 fps, bitrate 260 Kbps. */
+    AgoraVideoProfilePortrait360P_3 = 1032, // iOS
+    /** Resolution 360 &times; 640, frame rate 30 fps, bitrate 600 Kbps. */
+    AgoraVideoProfilePortrait360P_4 = 1033,
+    /** Resolution 360 &times; 360, frame rate 30 fps, bitrate 400 Kbps. */
+    AgoraVideoProfilePortrait360P_6 = 1035,
+    /** Resolution 360 &times; 480, frame rate 15 fps, bitrate 320 Kbps. */
+    AgoraVideoProfilePortrait360P_7 = 1036,
+    /** Resolution 360 &times; 480, frame rate 30 fps, bitrate 490 Kbps. */
+    AgoraVideoProfilePortrait360P_8 = 1037,
+    /** Resolution 360 &times; 640, frame rate 15 fps, bitrate 600 Kbps. */
+    AgoraVideoProfilePortrait360P_9 = 1038,
+    /** Resolution 360 &times; 640, frame rate 24 fps, bitrate 800 Kbps. */
+    AgoraVideoProfilePortrait360P_10 = 1039,
+    /** Resolution 360 &times; 640, frame rate 24 fps, bitrate 800 Kbps. */
+    AgoraVideoProfilePortrait360P_11 = 1100,
+    /** Resolution 480 &times; 640, frame rate 15 fps, bitrate 500 Kbps. */
+    AgoraVideoProfilePortrait480P = 1040,
+    /** Resolution 480 &times; 480, frame rate 15 fps, bitrate 400 Kbps. */
+    AgoraVideoProfilePortrait480P_3 = 1042,    // iOS
+    /** Resolution 480 &times; 640, frame rate 30 fps, bitrate 750 Kbps. */
+    AgoraVideoProfilePortrait480P_4 = 1043,
+    /** Resolution 480 &times; 480, frame rate 30 fps, bitrate 600 Kbps. */
+    AgoraVideoProfilePortrait480P_6 = 1045,
+    /** Resolution 480 &times; 848, frame rate 15 fps, bitrate 610 Kbps. */
+    AgoraVideoProfilePortrait480P_8 = 1047,
+    /** Resolution 480 &times; 848, frame rate 30 fps, bitrate 930 Kbps. */
+    AgoraVideoProfilePortrait480P_9 = 1048,
+    /** Resolution 480 &times; 640, frame rate 10 fps, bitrate 400 Kbps. */
+    AgoraVideoProfilePortrait480P_10 = 1049,
+    /** Resolution 720 &times; 1280, frame rate 15 fps, bitrate 1130 Kbps. */
+    AgoraVideoProfilePortrait720P = 1050,
+    /** Resolution 720 &times; 1280, frame rate 30 fps, bitrate 1710 Kbps. */
+    AgoraVideoProfilePortrait720P_3 = 1052,
+    /** Resolution 720 &times; 960, frame rate 15 fps, bitrate 910 Kbps. */
+    AgoraVideoProfilePortrait720P_5 = 1054,
+    /** Resolution 720 &times; 960, frame rate 30 fps, bitrate 1380 Kbps. */
+    AgoraVideoProfilePortrait720P_6 = 1055,
+    /** Resolution 1080 &times; 1920, frame rate 15 fps, bitrate 2080 Kbps. */
+    AgoraVideoProfilePortrait1080P = 1060, // macOS
+    /** Resolution 1080 &times; 1920, frame rate 30 fps, bitrate 3150 Kbps. */
+    AgoraVideoProfilePortrait1080P_3 = 1062, // macOS
+    /** Resolution 1080 &times; 1920, frame rate 60 fps, bitrate 4780 Kbps. */
+    AgoraVideoProfilePortrait1080P_5 = 1064, // macOS
+    /** Resolution 1440 &times; 2560, frame rate 30 fps, bitrate 4850 Kbps. */
+    AgoraVideoProfilePortrait1440P = 1066, // macOS
+    /** Resolution 1440 &times; 2560, frame rate 60 fps, bitrate 6500 Kbps. */
+    AgoraVideoProfilePortrait1440P_2 = 1067, // macOS
+    /** Resolution 2160 &times; 3840, frame rate 30 fps, bitrate 6500 Kbps. */
+    AgoraVideoProfilePortrait4K = 1070, // macOS
+    /** Resolution 2160 &times; 3840, frame rate 60 fps, bitrate 6500 Kbps. */
+    AgoraVideoProfilePortrait4K_3 = 1072, // macOS
+    /** (Default) Resolution 640 &times; 360, frame rate 15 fps, bitrate 400 Kbps. */
+    AgoraVideoProfileDEFAULT = AgoraVideoProfileLandscape360P,
+};
+
+/** Frame rate of the video. */
+typedef NS_ENUM(NSInteger, AgoraVideoFrameRate) {
+    /** 1 fps. */
+    AgoraVideoFrameRateFps1 = 1,
+    /** 7 fps. */
+    AgoraVideoFrameRateFps7 = 7,
+    /** 10 fps. */
+    AgoraVideoFrameRateFps10 = 10,
+    /** 15 fps. */
+    AgoraVideoFrameRateFps15 = 15,
+    /** 24 fps. */
+    AgoraVideoFrameRateFps24 = 24,
+    /** 30 fps. */
+    AgoraVideoFrameRateFps30 = 30,
+    /** 60 fps. */
+    AgoraVideoFrameRateFps60 = 60,
+};
+
+/** Video output orientation mode.
+
+  **Note:** When a custom video source is used, if you set AgoraVideoOutputOrientationMode as AgoraVideoOutputOrientationModeFixedLandscape(1) or AgoraVideoOutputOrientationModeFixedPortrait(2), when the rotated video image has a different orientation than the specified output orientation, the video encoder first crops it and then encodes it.
+ */
+typedef NS_ENUM(NSInteger, AgoraVideoOutputOrientationMode) {
+    /** Adaptive mode (Default).
+     <p>The video encoder adapts to the orientation mode of the video input device. When you use a custom video source, the output video from the encoder inherits the orientation of the original video.
+     <ul><li>If the width of the captured video from the SDK is greater than the height, the encoder sends the video in landscape mode. The encoder also sends the rotational information of the video, and the receiver uses the rotational information to rotate the received video.</li>
+     <li>If the original video is in portrait mode, the output video from the encoder is also in portrait mode. The encoder also sends the rotational information of the video to the receiver.</li></ul></p>
+     */
+    AgoraVideoOutputOrientationModeAdaptative = 0,
+    /** Landscape mode.
+     <p>The video encoder always sends the video in landscape mode. The video encoder rotates the original video before sending it and the rotational information is 0. This mode applies to scenarios involving CDN live streaming.</p>
+     */
+    AgoraVideoOutputOrientationModeFixedLandscape = 1,
+     /** Portrait mode.
+      <p>The video encoder always sends the video in portrait mode. The video encoder rotates the original video before sending it and the rotational information is 0. This mode applies to scenarios involving CDN live streaming.</p>
+      */
+    AgoraVideoOutputOrientationModeFixedPortrait = 2,
+};
+
+/** Channel profile. */
+typedef NS_ENUM(NSInteger, AgoraChannelProfile) {
+    /** Communication (default).
+     <p>This is used in one-on-one or group calls, where all users in the channel can talk freely.</p>
+     */
+    AgoraChannelProfileCommunication = 0,
+    /** Live Broadcast.
+     <p>Host and audience roles that can be set by calling the [setClientRole]([AgoraRtcEngineKit setClientRole:]) method. The host sends and receives voice/video, while the audience can only receive voice/video.</p>
+     */
+    AgoraChannelProfileLiveBroadcasting = 1,
+    /** Gaming.
+     <p>This mode is for the Agora Gaming SDK only.</p>
+     <p>Any user in the channel can talk freely. This mode uses the codec with low-power consumption and low bitrate by default. </p>
+     */
+    AgoraChannelProfileGame = 2,
+};
+
+/** Client role in a live broadcast. */
+typedef NS_ENUM(NSInteger, AgoraClientRole) {
+    /** Host. */
+    AgoraClientRoleBroadcaster = 1,
+    /** Audience. */
+    AgoraClientRoleAudience = 2,
+};
+
+
+/** Media type. */
+typedef NS_ENUM(NSInteger, AgoraMediaType) {
+    /** No audio and video. */
+    AgoraMediaTypeNone = 0,
+    /** Audio only. */
+    AgoraMediaTypeAudioOnly = 1,
+    /** Video only. */
+    AgoraMediaTypeVideoOnly = 2,
+    /** Audio and video. */
+    AgoraMediaTypeAudioAndVideo = 3,
+};
+
+
+/** Encryption mode.
+
+When encryptionMode is set as NULL, the encryption mode is set to 128-bit AES encryption, XTS mode by default.
+*/
+typedef NS_ENUM(NSInteger, AgoraEncryptionMode) {
+    AgoraEncryptionModeNone = 0,
+    /** 128-bit AES encryption, XTS mode. */
+    AgoraEncryptionModeAES128XTS = 1,
+    /** 256-bit AES encryption, XTS mode. */
+    AgoraEncryptionModeAES256XTS = 2,
+    /** 128-bit AES encryption, ECB mode. */
+    AgoraEncryptionModeAES128ECB = 3,
+};
+
+/** Reason for the user being offline. */
+typedef NS_ENUM(NSUInteger, AgoraUserOfflineReason) {
+    /** The user left the current channel. */
+    AgoraUserOfflineReasonQuit = 0,
+    /** The SDK timed out and the user dropped offline because no data packet is received within a certain period of time. If a user quits the call and the message is not passed to the SDK (due to an unreliable channel), the SDK assumes the user dropped offline. */
+    AgoraUserOfflineReasonDropped = 1,
+    /** (Live broadcast only.) The client role switched from the host to the audience. */
+    AgoraUserOfflineReasonBecomeAudience = 2,
+};
+
+/** State of importing an external video stream in a live broadcast. */
+typedef NS_ENUM(NSUInteger, AgoraInjectStreamStatus) {
+    /** The external video stream imported successfully. */
+    AgoraInjectStreamStatusStartSuccess = 0,
+    /** The external video stream already exists. */
+    AgoraInjectStreamStatusStartAlreadyExists = 1,
+    /** The external video stream import is unauthorized. */
+    AgoraInjectStreamStatusStartUnauthorized = 2,
+    /** Import external video stream timeout. */
+    AgoraInjectStreamStatusStartTimedout = 3,
+    /** The external video stream failed to import. */
+    AgoraInjectStreamStatusStartFailed = 4,
+    /** The external video stream imports successfully. */
+    AgoraInjectStreamStatusStopSuccess = 5,
+    /** No external video stream is found. */
+    AgoraInjectStreamStatusStopNotFound = 6,
+    /** The external video stream is stopped from being unauthorized. */
+    AgoraInjectStreamStatusStopUnauthorized = 7,
+    /** Importing the external video stream timeout. */
+    AgoraInjectStreamStatusStopTimedout = 8,
+    /** Importing the external video stream failed. */
+    AgoraInjectStreamStatusStopFailed = 9,
+    /** The external video stream import is interrupted. */
+    AgoraInjectStreamStatusBroken = 10,
+};
+
+/** Output log filter level. */
+typedef NS_ENUM(NSUInteger, AgoraLogFilter) {
+    /** Do not output any log information. */
+    AgoraLogFilterOff = 0,
+    /** Output all log information. */
+    AgoraLogFilterDebug = 0x080f,
+    /** Output CRITICAL, ERROR, WARNING, and INFO level log information. */
+    AgoraLogFilterInfo = 0x000f,
+    /** Outputs CRITICAL, ERROR, and WARNING level log information. */
+    AgoraLogFilterWarning = 0x000e,
+    /** Outputs CRITICAL and ERROR level log information. */
+    AgoraLogFilterError = 0x000c,
+    /** Outputs CRITICAL level log information. */
+    AgoraLogFilterCritical = 0x0008,
+};
+
+/** Audio recording quality. */
+typedef NS_ENUM(NSInteger, AgoraAudioRecordingQuality) {
+   /** Low quality: The file size is around 1.2 MB after 10 minutes of recording. */
+    AgoraAudioRecordingQualityLow = 0,
+    /** Medium quality: The file size is around 2 MB after 10 minutes of recording. */
+    AgoraAudioRecordingQualityMedium = 1,
+    /** High quality: The file size is around 3.75 MB after 10 minutes of recording. */
+    AgoraAudioRecordingQualityHigh = 2
+};
+
+/** Lifecycle of the CDN live video stream.
+
+**DEPRECATED**
+*/
+typedef NS_ENUM(NSInteger, AgoraRtmpStreamLifeCycle) {
+    /** Bound to the channel lifecycle. If all hosts leave the channel, the CDN live streaming stops after 30 seconds. */
+    AgoraRtmpStreamLifeCycleBindToChannel = 1,
+    /** Bound to the owner of the RTMP stream. If the owner leaves the channel, the CDN live streaming stops immediately. */
+    AgoraRtmpStreamLifeCycleBindToOwnner = 2,
+};
+
+/** Network quality. */
+typedef NS_ENUM(NSUInteger, AgoraNetworkQuality) {
+    /** The network quality is unknown. */
+    AgoraNetworkQualityUnknown = 0,
+    /**  The network quality is excellent. */
+    AgoraNetworkQualityExcellent = 1,
+    /** The network quality is quite good, but the bitrate may be slightly lower than excellent. */
+    AgoraNetworkQualityGood = 2,
+    /** Users can feel the communication slightly impaired. */
+    AgoraNetworkQualityPoor = 3,
+    /** Users can communicate only not very smoothly. */
+    AgoraNetworkQualityBad = 4,
+     /** The network quality is so bad that users can hardly communicate. */
+    AgoraNetworkQualityVBad = 5,
+     /** The network is disconnected and users cannot communicate at all. */
+    AgoraNetworkQualityDown = 6,
+};
+
+/** Video stream type. */
+typedef NS_ENUM(NSInteger, AgoraVideoStreamType) {
+    /** High-bitrate, high-resolution video stream. */
+    AgoraVideoStreamTypeHigh = 0,
+    /** Low-bitrate, low-resolution video stream. */
+    AgoraVideoStreamTypeLow = 1,
+};
+
+/** Video display mode. */
+typedef NS_ENUM(NSUInteger, AgoraVideoRenderMode) {
+    /** Hidden(1): Uniformly scale the video until it fills the visible boundaries (cropped). One dimension of the video may have clipped contents. */
+    AgoraVideoRenderModeHidden = 1,
+
+    /** Fit(2): Uniformly scale the video until one of its dimension fits the boundary (zoomed to fit). Areas that are not filled due to the disparity in the aspect ratio are filled with black. */
+    AgoraVideoRenderModeFit = 2,
+
+    /**
+     Adaptive(3)：This mode is deprecated.
+     */
+    AgoraVideoRenderModeAdaptive __deprecated_enum_msg("AgoraVideoRenderModeAdaptive is deprecated.") = 3,
+};
+
+/** Self-defined video codec profile. */
+typedef NS_ENUM(NSInteger, AgoraVideoCodecProfileType) {
+    /** 66: Baseline video codec profile. Generally used in video calls on mobile phones. */
+    AgoraVideoCodecProfileTypeBaseLine = 66,
+    /** 77: Main video codec profile. Generally used in mainstream electronics, such as MP4 players, portable video players, PSP, and iPads. */
+    AgoraVideoCodecProfileTypeMain = 77,
+    /** 100: (Default) High video codec profile. Generally used in high-resolution broadcasts or television. */
+    AgoraVideoCodecProfileTypeHigh = 100
+};
+
+/** Video mirror mode. */
+typedef NS_ENUM(NSUInteger, AgoraVideoMirrorMode) {
+    /** The SDK determines the default mirror mode. */
+    AgoraVideoMirrorModeAuto = 0,
+    /** Enables mirror mode. */
+    AgoraVideoMirrorModeEnabled = 1,
+    /** Disables mirror mode. */
+    AgoraVideoMirrorModeDisabled = 2,
+};
+
+/** Remote video state. */
+typedef NS_ENUM(NSUInteger, AgoraVideoRemoteState) {
+    /** The remote video stopped playing. */
+    AgoraVideoRemoteStateStopped = 0,
+    /** The remote video is playing. */
+    AgoraVideoRemoteStateRunning = 1,
+    /** The remote video is frozen. */
+    AgoraVideoRemoteStateFrozen = 2,
+};
+
+/** Stream fallback option. */
+typedef NS_ENUM(NSInteger, AgoraStreamFallbackOptions) {
+    /** No fallback behavior for the local/remote stream when the uplink/downlink network condition is unreliable. The quality of the stream is not guaranteed. */
+    AgoraStreamFallbackOptionDisabled = 0,
+    /** Under unreliable downlink network conditions, the remote stream falls back to the low-video stream (low resolution and low bitrate). You can only set this option in [setRemoteSubscribeFallbackOption]([AgoraRtcEngineKit setRemoteSubscribeFallbackOption:]). Nothing happens when you set this in [setLocalPublishFallbackOption]([AgoraRtcEngineKit setLocalPublishFallbackOption:]). */
+    AgoraStreamFallbackOptionVideoStreamLow = 1,
+    /**
+     <li> Under unreliable uplink network conditions, the published stream falls back audio only.
+     <li>> Under unreliable downlink network conditions, the remote stream first falls back to the low-video stream (low resolution and low bitrate); and then to an audio-only stream if the network condition deteriorates. */
+    AgoraStreamFallbackOptionAudioOnly = 2,
+};
+
+/** Audio sampling rate. */
+typedef NS_ENUM(NSInteger, AgoraAudioSampleRateType) {
+    /** 32 kHz. */
+    AgoraAudioSampleRateType32000 = 32000,
+    /** 44.1 kHz. */
+    AgoraAudioSampleRateType44100 = 44100,
+    /** 48 kHz. */
+    AgoraAudioSampleRateType48000 = 48000,
+};
+
+/** Audio profile. */
+typedef NS_ENUM(NSInteger, AgoraAudioProfile) {
+    /** Default audio profile. In the communication profile, the default value is 1; in the live-broadcast profile, the default value is 2. */
+    AgoraAudioProfileDefault = 0,
+    /** Sampling rate of 32 kHz, audio encoding, mono, and a bitrate of up to 18 Kbps. */
+    AgoraAudioProfileSpeechStandard = 1,
+    /** Sampling rate of 48 kHz, music encoding, mono, and a bitrate of up to 48 Kbps. */
+    AgoraAudioProfileMusicStandard = 2,
+    /** Sampling rate of 48 kHz, music encoding, stereo, and a bitrate of up to 56 Kbps. */
+    AgoraAudioProfileMusicStandardStereo = 3,
+    /** Sampling rate of 48 kHz, music encoding, mono, and a bitrate of up to 128 Kbps. */
+    AgoraAudioProfileMusicHighQuality = 4,
+    /** Sampling rate of 48 kHz, music encoding, stereo, and a bitrate of up to 192 Kbps. */
+    AgoraAudioProfileMusicHighQualityStereo = 5,
+};
+
+/** Audio scenario. */
+typedef NS_ENUM(NSInteger, AgoraAudioScenario) {
+    /** Default. */
+    AgoraAudioScenarioDefault = 0,
+    /** Entertainment scenario, supporting voice during gameplay. */
+    AgoraAudioScenarioChatRoomEntertainment = 1,
+    /** Education scenario, prioritizing fluency and stability. */
+    AgoraAudioScenarioEducation = 2,
+    /** Live gaming scenario, enabling the gaming audio effects in the speaker mode in a live broadcast scenario. Choose this scenario for high-fidelity music playback.*/
+    AgoraAudioScenarioGameStreaming = 3,
+    /** Showroom scenario, optimizing the audio quality with external professional equipment. */
+    AgoraAudioScenarioShowRoom = 4,
+    /** Gaming scenario. */
+    AgoraAudioScenarioChatRoomGaming = 5
+};
+
+/** Audio output routing. */
+typedef NS_ENUM(NSInteger, AgoraAudioOutputRouting) {
+    /** Default. */
+    AgoraAudioOutputRoutingDefault = -1,
+    /** Headset.*/
+    AgoraAudioOutputRoutingHeadset = 0,
+    /** Earpiece. */
+    AgoraAudioOutputRoutingEarpiece = 1,
+    /** Headset with no microphone. */
+    AgoraAudioOutputRoutingHeadsetNoMic = 2,
+    /** Speakerphone. */
+    AgoraAudioOutputRoutingSpeakerphone = 3,
+    /** Loudspeaker. */
+    AgoraAudioOutputRoutingLoudspeaker = 4,
+    /** Bluetooth headset. */
+    AgoraAudioOutputRoutingHeadsetBluetooth = 5
+};
+
+/** Use mode of the onRecordAudioFrame callback. */
+typedef NS_ENUM(NSInteger, AgoraAudioRawFrameOperationMode) {
+    /** Read-only mode: Users only read the AudioFrame data without modifying anything. For example, when users acquire data with the Agora SDK then push the RTMP streams. */
+    AgoraAudioRawFrameOperationModeReadOnly = 0,
+    /** Write-only mode: Users replace the AudioFrame data with their own data and pass them to the SDK for encoding. For example, when users acquire data. */
+    AgoraAudioRawFrameOperationModeWriteOnly = 1,
+    /** Read and write mode: Users read the data from AudioFrame, modify it, and then play it. For example, when users have their own sound-effect processing module and perform some voice pre-processing such as a voice change. */
+    AgoraAudioRawFrameOperationModeReadWrite = 2,
+};
+
+/** Audio equalization band frequency. */
+typedef NS_ENUM(NSInteger, AgoraAudioEqualizationBandFrequency) {
+    /** 31 Hz. */
+    AgoraAudioEqualizationBand31 = 0,
+    /** 62 Hz. */
+    AgoraAudioEqualizationBand62 = 1,
+    /** 125 Hz. */
+    AgoraAudioEqualizationBand125 = 2,
+    /** 250 Hz. */
+    AgoraAudioEqualizationBand250 = 3,
+    /** 500 Hz */
+    AgoraAudioEqualizationBand500 = 4,
+    /** 1 kHz. */
+    AgoraAudioEqualizationBand1K = 5,
+    /** 2 kHz. */
+    AgoraAudioEqualizationBand2K = 6,
+    /** 4 kHz. */
+    AgoraAudioEqualizationBand4K = 7,
+    /** 8 kHz. */
+    AgoraAudioEqualizationBand8K = 8,
+    /** 16 kHz. */
+    AgoraAudioEqualizationBand16K = 9,
+};
+
+/** Audio reverberation type. */
+typedef NS_ENUM(NSInteger, AgoraAudioReverbType) {
+    /** The level of the dry signal (dB). The value ranges between -20 and 10. */
+    AgoraAudioReverbDryLevel = 0,
+    /** The level of the early reflection signal (wet signal) in dB. The value ranges between -20 and 10. */
+    AgoraAudioReverbWetLevel = 1,
+    /** The room size of the reverberation. A larger room size means a stronger reverberation. The value ranges between 0 and 100. */
+    AgoraAudioReverbRoomSize = 2,
+    /** The length of the initial delay of the wet signal (ms). The value ranges between 0 and 200. */
+    AgoraAudioReverbWetDelay = 3,
+     /** The reverberation strength. The value ranges between 0 and 100. */
+    AgoraAudioReverbStrength = 4,
+};
+
+/** Audio session restriction. */
+typedef NS_OPTIONS(NSUInteger, AgoraAudioSessionOperationRestriction) {
+    /** No restriction, the SDK has full control of the audio session operations. */
+    AgoraAudioSessionOperationRestrictionNone              = 0,
+    /** The SDK does not change the audio session category. */
+    AgoraAudioSessionOperationRestrictionSetCategory       = 1,
+    /** The SDK does not change any setting of the audio session (category, mode, categoryOptions). */
+    AgoraAudioSessionOperationRestrictionConfigureSession  = 1 << 1,
+    /** The SDK keeps the audio session active when leaving a channel. */
+    AgoraAudioSessionOperationRestrictionDeactivateSession = 1 << 2,
+    /** The SDK does not configure the audio session anymore. */
+    AgoraAudioSessionOperationRestrictionAll               = 1 << 7
+};
+
+/** Media device type. */
+typedef NS_ENUM(NSInteger, AgoraMediaDeviceType) {
+    /** Unknown device. */
+    AgoraMediaDeviceTypeAudioUnknown = -1,
+    /** Audio recording device. */
+    AgoraMediaDeviceTypeAudioRecording = 0,
+    /** Audio playback device. */
+    AgoraMediaDeviceTypeAudioPlayout = 1,
+    /** Video render device. */
+    AgoraMediaDeviceTypeVideoRender = 2,
+    /** Video capture device. */
+    AgoraMediaDeviceTypeVideoCapture = 3,
+};
+
+/** Connection states. */
+typedef NS_ENUM(NSInteger, AgoraConnectionStateType) {
+    /** <p>1: The SDK is disconnected from Agora's edge server.</p>
+    <ul>
+        <li>This is the initial state before calling the [joinChannelByToken]([AgoraRtcEngineKit joinChannelByToken:channelId:info:uid:joinSuccess:]) method.</li>
+        <li>The SDK also enters this state when the app calls the [leaveChannel]([AgoraRtcEngineKit leaveChannel:]) method.</li>
+    </ul>  
+    */
+    AgoraConnectionStateDisconnected = 1,
+    /** <p>2: The SDK is connecting to Agora's edge server.</p>
+    <ul>
+        <li>When the app calls the [joinChannelByToken]([AgoraRtcEngineKit joinChannelByToken:channelId:info:uid:joinSuccess:]) method, the SDK starts to establish a connection to the specified channel, triggers the [connectionChangedToState]([AgoraRtcEngineDelegate rtcEngine:connectionChangedToState:reason:]) callback, and switches to the `AgoraConnectionStateConnecting` state.</li>
+        <li>When the SDK successfully joins the channel, the SDK triggers the [connectionChangedToState]([AgoraRtcEngineDelegate rtcEngine:connectionChangedToState:reason:]) callback and switches to the `AgoraConnectionStateConnected` state.</li>
+        <li>After the SDK joins the channel and when it finishes initializing the media engine, the SDK triggers the [didJoinChannel]([AgoraRtcEngineDelegate rtcEngine:didJoinChannel:withUid:elapsed:]) callback.</li>
+    </ul>
+*/
+    AgoraConnectionStateConnecting = 2,
+    /** <p>3: The SDK is connected to Agora's edge server and joins a channel. You can now publish or subscribe to a media stream in the channel.</p>   
+    <p>If the connection to the channel is lost because, for example, the network is down or switched, the SDK automatically tries to reconnect and triggers:</p>
+    <ul>
+        <li>The [rtcEngineConnectionDidInterrupted]([AgoraRtcEngineDelegate rtcEngineConnectionDidInterrupted:])(deprecated) callback.</li>
+        <li>The [connectionChangedToState]([AgoraRtcEngineDelegate rtcEngine:connectionChangedToState:reason:]) callback, and switches to the `AgoraConnectionStateReconnecting` state.</li>
+    </ul>
+    */
+    AgoraConnectionStateConnected = 3,
+    /** <p>4: The SDK keeps rejoining the channel after being disconnected from a joined channel because of network issues.</p>
+    <ul>
+        <li>If the SDK cannot rejoin the channel within 10 seconds after being disconnected from Agora's edge server, the SDK triggers the [rtcEngineConnectionDidLost]([AgoraRtcEngineDelegate rtcEngineConnectionDidLost:]) callback, stays in the `AgoraConnectionStateReconnecting` state, and keeps rejoining the channel.</li>
+        <li>If the SDK fails to rejoin the channel 20 minutes after being disconnected from Agora's edge server, the SDK triggers the [connectionChangedToState]([AgoraRtcEngineDelegate rtcEngine:connectionChangedToState:reason:]) callback, switches to the `AgoraConnectionStateFailed` state, and stops rejoining the channel.</li>
+    </ul>
+
+    */
+    AgoraConnectionStateReconnecting = 4,
+    /** <p>5: The SDK fails to connect to Agora's edge server or join the channel.</p>
+    <p>You must call the [leaveChannel]([AgoraRtcEngineKit leaveChannel:])method to leave this state, and call the [joinChannelByToken]([AgoraRtcEngineKit joinChannelByToken:channelId:info:uid:joinSuccess:]) method again to rejoin the channel.</p>
+    <p>If the SDK is banned from joining the channel by Agora's edge server (through the RESTful API), the SDK triggers the [rtcEngineConnectionDidBanned]([AgoraRtcEngineDelegate rtcEngineConnectionDidBanned:])(deprecated) and [connectionChangedToState]([AgoraRtcEngineDelegate rtcEngine:connectionChangedToState:reason:]) callbacks.</p>
+    */
+    AgoraConnectionStateFailed = 5,
+};
+
+/** Reason for the connection state change. */
+typedef NS_ENUM(NSUInteger, AgoraConnectionChangedReason) {
+    /** 0: The SDK is connecting to Agora's edge server. */
+    AgoraConnectionChangedConnecting = 0,
+    /** 1: The SDK has joined the channel successfully. */
+    AgoraConnectionChangedJoinSuccess = 1,
+    /** 2: The connection between the SDK and Agora's edge server is interrupted.  */
+    AgoraConnectionChangedInterrupted = 2,
+    /** 3: The connection between the SDK and Agora's edge server is banned by Agora's edge server. */
+    AgoraConnectionChangedBannedByServer = 3,
+    /** 4: The SDK fails to join the channel for more than 20 minutes and stops reconnecting to the channel. */
+    AgoraConnectionChangedJoinFailed = 4,
+    /** 5: The SDK has left the channel. */
+    AgoraConnectionChangedLeaveChannel = 5,
+};

ios/RCTAgora/libs/AgoraRtcEngineKit.framework/Headers/AgoraLiveKit.h

@@ -0,0 +1,243 @@
+//
+//  AgoraLiveKit.h
+//  AgoraLiveKit
+//
+//  Created by Junhao Wang
+//  Copyright (c) 2017 Agora. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+
+#import "AgoraLivePublisher.h"
+#import "AgoraLiveSubscriber.h"
+#import "AgoraRtcEngineKit.h"
+
+/** A class for enabling or disabling the video.
+ */
+__attribute__((visibility("default"))) @interface AgoraLiveChannelConfig: NSObject
+@property (assign, nonatomic) BOOL videoEnabled;
+
++(AgoraLiveChannelConfig *_Nonnull) defaultConfig;
+@end
+
+/** The base class for managing a live broadcast.
+
+ AgoraLiveKit manages the channel and all actions apart from publishing and subscribing.
+ */
+@class AgoraLiveKit;
+
+/** Protocol providing the AgoraLiveKit class with callbacks.
+ */
+@protocol AgoraLiveDelegate <NSObject>
+@optional
+
+
+/** A warning occurred during SDK runtime.
+
+ The application can ignore the warning, and the SDK tries to resume automatically.
+
+ @param kit         AgoraLiveKit
+ @param warningCode AgoraWarningCode
+ */
+- (void)liveKit:(AgoraLiveKit *_Nonnull)kit didOccurWarning:(AgoraWarningCode)warningCode;
+
+/** An error occurred during SDK runtime.
+
+ The SDK cannot resume a normal state, and the application needs to handle it.
+
+ @param kit       AgoraLiveKit
+ @param errorCode AgoraErrorCode
+ */
+- (void)liveKit:(AgoraLiveKit *_Nonnull)kit didOccurError:(AgoraErrorCode)errorCode;
+
+/** A user joined the channel.
+
+ @param kit     AgoraLiveKit
+ @param channel Channel name
+ @param uid     Local user ID
+ @param elapsed Time elapsed (ms) from calling [joinChannelByToken]([AgoraRtcEngineKit joinChannelByToken:channelId:info:uid:joinSuccess:]) until this callback is triggered.
+  */
+- (void)liveKit:(AgoraLiveKit *_Nonnull)kit didJoinChannel:(NSString *_Nonnull)channel withUid:(NSUInteger)uid elapsed:(NSInteger) elapsed;
+
+/** The statistics of the call when leaving a channel
+
+ @param kit    AgoraLiveKit
+ */
+- (void)liveKitDidLeaveChannel:(AgoraLiveKit *_Nonnull)kit;
+
+/** A user rejoined the channel
+
+ @param kit     AgoraLiveKit
+ @param channel Channel name.
+ @param uid     User ID.
+ @param elapsed Time elapsed (ms) from calling [joinChannelByToken]([AgoraRtcEngineKit joinChannelByToken:channelId:info:uid:joinSuccess:]) until this callback is triggered.
+ */
+- (void)liveKit:(AgoraLiveKit *_Nonnull)kit didRejoinChannel:(NSString *_Nonnull)channel withUid:(NSUInteger)uid elapsed:(NSInteger) elapsed;
+
+/** Generates a new Token.
+
+ When the Token is enabled, and the specified Token is invalid or has expired, this function will be called.
+ The app should generate a new Token and call renewToken to refresh the key.
+
+ Note: AgoraErrorCodeTokenExpired = -109 and AgoraErrorCodeInvalidToken = -110 are also reported through the [didOccurError](liveKit:didOccurError:) callback. Move the renew token logic into this callback.
+
+ @param kit AgoraLiveKit
+ */
+- (void)liveKitRequestToken:(AgoraLiveKit *_Nonnull)kit;
+
+/**
+ The Token will expire within 30 seconds.
+
+ If the Token you specified when calling [joinChannelByToken]([AgoraRtcEngineKit joinChannelByToken:channelId:info:uid:joinSuccess:]) expires, you will become offline. This callback is triggered 30 seconds before the Token expires to remind the app to renew the Token.
+
+ Upon receiving this callback, the user needs to generate a new Token on your server and call renewToken to pass the new Token on to the SDK.
+
+
+ @param kit AgoraLiveKit
+ @param token The Token that will expire in 30 seconds.
+ */
+- (void)liveKit:(AgoraLiveKit * _Nonnull)kit tokenPrivilegeWillExpire:(NSString * _Nonnull)token;
+
+// statistics
+
+/** The statistics of the RTC AgoraLiveKit status every two seconds.
+
+ @param kit    AgoraLiveKit
+ @param stats  Statistics of the RTC status, including the duration, sent bytes, and received bytes
+ */
+- (void)liveKit:(AgoraLiveKit *_Nonnull)kit reportLiveStats:(AgoraChannelStats *_Nonnull)stats;
+// network
+
+/** The connection between the SDK and the server has been interrupted.
+
+This callback is triggered when the SDK losses connection with the server.
+
+Once the connection is lost, the SDK attempts to reconnect until the
+   application calls [leaveChannel]([AgoraLiveKit leaveChannel]).
+
+ @param kit    AgoraLiveKit
+ */
+- (void)liveKitConnectionDidInterrupted:(AgoraLiveKit *_Nonnull)kit;
+
+/** The connection to the server is lost.
+
+ This event is reported after the connection to the server is interrupted and the reconnection time has exceeded (10 seconds by default).
+ The SDK tries to automatically reconnect with the server until the app calls [leaveChannel]([AgoraLiveKit leaveChannel]).
+
+@param kit    AgoraLiveKit
+ */
+- (void)liveKitConnectionDidLost:(AgoraLiveKit *_Nonnull)kit;
+
+/** The network quality of the local user.
+
+ @param kit     AgoraLiveKit
+ @param uid     User ID
+ @param txQuality Network transmission quality: AgoraNetworkQuality
+ @param rxQuality Network receiving quality: AgoraNetworkQuality
+ */
+- (void)liveKit:(AgoraLiveKit *_Nonnull)kit networkQuality:(NSUInteger)uid txQuality:(AgoraNetworkQuality)txQuality rxQuality:(AgoraNetworkQuality)rxQuality;
+@end
+
+/**
+ AgoraLiveKit is the base class for managing a live broadcast. AgoraLiveKit manages the channel and all actions apart from publishing and subscribing.
+ */
+__attribute__((visibility("default"))) @interface AgoraLiveKit : NSObject
+
+/**
+ Protocol providing the AgoraLiveKit class with callbacks.
+ */
+@property (weak, nonatomic) _Nullable id<AgoraLiveDelegate> delegate;
+
+/** Returns the version of the Agora SDK.
+
+@return string, SDK version
+*/
++ (NSString *_Nonnull)getSdkVersion;
+
+/** Returns the native handler of the SDK engine
+ */
+- (AgoraRtcEngineKit *_Nonnull)getRtcEngineKit;
+
+/** Initializes the AgoraLiveKit object.
+
+ @param appId The appId is issued to the application developers by Agora.
+
+ @return an object of AgoraLiveKit class
+ */
++ (instancetype _Nonnull)sharedLiveKitWithAppId:(NSString *_Nonnull)appId;
+
+
+/**
+ Destroys the engine instance.
+
+ This method releases all the resources used by the Agora SDK.  This is useful for applications occasionally making voice calls, to free up resources for other operations when not making calls.
+
+ Once the application has called destroy() to destroy the created RtcEngine instance,
+ no other methods in the SDK can be used and no callbacks occur.
+
+ To start communications again, initialize [sharedEngineWithappId](sharedEngineWithAppId:delegate:) to establish a new AgoraRtcEngineKit instance.
+
+ Note: This method is called synchronously. The result returns after the IRtcEngine
+ object resources are released. The app should not call this interface in the
+ callback generated by the SDK, otherwise the SDK must wait for the callback
+ to return before it can reclaim the related object resources, causing a deadlock.
+
+ */
++ (void)destroy;
+
+/** Core Methods */
+
+/**  Allows a user to join a channel.
+
+ This method creates an open UDP socket to the AgoraLiveKit cloud service to join a channel.
+ Users in the same channel can talk to each other using the same App ID. This method is asynchronous.
+
+
+ @param token A Token generated by the app through signature certification.
+ @param channelId Channel ID.  Joining a channel with the same channel ID means that users are joining the same room.
+ The channel ID supported scope: a-z, A-Z, 0-9, space, !#$%&()+-:;&le;.,>?@[]^_{|}~
+ @param channelConfig AgoraLiveChannelConfig
+ @param uid Optional: ID of each user in the channel that is unique. If it is set as 0, the SDK automatically assigns an ID, which can be found in the [didJoinChannel]([AgoraLiveDelegate liveKit:didJoinChannel:withUid:elapsed:]) delegate.
+
+ @return * 0: Success.
* <0: Failure.
+ */
+- (int)joinChannelByToken:(NSString *_Nullable)token
+               channelId:(NSString *_Nonnull)channelId
+            config:(AgoraLiveChannelConfig *_Nonnull)channelConfig
+               uid:(NSUInteger)uid;
+
+/**
+ Allows a user to leave a channel, such as hanging up or exiting a call.
+
+ @return * 0: Success.
* <0: Failure.
+ */
+- (int)leaveChannel;
+
+
+/** Updates the Token.
+
+ The key expires after a certain period of time once the Token scheme is enabled. When the [didOccurError]([AgoraLiveDelegate liveKit:didOccurError:]) callback reports the error ERR_TOKEN_EXPIRED(109), the application should retrieve a new key and then call this method to renew it. Failure to do so will result in the SDK disconnecting from the server.
+
+ @param token New Token.
+
+ @return * 0: Success.
* <0: Failure.
+ */
+- (int)renewToken:(NSString*_Nonnull)token;
+
+/** Starts the local video preview.
+
+ Before starting the preview, always call the setupLocalVideo:local: method to set up the preview window and configure its attributes and also call the enableVideo method to enable video. If before calling [joinChannelByToken](joinChannelByToken:channelId:info:uid:joinSuccess:) to join the channel, you have called startPreview to start the local video preview, then the local preview will be still in the started state after you called [leaveChannel]([AgoraLiveKit leaveChannel]) to exit the channel. You can call stopPreview to close the local preview.
+
+ @param mode Video display mode: AgoraVideoRenderMode
+ @return * 0: Success.
* <0: Failure.
+ */
+- (int)startPreview:(VIEW_CLASS *_Nonnull)view
+         renderMode:(AgoraVideoRenderMode)mode;
+
+/** Stops the local video preview.
+
+ @return * 0: Success.
* <0: Failure.
+ */
+- (int)stopPreview;
+
+@end

ios/RCTAgora/libs/AgoraRtcEngineKit.framework/Headers/AgoraLivePublisher.h

@@ -0,0 +1,181 @@
+//
+//  AgoraLivePublisher.h
+//  AgoraLiveKit
+//
+//  Created by Sting Feng on 2015-8-11.
+//  Copyright (c) 2015 Agora. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+#import "AgoraObjects.h"
+
+/** The base class for managing a live broadcast.  AgoraLiveKit manages the channel and all actions apart from publishing and subscribing.
+ */
+@class AgoraLiveKit;
+
+/** A class for managing the actions related to live publishing.
+ */
+@class AgoraLivePublisher;
+
+/** Protocol providing the AgoraLivePublisher class with callbacks.
+ */
+@protocol AgoraLivePublisherDelegate <NSObject>
+@optional
+
+/**
+ A stream was published.
+
+ @param publisher AgoraRtcEngineKit object.
+ @param url Address to which the publisher publishes the stream.
+ @param error AgoraErrorCode
+ */
+-(void)publisher:(AgoraLivePublisher *_Nonnull)publisher streamPublishedWithUrl:(NSString *_Nonnull)url error:(AgoraErrorCode)error;
+
+/**
+ A stream was unpublished.
+
+ @param publisher AgoraRtcEngineKit object.
+ @param url Address to which the publisher unpublishes the stream.
+ */
+-(void)publisher:(AgoraLivePublisher *_Nonnull)publisher streamUnpublishedWithUrl:(NSString *_Nonnull)url;
+
+/**
+ The publisher transcoding was updated.
+
+ @param publisher AgoraRtcEngineKit object
+ */
+-(void)publisherTranscodingUpdated: (AgoraLivePublisher *_Nonnull)publisher;
+
+/**
+ The state of the imported external video stream.
+
+ @param publisher AgoraRtcEngineKit object.
+ @param url URL address of the imported external video stream added to the live broadcast.
+ @param uid User ID.
+ @param status State of the externally injected video stream: AgoraInjectStreamStatus.
+ */
+-(void)publisher:(AgoraLivePublisher *_Nonnull)publisher streamInjectedStatusOfUrl:(NSString *_Nonnull)url uid:(NSUInteger)uid status:(AgoraInjectStreamStatus)status;
+@end
+
+
+/**
+ The AgoraLivePublisher class manages all actions related to live broadcast publishing.
+
+ */
+__attribute__((visibility("default"))) @interface AgoraLivePublisher: NSObject
+
+/**
+ Sets the delegate.
+
+ @param delegate AgoraLivePublisherDelegate
+ */
+-(void)setDelegate:(_Nullable id<AgoraLivePublisherDelegate>)delegate;
+
+/**
+ Initializes the publisher.
+
+ @param kit AgoraLiveKit
+ @return AgoraLivePublisher object
+ */
+-(instancetype _Nonnull)initWithLiveKit:(AgoraLiveKit *_Nonnull)kit;
+
+/**  Sets the video encoding profile manually.
+
+ @param resolution Resolution of the video. The highest value is 1280 &times; 720.
+ @param frameRate Frame rate of the video. The highest value is 30. You can set it to 5, 10, 15, 24, 30, and so on.
+ @param bitrate Bitrate of the video. You need to manually work out the frame rate according to the width, height, and frame rate. With the same width and height, the bitrate varies with the change of the frame rate:
+
+* If the frame rate is 5 fps, divide the recommended bitrate by 2.
+* If the frame rate is 15 fps, use the recommended bitrate.
+* If the frame rate is 30 fps, multiply the recommended bitrate by 1.5.
+* Calculate your bitrate with the ratio if you choose other frame rates.
+
+ If the bitrate you set is beyond the proper range, the SDK will automatically adjust it to a value within the range.
+ */
+- (void)setVideoResolution:(CGSize)resolution andFrameRate:(NSInteger)frameRate bitrate:(NSInteger)bitrate;
+
+/**
+Sets live transcoding.
+
+ This method is used for CDN live. It sets the video layout and audio for CDN live.
+
+ @param transcoding AgoraLiveTranscoding object.
+ */
+-(void)setLiveTranscoding:(AgoraLiveTranscoding *_Nullable)transcoding;
+
+
+/**
+ Adds a watermark to the local video stream.
+
+ This method adds a watermark in the PNG file format onto the local video stream for the recording device and the audience in the channel and CDN live to see or capture it.
+ To add the PNG file onto a CDN live publishing stream only, see [setLiveTranscoding](setLiveTranscoding:).
+
+
+ @param watermark AgoraImage
+ @return Name of the watermark image.
+ */
+-(int)addVideoWatermark:(AgoraImage * _Nonnull)watermark  NS_SWIFT_NAME(addVideoWatermark(_:));
+
+/**
+Removes the watermark from the video stream.
+ */
+-(void)clearVideoWatermarks;
+
+/** Sets the media type.
+
+ @param mediaType AgoraMediaType
+ */
+-(void)setMediaType:(AgoraMediaType)mediaType;
+
+/** Adds a stream URL.
+
+ This method is used for CDN live. It adds the URL to which the host publishes the stream.
+ Note: This method only adds one URL each time it is called.
+
+ @param url URL to which the host publishes the stream.
+ @param transcodingEnabled * YES: Enable transcoding.
+ * NO: Disable transcoding.
+
+ */
+-(void)addStreamUrl:(NSString *_Nullable)url transcodingEnabled:(BOOL)transcodingEnabled;
+
+/** Removes a stream URL.
+
+ This method is used for CDN live. It removes the URL to which the host publishes the stream.
+ Note: This method only removes one URL each time it is called.
+
+ @param url URL to which the host publishes the stream.
+ */
+-(void)removeStreamUrl:(NSString *_Nullable)url;
+
+/** Publishes a stream.
+ */
+-(void)publish;
+
+/** Stops stream publishing.
+ */
+-(void)unpublish;
+
+#if TARGET_OS_IPHONE
+/**
+ Switches between front and rear cameras.
+ */
+-(void)switchCamera;
+#endif
+
+/**
+Adds a URL address of the added stream into the live broadcast channel.
+
+ @param url URL address to add to the ongoing live broadcast. Valid protocols are RTMP, HLS, and FLV live streaming protocols and the MP3/MP4 streams.
+ @param config AgoraLiveInjectStreamConfig
+ */
+- (void)addInjectStreamUrl:(NSString *_Nonnull)url config:(AgoraLiveInjectStreamConfig * _Nonnull)config;
+
+/**
+ Removes the URL from the live broadcast.
+
+ @param url URL address of the added stream to remove.
+ */
+- (void)removeInjectStreamUrl:(NSString *_Nonnull)url;
+
+@end

ios/RCTAgora/libs/AgoraRtcEngineKit.framework/Headers/AgoraLiveSubscriber.h

@@ -0,0 +1,121 @@
+//
+//  AgoraLiveSubscriber.h
+//  AgoraLiveKit
+//
+//  Created by Sting Feng on 2015-8-11.
+//  Copyright (c) 2015 Agora. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+#import "AgoraObjects.h"
+
+/** The base class for managing a live broadcast.  AgoraLiveKit manages the channel and all actions apart from publishing and subscribing.
+ */
+@class AgoraLiveKit;
+
+/** A class for managing actions related to live subscribing.
+ */
+@class AgoraLiveSubscriber;
+
+/** Protocol providing the AgoraLiveSubscriber class with callbacks.
+ */
+@protocol AgoraLiveSubscriberDelegate <NSObject>
+@optional
+
+// Subscriber
+
+/**
+ A stream was published by a specified host.
+
+ @param subscriber AgoraLiveSubscriber
+ @param uid User ID of the host
+ @param type Stream type: AgoraMediaType
+ */
+- (void)subscriber: (AgoraLiveSubscriber *_Nonnull)subscriber publishedByHostUid:(NSUInteger)uid streamType:(AgoraMediaType) type;
+
+/**
+ The stream type was changed by a specified host.
+
+ @param subscriber AgoraLiveSubscriber
+ @param type AgoraMediaType
+ @param uid User ID of the host
+ */
+- (void)subscriber: (AgoraLiveSubscriber *_Nonnull)subscriber streamTypeChangedTo:(AgoraMediaType) type byHostUid:(NSUInteger)uid;
+
+// Unmute, offline
+
+/**
+ A stream was unpublished by a specified host.
+
+ @param subscriber AgoraLiveSubscriber
+ @param uid User ID of the host
+ */
+- (void)subscriber: (AgoraLiveSubscriber *_Nonnull)subscriber unpublishedByHostUid:(NSUInteger)uid;
+
+// Video
+/** The first frame of the specified remote user was displayed successfully.
+ *
+ *  @param subscriber     Live subscriber.
+ *  @param uid     Remote user id.
+ *  @param size    Size of video stream.
+ *  @param elapsed Time elapsed (ms) from the beginning of the session.
+ */
+- (void)subscriber:(AgoraLiveSubscriber *_Nonnull)subscriber firstRemoteVideoDecodedOfHostUid:(NSUInteger)uid size:(CGSize)size elapsed:(NSInteger)elapsed;
+
+/**
+ *  The video size and rotational change of the specified user.
+ *
+ *  @param subscriber     Live subscriber
+ *  @param uid     User ID
+ *  @param size    New video size
+ *  @param rotation  New video rotation
+ */
+- (void)subscriber:(AgoraLiveSubscriber *_Nonnull)subscriber videoSizeChangedOfHostUid:(NSUInteger)uid size:(CGSize)size rotation:(NSInteger)rotation;
+@end
+
+
+/**
+ The AgoraLiveSubscriber class manages all actions related to live broadcast subscribing.
+
+ */
+__attribute__((visibility("default"))) @interface AgoraLiveSubscriber: NSObject // AgoraLiveSubscriber
+
+/**
+ Initializes an AgoraLiveSubscriber object.
+
+ @param kit AgoraLiveKit
+ @return AgoraLiveSubscriber object.
+ */
+-(instancetype _Nonnull)initWithLiveKit:(AgoraLiveKit * _Nonnull)kit;
+
+
+/**
+ Sets the delegate.
+
+ @param delegate AgoraLiveSubscriberDelegate
+ */
+-(void)setDelegate:(_Nullable id<AgoraLiveSubscriberDelegate>)delegate;
+
+/**
+ Subscribes to a host.
+
+ @param uid User ID of the host
+ @param mediaType Media type: AgoraMediaType
+ @param view View to render
+ @param mode Video display mode: AgoraVideoRenderMode
+ @param videoType AgoraVideoStreamType
+ */
+- (void)subscribeToHostUid:(NSUInteger)uid
+             mediaType:(AgoraMediaType)mediaType
+                  view:(VIEW_CLASS *_Nullable)view
+            renderMode:(AgoraVideoRenderMode)mode
+             videoType:(AgoraVideoStreamType)videoType;
+
+/**
+ Unsubscribes from a host.
+
+ @param uid User ID of the host
+ */
+-(void)unsubscribeToHostUid:(NSUInteger)uid;
+
+@end

ios/RCTAgora/libs/AgoraRtcEngineKit.framework/Headers/AgoraMediaIO.h

@@ -0,0 +1,281 @@
+//
+//  AgoraMediaIO.h
+//  AgoraRtcEngineKit
+//
+//  Copyright (c) 2018 Agora. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+#import <AVFoundation/AVFoundation.h>
+#import "AgoraEnumerates.h"
+#import "AgoraObjects.h"
+
+
+/** Video pixel format.
+
+ This enumeration defines the pixel format of the video frame. Agora supports three pixel formats on iOS: I420, BGRA, and NV12. For information on the YVU format, see:
+
+   * [FourCC YUV Pixel Formats](http://www.fourcc.org/yuv.php)
+   * [Recommended 8-Bit YUV Formats for Video Rendering](https://docs.microsoft.com/zh-cn/windows/desktop/medfound/recommended-8-bit-yuv-formats-for-video-rendering)
+ */
+typedef NS_ENUM(NSUInteger, AgoraVideoPixelFormat) {
+    /** I420 */
+    AgoraVideoPixelFormatI420   = 1,
+    /** BGRA */
+    AgoraVideoPixelFormatBGRA   = 2,
+    /** NV12 */
+    AgoraVideoPixelFormatNV12   = 8,
+};
+
+/** Video rotation.
+
+ This enumeration defines the rotating angle of the video. Agora supports rotating clockwise by 0, 90, 180, and 270 degrees.
+ */
+typedef NS_ENUM(NSInteger, AgoraVideoRotation) {
+    /** No rotation */
+    AgoraVideoRotationNone      = 0,
+    /** 90 degrees */
+    AgoraVideoRotation90        = 1,
+    /** 180 degrees */
+    AgoraVideoRotation180       = 2,
+    /** 270 degrees */
+    AgoraVideoRotation270       = 3,
+};
+
+/** Video buffer type */
+typedef NS_ENUM(NSInteger, AgoraVideoBufferType) {
+   /** Use a pixel buffer to transmit the video data. */
+    AgoraVideoBufferTypePixelBuffer = 1,
+    /** Use raw data to transmit the video data. */
+    AgoraVideoBufferTypeRawData     = 2,
+};
+
+/** An object supporting video data in two formats; pixel buffer and raw data.
+
+ When the video source is initialized, the media engine passes this object to the developer and the developer needs to reserve it, and then pass the video frame to the media engine through this object once the video source is initialized.
+ Call [bufferType]([AgoraVideoSinkProtocol bufferType]) to specify a buffer type. The video data can only be transmitted in the corresponding type.
+ */
+@protocol AgoraVideoFrameConsumer <NSObject>
+
+/** Uses the video information in the pixel buffer.
+
+ @param pixelBuffer Buffer type
+ @param timestamp   Time stamp (ms) of the video frame. For each video frame, developers need to set a timestamp.
+ @param rotation    AgoraVideoRotation
+ */
+- (void)consumePixelBuffer:(CVPixelBufferRef _Nonnull)pixelBuffer
+             withTimestamp:(CMTime)timestamp
+                  rotation:(AgoraVideoRotation)rotation;
+
+/** Uses the video information in the raw data.
+
+ @param rawData   Raw data of the video frame.
+ @param timestamp Time stamp (ms) of the video frame.
+ @param format    AgoraVideoPixelFormat
+ @param size      Size of the raw video data.
+ @param rotation  AgoraVideoRotation
+ */
+- (void)consumeRawData:(void * _Nonnull)rawData
+         withTimestamp:(CMTime)timestamp
+                format:(AgoraVideoPixelFormat)format
+                  size:(CGSize)size
+              rotation:(AgoraVideoRotation)rotation;
+@end
+
+/** Defines a set of protocols to implement the custom video source and pass it to the underlying media engine to replace the default video source.
+
+ AgoraVideoSourceProtocol allows you to take the ownership of the video source and manipulate it.
+ By default, when enabling real-time communications, the Agora SDK enables the default video input device (built-in camera) to start video streaming.
+ By calling [setVideoSource]([AgoraRtcEngineKit setVideoSource:]), you can change the default video input device, control it, and send the video source from the specified input device to the Agora Media Engine to handle the remaining video process; such as video filtering and publishing the video to the RTC connection.
+ Once you have implemented this interface, the Agora Media Engine automatically releases the ownership of the current video input device and passes the ownership to you, so that you can use the same video input device to capture the video stream.
+ AgoraVideoSourceProtocol consists of the following methods:
+
+ * Initializes the Video Source ([shouldInitialize](shouldInitialize))
+ * Enables the Video Source ([shouldStart](shouldStart))
+ * Disables the Video Source ([shouldStop](shouldStop))
+ * Releases the Video Source ([shouldDispose](shouldDispose))
+ * Retrieves the Buffer Type ([bufferType](bufferType))
+
+ Note:
+
+ * All methods in the [AgoraVideoSourceProtocol]([AgoraVideoSourceProtocol]) are callbacks. The media engine maintains a finite state machine and uses these functions at the right time. Do not use these functions directly in the app.
+ * These functions are synchronized.
+ * If the media engine restarts during the process, these functions can be repeated for a couple of times.
+ * These functions are not in the primary thread.
+
+ When using the AgoraVideoSourceProtocol, call AgoraVideoBufferType, AgoraVideoPixelFormat, and AgoraVideoRotation to set the buffer type, pixel format, and rotation angle of the transmitted video.
+ */
+@protocol AgoraVideoSourceProtocol <NSObject>
+@required
+/** See AgoraVideoFrameConsumer */
+@property (strong) id<AgoraVideoFrameConsumer> _Nullable consumer;
+/** Initializes the video source.
+
+ The media engine calls this method to initialize the video source. You can also initialize the video source before this method is called and return YES to the media engine in this method. You need to pass YES or NO in this method to tell the media engine if the video source is initialized.
+ When the video source is initialized, the media engine initializes the AgoraVideoFrameConsumer pointer in AgoraVideoSourceProtocol, then the video source sends the video frame to the media engine through the AgoraVideoFrameConsumer method.
+
+ @return * YES: If the external video source is initialized.
+ * NO: If the external video source is not ready or fails to initialize, the media engine stops and reports the error.
+ */
+- (BOOL)shouldInitialize;
+
+/** Enables the video source.
+
+ Call this method when the media engine is ready to start video streaming. You should start the video source to capture the video frame. Once the frame is ready, use the AgoraVideoFrameConsumer to consume the video frame.
+ Pass one of the following return values to the media engine:
+
+ * YES: If the external video source is enabled and AgoraVideoFrameConsumer is called to receive video frames.
+ * NO: If the external video source is not ready or fails to enable, the media engine stops and reports the error.
+
+ After YES is returned, video frames can be passed to the media engine through the preset AgoraVideoFrameConsumer interface method.
+ */
+- (void)shouldStart;
+
+/** Disables the video source.
+
+ Call this method when the media engine stops streaming. You should then stop capturing the video frame and consuming it. After this method is called, the video frames are discarded by the media engine.
+ */
+- (void)shouldStop;
+
+/** Releases the video source.
+
+Call this method when AgoraVideoFrameConsumer is released by the media engine. You can now release the video source as well as AgoraVideoFrameConsumer.
+ */
+- (void)shouldDispose;
+
+/** Retrieves the buffer type.
+
+ Passes the buffer type previously set in [AgoraVideoBufferType]([AgoraVideoBufferType]) to the media engine. This buffer type is used to set up the correct media engine environment.
+
+ @return return AgoraVideoBufferType
+ */
+- (AgoraVideoBufferType)bufferType;
+@end
+
+/** Defines a set of protocols to implement the custom video sink and pass it to the underlying media engine to replace the default video sink.
+
+ AgoraVideoSinkProtocol allows you to implement the custom video source.
+ By default, when you try to enable real-time communications, the Agora SDK enables the default video sink to start video rendering. By calling [setLocalVideoRenderer]([AgoraRtcEngineKit setLocalVideoRenderer:]) and [setRemoteVideoRenderer]([AgoraRtcEngineKit setRemoteVideoRenderer:forUserId:]), you can change the default video sink.
+ Once you have implemented this interface, you will receive callbacks from the media engine to indicate the state of the custom video sink, the underlying media engine, and enable their synchronization. Follow each callback to handle the resource allocation, and to release and receive the video frame from the media engine.
+ The AgoraVideoSinkProtocol defines a set of protocols to create a customized video sink. The AgoraVideoFrameConsumer interface passes the video frames to the media engine, which then passes them to the renderer.
+ After a customized video sink is created, the app passes it to the media engine, see [setLocalVideoRenderer]([AgoraRtcEngineKit setLocalVideoRenderer:]) and [setRemoteVideoRenderer]([AgoraRtcEngineKit setRemoteVideoRenderer:forUserId:]).
+ AgoraVideoSinkProtocol consists of the following callbacks:
+
+ * Initializes the Video Sink ([shouldInitialize](shouldInitialize))
+ * Enables the Video Sink ([shouldStart](shouldStart))
+ * Disables the Video Sink ([shouldStop](shouldStop))
+ * Releases the Video Sink ([shouldDispose](shouldDispose))
+ * Retrieves the Buffer Type ([bufferType](bufferType))
+ * Retrieves the Pixel Format ([pixelFormat](pixelFormat))
+ * (Optional) Outputs the Video in the Pixel Buffer ([renderPixelBuffer](renderPixelBuffer:rotation:))
+ * (Optional) Outputs the Video in the Raw Data ([renderRawData](renderRawData:size:rotation:))
+
+ Note: All methods defined in AgoraVideoSinkProtocol are callbacks. The media engine uses these functions to inform the customized renderer of its internal changes.
+ An example is shown in the following steps to customize the video sink:
+
+ 1. Call bufferType and AgoraVideoPixelFormat to set the buffer type and pixel format of the video frame.
+ 2. Implement [shouldInitialize](shouldInitialize), [shouldStart](shouldStart), [shouldStop](shouldStop), and [shouldDispose](shouldDispose) to manage the customized video sink.
+ 3. Implement the buffer type and pixel format as specified in AgoraVideoFrameConsumer.
+ 4. Create the customized video sink object.
+ 5. Call the [setLocalVideoRenderer]([AgoraRtcEngineKit setLocalVideoRenderer:]) and [setRemoteVideoRenderer]([AgoraRtcEngineKit setRemoteVideoRenderer:forUserId:]) methods to set the local and remote renderers.
+ 6. The media engine calls functions in AgoraVideoSinkProtocol according to its internal state.
+ */
+@protocol AgoraVideoSinkProtocol <NSObject>
+@required
+/** Initializes the video  sink.
+
+ You can also initialize the video sink before this method is called and return YES in this method.
+
+ @return * YES: If the video sink is initialized.
+ * NO: If the video sink is not ready or fails to initialize, the media engine stops and reports the error.
+ */
+- (BOOL)shouldInitialize;
+
+/** Enables the video sink.
+
+ Call this method when the media engine starts streaming.
+
+ * YES: If the video sink is ready. The media engine provides the video frame to the custom video sink by calling the AgoraVideoFrameConsumer interface.
+ * NO: If the video sink is not ready.
+ */
+- (void)shouldStart;
+
+/** Disables the video sink.
+
+ Call this method when the media engine stops video streaming. You should then stop the video sink.
+ */
+- (void)shouldStop;
+
+/** Releases the video sink.
+
+ Call this method when the media engine wants to release the video sink resources.
+ */
+- (void)shouldDispose;
+
+/** Retrieves the buffer type and passes the buffer type specified in [AgoraVideoBufferType]([AgoraVideoBufferType]) to the media engine.
+
+ @return bufferType AgoraVideoBufferType
+ */
+- (AgoraVideoBufferType)bufferType;
+
+/** Retrieves the pixel format and passes it to the media engine.
+
+ @return pixelFormat AgoraVideoPixelFormat
+ */
+- (AgoraVideoPixelFormat)pixelFormat;
+
+@optional
+/** (Optional) Outputs the video in the pixel buffer.
+
+ @param pixelBuffer Video in the pixel buffer.
+ @param rotation    Clockwise rotating angle of the video frame. See AgoraVideoRotation.
+ */
+- (void)renderPixelBuffer:(CVPixelBufferRef _Nonnull)pixelBuffer
+                 rotation:(AgoraVideoRotation)rotation;
+
+/** (Optional) Outputs the video in the raw data.
+
+ @param rawData  Raw video data.
+ @param size     Size of the raw video.
+ @param rotation Clockwise rotating angle of the video frame. See AgoraVideoRotation.
+ */
+- (void)renderRawData:(void * _Nonnull)rawData
+                 size:(CGSize)size
+             rotation:(AgoraVideoRotation)rotation;
+@end
+
+
+#pragma mark - Agora Default Media IO
+/** Default camera position */
+typedef NS_ENUM(NSInteger, AgoraRtcDefaultCameraPosition) {
+    /** Front camera */
+    AgoraRtcDefaultCameraPositionFront = 0,
+    /** Rear camera */
+    AgoraRtcDefaultCameraPositionBack = 1,
+};
+
+__attribute__((visibility("default"))) @interface AgoraRtcDefaultCamera: NSObject<AgoraVideoSourceProtocol>
+#if TARGET_OS_IPHONE
+@property (nonatomic, assign) AgoraRtcDefaultCameraPosition position;
+- (instancetype _Nonnull)initWithPosition:(AgoraRtcDefaultCameraPosition)position;
+#endif
+@end
+
+#if (!(TARGET_OS_IPHONE) && (TARGET_OS_MAC))
+__attribute__((visibility("default"))) @interface AgoraRtcScreenCapture: NSObject<AgoraVideoSourceProtocol>
+@property (nonatomic, readonly) NSUInteger windowId;
++ (instancetype _Nonnull)fullScreenCaptureWithFrequency:(NSInteger)captureFrequency
+                                                bitRate:(NSInteger)bitRate;
++ (instancetype _Nonnull)windowCaptureWithId:(CGWindowID)windowId
+                            captureFrequency:(NSInteger)captureFrequency
+                                     bitRate:(NSInteger)bitRate
+                                        rect:(CGRect)rect;
+@end
+#endif
+
+__attribute__((visibility("default"))) @interface AgoraRtcDefaultRenderer: NSObject<AgoraVideoSinkProtocol>
+@property (nonatomic, strong, readonly) VIEW_CLASS * _Nonnull view;
+@property (nonatomic, assign) AgoraVideoRenderMode mode;
+- (instancetype _Nonnull)initWithView:(VIEW_CLASS * _Nonnull)view
+                           renderMode:(AgoraVideoRenderMode)mode;
+@end

ios/RCTAgora/libs/AgoraRtcEngineKit.framework/Headers/AgoraObjects.h

@@ -0,0 +1,765 @@
+//
+//  AgoraObjects.h
+//  AgoraRtcEngineKit
+//
+//  Copyright (c) 2018 Agora. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+#import <CoreMedia/CoreMedia.h>
+#import "AgoraEnumerates.h"
+
+#if TARGET_OS_IPHONE
+#import <UIKit/UIKit.h>
+typedef UIView VIEW_CLASS;
+typedef UIColor COLOR_CLASS;
+#elif TARGET_OS_MAC
+#import <AppKit/AppKit.h>
+typedef NSView VIEW_CLASS;
+typedef NSColor COLOR_CLASS;
+#endif
+
+/** Properties of the video canvas object.
+ */
+__attribute__((visibility("default"))) @interface AgoraRtcVideoCanvas : NSObject
+/** The video display view.
+
+ VIEW_CLASS is a general name for this property. See the following definitions for iOS and macOS:
+
+ - iOS: UIView
+ - MacOS: NSView
+ */
+@property (strong, nonatomic) VIEW_CLASS* _Nullable view;
+/** Render mode of the view: AgoraVideoRenderMode
+ */
+@property (assign, nonatomic) AgoraVideoRenderMode renderMode;
+/** User ID of the view.
+ */
+@property (assign, nonatomic) NSUInteger uid;
+@end
+
+/** Statistics of the local video stream.
+ */
+__attribute__((visibility("default"))) @interface AgoraRtcLocalVideoStats : NSObject
+/** Data transmission bitrate (Kbps) since last count.
+ */
+@property (assign, nonatomic) NSUInteger sentBitrate;
+/** Data transmission frame rate (fps) since last count.
+ */
+@property (assign, nonatomic) NSUInteger sentFrameRate;
+@end
+
+/** Statistics of the remote video stream.
+ */
+__attribute__((visibility("default"))) @interface AgoraRtcRemoteVideoStats : NSObject
+/** User ID of the user sending the video streams.
+ */
+@property (assign, nonatomic) NSUInteger uid;
+/** Time delay (ms).
+ */
+@property (assign, nonatomic) NSUInteger __deprecated delay;
+/** Width (pixels) of the video stream.
+ */
+@property (assign, nonatomic) NSUInteger width;
+/** Height (pixels) of the video stream.
+ */
+@property (assign, nonatomic) NSUInteger height;
+/** Data receive bitrate (Kbps) since last count.
+ */
+@property (assign, nonatomic) NSUInteger receivedBitrate;
+/** Data receive frame rate (fps) since last count.
+ */
+@property (assign, nonatomic) NSUInteger receivedFrameRate;
+/** Video stream type (high-stream or low-stream).
+ */
+@property (assign, nonatomic) AgoraVideoStreamType rxStreamType;
+@end
+
+/** Statistics of the remote audio stream.
+ */
+__attribute__((visibility("default"))) @interface AgoraRtcRemoteAudioStats : NSObject
+/** User ID of the user sending the audio streams.
+ */
+@property (assign, nonatomic) NSUInteger uid;
+/** Audio quality received by the user.
+ */
+@property (assign, nonatomic) NSUInteger quality;
+/** Network delay from the sender to the receiver.
+ */
+@property (assign, nonatomic) NSUInteger networkTransportDelay;
+/** Jitter buffer delay at the receiver.
+ */
+@property (assign, nonatomic) NSUInteger jitterBufferDelay;
+/** Packet loss rate in the reported interval.
+ */
+@property (assign, nonatomic) NSUInteger audioLossRate;
+@end
+
+/** Properties of the audio volume information.
+
+An array containing the user ID and volume information for each speaker:
+
+- uid: User ID of the speaker. The uid of the local user is 0.
+- volume：Volume of the speaker. The value ranges between 0 (lowest volume) and 255 (highest volume).
+ */
+__attribute__((visibility("default"))) @interface AgoraRtcAudioVolumeInfo : NSObject
+/** User ID of the speaker.
+ */
+@property (assign, nonatomic) NSUInteger uid;
+/** The volume of the speaker. The value ranges between 0 (lowest volume) to 255 (highest volume).
+ */
+@property (assign, nonatomic) NSUInteger volume;
+@end
+
+/** Statistics of the channel
+ */
+__attribute__((visibility("default"))) @interface AgoraChannelStats: NSObject
+/** Call duration in seconds, represented by an aggregate value.
+ */
+@property (assign, nonatomic) NSInteger duration;
+/** Total number of bytes transmitted, represented by an aggregate value.
+ */
+@property (assign, nonatomic) NSInteger txBytes;
+/** Total number of bytes received, represented by an aggregate value.
+ */
+@property (assign, nonatomic) NSInteger rxBytes;
+/** Audio transmission bitrate (Kbps), represented by an instantaneous value.
+ */
+@property (assign, nonatomic) NSInteger txAudioKBitrate;
+/** Audio receive bitrate (Kbps), represented by an instantaneous value.
+ */
+@property (assign, nonatomic) NSInteger rxAudioKBitrate;
+/** Video transmission bitrate (Kbps), represented by an instantaneous value.
+ */
+@property (assign, nonatomic) NSInteger txVideoKBitrate;
+/** Video receive bitrate (Kbps), represented by an instantaneous value.
+ */
+@property (assign, nonatomic) NSInteger rxVideoKBitrate;
+/** Client-server latency (ms)
+ */
+@property (assign, nonatomic) NSInteger lastmileDelay;
+/** Number of users in the channel.
+
+- Communication profile: The number of users in the channel.
+- Live broadcast profile:
+
+  - If the local user is an audience: The number of hosts in the channel + 1.
+  - if the user is a host: The number of hosts in the channel.
+ */
+@property (assign, nonatomic) NSInteger userCount;
+/** Application CPU usage (%).
+ */
+@property (assign, nonatomic) double cpuAppUsage;
+/** System CPU usage (%).
+ */
+@property (assign, nonatomic) double cpuTotalUsage;
+@end
+
+/** Properties of the video encoder configuration.
+ */
+__attribute__((visibility("default"))) @interface AgoraVideoEncoderConfiguration: NSObject
+/** The video frame dimension used to specify the video quality in the total number of pixels along a frame's width and height.
+
+You can customize the dimension, or select from the following list:
+
+ - AgoraVideoDimension120x120
+ - AgoraVideoDimension160x120
+ - AgoraVideoDimension180x180
+ - AgoraVideoDimension240x180
+ - AgoraVideoDimension320x180
+ - AgoraVideoDimension240x240
+ - AgoraVideoDimension320x240
+ - AgoraVideoDimension424x240
+ - AgoraVideoDimension360x360
+ - AgoraVideoDimension480x360
+ - AgoraVideoDimension640x360
+ - AgoraVideoDimension480x480
+ - AgoraVideoDimension640x480
+ - AgoraVideoDimension840x480
+ - AgoraVideoDimension960x720
+ - AgoraVideoDimension1280x720
+
+ Note:
+
+ - The dimension does not specify the orientation mode of the output ratio. For how to set the video orientation, see [AgoraVideoOutputOrientationMode](AgoraVideoOutputOrientationMode).
+ - Whether 720p can be supported depends on the device. If the device cannot support 720p, the frame rate will be lower than the one listed in the table. Agora optimizes the video in lower-end devices.
+ - iPhone does not support video frame dimensions above 720p.
+ */
+@property (assign, nonatomic) CGSize dimensions;
+
+/** Frame rate of the video: AgoraVideoFrameRate
+
+  *  AgoraVideoFrameRateFps1(1): 1 fps
+  *  AgoraVideoFrameRateFps7(7): 7 fps
+  *  AgoraVideoFrameRateFps10(10): 10 fps
+  *  AgoraVideoFrameRateFps15(15): 15 fps
+  *  AgoraVideoFrameRateFps24(24): 24 fps
+  *  AgoraVideoFrameRateFps30(30): 30 fps
+  *  AgoraVideoFrameRateFps60(30): 60 fps (macOS only)
+ */
+@property (assign, nonatomic) AgoraVideoFrameRate frameRate;
+
+/** Bitrate of the video.
+
+ Sets the video bitrate (Kbps). Refer to the table below and set your bitrate. If the bitrate you set is beyond the proper range, the SDK automatically adjusts it to a value within the range. You can also choose from the following options:
+
+ - AgoraVideoBitrateStandard: (Recommended) The standard bitrate mode. In this mode, the bitrates differ between the live broadcast and communication profiles:
+
+     - Communication profile: The video bitrate is the same as the base bitrate.
+     - Live broadcast profile: The video bitrate is twice the base bitrate.
+
+ - AgoraVideoBitrateCompatible: The compatible bitrate mode. In this mode, the bitrate stays the same regardless of the profile. In a live broadcast profile, if you choose this mode, the video frame rate may be lower than the set value.
+
+Agora uses different video codecs for different profiles to optimize the user experience. For example, a communication profile prioritizes the smoothness while a live broadcast profile prioritizes the video quality (a higher bitrate). Therefore, Agora recommends setting this parameter as AgoraVideoBitrateStandard.
+
+**Video Bitrate Table**
+
+| Resolution        	| Frame Rate (fps) 	| Base Bitrate (Kbps, for Communication) 	| Live Bitrate (Kbps, for Live Broadcast) 	|
+|-------------------	|------------------	|----------------------------------------	|-----------------------------------------	|
+| 160 &times; 120   	| 15               	| 65                                     	| 130                                     	|
+| 120 &times; 120   	| 15               	| 50                                     	| 100                                     	|
+| 320 &times; 180   	| 15               	| 140                                    	| 280                                     	|
+| 180 &times; 180   	| 15               	| 100                                    	| 200                                     	|
+| 240 &times; 180   	| 15               	| 120                                    	| 240                                     	|
+| 320 &times; 240   	| 15               	| 200                                    	| 400                                     	|
+| 240 &times; 240   	| 15               	| 140                                    	| 280                                     	|
+| 424 &times; 240   	| 15               	| 220                                    	| 440                                     	|
+| 640 &times; 360   	| 15               	| 400                                    	| 800                                     	|
+| 360 &times; 360   	| 15               	| 260                                    	| 520                                     	|
+| 640 &times; 360   	| 30               	| 600                                    	| 1200                                    	|
+| 360 &times; 360   	| 30               	| 400                                    	| 800                                     	|
+| 480 &times; 360   	| 15               	| 320                                    	| 640                                     	|
+| 480 &times; 360   	| 30               	| 490                                    	| 980                                     	|
+| 640 &times; 480   	| 15               	| 500                                    	| 1000                                    	|
+| 480 &times; 480   	| 15               	| 400                                    	| 800                                     	|
+| 640 &times; 480   	| 30               	| 750                                    	| 1500                                    	|
+| 480 &times; 480   	| 30               	| 600                                    	| 1200                                    	|
+| 848 &times; 480   	| 15               	| 610                                    	| 1220                                    	|
+| 848 &times; 480   	| 30               	| 930                                    	| 1860                                    	|
+| 640 &times; 480   	| 10               	| 400                                    	| 800                                     	|
+| 1280 &times; 720  	| 15               	| 1130                                   	| 2260                                    	|
+| 1280 &times; 720  	| 30               	| 1710                                   	| 3420                                    	|
+| 960 &times; 720   	| 15               	| 910                                    	| 1820                                    	|
+| 960 &times; 720   	| 30               	| 1380                                   	| 2760                                    	|
+| 1920 &times; 1080 	| 15               	| 2080                                   	| 4160                                    	|
+| 1920 &times; 1080 	| 30               	| 3150                                   	| 6300                                    	|
+| 1920 &times; 1080 	| 60               	| 4780                                   	| 6500                                    	|
+| 2560 &times; 1440 	| 30               	| 4850                                   	| 6500                                    	|
+| 2560 &times; 1440 	| 60               	| 6500                                   	| 6500                                    	|
+| 3840 &times; 2160 	| 30               	| 6500                                   	| 6500                                    	|
+| 3840 &times; 2160 	| 60               	| 6500                                   	| 6500                                    	|
+
+
+**Note:**
+
+The base bitrate in this table applies to a communication profile. A live broadcast profile generally requires a higher bitrate for better video quality. Agora recommends setting the bitrate mode as AgoraVideoBitrateStandard. You can also set the bitrate as twice the base bitrate.
+
+
+*/
+@property (assign, nonatomic) NSInteger bitrate;
+
+/** The minimum encoding bitrate.
+
+Sets the minimum encoding bitrate, in Kbps.
+
+The Agora SDK automatically adjusts the encoding bitrate to adapt to the network conditions. Using a value greater than the default value forces the video encoder to output high-quality images but may cause more packet loss and hence sacrifice the smoothness of the video transmission. Unless you have special requirements for image quality, Agora does not recommend changing this value.
+
+**Note:**
+
+This parameter applies only to the live broadcast profile.*/
+@property (assign, nonatomic) NSInteger minBitrate;
+
+/** Video orientation mode of the video: AgoraVideoOutputOrientationMode
+
+ * AgoraVideoOutputOrientationModeAdaptative(0): (Default) The output video always follows the orientation of the captured video, because the receiver takes the rotational information passed on from the video encoder.
+   - If the captured video is in landscape mode, the output video is in landscape mode.
+   - If the captured video is in portrait mode, the output video is in portrait mode.
+ * AgoraVideoOutputOrientationModeFixedLandscape(1): The output video is always in landscape mode. If the captured video is in portrait mode, the video encoder crops it to fit the output. This applies to situations where the receiver cannot process the rotational information. For example, CDN live streaming.
+ * AgoraVideoOutputOrientationModeFixedPortrait(2): The output video is always in portrait mode. If the captured video is in landscape mode, the video encoder crops it to fit the output. This applies to situations where the receiver cannot process the rotational information. For example, CDN live streaming.
+
+For scenarios with video rotation, Agora provides [Basic: Video Rotation Guide](https://docs.agora.io/en/2.3/product/Interactive%20Broadcast/Quickstart%20Guide/rotation_guide_ios) to guide users on how to set this parameter to get the video orientation that they want.
+
+ */
+@property (assign, nonatomic) AgoraVideoOutputOrientationMode orientationMode;
+
+/** Initializes and returns a newly allocated AgoraVideoEncoderConfiguration object with the specified video resolution.
+
+ @param size Video resolution.
+ @param frameRate Video frame rate.
+ @param bitrate Video bitrate.
+ @param orientationMode AgoraVideoOutputOrientationMode.
+ @return An initialized AgoraVideoEncoderConfiguration object.
+ */
+- (instancetype _Nonnull)initWithSize:(CGSize)size
+                            frameRate:(AgoraVideoFrameRate)frameRate
+                              bitrate:(NSInteger)bitrate
+                      orientationMode:(AgoraVideoOutputOrientationMode)orientationMode;
+
+/** Initializes and returns a newly allocated AgoraVideoEncoderConfiguration object with the specified video width and height.
+
+ @param width Width of the video.
+ @param height Height of the video.
+ @param frameRate Video frame rate.
+ @param bitrate Video bitrate.
+ @param orientationMode AgoraVideoOutputOrientationMode.
+ @return An initialized AgoraVideoEncoderConfiguration object.
+ */
+- (instancetype _Nonnull)initWithWidth:(NSInteger)width
+                                height:(NSInteger)height
+                             frameRate:(AgoraVideoFrameRate)frameRate
+                               bitrate:(NSInteger)bitrate
+                       orientationMode:(AgoraVideoOutputOrientationMode)orientationMode;
+@end
+
+/** A class for providing user-specific CDN live audio/video transcoding settings.
+ */
+__attribute__((visibility("default"))) @interface AgoraLiveTranscodingUser: NSObject
+/** User ID of the CDN live host.
+ */
+@property (assign, nonatomic) NSUInteger uid;
+/** Position and size of the video frame.
+ */
+@property (assign, nonatomic) CGRect rect;
+/**  Layer position of the video frame. The value ranges between 0 and 100.
+
+From v2.3.0, the Agora SDK supports setting zOrder as 0.
+
+    - 0: (Default) Lowest.
+    - 100: Highest.
+
+ Note: If the value is set to < 0 or > 100, the ERR_INVALID_ARGUMENT error occurs.
+ */
+@property (assign, nonatomic) NSInteger zOrder;
+/** Transparency of the video frame.
+
+ The value ranges between 0.0 and 1.0:
+
+ * 0.0: Completely transparent.
+ * 1.0: (Default) Opaque.
+ */
+@property (assign, nonatomic) double alpha;
+/** The audio channel of the sound.
+
+ The default value is 0:
+
+    - 0: (Default) Supports dual channels. Depends on the upstream of the broadcaster.
+    - 1: The audio stream of the broadcaster uses the FL audio channel. If the upstream of the broadcaster uses multiple audio channels, these channels will be mixed into mono first.
+    - 2: The audio stream of the broadcaster uses the FC audio channel. If the upstream of the broadcaster uses multiple audio channels, these channels will be mixed into mono first.
+    - 3: The audio stream of the broadcaster uses the FR audio channel. If the upstream of the broadcaster uses multiple audio channels, these channels will be mixed into mono first.
+    - 4: The audio stream of the broadcaster uses the BL audio channel. If the upstream of the broadcaster uses multiple audio channels, these channels will be mixed into mono first.
+    - 5: The audio stream of the broadcaster uses the BR audio channel. If the upstream of the broadcaster uses multiple audio channels, these channels will be mixed into mono first.
+
+Note: If your setting is not 0, you may need a specialized player.
+ */
+@property (assign, nonatomic) NSInteger audioChannel;
+@end
+
+/** Image properties.
+
+ A class for setting the properties of the watermark and background images in live broadcasting.
+ */
+__attribute__((visibility("default"))) @interface AgoraImage: NSObject
+/** HTTP/HTTPS address of the image on the broadcasting video.
+ */
+@property (strong, nonatomic) NSURL *_Nonnull url;
+/** Position and size of the image on the broadcasting video in CGRect.
+ */
+@property (assign, nonatomic) CGRect rect;
+@end
+
+/** A class for managing user-specific CDN live audio/video transcoding settings.
+ */
+__attribute__((visibility("default"))) @interface AgoraLiveTranscoding: NSObject
+/** Size of the video (width and height).
+ */
+@property (assign, nonatomic) CGSize size;
+/** Bitrate of the CDN live output video stream. The default value is 400 Kbps.
+ */
+@property (assign, nonatomic) NSInteger videoBitrate;
+/** Frame rate of the CDN live output video stream. The default value is 15 fps.
+ */
+@property (assign, nonatomic) NSInteger videoFramerate;
+/** Latency mode:
+
+ * YES: Low latency with unassured quality.
+ * NO:（Default）High latency with assured quality.
+ */
+@property (assign, nonatomic) BOOL lowLatency;
+/** Video GOP in frames. The default value is 30 fps. */
+@property (assign, nonatomic) NSInteger videoGop;
+/** Video codec profile type: AgoraVideoCodecProfileType.
+ */
+@property (assign, nonatomic) AgoraVideoCodecProfileType videoCodecProfile;
+
+/** An AgoraLiveTranscodingUser object managing the user layout configuration in the CDN live stream. Agora supports a maximum of 17 transcoding users in a CDN live stream channel. See AgoraLiveTranscodingUser for details.
+ */
+@property (copy, nonatomic) NSArray<AgoraLiveTranscodingUser *> *_Nullable transcodingUsers;
+/** Reserved property. Extra user-defined information to send SEI for the H.264/H.265 video stream to the CDN live client.
+ */
+@property (copy, nonatomic) NSString *_Nullable transcodingExtraInfo;
+/** The watermark image added to the CDN live publishing stream.
+
+The audience of the CDN live publishing stream can see the watermark. See AgoraImage for the definition of the watermark.
+ */
+@property (strong, nonatomic) AgoraImage *_Nullable watermark;
+/** The background image added to the CDN live publishing stream.
+
+The audience of the CDN live publishing stream can see the background image. See AgoraImage for the definition of the background image.
+ */
+@property (strong, nonatomic) AgoraImage *_Nullable backgroundImage;
+/** The background color in RGB hex value. Value only, do not include a #.
+
+COLOR_CLASS is a general name for the type:
+
+* iOS: UIColor
+* MacOS: NSColor
+ */
+@property (strong, nonatomic) COLOR_CLASS *_Nullable backgroundColor;
+
+/** Self-defined audio sampling rate: AgoraAudioSampleRateType.
+ */
+@property (assign, nonatomic) AgoraAudioSampleRateType audioSampleRate;
+/** Bitrate (Kbps) of the CDN live audio output stream. The default value is 48, and the highest value is 128.
+ */
+@property (assign, nonatomic) NSInteger audioBitrate;
+/** Agora’s self-defined audio channel type. Agora recommends choosing 1 or 2. Special players are required if you choose 3, 4 or 5:
+
+ * 1: (Default) Mono
+ * 2: Two-channel stereo
+ * 3: Three-channel stereo
+ * 4: Four-channel stereo
+ * 5: Five-channel stereo
+ */
+@property (assign, nonatomic) NSInteger audioChannels;
+
+/** Creates a default transcoding object.
+
+ @return Default AgoraLiveTranscoding object.
+ */
++(AgoraLiveTranscoding *_Nonnull) defaultTranscoding;
+
+-(int)addUser:(AgoraLiveTranscodingUser * _Nonnull)user;
+
+-(int)removeUser:(NSUInteger)uid;
+@end
+
+/** Configuration of the imported live broadcast voice or video stream.
+ */
+__attribute__((visibility("default"))) @interface AgoraLiveInjectStreamConfig: NSObject
+/** Size of the added stream to the broadcast.
+
+The default value is 0; same size as the original stream.
+ */
+@property (assign, nonatomic) CGSize size;
+/** Video GOP of the added stream to the broadcast.
+
+The default value is 30 fps.
+ */
+@property (assign, nonatomic) NSInteger videoGop;
+/** Video frame rate of the added stream to the broadcast.
+
+The default value is 15 fps.
+ */
+@property (assign, nonatomic) NSInteger videoFramerate;
+/** Video bitrate of the added stream to the broadcast.
+
+The default value is 400 Kbps.
+
+The setting of the video bitrate is closely linked to the resolution. If the video bitrate you set is beyond a reasonable range, the SDK will set it within a reasonable range instead.
+ */
+@property (assign, nonatomic) NSInteger videoBitrate;
+
+/** Audio sampling rate of the added stream to the broadcast.
+
+The default value is 48000. See AgoraAudioSampleRateType for details.
+
+**Note:**
+
+Agora recommends using the default value.
+ */
+@property (assign, nonatomic) AgoraAudioSampleRateType audioSampleRate;
+/** Audio bitrate of the added stream to the broadcast.
+
+The default value is 48 Kbps.
+
+**Note:**
+
+Agora recommends using the default value.
+ */
+@property (assign, nonatomic) NSInteger audioBitrate;
+/** Number of audio channels to add to the broadcast. The values are 1 and 2.
+
+The default value is 1.
+
+**Note:**
+
+Agora recommends using the default value.
+ */
+@property (assign, nonatomic) NSInteger audioChannels;
+
+/** Creates a default stream configuration object.
+
+ @return Default stream configuration object.
+ */
++(AgoraLiveInjectStreamConfig *_Nonnull) defaultConfig;
+@end
+
+__deprecated
+
+/** Defines the region to show the video on the screen for each host in the channel.
+
+**DEPRECATED**
+
+ */
+__attribute__((visibility("default"))) @interface AgoraRtcVideoCompositingRegion : NSObject
+/** ID of the user whose video is displayed on the screen. */
+@property (assign, nonatomic) NSUInteger uid;
+/** Horizontal position of the region on the screen. The value ranges between 0.0 and 1.0. */
+@property (assign, nonatomic) CGFloat x;
+/** Vertical position of the region on the screen. The value ranges between 0.0 and 1.0. */
+@property (assign, nonatomic) CGFloat y;
+/** Actual width of the region. The value ranges between 0.0 and 1.0. For example, if the width of the screen is 360, and the width of the region is 120, set the width value as 0.33. */
+@property (assign, nonatomic) CGFloat width;
+/** Actual height of the region. The value ranges between 0.0 and 1.0. For example, if the height of the screen is 240, and the height of the region is 120, set the height value as 0.5. */
+@property (assign, nonatomic) CGFloat height;
+/** Layer position of the region. The value ranges between 0 and 100:
+
+- 0: The region is at the bottom layer.
+- 100: The region is at the top layer.
+
+From v2.3.0, the Agora SDK supports setting zOrder as 0.
+ */
+@property (assign, nonatomic) NSInteger zOrder;
+/** The transparency of the region. The value ranges between 0.0 and 1.0:
+
+- 0: The region is transparent.
+- 1: (Default) The region is opaque.
+*/
+@property (assign, nonatomic) CGFloat alpha;
+/** Please ignore this property. Setting this property will not take effect. */
+@property (assign, nonatomic) AgoraVideoRenderMode renderMode;
+@end
+
+__deprecated
+/** Rtc video compositing layout.
+
+**DEPRECATED**
+ */
+__attribute__((visibility("default"))) @interface AgoraRtcVideoCompositingLayout : NSObject
+/** Please ignore this property.
+
+Width of the entire canvas (display window or screen).
+ */
+@property (assign, nonatomic) NSInteger canvasWidth;
+/** Please ignore this property.
+
+Height of the entire canvas (display window or screen).
+ */
+@property (assign, nonatomic) NSInteger canvasHeight;
+/** The background color in RGB hex value. Value only, do not include a #.
+ */
+@property (copy, nonatomic) NSString * _Nullable backgroundColor;
+/** Screen display region information.
+
+Sets the screen display region of a host or a delegated host in a CDN live stream. See AgoraRtcVideoCompositingRegion for details.
+ */
+@property (copy, nonatomic) NSArray<AgoraRtcVideoCompositingRegion *> * _Nullable regions;
+/** Application defined data. Maximum size of 2048 bytes. */
+@property (copy, nonatomic) NSString * _Nullable appData;
+@end
+
+/** CDN live stream settings.
+
+ **DEPRECATED**
+
+ Agora recommends using [setLiveTranscoding]([AgoraRtcEngineKit setLiveTranscoding:]) to set the CDN live stream settings.
+ */
+__deprecated
+__attribute__((visibility("default"))) @interface AgoraPublisherConfiguration : NSObject
+/** Sets whether or not the current host is the RTMP stream owner.
+
+ - YES: (Default) The current host is the RTMP stream owner and the push-stream configuration is enabled.
+ - NO: The current host is not the RTMP stream owner and the push-stream configuration is disabled.
+ */
+@property (assign, nonatomic) BOOL owner;
+
+/** Width of the CDN live output data stream. The default value is 360.
+ */
+@property (assign, nonatomic) NSInteger width;
+/** Height of the CDN live output data stream. The default value is 640.
+ */
+@property (assign, nonatomic) NSInteger height;
+/** Frame rate of the CDN live output data stream. The default value is 15 fps.
+ */
+@property (assign, nonatomic) NSInteger framerate;
+/** Bitrate of the CDN live output data stream. The default value is 500 Kbps.
+ */
+@property (assign, nonatomic) NSInteger bitrate;
+/** Audio sample rate of the CDN live output data stream. The default value is 48000.
+ */
+@property (assign, nonatomic) NSInteger audiosamplerate;
+/** Audio bitrate of the CDN live output data stream.  The default value is 48.
+ */
+@property (assign, nonatomic) NSInteger audiobitrate;
+/** Audio channels of the CDN live output data stream. The default value is 1.
+ */
+@property (assign, nonatomic) NSInteger audiochannels;
+/**
+
+* 0: Tile horizontally.
+* 1: Layered windows.
+* 2: Tile vertically.
+ */
+@property (assign, nonatomic) NSInteger defaultLayout;
+/** CDN live video stream lifecycle: AgoraRtmpStreamLifeCycle.
+ */
+@property (assign, nonatomic) AgoraRtmpStreamLifeCycle lifeCycle;
+
+/** Width of the injected stream. Set it as 0.
+ */
+@property (assign, nonatomic) NSInteger injectStreamWidth;
+
+/** Height of the injected stream. Set it as 0.
+ */
+@property (assign, nonatomic) NSInteger injectStreamHeight;
+
+/** Address of the injected stream into the channel.
+ */
+@property (copy, nonatomic) NSString * _Nullable injectStreamUrl;
+
+/** The push-stream address for the picture-in-picture layouts. The default value is nil.
+ */
+@property (copy, nonatomic) NSString * _Nullable publishUrl;
+
+/** The push-stream HTTP/HTTPS URL address of the original stream not requiring picture-blending. The default value is nil.
+ */
+@property (copy, nonatomic) NSString * _Nullable rawStreamUrl;
+
+/** Reserved field. The default value is nil.
+ */
+@property (copy, nonatomic) NSString * _Nullable extraInfo;
+
+/** Whether or not the configuration is validated.
+ */
+-(BOOL) validate;
+@end
+
+#if (!(TARGET_OS_IPHONE) && (TARGET_OS_MAC))
+
+/** AgoraRtcDeviceInfo array.
+ */
+__attribute__((visibility("default"))) @interface AgoraRtcDeviceInfo : NSObject
+@property (assign, nonatomic) int __deprecated index;
+
+/** Device type: AgoraMediaDeviceType.
+ */
+@property (assign, nonatomic) AgoraMediaDeviceType type;
+
+/** Device ID.
+ */
+@property (copy, nonatomic) NSString * _Nullable deviceId;
+
+/** Device name.
+ */
+@property (copy, nonatomic) NSString * _Nullable deviceName;
+@end
+#endif
+
+/** Video frame containing the Agora SDK's encoded video data.
+ */
+__attribute__((visibility("default"))) @interface AgoraVideoFrame : NSObject
+/** Video format:
+
+ * 1: I420
+ * 2: BGRA
+ * 3: NV21
+ * 4: RGBA
+ * 5: IMC2
+ * 7: ARGB
+ * 8: NV12
+ * 12: iOS texture (CVPixelBufferRef)
+ */
+@property (assign, nonatomic) NSInteger format;
+
+/** Timestamp of the incoming video frame (ms).
+
+An incorrect timestamp results in frame loss or unsynchronized audio and video.
+
+ */
+@property (assign, nonatomic) CMTime time; // Time for this frame.
+
+@property (assign, nonatomic) int stride DEPRECATED_MSG_ATTRIBUTE("use strideInPixels instead");
+
+/** Line spacing of the incoming video frame, which must be in pixels instead of bytes. For textures, it is the width of the texture.
+ */
+@property (assign, nonatomic) int strideInPixels; // Number of pixels between two consecutive rows. Note: in pixel, not byte. Not used for iOS textures.
+
+/** Height of the incoming video frame
+ */
+@property (assign, nonatomic) int height; // Number of rows of pixels. Not used for iOS textures.
+
+/** CVPixelBuffer
+ */
+@property (assign, nonatomic) CVPixelBufferRef _Nullable textureBuf;
+
+/** Raw data buffer
+ */
+@property (strong, nonatomic) NSData * _Nullable dataBuf;  // Raw data buffer. Not used for iOS textures.
+
+/** (Optional) The number of pixels trimmed from the left. The default value is 0.
+ */
+@property (assign, nonatomic) int cropLeft;   // Number of pixels to crop on the left boundary.
+/** (Optional) The number of pixels trimmed from the top. The default value is 0.
+ */
+@property (assign, nonatomic) int cropTop;    // Number of pixels to crop on the top boundary.
+/** (Optional) The number of pixels trimmed from the right. The default value is 0.
+ */
+@property (assign, nonatomic) int cropRight;  // Number of pixels to crop on the right boundary.
+/** (Optional) The number of pixels trimmed from the bottom. The default value is 0.
+ */
+@property (assign, nonatomic) int cropBottom; // Number of pixels to crop on the bottom boundary.
+/** (Optional) The clockwise rotation of the incoming video frame.
+
+Optional values: 0, 90, 180, or 270. The default value is 0.
+ */
+@property (assign, nonatomic) int rotation;   // 0, 90, 180, 270. See document for rotation calculation.
+/* Note
+ * 1. strideInPixels
+ *    Stride is in pixels, not bytes.
+ * 2. About the frame width and height.
+ *    No field is defined for the width. However, it can be deduced by:
+ *       croppedWidth = (strideInPixels - cropLeft - cropRight)
+ *    And
+ *       croppedHeight = (height - cropTop - cropBottom)
+ * 3. About crop.
+ *    _________________________________________________________________.....
+ *    |                        ^                                      |  ^
+ *    |                        |                                      |  |
+ *    |                     cropTop                                   |  |
+ *    |                        |                                      |  |
+ *    |                        v                                      |  |
+ *    |                ________________________________               |  |
+ *    |                |                              |               |  |
+ *    |                |                              |               |  |
+ *    |<-- cropLeft -->|          valid region        |<- cropRight ->|
+ *    |                |                              |               | height
+ *    |                |                              |               |
+ *    |                |_____________________________ |               |  |
+ *    |                        ^                                      |  |
+ *    |                        |                                      |  |
+ *    |                     cropBottom                                |  |
+ *    |                        |                                      |  |
+ *    |                        v                                      |  v
+ *    _________________________________________________________________......
+ *    |                                                               |
+ *    |<---------------- strideInPixels ----------------------------->|
+ *
+ *    If your buffer contains garbage data, you can crop them. For example, the frame size is
+ *    360 &times; 640, often the buffer stride is 368, that is, the extra 8 pixels on the
+ *    right are for padding, and should be removed. In this case, you can set:
+ *    strideInPixels = 368;
+ *    height = 640;
+ *    cropRight = 8;
+ *    // cropLeft, cropTop, cropBottom are set to a default of 0
+ */
+@end

ios/RCTAgora/libs/AgoraRtcEngineKit.framework/Headers/IAgoraMediaEngine.h

@@ -31,6 +31,7 @@ public:
     int samplesPerSec;  //sampling rate
     void* buffer;  //data buffer
     int64_t renderTimeMs;
+    int avsync_type;
   };
 public:
   virtual bool onRecordAudioFrame(AudioFrame& audioFrame) = 0;
@@ -57,6 +58,7 @@ public:
     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;
@@ -164,14 +166,46 @@ public:
   virtual IExternalVideoRender* createRenderInstance(const ExternalVideoRenerContext& context) = 0;
 };
 
-class IMediaEngine
+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 = false){ return -1; }
+  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

ios/RCTAgora/libs/AgoraRtcEngineKit.framework/Headers/IAgoraService.h

@@ -0,0 +1,79 @@
+//  Agora SDK
+//
+//  Copyright (c) 2018 Agora.io. All rights reserved.
+//
+
+#ifndef AGORA_SERVICE_H
+#define AGORA_SERVICE_H
+#include "AgoraBase.h"
+
+namespace agora {
+    namespace rtc {
+        class IRtcEngine;
+    }
+    namespace signaling {
+        class ISignalingEngine;
+    }
+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.3.0
+    */
+    virtual const char* getVersion(int* build) = 0;
+
+    virtual rtc::IRtcEngine* createRtcEngine() = 0;
+    virtual signaling::ISignalingEngine* createSignalingEngine() = 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

ios/RCTAgora/libs/AgoraRtcEngineKit.framework/Headers/ICodingModuleCallback.h

@@ -1,62 +0,0 @@
-
-#ifndef _I_CODING_MODULE_CALLBACK_H_
-#define _I_CODING_MODULE_CALLBACK_H_
-
-#ifdef AGORAVOICE_EXPORT
-#define AGORAVOICE_DLLEXPORT HELPER_DLL_EXPORT
-#elif AGORAVOICE_DLL
-#define AGORAVOICE_DLLIMPORT HELPER_DLL_IMPORT
-#else
-#define AGORAVOICE_DLLEXPORT
-#endif
-
-namespace AgoraRTC {
-
-  struct VFrameInfo {
-    int frame_type; //2: Key frame, 0: P Frame, 1: B Frame
-    unsigned int frame_num;
-    unsigned int width;
-    unsigned int height;
-    bool sps_pps_handle;
-  };
-
-  // Callback class used for recording/playback video file
-  class VCMVideoFileCallback {
-  public:
-    virtual int onDecodeVideo(unsigned int video_ts, unsigned char payload_type, unsigned char* buffer, unsigned int length, VFrameInfo info) = 0;
-    virtual int onEncodeVideo(unsigned int video_ts, unsigned char payload_type, unsigned char* buffer, unsigned int length, VFrameInfo info) = 0;
-
-    virtual int onDecodeVideoSEI(const char* info, int len) = 0;
-    //virtual int onEncodeVideoSEI(char** info, int *len) = 0;
-  };
-
-  // Callback class used for recording/playback audio file
-  class ACMAudioFileCallback {
-  public:
-    virtual int onDecodeAudio(unsigned int audio_ts, unsigned char payload_type, unsigned int channels, unsigned char* buffer, unsigned int length) = 0;
-    virtual int onEncodeAudio(unsigned int audio_ts, unsigned char payload_type, unsigned int channels, unsigned char* buffer, unsigned int length) = 0;
-  };
-
-  class ICMFile : public VCMVideoFileCallback,
-                  public ACMAudioFileCallback {
-  public:
-    virtual int startAudioRecord() = 0;
-    virtual int startVideoRecord() = 0;
-    virtual int stopAudioRecord() = 0;
-    virtual int stopVideoRecord() = 0;
-    virtual int setVideoRotation(int rotation) = 0;
-  };
-
-  class ICMFileObserver {
-  public:
-    virtual ICMFile* GetICMFileObject(unsigned int uid) = 0;
-    virtual int InsertRawAudioPacket(unsigned int uid, const unsigned char*  payloadData, unsigned short payloadSize,
-      int payload_type, unsigned int timeStamp, unsigned short seqNumber) = 0;
-  };
-
-}
-
-AGORAVOICE_DLLEXPORT int RegisterICMFileObserver(AgoraRTC::ICMFileObserver* observer);
-AGORAVOICE_DLLEXPORT int Set264SPSPPS(char* spspps, int len);
-
-#endif