chore. upgrade to 2.8.0

CHANGELOG

 ## THE CHANGELOG
 
+#### 2.8.0-alpha.1
+  - add `string uid` api support
+  - android: deprecate `lowLatency` member of LiveTranscoding
+  - add methods `getUserInfoByUserAccount`, `getUserInfoByUid`, `joinChannelWithUserAccount`, `registerLocalUserAccount`
+  - add events `localUserRegistered`, `userInfoUpdated`
+  - android: upgrade native sdk to 2.8.2
+  - ios: upgrade native sdk to 2.8.0
+
 #### 2.4.1-alpha.3
 - refactor setLiveTranscoding: rename ios & android native parameters. export enum for javascript/typescript api.
 - fix negative number case in android platform.

android/build.gradle

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

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

     public final static String AGRejoinChannelSuccess = "rejoinChannelSuccess";
     public final static String AGLeaveChannel = "leaveChannel";
     public final static String AGClientRoleChanged = "clientRoleChanged";
+    public final static String AGLocalUserRegistered = "localUserRegistered";
+    public final static String AGUserInfoUpdated = "userInfoUpdated";
     public final static String AGUserJoined = "userJoined";
     public final static String AGUserOffline = "userOffline";
     public final static String AGConnectionStateChanged = "connectionStateChanged";

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

 import io.agora.rtc.internal.LastmileProbeConfig;
 import io.agora.rtc.live.LiveInjectStreamConfig;
 import io.agora.rtc.live.LiveTranscoding;
+import io.agora.rtc.models.UserInfo;
 import io.agora.rtc.video.AgoraImage;
 import io.agora.rtc.video.BeautyOptions;
 import io.agora.rtc.video.CameraCapturerConfiguration;
     private static final String AgoraAudioMode = "AudioMode";
     private static final String AgoraVideoMode = "VideoMode";
 
+    private RtcEngine rtcEngine;
+    private String appId;
+
     public AgoraModule(ReactApplicationContext context) {
         super(context);
     }
             });
         }
 
+        @Override
+        public void onLocalUserRegistered(final int uid, final String userAccount) {
+            runOnUiThread(new Runnable() {
+                @Override
+                public void run() {
+                    WritableMap map = Arguments.createMap();
+                    map.putInt("uid", uid);
+                    map.putString("userAccount", userAccount);
+                    sendEvent(getReactApplicationContext(), AGLocalUserRegistered, map);
+                }
+            });
+        }
+
+        @Override
+        public void onUserInfoUpdated(final int uid, final UserInfo peer) {
+            runOnUiThread(new Runnable() {
+                @Override
+                public void run() {
+                    WritableMap map = Arguments.createMap();
+                    map.putInt("uid", uid);
+                    WritableMap peerInfo = Arguments.createMap();
+                    peerInfo.putInt("uid", peer.uid);
+                    peerInfo.putString("userAccount", peer.userAccount);
+                    map.putMap("peer", peerInfo);
+                    sendEvent(getReactApplicationContext(), AGUserInfoUpdated, map);
+                }
+            });
+        }
+
         @Override
         public void onUserJoined(final int uid, final int elapsed) {
             runOnUiThread(new Runnable() {
                     statsMap.putInt("networkTransportDelay", stats.networkTransportDelay);
                     statsMap.putInt("jitterBufferDelay", stats.jitterBufferDelay);
                     statsMap.putInt("audioLossRate", stats.audioLossRate);
+                    statsMap.putInt("totalFrozenTime", stats.totalFrozenTime);
+                    statsMap.putInt("frozenRate", stats.frozenRate);
+                    statsMap.putInt("numChannels", stats.numChannels);
+                    statsMap.putInt("receivedSampleRate", stats.receivedSampleRate);
+                    statsMap.putInt("receivedBitrate", stats.receivedBitrate);
                     WritableMap map = Arguments.createMap();
                     map.putMap("stats", statsMap);
                     sendEvent(getReactApplicationContext(), AGRemoteAudioStats, map);
                     statsMap.putInt("receivedBitrate", stats.receivedBitrate);
                     statsMap.putInt("rendererOutputFrameRate", stats.rendererOutputFrameRate);
                     statsMap.putInt("rxStreamType", stats.rxStreamType);
+                    statsMap.putInt("totalFrozenTime", stats.totalFrozenTime);
+                    statsMap.putInt("frozenRate", stats.frozenRate);
                     WritableMap map = Arguments.createMap();
                     map.putMap("stats", statsMap);
                     sendEvent(getReactApplicationContext(), AGRemoteVideoStats, map);
     @ReactMethod
     public void init(ReadableMap options) {
         AgoraManager.getInstance().init(getReactApplicationContext(), mRtcEventHandler, options);
+        appId = options.getString("appid");
+        rtcEngine = AgoraManager.getInstance().mRtcEngine;
     }
 
     @ReactMethod
         }
     }
 
+    @ReactMethod
+    public void registerLocalUserAccount(ReadableMap options, Promise promise) {
+        Integer res = rtcEngine.registerLocalUserAccount(appId, options.getString("userAccount"));
+        if (res == 0) {
+            promise.resolve(null);
+        } else {
+            promise.reject("-1", res.toString());
+        }
+    }
+
+    @ReactMethod
+    public void joinChannelWithUserAccount(ReadableMap options, Promise promise) {
+        String token = null;
+        if (options.hasKey("token")) {
+            token = options.getString("token");
+        }
+        Integer res = rtcEngine.joinChannelWithUserAccount(token, options.getString("channelName"), options.getString("userAccount"));
+        if (res == 0) {
+            promise.resolve(null);
+        } else {
+            promise.reject("-1", res.toString());
+        }
+    }
+
+    @ReactMethod
+    public void getUserInfoByUid(Integer uid, Promise promise) {
+        UserInfo info = new UserInfo();
+        Integer res = rtcEngine.getUserInfoByUid(uid, info);
+        if (res == 0) {
+            WritableMap map = Arguments.createMap();
+            map.putInt("uid", info.uid);
+            map.putString("userAccount", info.userAccount);
+            promise.resolve(map);
+        } else {
+            promise.reject("-1", res.toString());
+        }
+    }
+
+    @ReactMethod
+    public void getUserInfoByUserAccount(String userAccount, Promise promise) {
+        UserInfo info = new UserInfo();
+        Integer res = rtcEngine.getUserInfoByUserAccount(userAccount, info);
+        if (res == 0) {
+            WritableMap map = Arguments.createMap();
+            map.putInt("uid", info.uid);
+            map.putString("userAccount", info.userAccount);
+            promise.resolve(map);
+        } else {
+            promise.reject("-1", res.toString());
+        }
+    }
+
     @ReactMethod
     public void leaveChannel(Promise promise) {
         Integer res = AgoraManager.getInstance().leaveChannel();
         if (options.hasKey("videoFramerate")) {
             transcoding.videoFramerate = options.getInt("videoFramerate");
         }
-        if (options.hasKey("lowLatency")) {
-            transcoding.lowLatency = options.getBoolean("lowLatency");
-        }
         if (options.hasKey("videoGop")) {
             transcoding.videoGop = options.getInt("videoGop");
         }

ios/RCTAgora/AgoraConst.h

 static NSString *AGRejoinChannelSuccess = @"rejoinChannelSuccess";
 static NSString *AGLeaveChannel = @"leaveChannel";
 static NSString *AGClientRoleChanged = @"clientRoleChanged";
+static NSString *AGLocalUserRegistered = @"localUserRegistered";
+static NSString *AGUserInfoUpdated = @"userInfoUpdated";
 static NSString *AGUserJoined = @"userJoined";
 static NSString *AGUserOffline = @"userOffline";
 static NSString *AGConnectionStateChanged = @"connectionStateChanged";

ios/RCTAgora/AgoraConst.m

                                   AGRejoinChannelSuccess,
                                   AGLeaveChannel,
                                   AGClientRoleChanged,
+                                  AGLocalUserRegistered,
+                                  AGUserInfoUpdated,
                                   AGUserJoined,
                                   AGUserOffline,
                                   AGConnectionStateChanged,

ios/RCTAgora/RCTAgora.m

 
 @interface RCTAgora ()
 @property (strong, nonatomic) AgoraRtcEngineKit *rtcEngine;
+@property (strong, nonatomic) NSString *appId;
 @property (strong, nonatomic) NSData *metadata;
 @end
 
   [AgoraConst share].appid = options[@"appid"];
   
   self.rtcEngine = [AgoraRtcEngineKit sharedEngineWithAppId:options[@"appid"] delegate:self];
+  self.appId = options[@"appid"];
   
   [AgoraConst share].rtcEngine = self.rtcEngine;
   
   }
 }
 
+// register user account
+RCT_EXPORT_METHOD(registerLocalUserAccount:(NSDictionary *)options
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject) {
+  NSInteger res = [self.rtcEngine registerLocalUserAccount:options[@"userAccount"] appId:self.appId];
+  if (res == 0) {
+    resolve(nil);
+  } else {
+    reject(@(-1).stringValue, @(res).stringValue, nil);
+  }
+}
+
+// join channel with user account
+RCT_EXPORT_METHOD(joinChannelWithUserAccount:(NSDictionary *)options
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject) {
+  NSString *token = [options objectForKey:@"token"] != nil ? options[@"token"] : nil;
+  NSInteger res = [self.rtcEngine joinChannelByUserAccount:options[@"userAccount"] token:token channelId:options[@"channelName"] joinSuccess:nil];
+  if (res == 0) {
+    resolve(nil);
+  } else {
+    reject(@(-1).stringValue, @(res).stringValue, nil);
+  }
+}
+
+// get user info by uid
+RCT_EXPORT_METHOD(getUserInfoByUid:(NSUInteger)uid
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject) {
+  AgoraErrorCode code = 0;
+  AgoraUserInfo *info = [self.rtcEngine getUserInfoByUid:uid withError:&code];
+  if ((int)code == 0) {
+    resolve(@{
+        @"uid": @(info.uid),
+        @"userAccount": info.userAccount
+    });
+  } else {
+    reject(@(-1).stringValue, @((int)code).stringValue, nil);
+  }
+}
+
+// get user info by user account
+RCT_EXPORT_METHOD(getUserInfoByUserAccount:(NSString *)userAccount
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject) {
+  AgoraErrorCode code = 0;
+  AgoraUserInfo *info = [self.rtcEngine getUserInfoByUserAccount:userAccount withError:&code];
+  if ((int)code == 0) {
+    resolve(@{
+              @"uid": @(info.uid),
+              @"userAccount": info.userAccount
+              });
+  } else {
+    reject(@(-1).stringValue, @((int)code).stringValue, nil);
+  }
+}
+
 // leave channel
 RCT_EXPORT_METHOD(leaveChannel
                   :(RCTPromiseResolveBlock) resolve
   if ([options objectForKey:@"videoFramerate"]) {
     transcoding.videoFramerate = [options[@"videoFramerate"] integerValue];
   }
-  if ([options objectForKey:@"lowLatancy"]) {
-    transcoding.lowLatency = [options[@"lowLatancy"] boolValue];
-  }
   if ([options objectForKey:@"videoGop"]) {
     transcoding.videoGop = [options[@"videoGop"] integerValue];
   }
                                         }];
 }
 
+- (void)rtcEngine:(AgoraRtcEngineKit *_Nonnull)engine didRegisteredLocalUser:(NSString *_Nonnull)userAccount withUid:(NSUInteger)uid {
+  [self sendEvent:AGLocalUserRegistered params:@{
+                                                 @"uid": @(uid),
+                                                 @"userAccount": userAccount
+                                                 }];
+}
+
+- (void)rtcEngine:(AgoraRtcEngineKit *_Nonnull)engine didUpdatedUserInfo:(AgoraUserInfo *_Nonnull)userInfo withUid:(NSUInteger)uid {
+  [self sendEvent:AGUserInfoUpdated params:@{
+                                                 @"uid": @(uid),
+                                                 @"peer": @{
+                                                     @"uid": @(userInfo.uid),
+                                                     @"userAccount": userInfo.userAccount
+                                                 }}];
+}
+
+
 - (void)rtcEngine:(AgoraRtcEngineKit *_Nonnull)engine didOfflineOfUid:(NSUInteger)uid reason:(AgoraUserOfflineReason)reason {
   [self sendEvent:AGUserOffline params:@{
                                          @"uid": @(uid),
                                                   @"quality": @(stats.quality),
                                                   @"networkTransportDelay": @(stats.networkTransportDelay),
                                                   @"jitterBufferDelay": @(stats.jitterBufferDelay),
-                                                  @"audioLossRate": @(stats.audioLossRate)
+                                                  @"audioLossRate": @(stats.audioLossRate),
+                                                  @"totalFrozenTime": @(stats.totalFrozenTime),
+                                                  @"frozenRate": @(stats.frozenRate),
+                                                  @"numChannels": @(stats.numChannels),
+                                                  @"receivedSampleRate": @(stats.receivedSampleRate),
+                                                  @"receivedBitrate": @(stats.receivedBitrate),
                                                   }
                                               }];
 }
                                                   @"receivedBitrate": @(stats.receivedBitrate),
                                                   @"rendererOutputFrameRate": @(stats.rendererOutputFrameRate),
                                                   @"rxStreamType": @(stats.rxStreamType),
-                                                  @"decoderOutputFrameRate": @(stats.decoderOutputFrameRate)
+                                                  @"decoderOutputFrameRate": @(stats.decoderOutputFrameRate),
+                                                  @"totalFrozenTime": @(stats.totalFrozenTime),
+                                                  @"frozenRate": @(stats.frozenRate)
                                                   }
                                               }];
 }
                                                      }];
 }
 
-@end
+@end

lib/RtcEngine.native.d.ts

-import { Option, Callback, AudioMixingOption, PlayEffectOption, AudioRecordingOption, AudioFrameOption, MixedAudioFrameOption, ImageOption, VideoStreamOption, DefaultVideoStreamOption, InjectStreamOption, RemoveInjectStreamOption, PublishStreamOption, RemovePublishStreamOption, LiveTranscodingOption, PositionOption, BeautyOption, LastmileProbeConfig, CameraCapturerConfiguration } from "./types";
+import { Option, Callback, AgoraUserInfo, AudioMixingOption, PlayEffectOption, AudioRecordingOption, AudioFrameOption, MixedAudioFrameOption, ImageOption, VideoStreamOption, DefaultVideoStreamOption, InjectStreamOption, RemoveInjectStreamOption, PublishStreamOption, RemovePublishStreamOption, LiveTranscodingOption, PositionOption, BeautyOption, LastmileProbeConfig, CameraCapturerConfiguration } from "./types";
 /**
  * RtcEngine is the javascript object for control agora native sdk through react native bridge.
  *
      * @param info
      */
     static joinChannel(channelName: string, uid?: number, token?: string, info?: Object): Promise<any>;
+    /**
+     * Registers a user account.
+     *
+     * Once registered, the user account can be used to identify the local user when the user joins the channel. After the user successfully registers a user account, the SDK triggers the `on("localUserRegistered", callback)` on the local client, reporting the user ID and user account of the local user.
+     * To join a channel with a user account, you can choose either of the following:
+     * Call the {@link registerLocalUserAccount} method to create a user account, and then the {@link joinChannelWithUserAccount} method to join the channel.
+     * Call the {@link joinChannelWithUserAccount} method to join the channel.
+     *
+     * @note To ensure smooth communication, use the same parameter type to identify the user. For example, if a user joins the channel with a user ID, then ensure all the other users use the user ID too. The same applies to the user account. If a user joins the channel with the Agora Web SDK, ensure that the uid of the user is set to the same parameter type.
+     *
+     * @param userAccount
+     * @returns Promise<any>
+     */
+    static registerLocalUserAccount(userAccount: string): Promise<any>;
+    /**
+     * Joins the channel with a user account.
+     *
+     * After the user successfully joins the channel, the SDK triggers the following callbacks:
+     *
+     * The local client: `on("localUserRegistered", callback)` and `on("joinChannelSuccess", callback)`.
+     * The remote client: `on("userJoined", callback)` and `on("userInfoUpdated", callback)`, if the user joining the channel is in the Communication profile, or is a BROADCASTER in the Live Broadcast profile.
+     *
+     * @note To ensure smooth communication, use the same parameter type to identify the user. For example, if a user joins the channel with a user ID, then ensure all the other users use the user ID too. The same applies to the user account. If a user joins the channel with the Agora Web SDK, ensure that the uid of the user is set to the same parameter type.
+     *
+     * @param channelName
+     * @param userAccount
+     * @param token
+     * @returns Promise<any>
+     */
+    static joinChannelWithUserAccount(channelName: string, userAccount: string, token: string): Promise<any>;
+    /**
+     * Gets the user information by passing in the user account.
+     *
+     * After receiving the "userInfoUpdated" callback, you can call this method to get the user ID of the remote user from the {@link AgoraUserInfo} object by passing in the userAccount.
+     * @param uid
+     * @returns Promise<{@link AgoraUserInfo}>
+     */
+    static getUserInfoByUid(uid: number): Promise<AgoraUserInfo>;
+    /**
+     * Gets the user information by passing in the user account.
+     *
+     * After receiving the "userInfoUpdated" callback, you can call this method to get the user ID of the remote user from the {@link AgoraUserInfo} object by passing in the userAccount.
+     * @param userAccount
+     * @returns Promise<{@link AgoraUserInfo}>
+     */
+    static getUserInfoByUserAccount(userAccount: string): Promise<AgoraUserInfo>;
     /**
      * add event listener
      *
      * localVideoChanged | occurs when the local video changed  | on("localVideoChanged", evt) |
      * networkTypeChanged | occurs when the device network type changed | on("networkTypeChanged", evt) |
      * mediaMetaDataReceived | occurs when you received media meta data from the remote side through sendMediaData | on("mediaMetaDataReceived", evt) |
+     * localUserRegistered | occurs when you register user account success | on("localUserRegistered", evt) |
+     * userInfoUpdated | occurs when you peer side using user account join channel | on("userInfoUpdated", evt) |
      * ---
      *
      * @param eventType

lib/RtcEngine.native.js

     static joinChannel(channelName, uid, token, info) {
         return Agora.joinChannel({ channelName, uid, token, info });
     }
+    /**
+     * Registers a user account.
+     *
+     * Once registered, the user account can be used to identify the local user when the user joins the channel. After the user successfully registers a user account, the SDK triggers the `on("localUserRegistered", callback)` on the local client, reporting the user ID and user account of the local user.
+     * To join a channel with a user account, you can choose either of the following:
+     * Call the {@link registerLocalUserAccount} method to create a user account, and then the {@link joinChannelWithUserAccount} method to join the channel.
+     * Call the {@link joinChannelWithUserAccount} method to join the channel.
+     *
+     * @note To ensure smooth communication, use the same parameter type to identify the user. For example, if a user joins the channel with a user ID, then ensure all the other users use the user ID too. The same applies to the user account. If a user joins the channel with the Agora Web SDK, ensure that the uid of the user is set to the same parameter type.
+     *
+     * @param userAccount
+     * @returns Promise<any>
+     */
+    static registerLocalUserAccount(userAccount) {
+        return Agora.registerLocalUserAccount({ userAccount });
+    }
+    /**
+     * Joins the channel with a user account.
+     *
+     * After the user successfully joins the channel, the SDK triggers the following callbacks:
+     *
+     * The local client: `on("localUserRegistered", callback)` and `on("joinChannelSuccess", callback)`.
+     * The remote client: `on("userJoined", callback)` and `on("userInfoUpdated", callback)`, if the user joining the channel is in the Communication profile, or is a BROADCASTER in the Live Broadcast profile.
+     *
+     * @note To ensure smooth communication, use the same parameter type to identify the user. For example, if a user joins the channel with a user ID, then ensure all the other users use the user ID too. The same applies to the user account. If a user joins the channel with the Agora Web SDK, ensure that the uid of the user is set to the same parameter type.
+     *
+     * @param channelName
+     * @param userAccount
+     * @param token
+     * @returns Promise<any>
+     */
+    static joinChannelWithUserAccount(channelName, userAccount, token) {
+        return Agora.joinChannelWithUserAccount({ channelName, userAccount, token });
+    }
+    /**
+     * Gets the user information by passing in the user account.
+     *
+     * After receiving the "userInfoUpdated" callback, you can call this method to get the user ID of the remote user from the {@link AgoraUserInfo} object by passing in the userAccount.
+     * @param uid
+     * @returns Promise<{@link AgoraUserInfo}>
+     */
+    static getUserInfoByUid(uid) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (react_native_1.Platform.OS === 'android') {
+                const _uid = this.Uint32ToInt32(uid);
+                let result = yield Agora.getUserInfoByUid(_uid);
+                result.uid = this.Uint32ToInt32(result.uid);
+                return result;
+            }
+            return Agora.getUserInfoByUid(uid);
+        });
+    }
+    /**
+     * Gets the user information by passing in the user account.
+     *
+     * After receiving the "userInfoUpdated" callback, you can call this method to get the user ID of the remote user from the {@link AgoraUserInfo} object by passing in the userAccount.
+     * @param userAccount
+     * @returns Promise<{@link AgoraUserInfo}>
+     */
+    static getUserInfoByUserAccount(userAccount) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (react_native_1.Platform.OS === 'android') {
+                let result = yield Agora.getUserInfoByUserAccount(userAccount);
+                result.uid = this.Uint32ToInt32(result.uid);
+                return result;
+            }
+            return Agora.getUserInfoByUserAccount(userAccount);
+        });
+    }
     /**
      * add event listener
      *
      * localVideoChanged | occurs when the local video changed  | on("localVideoChanged", evt) |
      * networkTypeChanged | occurs when the device network type changed | on("networkTypeChanged", evt) |
      * mediaMetaDataReceived | occurs when you received media meta data from the remote side through sendMediaData | on("mediaMetaDataReceived", evt) |
+     * localUserRegistered | occurs when you register user account success | on("localUserRegistered", evt) |
+     * userInfoUpdated | occurs when you peer side using user account join channel | on("userInfoUpdated", evt) |
      * ---
      *
      * @param eventType
             'remoteSubscribeFallbackToAudioOnly',
             'networkQuality',
             'streamInjectedStatus',
+            'localUserRegistered'
         ].indexOf(eventType) != -1) {
             AgoraEventEmitter.addListener(`${RtcEngine.AG_PREFIX}${eventType}`, (args) => {
                 const uint32_uid = new Uint32Array(1);
             });
             return;
         }
+        if (['userInfoUpdated'].indexOf(eventType) != -1) {
+            AgoraEventEmitter.addListener(`${RtcEngine.AG_PREFIX}${eventType}`, (args) => {
+                const uint32_uid = new Uint32Array(1);
+                uint32_uid[0] = args.uid;
+                args.uid = uint32_uid[0];
+                const uint32_peer_uid = new Uint32Array(1);
+                uint32_peer_uid[0] = args.peer.uid;
+                args.peer.uid = uint32_peer_uid[0];
+                listener(args);
+            });
+            return;
+        }
         if (['audioVolumeIndication'].indexOf(eventType) != -1) {
             AgoraEventEmitter.addListener(`${RtcEngine.AG_PREFIX}${eventType}`, (args) => {
                 args.speakers.map((speaker) => {

lib/types.d.ts

     HIDDEN = 1,
     FIT = 2
 }
+/**
+ * AgoraUserInfo
+ * @property uid: number
+ * @property userAccount: string
+ */
+export interface AgoraUserInfo {
+    uid: number;
+    userAccount: string;
+}
 /**
  * VideoEncoderConfig details
  * @property width: number | The encoder video's width

lib/types.js

     AgoraViewMode[AgoraViewMode["HIDDEN"] = 1] = "HIDDEN";
     AgoraViewMode[AgoraViewMode["FIT"] = 2] = "FIT";
 })(AgoraViewMode = exports.AgoraViewMode || (exports.AgoraViewMode = {}));
+;
 var VideoCodecProfile;
 (function (VideoCodecProfile) {
     VideoCodecProfile[VideoCodecProfile["BASELINE"] = 66] = "BASELINE";

lib/types.js.map

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

package.json

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

react-native-agora.podspec

         sp.source_files = './ios/RCTAgora/libs/AgoraRtcCryptoLoader.framework/**/*.{c,h,m,mm,S,cpp}'
         sp.vendored_libraries = 'libcrypto.a'
     end
-      
+
     s.dependency 'React'
-    s.dependency "AgoraRtcEngine_iOS", "2.4.1"
-end
+    s.dependency "AgoraRtcEngine_iOS", "2.8"
+end

src/RtcEngine.native.ts

 import {
     Option, Callback,
     VideoOption,
+    AgoraUserInfo,
     AudioMixingOption,
     DataStreamOption,
     PlayEffectOption,
         return Agora.joinChannel({channelName, uid, token, info});
     }
 
+    /**
+     * Registers a user account.
+     * 
+     * Once registered, the user account can be used to identify the local user when the user joins the channel. After the user successfully registers a user account, the SDK triggers the `on("localUserRegistered", callback)` on the local client, reporting the user ID and user account of the local user.
+     * To join a channel with a user account, you can choose either of the following:
+     * Call the {@link registerLocalUserAccount} method to create a user account, and then the {@link joinChannelWithUserAccount} method to join the channel.
+     * Call the {@link joinChannelWithUserAccount} method to join the channel.
+     * 
+     * @note To ensure smooth communication, use the same parameter type to identify the user. For example, if a user joins the channel with a user ID, then ensure all the other users use the user ID too. The same applies to the user account. If a user joins the channel with the Agora Web SDK, ensure that the uid of the user is set to the same parameter type.
+     * 
+     * @param userAccount
+     * @returns Promise<any>
+     */
+    public static registerLocalUserAccount(userAccount: string): Promise<any> {
+        return Agora.registerLocalUserAccount({userAccount});
+    }
+
+    /**
+     * Joins the channel with a user account.
+     * 
+     * After the user successfully joins the channel, the SDK triggers the following callbacks:
+     *
+     * The local client: `on("localUserRegistered", callback)` and `on("joinChannelSuccess", callback)`.
+     * The remote client: `on("userJoined", callback)` and `on("userInfoUpdated", callback)`, if the user joining the channel is in the Communication profile, or is a BROADCASTER in the Live Broadcast profile.
+     * 
+     * @note To ensure smooth communication, use the same parameter type to identify the user. For example, if a user joins the channel with a user ID, then ensure all the other users use the user ID too. The same applies to the user account. If a user joins the channel with the Agora Web SDK, ensure that the uid of the user is set to the same parameter type.
+     * 
+     * @param channelName
+     * @param userAccount
+     * @param token
+     * @returns Promise<any>
+     */
+    public static joinChannelWithUserAccount(channelName: string, userAccount: string, token: string): Promise<any> {
+        return Agora.joinChannelWithUserAccount({channelName, userAccount, token});
+    }
+
+    /**
+     * Gets the user information by passing in the user account.
+     * 
+     * After receiving the "userInfoUpdated" callback, you can call this method to get the user ID of the remote user from the {@link AgoraUserInfo} object by passing in the userAccount.
+     * @param uid 
+     * @returns Promise<{@link AgoraUserInfo}>
+     */
+    public static async getUserInfoByUid(uid: number): Promise<AgoraUserInfo> {
+        if (Platform.OS === 'android') {
+            const _uid = this.Uint32ToInt32(uid);
+            let result = await Agora.getUserInfoByUid(_uid);
+            result.uid = this.Uint32ToInt32(result.uid);
+            return result;
+        }
+        return Agora.getUserInfoByUid(uid);
+    }
+
+    /**
+     * Gets the user information by passing in the user account.
+     * 
+     * After receiving the "userInfoUpdated" callback, you can call this method to get the user ID of the remote user from the {@link AgoraUserInfo} object by passing in the userAccount.
+     * @param userAccount 
+     * @returns Promise<{@link AgoraUserInfo}>
+     */
+    public static async getUserInfoByUserAccount(userAccount: string): Promise<AgoraUserInfo> {
+        if (Platform.OS === 'android') {
+            let result = await Agora.getUserInfoByUserAccount(userAccount);
+            result.uid = this.Uint32ToInt32(result.uid);
+            return result;
+        }
+        return Agora.getUserInfoByUserAccount(userAccount);
+    }
+
     /**
      * add event listener
      *
      * localVideoChanged | occurs when the local video changed  | on("localVideoChanged", evt) | 
      * networkTypeChanged | occurs when the device network type changed | on("networkTypeChanged", evt) | 
      * mediaMetaDataReceived | occurs when you received media meta data from the remote side through sendMediaData | on("mediaMetaDataReceived", evt) | 
+     * localUserRegistered | occurs when you register user account success | on("localUserRegistered", evt) |
+     * userInfoUpdated | occurs when you peer side using user account join channel | on("userInfoUpdated", evt) |
      * ---
      * 
      * @param eventType
             'remoteSubscribeFallbackToAudioOnly',
             'networkQuality',
             'streamInjectedStatus',
+            'localUserRegistered'
         ].indexOf(eventType) != -1) {
             AgoraEventEmitter.addListener(`${RtcEngine.AG_PREFIX}${eventType}`, (args) => {
                 const uint32_uid = new Uint32Array(1);
             return;
         }
 
+        if (['userInfoUpdated'].indexOf(eventType) != -1) {
+            AgoraEventEmitter.addListener(`${RtcEngine.AG_PREFIX}${eventType}`, (args) => {
+                const uint32_uid = new Uint32Array(1);
+                uint32_uid[0] = args.uid;
+                args.uid = uint32_uid[0];
+
+                const uint32_peer_uid = new Uint32Array(1);
+                uint32_peer_uid[0] = args.peer.uid;
+                args.peer.uid = uint32_peer_uid[0];
+                listener(args);
+            });
+            return;
+        }
+
         if (['audioVolumeIndication'].indexOf(eventType) != -1) {
             AgoraEventEmitter.addListener(`${RtcEngine.AG_PREFIX}${eventType}`, (args) => {
                 args.speakers.map((speaker: any) => {

src/types.ts

   FIT = 2
 }
 
+/**
+ * AgoraUserInfo
+ * @property uid: number
+ * @property userAccount: string
+ */
+export interface AgoraUserInfo {
+  uid: number
+  userAccount: string
+};
+
 /**
  * VideoEncoderConfig details
  * @property width: number | The encoder video's width
   size: Size,
   videoBitrate: number,
   videoFramerate: number,
-  lowLatency: boolean,
+  lowLatency: boolean, // @deprecate lowLatency
   videoGop: number,
   videoCodecProfile: VideoCodecProfile,
   audioCodecProfile: AudioCodecProfile,