com.taptap.sdk.relationlite 4.6.1-alpha.13

package/Mobile/Editor/NativeDependencies.xml

@@ -0,0 +1,10 @@
+<?xml version="1.0" ?>
+<dependencies>
+  <androidPackages>
+    <repositories>
+      <repository>https://repo.maven.apache.org/maven2</repository>
+      <repository>https://nexus.xmxdev.com/repository/maven-public</repository>
+    </repositories>
+    <androidPackage spec="com.taptap.sdk:tap-relation-lite-unity:4.6.1-alpha.13"/>
+  </androidPackages>
+</dependencies>

package/Mobile/Editor/NativeDependencies.xml.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 031b433e4a7574f1ba114280a11d8f2e
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Mobile/Editor/TapRelationLiteMobileProcessBuild.cs

@@ -0,0 +1,20 @@
+using System;
+using UnityEditor.Build.Reporting;
+using TapSDK.Core.Editor;
+
+namespace TapSDK.RelationLite.Mobile.Editor {
+    public class TapRelationLiteMobileProcessBuild : SDKLinkProcessBuild {
+        public override int callbackOrder => 0;
+
+        public override string LinkPath => "TapSDK/RelationLite/link.xml";
+
+        public override LinkedAssembly[] LinkedAssemblies => new LinkedAssembly[] {
+                    new LinkedAssembly { Fullname = "TapSDK.RelationLite.Runtime" },
+                    new LinkedAssembly { Fullname = "TapSDK.RelationLite.Mobile.Runtime" }
+                };
+
+        public override Func<BuildReport, bool> IsTargetPlatform => (report) => {
+            return BuildTargetUtils.IsSupportMobile(report.summary.platform);
+        };
+    }
+}

package/Mobile/Editor/TapRelationLiteMobileProcessBuild.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 5807ad40da34740a1a3b06417569af1e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Mobile/Editor/TapSDK.RelationLite.Mobile.Editor.asmdef

@@ -0,0 +1,19 @@
+{
+    "name": "TapSDK.RelationLite.Mobile.Editor",
+    "references": [
+        "GUID:56f3da7a178484843974054bafe77e73",
+        "GUID:8880fb2a8006d444dbd9edc4ab2647af",
+        "GUID:d276369ee184b4cb69a14a9fe493e761"
+    ],
+    "includePlatforms": [
+        "Editor"
+    ],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
+}

package/Mobile/Editor/TapSDK.RelationLite.Mobile.Editor.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 4c897404031b24a789fa1e8e9a339cf3
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Mobile/Editor.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: f2795a6f8880c4f04ba87c18cfecda74
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Mobile/Runtime/TapSDK.RelationLite.Mobile.Runtime.asmdef

@@ -0,0 +1,23 @@
+{
+    "name": "TapSDK.RelationLite.Mobile.Runtime",
+    "references": [
+        "GUID:8880fb2a8006d444dbd9edc4ab2647af",
+        "GUID:7d5ef2062f3704e1ab74aac0e4d5a1a7",
+        "GUID:10560023d8780423cb943c7a324b69f2",
+        "GUID:6f33d8db82c9445088544f91d41e65a2"
+    ],
+    "includePlatforms": [
+        "Android",
+        "iOS"
+    ],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": true,
+    "precompiledReferences": [
+        "Newtonsoft.Json.dll"
+    ],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
+} 

package/Mobile/Runtime/TapSDK.RelationLite.Mobile.Runtime.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 472cd6ad2327447ed996e69cd4014c9b
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Mobile/Runtime/TapTapRelationLiteImpl.cs

@@ -0,0 +1,405 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using TapSDK.Core;
+using TapSDK.Core.Internal;
+using TapSDK.Core.Internal.Utils;
+using Newtonsoft.Json;
+using System.Runtime.InteropServices;
+#if UNITY_IOS
+using UnityEngine.iOS;
+#endif
+
+namespace TapSDK.RelationLite
+{
+    public class TapTapRelationLiteImpl : ITapTapRelationLite
+    {
+        private const string SERVICE_NAME = "BridgeRelationLiteService";
+        private static List<ITapTapRelationLiteCallback> callbacks = new List<ITapTapRelationLiteCallback>();
+        private static bool hasRegisterCallBack = false;
+        private string _clientId;
+        private TapTapRegionType _regionType;
+
+        public TapTapRelationLiteImpl()
+        {
+            EngineBridge.GetInstance().Register(
+                "com.taptap.sdk.relation.lite.unity.BridgeRelationLiteService",
+                "com.taptap.sdk.relation.lite.unity.BridgeRelationLiteServiceImpl");
+        }
+
+        public void Init(string clientId, TapTapRegionType regionType)
+        {
+            _clientId = clientId;
+            _regionType = regionType;
+            Debug.Log($"TapTapRelationLite Init with clientId: {clientId}, regionType: {regionType}");
+        }
+
+        public void SetOrientation(int orientation)
+        {
+            EngineBridge.GetInstance().CallHandler(new Command.Builder()
+                .Service(SERVICE_NAME)
+                .Method("setOrientation")
+                .Args("orientation", orientation)
+                .Callback(false)
+                .OnceTime(true)
+                .CommandBuilder());
+        }
+
+        public void InviteGame()
+        {
+            Debug.Log("TapTapRelationLite InviteGame");
+
+            EngineBridge.GetInstance().CallHandler(new Command.Builder()
+                .Service(SERVICE_NAME)
+                .Method("inviteGame")
+                .Callback(false)
+                .OnceTime(true)
+                .CommandBuilder());
+        }
+
+        public void InviteTeam(string teamId)
+        {
+            Debug.Log($"TapTapRelationLite InviteTeam with teamId: {teamId}");
+
+            EngineBridge.GetInstance().CallHandler(new Command.Builder()
+                .Service(SERVICE_NAME)
+                .Method("inviteTeam")
+                .Args("teamId", teamId)
+                .Callback(false)
+                .OnceTime(true)
+                .CommandBuilder());
+        }
+
+        public void GetFriendsList(string nextPageToken, ITapTapRelationLiteRequestCallback callback)
+        {
+            Debug.Log($"TapTapRelationLite GetFriendsList with nextPageToken: {nextPageToken}");
+
+            EngineBridge.GetInstance().CallHandler(new Command.Builder()
+                .Service(SERVICE_NAME)
+                .Method("getFriendsList")
+                .Args("nextPageToken", nextPageToken)
+                .Callback(true)
+                .OnceTime(true)
+                .CommandBuilder(), (result) =>
+                {
+                    if (callback == null) return;
+
+                    try
+                    {
+                        if (result.code != Result.RESULT_SUCCESS || string.IsNullOrEmpty(result.content))
+                        {
+                            callback.OnFriendsListResult("", new List<RelationLiteUserItem>());
+                            return;
+                        }
+
+                        var dic = Json.Deserialize(result.content) as Dictionary<string, object>;
+                        if (dic != null && dic.ContainsKey("next_page_token") && dic.ContainsKey("friends_list"))
+                        {
+                            string nextPage = SafeDictionary.GetValue<string>(dic, "next_page_token");
+                            string jsonStr = SafeDictionary.GetValue<string>(dic, "friends_list");
+                            List<RelationLiteUserItem> friendsList = JsonConvert.DeserializeObject<List<RelationLiteUserItem>>(jsonStr);
+                            callback.OnFriendsListResult(nextPage, friendsList);
+                        }
+                        else
+                        {
+                            callback.OnFriendsListResult("", new List<RelationLiteUserItem>());
+                        }
+                    }
+                    catch (Exception e)
+                    {
+                        callback.OnFriendsListResult("", new List<RelationLiteUserItem>());
+                        Debug.LogError($"GetFriendsList parse result error: {e.Message}");
+                    }
+                });
+
+        }
+
+        public void GetFollowingList(string nextPageToken, ITapTapRelationLiteRequestCallback callback)
+        {
+            Debug.Log($"TapTapRelationLite GetFollowingList with nextPageToken: {nextPageToken}");
+
+            EngineBridge.GetInstance().CallHandler(new Command.Builder()
+                .Service(SERVICE_NAME)
+                .Method("getFollowingList")
+                .Args("nextPageToken", nextPageToken)
+                .Callback(true)
+                .OnceTime(true)
+                .CommandBuilder(), (result) =>
+                {
+                    if (callback == null) return;
+
+                    try
+                    {
+                        if (result.code != Result.RESULT_SUCCESS || string.IsNullOrEmpty(result.content))
+                        {
+                            callback.OnFollowingListResult("", new List<RelationLiteUserItem>());
+                            return;
+                        }
+
+                        var dic = Json.Deserialize(result.content) as Dictionary<string, object>;
+                        if (dic != null && dic.ContainsKey("next_page_token") && dic.ContainsKey("following_list"))
+                        {
+                            string nextPage = SafeDictionary.GetValue<string>(dic, "next_page_token");
+                            string jsonStr = SafeDictionary.GetValue<string>(dic, "following_list");
+                            List<RelationLiteUserItem> followingList = JsonConvert.DeserializeObject<List<RelationLiteUserItem>>(jsonStr);
+                            callback.OnFollowingListResult(nextPage, followingList);
+                        }
+                        else
+                        {
+                            callback.OnFollowingListResult("", new List<RelationLiteUserItem>());
+                        }
+                    }
+                    catch (Exception e)
+                    {
+                        callback.OnFollowingListResult("", new List<RelationLiteUserItem>());
+                        Debug.LogError($"GetFollowingList parse result error: {e.Message}");
+                    }
+                });
+
+        }
+
+        public void GetFansList(string nextPageToken, ITapTapRelationLiteRequestCallback callback)
+        {
+            Debug.Log($"TapTapRelationLite GetFansList with nextPageToken: {nextPageToken}");
+
+            EngineBridge.GetInstance().CallHandler(new Command.Builder()
+                .Service(SERVICE_NAME)
+                .Method("getFansList")
+                .Args("nextPageToken", nextPageToken)
+                .Callback(true)
+                .OnceTime(true)
+                .CommandBuilder(), (result) =>
+                {
+                    if (callback == null) return;
+
+                    try
+                    {
+                        if (result.code != Result.RESULT_SUCCESS || string.IsNullOrEmpty(result.content))
+                        {
+                            callback.OnFansListResult("", new List<RelationLiteUserItem>());
+                            return;
+                        }
+
+                        var dic = Json.Deserialize(result.content) as Dictionary<string, object>;
+                        if (dic != null && dic.ContainsKey("next_page_token") && dic.ContainsKey("fans_list"))
+                        {
+                            string nextPage = SafeDictionary.GetValue<string>(dic, "next_page_token");
+                            string jsonStr = SafeDictionary.GetValue<string>(dic, "fans_list");
+                            List<RelationLiteUserItem> fansList = JsonConvert.DeserializeObject<List<RelationLiteUserItem>>(jsonStr);
+                            callback.OnFansListResult(nextPage, fansList);
+                        }
+                        else
+                        {
+                            callback.OnFansListResult("", new List<RelationLiteUserItem>());
+                        }
+                    }
+                    catch (Exception e)
+                    {
+                        callback.OnFansListResult("", new List<RelationLiteUserItem>());
+                        Debug.LogError($"GetFansList parse result error: {e.Message}");
+                    }
+                });
+
+        }
+
+        public void SyncRelationshipWithOpenId(int action, string nickname, string friendNickname, string friendOpenId, ITapTapRelationLiteRequestCallback callback)
+        {
+            Debug.Log($"TapTapRelationLite SyncRelationshipWithOpenId with action: {action}, nickname: {nickname}, friendNickname: {friendNickname}, friendOpenId: {friendOpenId}");
+
+            EngineBridge.GetInstance().CallHandler(new Command.Builder()
+                .Service(SERVICE_NAME)
+                .Method("syncRelationshipWithOpenId")
+                .Args("action", action)
+                .Args("nickname", nickname)
+                .Args("friendNickname", friendNickname)
+                .Args("friendOpenId", friendOpenId)
+                .Callback(true)
+                .OnceTime(true)
+                .CommandBuilder(), (result) =>
+                {
+                    if (callback == null) return;
+
+                    try
+                    {
+                        if (result.code != Result.RESULT_SUCCESS || string.IsNullOrEmpty(result.content))
+                        {
+                            callback.OnSyncRelationshipFail("", "", "");
+                            return;
+                        }
+
+                        var dic = Json.Deserialize(result.content) as Dictionary<string, object>;
+                        if (dic != null && dic.ContainsKey("success") && dic.ContainsKey("open_id"))
+                        {
+                            string openId = SafeDictionary.GetValue<string>(dic, "open_id");
+                            bool success = SafeDictionary.GetValue<bool>(dic, "success");
+                            if (success)
+                            {
+                                callback.OnSyncRelationshipSuccess(openId, "");
+                            }
+                            else
+                            {
+                                string errorMessage = SafeDictionary.GetValue<string>(dic, "error_message");
+                                callback.OnSyncRelationshipFail(errorMessage, openId, "");
+                            }
+                        }
+                        else
+                        {
+                            callback.OnSyncRelationshipFail("", "", "");
+                        }
+                    }
+                    catch (Exception e)
+                    {
+                        callback.OnSyncRelationshipFail(e.Message, "", "");
+                        Debug.LogError($"SyncRelationshipWithOpenId parse result error: {e.Message}");
+                    }
+                });
+
+        }
+
+        public void SyncRelationshipWithUnionId(int action, string nickname, string friendNickname, string friendUnionId, ITapTapRelationLiteRequestCallback callback)
+        {
+            Debug.Log($"TapTapRelationLite SyncRelationshipWithUnionId with action: {action}, nickname: {nickname}, friendNickname: {friendNickname}, friendUnionId: {friendUnionId}");
+
+            EngineBridge.GetInstance().CallHandler(new Command.Builder()
+                .Service(SERVICE_NAME)
+                .Method("syncRelationshipWithUnionId")
+                .Args("action", action)
+                .Args("nickname", nickname)
+                .Args("friendNickname", friendNickname)
+                .Args("friendUnionId", friendUnionId)
+                .Callback(true)
+                .OnceTime(true)
+                .CommandBuilder(), (result) =>
+                {
+                    if (callback == null) return;
+
+                    try
+                    {
+                        if (result.code != Result.RESULT_SUCCESS || string.IsNullOrEmpty(result.content))
+                        {
+                            callback.OnSyncRelationshipFail("request error", "", "");
+                            return;
+                        }
+
+                        var dic = Json.Deserialize(result.content) as Dictionary<string, object>;
+                        if (dic != null && dic.ContainsKey("success") && dic.ContainsKey("union_id"))
+                        {
+                            string unionId = SafeDictionary.GetValue<string>(dic, "union_id");
+                            bool success = SafeDictionary.GetValue<bool>(dic, "success");
+                            if (success)
+                            {
+                                callback.OnSyncRelationshipSuccess("", unionId);
+                            }
+                            else
+                            {
+                                string errorMessage = SafeDictionary.GetValue<string>(dic, "error_message");
+                                callback.OnSyncRelationshipFail(errorMessage, "", unionId);
+                            }
+                        }
+                        else
+                        {
+                            callback.OnSyncRelationshipFail("json format error", "", "");
+                        }
+                    }
+                    catch (Exception e)
+                    {
+                        callback.OnSyncRelationshipFail(e.Message, "", "");
+                        Debug.LogError($"SyncRelationshipWithOpenId parse result error: {e.Message}");
+                    }
+                });
+
+        }
+
+        public void ShowTapUserProfile(string openId, string unionId)
+        {
+            Debug.Log($"TapTapRelationLite ShowTapUserProfile with openId: {openId}, unionId: {unionId}");
+
+            EngineBridge.GetInstance().CallHandler(new Command.Builder()
+                .Service(SERVICE_NAME)
+                .Method("showTapUserProfile")
+                .Args("openId", openId)
+                .Args("unionId", unionId)
+                .Callback(false)
+                .OnceTime(true)
+                .CommandBuilder());
+        }
+
+        public void RegisterRelationLiteCallback(ITapTapRelationLiteCallback callback)
+        {
+            if (callback == null) return;
+            InitRegisterCallBack();
+            if (!callbacks.Contains(callback))
+            {
+                callbacks.Add(callback);
+                Debug.Log("TapTapRelationLite RegisterRelationLiteCallback");
+            }
+        }
+
+        public void UnregisterRelationLiteCallback(ITapTapRelationLiteCallback callback)
+        {
+            if (callback != null)
+            {
+                callbacks.Remove(callback);
+                var command = new Command.Builder();
+                command.Service(SERVICE_NAME);
+                command.Method("unregisterRelationLiteCallback")
+                    .Callback(true)
+                    .OnceTime(false);
+                EngineBridge.GetInstance().CallHandler(command.CommandBuilder(), (result) =>
+                {
+                    if (result.code != Result.RESULT_SUCCESS)
+                    {
+                        return;
+                    }
+
+                    if (string.IsNullOrEmpty(result.content))
+                    {
+                        return;
+                    }
+                    Debug.Log("TapSdk4UnityDemo -->> Bridge Callback == " + JsonConvert.SerializeObject(result));
+
+                });
+                Debug.Log("TapTapRelationLite UnregisterRelationLiteCallback");
+            }
+        }
+
+        private void InitRegisterCallBack()
+        {
+            if (hasRegisterCallBack)
+            {
+                return;
+            }
+            hasRegisterCallBack = true;
+
+            var command = new Command.Builder();
+            command.Service(SERVICE_NAME);
+            command.Method("registerRelationLiteCallback")
+                .Callback(true)
+                .OnceTime(false);
+            EngineBridge.GetInstance().CallHandler(command.CommandBuilder(), (result) =>
+            {
+                if (result.code != Result.RESULT_SUCCESS)
+                {
+                    return;
+                }
+
+                if (string.IsNullOrEmpty(result.content))
+                {
+                    return;
+                }
+                Debug.Log("TapSdk4UnityDemo -->> Bridge Callback == " + JsonConvert.SerializeObject(result));
+                var dic = Json.Deserialize(result.content) as Dictionary<string, object>;
+                var code = SafeDictionary.GetValue<int>(dic, "relation_lite_result_code");
+
+                if (code != null)
+                {
+                    callbacks.ForEach((x) => x.OnResult(code));
+                }
+
+            });
+
+            Debug.Log("TapTapRelationLite InitRegisterCallBack");
+        }
+    }
+}

package/Mobile/Runtime/TapTapRelationLiteImpl.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: d55782b4121834d3a9744b0d88043b35
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Mobile/Runtime.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 5e01c6b423ff84f628fafff18541ec23
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Mobile.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 9da0cdafaf2e544a3815e5b7c1679cd0
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Internal/Init/RelationLiteInitTask.cs

@@ -0,0 +1,20 @@
+using TapSDK.Core;
+using TapSDK.Core.Internal.Init;
+
+namespace TapSDK.RelationLite.Internal.Init 
+{
+    public class RelationLiteInitTask : IInitTask 
+    {
+        public int Order => 105;
+
+        public void Init(TapTapSdkOptions coreOption, TapTapSdkBaseOptions[] otherOptions)
+        {
+            TapTapRelationLiteManager.Instance.Init(coreOption.clientId, coreOption.region);
+        }
+
+        public void Init(TapTapSdkOptions coreOption)
+        {
+            TapTapRelationLiteManager.Instance.Init(coreOption.clientId, coreOption.region);
+        }
+    }
+} 

package/Runtime/Internal/Init/RelationLiteInitTask.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 54d0f9169ba1d4465bc34296f4a276fa
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Internal/Init.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: b6c252555cb1c4ad6a49a3f3ec2c7a9d
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Internal/TapTapRelationLiteManager.cs

@@ -0,0 +1,103 @@
+using System;
+using System.Collections.Generic;
+using TapSDK.Core;
+using TapSDK.Core.Internal.Utils;
+
+namespace TapSDK.RelationLite.Internal
+{
+    public class TapTapRelationLiteManager
+    {
+        private ITapTapRelationLite _impl;
+        private List<ITapTapRelationLiteCallback> _relationCallbacks;
+
+        private static TapTapRelationLiteManager instance;
+
+        private TapTapRelationLiteManager()
+        {
+            _impl = BridgeUtils.CreateBridgeImplementation(typeof(ITapTapRelationLite),
+                "TapSDK.RelationLite") as ITapTapRelationLite;
+            _relationCallbacks = new List<ITapTapRelationLiteCallback>();
+        }
+
+        public static TapTapRelationLiteManager Instance
+        {
+            get
+            {
+                if (instance == null)
+                {
+                    instance = new TapTapRelationLiteManager();
+                }
+                return instance;
+            }
+        }
+
+        public void Init(string clientId, TapTapRegionType regionType)
+        {
+            _impl.Init(clientId, regionType);
+        }
+
+        public void SetOrientation(int orientation)
+        {
+            _impl.SetOrientation(orientation);
+        }
+
+        public void InviteGame()
+        {
+            _impl.InviteGame();
+        }
+
+        public void InviteTeam(string teamId)
+        {
+            _impl.InviteTeam(teamId);
+        }
+
+        public void GetFriendsList(string nextPageToken, ITapTapRelationLiteRequestCallback callback)
+        {
+            _impl.GetFriendsList(nextPageToken, callback);
+        }
+
+        public void GetFollowingList(string nextPageToken, ITapTapRelationLiteRequestCallback callback)
+        {
+            _impl.GetFollowingList(nextPageToken, callback);
+        }
+
+        public void GetFansList(string nextPageToken, ITapTapRelationLiteRequestCallback callback)
+        {
+            _impl.GetFansList(nextPageToken, callback);
+        }
+
+        public void SyncRelationshipWithOpenId(int action, string nickname, string friendNickname, string friendOpenId, ITapTapRelationLiteRequestCallback callback)
+        {
+            _impl.SyncRelationshipWithOpenId(action, nickname, friendNickname, friendOpenId, callback);
+        }
+
+        public void SyncRelationshipWithUnionId(int action, string nickname, string friendNickname, string friendUnionId, ITapTapRelationLiteRequestCallback callback)
+        {
+            _impl.SyncRelationshipWithUnionId(action, nickname, friendNickname, friendUnionId, callback);
+        }
+
+        public void ShowTapUserProfile(string openId, string unionId)
+        {
+            _impl.ShowTapUserProfile(openId, unionId);
+        }
+
+
+        public void RegisterRelationLiteCallback(ITapTapRelationLiteCallback callback)
+        {
+            if (callback != null && !_relationCallbacks.Contains(callback))
+            {
+                _relationCallbacks.Add(callback);
+                _impl.RegisterRelationLiteCallback(callback);
+            }
+        }
+
+        public void UnregisterRelationLiteCallback(ITapTapRelationLiteCallback callback)
+        {
+            if (callback != null && _relationCallbacks.Contains(callback))
+            {
+                _relationCallbacks.Remove(callback);
+                _impl.UnregisterRelationLiteCallback(callback);
+            }
+        }
+    }
+} 

package/Runtime/Internal/TapTapRelationLiteManager.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 6641e553e2cf64d989a21c2a2c09c092
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Internal.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 3e47e403b3b984bd1b52835b54a8d3b6
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Public/FollowStatus.cs

@@ -0,0 +1,20 @@
+using System;
+using Newtonsoft.Json;
+
+namespace TapSDK.RelationLite
+{
+    public class FollowStatus
+    {
+        [JsonProperty("blocked_by")]
+        public bool blockedBy;
+
+        [JsonProperty("blocking")]
+        public bool blocking;
+
+        [JsonProperty("followed_by")]
+        public bool followedBy;
+
+        [JsonProperty("following")]
+        public bool following;
+    }
+} 

package/Runtime/Public/FollowStatus.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 5e5e84ebed40c4b3fad191bc71562a5d
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Public/ITapTapRelationLite.cs

@@ -0,0 +1,32 @@
+using System;
+using TapSDK.Core;
+
+namespace TapSDK.RelationLite
+{
+    public interface ITapTapRelationLite
+    {
+        void Init(string clientId, TapTapRegionType regionType);
+
+        void SetOrientation(int orientation);
+
+        void InviteGame();
+
+        void InviteTeam(string teamId);
+
+        void GetFriendsList(string nextPageToken, ITapTapRelationLiteRequestCallback callback);
+
+        void GetFollowingList(string nextPageToken, ITapTapRelationLiteRequestCallback callback);
+
+        void GetFansList(string nextPageToken, ITapTapRelationLiteRequestCallback callback);
+
+        void SyncRelationshipWithOpenId(int action, string nickname,string friendNickname, string friendOpenId, ITapTapRelationLiteRequestCallback callback);
+
+        void SyncRelationshipWithUnionId(int action, string nickname,string friendNickname, string friendUnionId, ITapTapRelationLiteRequestCallback callback);
+
+        void ShowTapUserProfile(string openId, string unionId);
+        
+        void RegisterRelationLiteCallback(ITapTapRelationLiteCallback callback);
+
+        void UnregisterRelationLiteCallback(ITapTapRelationLiteCallback callback);
+    }
+} 

package/Runtime/Public/ITapTapRelationLite.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 415bdd48f1f6d41e6b772eadd7b90cb8
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Public/ITapTapRelationLiteCallback.cs

@@ -0,0 +1,9 @@
+using System;
+
+namespace TapSDK.RelationLite
+{
+    public interface ITapTapRelationLiteCallback
+    {
+        void OnResult(int code);
+    }
+} 

package/Runtime/Public/ITapTapRelationLiteCallback.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: ea0ae0c022e4742ec9c9fac98b96ef5f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Public/ITapTapRelationLiteRequestCallback.cs

@@ -0,0 +1,16 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace TapSDK.RelationLite
+{
+    public interface ITapTapRelationLiteRequestCallback
+    {
+        void OnFriendsListResult(string nextPageToken, List<RelationLiteUserItem> friendsList);
+        void OnFollowingListResult(string nextPageToken, List<RelationLiteUserItem> followingList);
+        void OnFansListResult(string nextPageToken, List<RelationLiteUserItem> fansList);
+        void OnSyncRelationshipSuccess(string openId, string unionId);
+        void OnSyncRelationshipFail(string errorMessage, string openId, string unionId);
+        void OnRequestError(string errorMessage);
+    }
+}

package/Runtime/Public/ITapTapRelationLiteRequestCallback.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 9142ee9eb6cf54220856178ccfe34297
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Public/RelationLiteUserInfo.cs

@@ -0,0 +1,20 @@
+using System;
+using Newtonsoft.Json;
+
+namespace TapSDK.RelationLite
+{
+    public class RelationLiteUserInfo
+    {
+        [JsonProperty("alias")]
+        public string alias;
+
+        [JsonProperty("avatar")]
+        public string avatar;
+
+        [JsonProperty("name")]
+        public string name;
+
+        [JsonProperty("open_id")]
+        public string openId;
+    }
+} 

package/Runtime/Public/RelationLiteUserInfo.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: af1c5d94c142b47f4b10fac9333806d8
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Public/RelationLiteUserItem.cs

@@ -0,0 +1,18 @@
+using System;
+using Newtonsoft.Json;
+
+namespace TapSDK.RelationLite
+{
+    [Serializable]
+    public class RelationLiteUserItem
+    {
+        [JsonProperty("follow_status")]
+        public FollowStatus followStatus;
+
+        [JsonProperty("created_at")]
+        public long createdAt;
+
+        [JsonProperty("user")]
+        public RelationLiteUserInfo user;
+    }
+} 

package/Runtime/Public/RelationLiteUserItem.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 46adf4ef48e094ee59c36721f746dcad
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Public/TapTapRelationLite.cs

@@ -0,0 +1,82 @@
+using System;
+using System.Collections.Generic;
+using TapSDK.RelationLite.Internal;
+using TapSDK.Core;
+using TapSDK.Core.Internal.Utils;
+
+namespace TapSDK.RelationLite
+{
+    public class TapTapRelationLiteConstants
+    {
+        public static readonly int CALLBACK_CODE_ON_STOP = 500;
+        
+        // Relation action constants
+        public static readonly int ACTION_FOLLOW = 1;
+        public static readonly int ACTION_UNFOLLOW = 2;
+    }
+
+    public class TapTapRelationLite
+    {
+        public static void Init(string clientId, TapTapRegionType regionType)
+        {
+            TapTapRelationLiteManager.Instance.Init(clientId, regionType);
+        }
+
+        public static void SetOrientation(int orientation)
+        {
+            TapTapRelationLiteManager.Instance.SetOrientation(orientation);
+        }
+
+        public static void InviteGame()
+        {
+            TapTapRelationLiteManager.Instance.InviteGame();
+        }
+
+        public static void InviteTeam(string teamId)
+        {
+            TapTapRelationLiteManager.Instance.InviteTeam(teamId);
+        }
+
+        public static void GetFriendsList(string nextPageToken, ITapTapRelationLiteRequestCallback callback)
+        {
+            TapTapRelationLiteManager.Instance.GetFriendsList(nextPageToken, callback);
+        }
+
+        public static void GetFollowingList(string nextPageToken, ITapTapRelationLiteRequestCallback callback)
+        {
+            TapTapRelationLiteManager.Instance.GetFollowingList(nextPageToken, callback);
+        }
+
+        public static void GetFansList(string nextPageToken, ITapTapRelationLiteRequestCallback callback)
+        {
+            TapTapRelationLiteManager.Instance.GetFansList(nextPageToken, callback);
+        }
+
+        public static void SyncRelationshipWithOpenId(int action, string nickname, string friendNickname, string friendOpenId, ITapTapRelationLiteRequestCallback callback)
+        {
+            TapTapRelationLiteManager.Instance.SyncRelationshipWithOpenId(action, nickname, friendNickname, friendOpenId, callback);
+        }
+
+        public static void SyncRelationshipWithUnionId(int action, string nickname, string friendNickname, string friendUnionId, ITapTapRelationLiteRequestCallback callback)
+        {
+            TapTapRelationLiteManager.Instance.SyncRelationshipWithUnionId(action, nickname, friendNickname, friendUnionId, callback);
+        }
+
+        public static void ShowTapUserProfile(string openId, string unionId)
+        {
+            TapTapRelationLiteManager.Instance.ShowTapUserProfile(openId, unionId);
+        }
+
+        public static void RegisterRelationLiteCallback(ITapTapRelationLiteCallback callback)
+        {
+            TapTapRelationLiteManager.Instance.RegisterRelationLiteCallback(callback);
+        }
+
+        public static void UnregisterRelationLiteCallback(ITapTapRelationLiteCallback callback)
+        {
+            TapTapRelationLiteManager.Instance.UnregisterRelationLiteCallback(callback);
+        }
+
+        public static readonly string Version = "4.6.1-alpha.13";
+    }
+} 

package/Runtime/Public/TapTapRelationLite.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 174475d58cd804709a7c2c75096455f9
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Public.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 8556603e2afd5496390c7eb288ed379e
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/TapSDK.RelationLite.Runtime.asmdef

@@ -0,0 +1,15 @@
+{
+    "name": "TapSDK.RelationLite.Runtime",
+    "references": [
+        "GUID:7d5ef2062f3704e1ab74aac0e4d5a1a7"
+    ],
+    "includePlatforms": [],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
+} 

package/Runtime/TapSDK.RelationLite.Runtime.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 8880fb2a8006d444dbd9edc4ab2647af
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: c12b65975cd8c457dac75db0e82b032b
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "com.taptap.sdk.relationlite",
+  "displayName": "TapTapSDK RelationLite",
+  "description": "TapTapSDK RelationLite",
+  "version": "4.6.1-alpha.13",
+  "unity": "2019.4",
+  "license": "MIT",
+  "dependencies": {
+    "com.taptap.sdk.core": "4.6.1-alpha.13",
+    "com.taptap.sdk.login": "4.6.1-alpha.13"
+  }
+}

package/package.json.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: c3c19870c550d4bd19214dd380f5ac6c
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: