fix: fixed sending and converting callback keys

Assets/PlayroomKit/PlayroomKit.cs

@@ -61,15 +61,18 @@ public class MatchMakingOptions
         [DllImport("__Internal")]
         private static extern void InsertCoinInternal(
             string options,
-            Action onLaunchCallback,
+            Action<string> onLaunchCallback,
             Action<string> onQuitInternalCallback,
-            Action onDisconnectCallback,
-            Action<string> onError);
+            Action<string> onDisconnectCallback,
+            Action<string> onError,
+            string onLaunchCallBackKey,
+            string onDisconnectCallBackKey
+            );
 
-        [MonoPInvokeCallback(typeof(Action))]
-        private static void InvokeInsertCoin()
+        [MonoPInvokeCallback(typeof(Action<string>))]
+        private static void InvokeInsertCoin(string key)
         {
-            CallbackManager.InvokeCallback();
+            CallbackManager.InvokeCallback(key);
 
 
 #if UNITY_WEBGL && !UNITY_EDITOR
@@ -92,11 +95,12 @@ public static void InsertCoin(InitOptions options = null, Action onLaunchCallBac
             if (IsRunningInBrowser())
             {
                 isPlayRoomInitialized = true;
-
 
-                CallbackManager.RegisterCallback(onLaunchCallBack);
-                CallbackManager.RegisterCallback(onDisconnectCallback);
 
+                string onLaunchCallBackKey = CallbackManager.RegisterCallback(onLaunchCallBack, "onLaunchCallBack");
+                string onDisconnectCallBackKey = CallbackManager.RegisterCallback(onDisconnectCallback, "onDisconnectCallBack");
+
+                Debug.Log(onLaunchCallBackKey);
 
                 string optionsJson = null;
                 if (options != null)
@@ -112,7 +116,9 @@ public static void InsertCoin(InitOptions options = null, Action onLaunchCallBac
 #endif
                 }
 
-                InsertCoinInternal(optionsJson, InvokeInsertCoin, __OnQuitInternalHandler, onDisconnectCallbackHandler, InvokeOnErrorInsertCoin);
+                InsertCoinInternal(
+                    optionsJson, InvokeInsertCoin, __OnQuitInternalHandler, onDisconnectCallbackHandler,
+                    InvokeOnErrorInsertCoin, onLaunchCallBackKey, onDisconnectCallBackKey);
             }
             else
             {
@@ -228,10 +234,10 @@ private static void __OnPlayerJoinCallbackHandler(string id)
             OnPlayerJoinWrapperCallback(id);
         }
 
-        [MonoPInvokeCallback(typeof(Action))]
-        private static void onDisconnectCallbackHandler()
+        [MonoPInvokeCallback(typeof(Action<string>))]
+        private static void onDisconnectCallbackHandler(string key)
         {
-            CallbackManager.InvokeCallback();
+            CallbackManager.InvokeCallback(key);
         }
 
 
@@ -404,7 +410,7 @@ public static Player Me()
 
 
         [DllImport("__Internal")]
-        private static extern void OnDisconnectInternal(Action callback);
+        private static extern void OnDisconnectInternal(Action<string> callback);
 
 
         public static void OnDisconnect(Action callback)

Assets/PlayroomKit/modules/CallbackManager.cs

@@ -0,0 +1,58 @@
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using UnityEngine;
+
+namespace Playroom
+{
+    public static class CallbackManager
+    {
+        private static Dictionary<string, Delegate> callbacks = new();
+
+        public static string RegisterCallback(Action callback, string key = null)
+        {
+            if (string.IsNullOrEmpty(key))
+                key = GenerateKey();
+
+
+            if (!callbacks.ContainsKey(key))
+            {
+                callbacks.Add(key, callback);
+            }
+            else
+            {
+                callbacks[key] = callback;
+            }
+
+            return key;
+        }
+
+
+        public static void InvokeCallback(string key)
+        {
+            if (callbacks.TryGetValue(key, out Delegate callback))
+            {
+                (callback as Action)?.Invoke();
+            }
+            else
+            {
+                Debug.LogError($"Callback with key {key} not found!");
+            }
+        }
+
+        private static string GenerateKey()
+        {
+            return Guid.NewGuid().ToString();
+        }
+
+
+
+        /// <summary>
+        /// Calls an external method to convert a string associated with a given key, called from the JS side only.
+        /// </summary>
+        /// <param name="key">The key associated with the string to be converted.</param>
+        [DllImport("__Internal")]
+        private static extern void ConvertString(string key);
+
+    }
+}

Assets/PlayroomKit/src/index.js

@@ -9,14 +9,22 @@ mergeInto(LibraryManager.library, {
     onLaunchCallBack,
     onQuitInternalCallback,
     onDisconnectCallback,
-    onError
+    onError,
+    onLaunchCallBackKey,
+    onQuitInternalCallbackKey
   ) {
+
+    onLaunchCallBackKey = UTF8ToString(onLaunchCallBackKey);
+    onQuitInternalCallbackKey = UTF8ToString(onQuitInternalCallbackKey);
+
     function OnLaunchCallBack() {
-      dynCall("v", onLaunchCallBack, []);
+      var key = _ConvertString(onLaunchCallBackKey);
+      dynCall("vi", onLaunchCallBack, [key]);
     }
 
     function OnDisconnectCallback() {
-      dynCall("v", onDisconnectCallback, []);
+      var key = _ConvertString(onQuitInternalCallbackKey);
+      dynCall("vi", onDisconnectCallback, [key]);
     }
     this.onPlayerJoinCallBacks = {};
     var options = optionsJson ? JSON.parse(UTF8ToString(optionsJson)) : {};
@@ -698,7 +706,7 @@ mergeInto(LibraryManager.library, {
     });
   },
 
-  WaitForStateInternal: function (stateKey, onStateSetCallback) {
+  WaitForStateInternal: function (state, onStateSetCallback) {
     if (!window.Playroom) {
       console.error(
         "Playroom library is not loaded. Please make sure to call InsertCoin first."
@@ -707,16 +715,12 @@ mergeInto(LibraryManager.library, {
       return;
     }
 
-    stateKey = UTF8ToString(stateKey);
-    Playroom.waitForState(stateKey)
+    state = UTF8ToString(state);
+    Playroom.waitForState(state)
       .then((stateVal) => {
-
-        var bufferSize = lengthBytesUTF8(stateKey) + 1;
-        var buffer = _malloc(bufferSize);
-        stringToUTF8(stateKey, buffer, bufferSize);
-
         stateVal = JSON.stringify(stateVal);
 
+        var buffer = _ConvertString(state);
 
         dynCall("vii", onStateSetCallback, [stringToNewUTF8(stateVal), buffer]);
       })
@@ -909,36 +913,17 @@ mergeInto(LibraryManager.library, {
       });
   },
 
-  // Utils for callback manager:
-  SendKey: function (key) {
-    if (!window.Playroom) {
-      console.error(
-        "Playroom library is not loaded. Please make sure to call InsertCoin first."
-      );
-      return;
-    }
-    console.log(UTF8ToString(key));
-    if (!this.callbackIds) {
-      this.callbackIds = [];
-    } 
-    this.callbackIds.push(UTF8ToString(key));
-  },
-
-  GetKey: function (key) {
-    if (!window.Playroom) {
-      console.error(
-        "Playroom library is not loaded. Please make sure to call InsertCoin first."
-      );
-      return;
-    }
-
-    var foundKey = this.callbackIds.find(function (item) {
-      return item === UTF8ToString(key);
-    });
-
-    var bufferSize = lengthBytesUTF8(foundKey) + 1;
+  // UTILS
+  /**
+   * Converts a given string into a UTF-8 encoded string and stores it in memory.
+   *
+   * @param {string} str - The string to be converted.
+   * @returns {number} The memory address of the buffer where the converted string is stored.
+   */
+  ConvertString: function (str) {
+    var bufferSize = lengthBytesUTF8(str) + 1;
     var buffer = _malloc(bufferSize);
-    stringToUTF8(foundKey, buffer, bufferSize);
+    stringToUTF8(str, buffer, bufferSize);
     return buffer;
   },
 });