com.taptap.sdk.relation 4.10.4-beta.2 → 4.10.4

package/Mobile/Editor/BuidPostProcessor.cs

@@ -13,11 +13,16 @@ using System.Diagnostics;
 #if UNITY_IOS
 public class BuildPostProcessor
 {
+    private const string RELATION_URL_SCHEME_PREFIX = "tds";
+    private const string RELATION_URL_SCHEME_NAME = "TapTapRelation";
+
     [PostProcessBuild(999)]
     public static void OnPostProcessBuild(BuildTarget buildTarget, string path)
     {
         if (buildTarget == BuildTarget.iOS)
         {
+            AddRelationURLScheme(path);
+
             var projPath = TapSDKCoreCompile.GetProjPath(path);
             var proj = TapSDKCoreCompile.ParseProjPath(projPath);
             var target = TapSDKCoreCompile.GetUnityTarget(proj);
@@ -53,6 +58,22 @@ public class BuildPostProcessor
             UnityEngine.Debug.LogWarning("TapRelation add Bundle Failed!");
         }
     }
-    
+
+    private static void AddRelationURLScheme(string path)
+    {
+        var clientId = TapSDKCoreCompile.GetAppClientIdFromTDSInfo(Application.dataPath);
+        if (string.IsNullOrEmpty(clientId))
+        {
+            UnityEngine.Debug.LogError("TapRelation Can't find app.client_id in TDS-Info.json or taptap.client_id in fallback TDS-Info.plist!");
+            return;
+        }
+
+        TapSDKCoreCompile.AddURLSchemeToPlist(
+            Path.GetFullPath(path),
+            RELATION_URL_SCHEME_NAME,
+            RELATION_URL_SCHEME_PREFIX + clientId
+        );
+    }
+
 }
 #endif

package/Mobile/Editor/NativeDependencies.xml

@@ -4,12 +4,12 @@
     <repositories>
       <repository>https://repo.maven.apache.org/maven2</repository>
     </repositories>
-    <androidPackage spec="com.taptap.sdk:tap-relation-unity:4.10.4-beta.2" />
+    <androidPackage spec="com.taptap.sdk:tap-relation-unity:4.10.4" />
   </androidPackages>
   <iosPods>
     <sources>
       <source>https://github.com/CocoaPods/Specs.git</source>
     </sources>
-    <iosPod addToAllTargets="false" bitcodeEnabled="false" name="TapTapSDK/Relation" version="4.10.4-beta.2" />
+    <iosPod addToAllTargets="false" bitcodeEnabled="false" name="TapTapSDK/Relation" version="4.10.4" />
   </iosPods>
 </dependencies>

package/Mobile/Editor/TapRelationAndroidPostGenerateGradleProject.cs

@@ -0,0 +1,221 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Xml;
+using TapSDK.Core.Editor;
+using UnityEditor.Android;
+using UnityEngine;
+
+namespace TapSDK.Relation.Mobile.Editor
+{
+    public class TapRelationAndroidPostGenerateGradleProject : IPostGenerateGradleAndroidProject
+    {
+        private const string AndroidNamespaceUri = "http://schemas.android.com/apk/res/android";
+        private const string RouterActivityName = "com.taptap.sdk.relation.TapRelationRouterActivity";
+        private const string RouterActivityTheme = "@android:style/Theme.Translucent.NoTitleBar";
+        private static readonly string[] InviteHosts = { "invite_game", "invite_team" };
+
+        public int callbackOrder => 0;
+
+        public void OnPostGenerateGradleAndroidProject(string path)
+        {
+            string manifestPath = GetLauncherManifestPath(path);
+            if (string.IsNullOrEmpty(manifestPath) || !File.Exists(manifestPath))
+            {
+                Debug.LogWarning($"[TapSDK][Relation] AndroidManifest.xml not found under: {path}");
+                return;
+            }
+
+            var clientIds = ExtractClientIds();
+            if (clientIds.Count == 0)
+            {
+                Debug.LogWarning("[TapSDK][Relation] No clientId found, skip relation scheme intent-filter.");
+                return;
+            }
+
+            EnsureRelationRouterIntentFilters(manifestPath, clientIds);
+        }
+
+        private static string GetLauncherManifestPath(string exportPath)
+        {
+            string[] candidates =
+            {
+                Path.Combine(exportPath, "launcher", "src", "main", "AndroidManifest.xml"),
+                Path.Combine(exportPath, "src", "main", "AndroidManifest.xml")
+            };
+
+            foreach (string candidate in candidates)
+            {
+                if (File.Exists(candidate))
+                {
+                    return candidate;
+                }
+            }
+
+            return null;
+        }
+
+        private static HashSet<string> ExtractClientIds()
+        {
+            var clientIds = new HashSet<string>();
+            var clientId = TapSDKCoreCompile.GetAppClientIdFromTDSInfo(Application.dataPath);
+            if (string.IsNullOrEmpty(clientId))
+            {
+                Debug.LogWarning("[TapSDK][Relation] app.client_id not found in TDS-Info.json or taptap.client_id not found in fallback TDS-Info.plist, skip relation scheme intent-filter.");
+                return clientIds;
+            }
+
+            clientIds.Add(clientId);
+            return clientIds;
+        }
+
+        private static void EnsureRelationRouterIntentFilters(string manifestPath, HashSet<string> clientIds)
+        {
+            var document = new XmlDocument();
+            document.Load(manifestPath);
+
+            XmlElement manifestElement = document.DocumentElement;
+            XmlElement applicationElement = manifestElement?.SelectSingleNode("application") as XmlElement;
+            if (applicationElement == null)
+            {
+                Debug.LogWarning($"[TapSDK][Relation] <application> node not found in manifest: {manifestPath}");
+                return;
+            }
+
+            XmlElement activityElement = FindActivity(applicationElement);
+            bool changed = false;
+            if (activityElement == null)
+            {
+                activityElement = document.CreateElement("activity");
+                activityElement.SetAttribute("name", AndroidNamespaceUri, RouterActivityName);
+                applicationElement.AppendChild(activityElement);
+                changed = true;
+            }
+
+            if (activityElement.GetAttribute("exported", AndroidNamespaceUri) != "true")
+            {
+                activityElement.SetAttribute("exported", AndroidNamespaceUri, "true");
+                changed = true;
+            }
+
+            if (activityElement.GetAttribute("noHistory", AndroidNamespaceUri) != "true")
+            {
+                activityElement.SetAttribute("noHistory", AndroidNamespaceUri, "true");
+                changed = true;
+            }
+
+            if (activityElement.GetAttribute("theme", AndroidNamespaceUri) != RouterActivityTheme)
+            {
+                activityElement.SetAttribute("theme", AndroidNamespaceUri, RouterActivityTheme);
+                changed = true;
+            }
+
+            foreach (string clientId in clientIds)
+            {
+                string scheme = "tds" + clientId;
+                foreach (string host in InviteHosts)
+                {
+                    if (HasIntentFilter(activityElement, scheme, host))
+                    {
+                        continue;
+                    }
+
+                    activityElement.AppendChild(CreateIntentFilter(document, scheme, host));
+                    changed = true;
+                }
+            }
+
+            if (changed)
+            {
+                SaveXml(document, manifestPath);
+            }
+        }
+
+        private static XmlElement FindActivity(XmlElement applicationElement)
+        {
+            foreach (XmlNode child in applicationElement.ChildNodes)
+            {
+                XmlElement element = child as XmlElement;
+                if (element == null || element.Name != "activity")
+                {
+                    continue;
+                }
+
+                if (element.GetAttribute("name", AndroidNamespaceUri) == RouterActivityName)
+                {
+                    return element;
+                }
+            }
+
+            return null;
+        }
+
+        private static bool HasIntentFilter(XmlElement activityElement, string scheme, string host)
+        {
+            foreach (XmlNode filterNode in activityElement.ChildNodes)
+            {
+                XmlElement filterElement = filterNode as XmlElement;
+                if (filterElement == null || filterElement.Name != "intent-filter")
+                {
+                    continue;
+                }
+
+                foreach (XmlNode dataNode in filterElement.ChildNodes)
+                {
+                    XmlElement dataElement = dataNode as XmlElement;
+                    if (dataElement == null || dataElement.Name != "data")
+                    {
+                        continue;
+                    }
+
+                    if (dataElement.GetAttribute("scheme", AndroidNamespaceUri) == scheme &&
+                        dataElement.GetAttribute("host", AndroidNamespaceUri) == host)
+                    {
+                        return true;
+                    }
+                }
+            }
+
+            return false;
+        }
+
+        private static XmlElement CreateIntentFilter(XmlDocument document, string scheme, string host)
+        {
+            XmlElement intentFilter = document.CreateElement("intent-filter");
+
+            XmlElement action = document.CreateElement("action");
+            action.SetAttribute("name", AndroidNamespaceUri, "android.intent.action.VIEW");
+            intentFilter.AppendChild(action);
+
+            XmlElement defaultCategory = document.CreateElement("category");
+            defaultCategory.SetAttribute("name", AndroidNamespaceUri, "android.intent.category.DEFAULT");
+            intentFilter.AppendChild(defaultCategory);
+
+            XmlElement browsableCategory = document.CreateElement("category");
+            browsableCategory.SetAttribute("name", AndroidNamespaceUri, "android.intent.category.BROWSABLE");
+            intentFilter.AppendChild(browsableCategory);
+
+            XmlElement data = document.CreateElement("data");
+            data.SetAttribute("scheme", AndroidNamespaceUri, scheme);
+            data.SetAttribute("host", AndroidNamespaceUri, host);
+            intentFilter.AppendChild(data);
+
+            return intentFilter;
+        }
+
+        private static void SaveXml(XmlDocument document, string path)
+        {
+            var settings = new XmlWriterSettings
+            {
+                Indent = true,
+                IndentChars = "    ",
+                NewLineChars = "\n",
+                NewLineHandling = NewLineHandling.Replace
+            };
+
+            using (XmlWriter writer = XmlWriter.Create(path, settings))
+            {
+                document.Save(writer);
+            }
+        }
+    }
+}

package/Mobile/Editor/TapRelationAndroidPostGenerateGradleProject.cs.meta

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

package/Mobile/Runtime/TapTapRelationImpl.cs

@@ -15,9 +15,16 @@ namespace TapSDK.Relation.Mobile
 {
     public class TapTapRelationImpl : ITapTapRelation
     {
+#if UNITY_IOS
+        [DllImport("__Internal")]
+        private static extern void RegisterTapTapSDKRelationAppDelegateListener();
+#endif
+
         private const string SERVICE_NAME = "BridgeRelationService";
         private static List<ITapTapRelationCallback> callbacks = new List<ITapTapRelationCallback>();
+        private static List<ITapTapRelationInviteCallback> inviteCallbacks = new List<ITapTapRelationInviteCallback>();
         private static bool hasRegisterCallBack = false;
+        private static bool hasRegisterInviteCallBack = false;
 
         public TapTapRelationImpl()
         {
@@ -28,7 +35,9 @@ namespace TapSDK.Relation.Mobile
 
         public void Init(string clientId, TapTapRegionType regionType, int screenOrientation)
         {
-
+#if UNITY_IOS
+            RegisterTapTapSDKRelationAppDelegateListener();
+#endif
         }
 
         public void StartMessenger()
@@ -175,13 +184,55 @@ namespace TapSDK.Relation.Mobile
             if (callback != null)
             {
                 callbacks.Remove(callback);
+                if (callbacks.Count == 0 && hasRegisterCallBack)
+                {
+                    var command = new Command.Builder()
+                        .Service(SERVICE_NAME)
+                        .Method("unregisterRelationCallback")
+                        .Callback(false)
+                        .OnceTime(false);
+                    EngineBridge.GetInstance().CallHandler(command.CommandBuilder());
+                    hasRegisterCallBack = false;
+                    TapLog.Log("TapTapRelation UnregisterRelationCallback");
+                }
+            }
+        }
+
+        public void RegisterRelationInviteCallback(ITapTapRelationInviteCallback callback)
+        {
+            if (callback == null) return;
+            InitRegisterInviteCallBack();
+            if (!inviteCallbacks.Contains(callback))
+            {
+                inviteCallbacks.Add(callback);
+            }
+        }
+
+        public void UnregisterRelationInviteCallback(ITapTapRelationInviteCallback callback)
+        {
+            if (callback != null)
+            {
+                inviteCallbacks.Remove(callback);
+                if (inviteCallbacks.Count == 0 && hasRegisterInviteCallBack)
+                {
+                    var command = new Command.Builder()
+                        .Service(SERVICE_NAME)
+                        .Method("unregisterRelationInviteCallback")
+                        .Callback(false)
+                        .OnceTime(false);
+                    EngineBridge.GetInstance().CallHandler(command.CommandBuilder());
+                    hasRegisterInviteCallBack = false;
+                    TapLog.Log("TapTapRelation UnregisterRelationInviteCallback");
+                }
             }
         }
 
         public void Destroy()
         {
             callbacks.Clear();
+            inviteCallbacks.Clear();
             hasRegisterCallBack = false;
+            hasRegisterInviteCallBack = false;
             EngineBridge.GetInstance().CallHandler(new Command.Builder()
                 .Service(SERVICE_NAME)
                 .Method("destroy")
@@ -237,5 +288,50 @@ namespace TapSDK.Relation.Mobile
             });
         }
 
+        private void InitRegisterInviteCallBack()
+        {
+            if (hasRegisterInviteCallBack)
+            {
+                return;
+            }
+            hasRegisterInviteCallBack = true;
+
+            var command = new Command.Builder();
+            command.Service(SERVICE_NAME);
+            command.Method("registerRelationInviteCallback")
+                .Callback(true)
+                .OnceTime(false);
+            EngineBridge.GetInstance().CallHandler(command.CommandBuilder(), (result) =>
+            {
+                if (result.code != Result.RESULT_SUCCESS || string.IsNullOrEmpty(result.content))
+                {
+                    return;
+                }
+
+                try
+                {
+                    TapLog.Log("Relation Invite -->> Bridge Callback == " + JsonConvert.SerializeObject(result));
+                    var dic = Json.Deserialize(result.content) as Dictionary<string, object>;
+                    var inviteType = SafeDictionary.GetValue<string>(dic, "invite_type");
+                    var openId = SafeDictionary.GetValue<string>(dic, "open_id");
+                    var unionId = SafeDictionary.GetValue<string>(dic, "union_id");
+                    var teamId = SafeDictionary.GetValue<string>(dic, "team_id");
+
+                    if (inviteType == "invite_team")
+                    {
+                        inviteCallbacks.ForEach(x => x.OnTeamInviteReceived(openId, unionId, teamId));
+                    }
+                    else if (inviteType == "invite_game")
+                    {
+                        inviteCallbacks.ForEach(x => x.OnGameInviteReceived(openId, unionId));
+                    }
+                }
+                catch (Exception e)
+                {
+                    TapLog.Error($"Relation invite callback parse result error: {e.Message}");
+                }
+            });
+        }
+
     }
-}
+}

package/Plugins/iOS/TapTapSDKRelationAppDelegate.mm

@@ -0,0 +1,37 @@
+#import <UIKit/UIKit.h>
+#import <Foundation/Foundation.h>
+#import <TapTapRelationSDK/TapTapRelationSDK-Swift.h>
+#import "UnityAppController.h"
+#import "AppDelegateListener.h"
+
+@interface TapTapSDKRelationAppDelegateListener : NSObject<AppDelegateListener>
+
++ (instancetype)sharedInstance;
+
+@end
+
+@implementation TapTapSDKRelationAppDelegateListener
+
++ (instancetype)sharedInstance {
+    static TapTapSDKRelationAppDelegateListener *sharedInstance = nil;
+    static dispatch_once_t onceToken;
+    dispatch_once(&onceToken, ^{
+        sharedInstance = [[TapTapSDKRelationAppDelegateListener alloc] init];
+    });
+    return sharedInstance;
+}
+
+- (void)onOpenURL:(NSNotification *)notification {
+    NSDictionary *userInfo = notification.userInfo;
+    NSURL *url = [userInfo valueForKey:@"url"];
+    if (url) {
+        [TapTapRelation openWithUrl:url];
+    }
+}
+
+@end
+
+extern "C" void RegisterTapTapSDKRelationAppDelegateListener() {
+    TapTapSDKRelationAppDelegateListener *listener = TapTapSDKRelationAppDelegateListener.sharedInstance;
+    UnityRegisterAppDelegateListener(listener);
+}

package/Plugins/iOS/TapTapSDKRelationAppDelegate.mm.meta

@@ -0,0 +1,37 @@
+fileFormatVersion: 2
+guid: 5b490cb365244c4fa89b5c1851fca570
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  defineConstraints: []
+  isPreloaded: 0
+  isOverridable: 0
+  isExplicitlyReferenced: 0
+  validateReferences: 1
+  platformData:
+  - first:
+      Any: 
+    second:
+      enabled: 0
+      settings: {}
+  - first:
+      Editor: Editor
+    second:
+      enabled: 0
+      settings:
+        DefaultValueInitialized: true
+  - first:
+      iPhone: iOS
+    second:
+      enabled: 1
+      settings: {}
+  - first:
+      tvOS: tvOS
+    second:
+      enabled: 1
+      settings: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Plugins/iOS.meta

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

package/Plugins.meta

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

package/Runtime/Internal/TapTapRelationManager.cs

@@ -77,10 +77,20 @@ namespace TapSDK.Relation.Internal
             platformWrapper?.UnregisterRelationCallback(callback);
         }
 
+        public void RegisterRelationInviteCallback(ITapTapRelationInviteCallback callback)
+        {
+            platformWrapper?.RegisterRelationInviteCallback(callback);
+        }
+
+        public void UnregisterRelationInviteCallback(ITapTapRelationInviteCallback callback)
+        {
+            platformWrapper?.UnregisterRelationInviteCallback(callback);
+        }
+
         public void Destroy()
         {
             platformWrapper?.Destroy();
         }
     }
 
-}
+}

package/Runtime/Public/ITapTapRelation.cs

@@ -16,7 +16,7 @@ namespace TapSDK.Relation
         void InviteTeam(string teamId);
 
         void ShowTapUserProfile(string openId, string unionId);
-        
+
         void GetNewFansCount(Action<int> callback);
 
         void GetUnreadMessageCount(Action<int> callback);
@@ -25,6 +25,10 @@ namespace TapSDK.Relation
 
         void UnregisterRelationCallback(ITapTapRelationCallback callback);
 
+        void RegisterRelationInviteCallback(ITapTapRelationInviteCallback callback);
+
+        void UnregisterRelationInviteCallback(ITapTapRelationInviteCallback callback);
+
         void Destroy();
     }
-}
+}

package/Runtime/Public/ITapTapRelationInviteCallback.cs

@@ -0,0 +1,9 @@
+namespace TapSDK.Relation
+{
+    public interface ITapTapRelationInviteCallback
+    {
+        void OnGameInviteReceived(string openId, string unionId);
+
+        void OnTeamInviteReceived(string openId, string unionId, string teamId);
+    }
+}

package/Runtime/Public/ITapTapRelationInviteCallback.cs.meta

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

package/Runtime/Public/TapTapRelation.cs

@@ -60,13 +60,23 @@ namespace TapSDK.Relation
             TapTapRelationManager.Instance.UnregisterRelationCallback(callback);
         }
 
+        public static void RegisterRelationInviteCallback(ITapTapRelationInviteCallback callback)
+        {
+            TapTapRelationManager.Instance.RegisterRelationInviteCallback(callback);
+        }
+
+        public static void UnregisterRelationInviteCallback(ITapTapRelationInviteCallback callback)
+        {
+            TapTapRelationManager.Instance.UnregisterRelationInviteCallback(callback);
+        }
+
         public static void Destroy()
         {
             TapTapRelationManager.Instance.Destroy();
         }
 
 
-        public static readonly string Version = "4.10.4-beta.2";
+        public static readonly string Version = "4.10.4";
 
 
     }

package/package.json

@@ -2,11 +2,11 @@
   "name": "com.taptap.sdk.relation",
   "displayName": "TapTapSDK Relation",
   "description": "TapTapSDK Relation",
-  "version": "4.10.4-beta.2",
+  "version": "4.10.4",
   "unity": "2019.4",
   "license": "MIT",
   "dependencies": {
-    "com.taptap.sdk.core": "4.10.4-beta.2",
-    "com.taptap.sdk.login": "4.10.4-beta.2"
+    "com.taptap.sdk.core": "4.10.4",
+    "com.taptap.sdk.login": "4.10.4"
   }
 }