com.beanbag.tiktokminigames 1.0.0

package/WebGL/TTStorageManager.cs

@@ -0,0 +1,155 @@
+using System.Runtime.InteropServices;
+using UnityEngine.Scripting;
+
+namespace TTSDK
+{
+    public static class TTStorage
+    {
+        public static void SetIntSync(string key, int value)
+        {
+            StarkStorageSetIntSync(key, value);
+        }
+
+        public static int GetIntSync(string key, int defaultValue)
+        {
+            return StarkStorageGetIntSync(key, defaultValue);
+        }
+
+        public static void SetFloatSync(string key, float value)
+        {
+            StarkStorageSetFloatSync(key, value);
+        }
+
+        public static float GetFloatSync(string key, float defaultValue)
+        {
+            return StarkStorageGetFloatSync(key, defaultValue);
+        }
+
+        public static void SetStringSync(string key, string value)
+        {
+            StarkStorageSetStringSync(key, value);
+        }
+
+        public static string GetStringSync(string key, string defaultValue)
+        {
+            return StarkStorageGetStringSync(key, defaultValue);
+        }
+
+        public static bool HasKeySync(string key)
+        {
+            return StarkStorageHasKeySync(key);
+        }
+
+        public static void DeleteKeySync(string key)
+        {
+            StarkStorageDeleteKeySync(key);
+        }
+
+        public static void DeleteAllSync()
+        {
+            StarkStorageDeleteAllSync();
+        }
+
+#if UNITY_WEBGL && !UNITY_EDITOR
+        [DllImport("__Internal")]
+        private static extern void StarkStorageSetIntSync(string key, int value);
+#else
+        static void StarkStorageSetIntSync(string key, int value)
+        {
+            UnityEngine.PlayerPrefs.SetInt(key, value);
+        }
+#endif
+
+#if UNITY_WEBGL && !UNITY_EDITOR
+        [DllImport("__Internal")]
+        private static extern int StarkStorageGetIntSync(string key, int defaultValue);
+#else
+        static int StarkStorageGetIntSync(string key, int defaultValue)
+        {
+            return UnityEngine.PlayerPrefs.GetInt(key, defaultValue);
+        }
+#endif
+
+#if UNITY_WEBGL && !UNITY_EDITOR
+        [DllImport("__Internal")]
+        private static extern void StarkStorageSetStringSync(string key, string value);
+#else
+        static void StarkStorageSetStringSync(string key, string value)
+        {
+            UnityEngine.PlayerPrefs.SetString(key, value);
+        }
+#endif
+
+
+#if UNITY_WEBGL && !UNITY_EDITOR
+        [DllImport("__Internal")]
+        private static extern string StarkStorageGetStringSync(string key, string defaultValue);
+#else
+        static string StarkStorageGetStringSync(string key, string defaultValue)
+        {
+            return UnityEngine.PlayerPrefs.GetString(key, defaultValue);
+        }
+#endif
+
+
+#if UNITY_WEBGL && !UNITY_EDITOR
+        [DllImport("__Internal")]
+        private static extern void StarkStorageSetFloatSync(string key, float value);
+#else
+        static void StarkStorageSetFloatSync(string key, float value)
+        {
+            UnityEngine.PlayerPrefs.SetFloat(key, value);
+        }
+#endif
+
+
+#if UNITY_WEBGL && !UNITY_EDITOR
+        [DllImport("__Internal")]
+        private static extern float StarkStorageGetFloatSync(string key, float defaultValue);
+#else
+        static float StarkStorageGetFloatSync(string key, float defaultValue)
+        {
+            return UnityEngine.PlayerPrefs.GetFloat(key, defaultValue);
+        }
+#endif
+
+
+#if UNITY_WEBGL && !UNITY_EDITOR
+        [DllImport("__Internal")]
+        private static extern void StarkStorageDeleteAllSync();
+#else
+        static void StarkStorageDeleteAllSync()
+        {
+            UnityEngine.PlayerPrefs.DeleteAll();
+        }
+#endif
+
+
+#if UNITY_WEBGL && !UNITY_EDITOR
+        [DllImport("__Internal")]
+        private static extern void StarkStorageDeleteKeySync(string key);
+#else
+        static void StarkStorageDeleteKeySync(string key)
+        {
+            UnityEngine.PlayerPrefs.DeleteKey(key);
+        }
+#endif
+
+
+#if UNITY_WEBGL && !UNITY_EDITOR
+        [DllImport("__Internal")]
+        private static extern bool StarkStorageHasKeySync(string key);
+#else
+        static bool StarkStorageHasKeySync(string key)
+        {
+            return UnityEngine.PlayerPrefs.HasKey(key);
+        }
+#endif
+
+#if UNITY_WEBGL && !UNITY_EDITOR
+        [Preserve]
+        [DllImport("__Internal")]
+        private static extern void StarkPointerStringify();
+#endif
+    }
+}

package/WebGL/TTStorageManager.cs.meta

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

package/WebGL/TTUNBridge.jslib

@@ -0,0 +1,117 @@
+mergeInto(LibraryManager.library, {
+  // ============================================================
+  // StarkSafeProxy: Wraps window.StarkSDK in a recursive Proxy
+  // so ALL method calls are automatically error-safe.
+  // No per-function try-catch needed in any jslib file.
+  // ============================================================
+  $StarkSafeProxy__postset: "StarkSafeProxy();",
+  $StarkSafeProxy: function () {
+    if (typeof Proxy === "undefined") return;
+
+    function makeSafe(target, path) {
+      return new Proxy(target, {
+        get: function (t, prop) {
+          if (typeof prop === "symbol") return t[prop];
+          var val;
+          try {
+            val = t[prop];
+          } catch (e) {
+            return undefined;
+          }
+          if (typeof val === "function") {
+            return function () {
+              try {
+                return val.apply(t, arguments);
+              } catch (e) {
+                console.error(
+                  "[" + path + "." + prop + "] error:",
+                  e.message || e
+                );
+              }
+            };
+          }
+          if (val != null && typeof val === "object") {
+            return makeSafe(val, path + "." + prop);
+          }
+          return val;
+        },
+        set: function (t, prop, v) {
+          t[prop] = v;
+          return true;
+        },
+      });
+    }
+
+    var _raw = window.StarkSDK || null;
+    var _safe = _raw ? makeSafe(_raw, "StarkSDK") : null;
+    Object.defineProperty(window, "StarkSDK", {
+      get: function () {
+        return _safe;
+      },
+      set: function (v) {
+        _raw = v;
+        _safe = v ? makeSafe(v, "StarkSDK") : v;
+      },
+      configurable: true,
+      enumerable: true,
+    });
+  },
+
+  // ============================================================
+  // Bridge utilities & functions
+  // ============================================================
+  StarkPointerStringify__deps: ["$StarkSafeProxy"],
+  StarkPointerStringify: function (str) {
+    if (typeof UTF8ToString !== "undefined") {
+      return UTF8ToString(str);
+    }
+    return Pointer_stringify(str);
+  },
+  unityCallJs: function (msg) {
+    if (typeof UNBridgeCore === "undefined") return;
+    try {
+      UNBridgeCore.handleMsgFromUnity(_StarkPointerStringify(msg));
+    } catch (e) {
+      console.error("[TTUNBridge] unityCallJs error:", e.message || e);
+    }
+  },
+  unityCallJsSync: function (msg) {
+    if (typeof UNBridgeCore === "undefined") return 0;
+    try {
+      var result = UNBridgeCore.handleMsgFromUnitySync(
+        _StarkPointerStringify(msg)
+      );
+      if (!result) return 0;
+      var bufferSize = lengthBytesUTF8(result) + 1;
+      var buffer = _malloc(bufferSize);
+      stringToUTF8(result, buffer, bufferSize);
+      return buffer;
+    } catch (e) {
+      console.error("[TTUNBridge] unityCallJsSync error:", e.message || e);
+      return 0;
+    }
+  },
+  h5HasAPI: function (apiName) {
+    try {
+      if (typeof UNBridgeCore === "undefined") return false;
+      return UNBridge.h5HasAPI(_StarkPointerStringify(apiName));
+    } catch (e) {
+      console.error("[TTUNBridge] h5HasAPI error:", e.message || e);
+      return false;
+    }
+  },
+  unityMixCallJs: function (msg) {
+    if (typeof UNBridgeCore === "undefined") return 0;
+    try {
+      var result = UNBridgeCore.onUnityMixCall(_StarkPointerStringify(msg));
+      if (!result) return 0;
+      var bufferSize = lengthBytesUTF8(result) + 1;
+      var buffer = _malloc(bufferSize);
+      stringToUTF8(result, buffer, bufferSize);
+      return buffer;
+    } catch (e) {
+      console.error("[TTUNBridge] unityMixCallJs error:", e.message || e);
+      return 0;
+    }
+  },
+});

package/WebGL/TTUNBridge.jslib.meta

@@ -0,0 +1,32 @@
+fileFormatVersion: 2
+guid: 5eb4a9465cc0f47118c08538402ee376
+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:
+      WebGL: WebGL
+    second:
+      enabled: 1
+      settings: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/WebGL/TTVersionAttribute.cs

@@ -0,0 +1,21 @@
+using System;
+
+namespace TTSDK
+{
+    [AttributeUsage(AttributeTargets.All, AllowMultiple = false, Inherited = true)]
+    public class TTVersionAttribute : Attribute
+    {
+        public string MinTTContainerAndroidVersion { get; set; }
+
+        public int MinAndroidOSVersion { get; set; }
+
+        public string WebGLMethod { get; set; }
+        
+        public bool IsSupportWebGL { get; set; }
+
+        /// <summary>
+        /// 最低客户端版本（宿主版本），如 "43.8.0"
+        /// </summary>
+        public string MinClientVersion { get; set; }
+    }
+}

package/WebGL/TTVersionAttribute.cs.meta

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

package/WebGL/TTWebGL.asmdef

@@ -0,0 +1,18 @@
+{
+    "name": "TTWebGL",
+    "rootNamespace": "",
+    "references": [
+        "GUID:986ad24dedab349ad9a8cb6ed29f9532",
+        "GUID:343deaaf83e0cee4ca978e7df0b80d21",
+        "GUID:2bafac87e7f4b9b418d9448d219b01ab"
+    ],
+    "includePlatforms": [],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
+}

package/WebGL/TTWebGL.asmdef.meta

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

package/WebGL/TTWebGLInterface.cs

@@ -0,0 +1,63 @@
+using System;
+using System.Runtime.InteropServices;
+using UnityEngine.Scripting;
+
+[assembly: Preserve]
+
+namespace TTSDK
+{
+    public delegate void GetFontDataDelegate(IntPtr pBuffer, int length);
+    public class TTWebGLInterface
+    {
+#if (UNITY_WEBPLAYER || UNITY_WEBGL)
+        //以下接口为Web使用，用于调用JS代码。
+        [method: Preserve]
+        [DllImport("__Internal")]
+        public static extern void unityCallJs(string msg);
+
+        [method: Preserve]
+        [DllImport("__Internal")]
+        public static extern string unityCallJsSync(string msg);
+
+        [method: Preserve]
+        [DllImport("__Internal")]
+        public static extern bool h5HasAPI(string apiName);
+
+        [method: Preserve]
+        [DllImport("__Internal")]
+        public static extern string unityMixCallJs(string msg);
+
+        [DllImport("__Internal")]
+        public static extern void StarkGetSystemFont(GetFontDataDelegate onFontData);
+#else
+        public static void unityCallJs(string msg)
+        {
+        }
+
+        public static string unityCallJsSync(string msg)
+        {
+            return "";
+        }
+
+        public static bool h5HasAPI(string apiName)
+        {
+            return false;
+        }
+
+        public static string unityMixCallJs(string msg)
+        {
+            return "";
+        }
+        
+        public static void StarkGetSystemFont(GetFontDataDelegate onFontData)
+        {
+            onFontData?.Invoke(IntPtr.Zero, 0);
+        }
+#endif
+#if UNITY_WEBGL && !UNITY_EDITOR
+        [Preserve]
+        [DllImport("__Internal")]
+        private static extern void StarkPointerStringify();
+#endif
+    }
+}

package/WebGL/TTWebGLInterface.cs.meta

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

package/WebGL.meta

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

package/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "com.beanbag.tiktokminigames",
+  "version": "1.0.0",
+  "displayName": "Tiktok Mini Games",
+  "description": "The helps to enable tiktok mini game ads, TTSDK Plugin Latest updates：[6.5.5]​",
+  "unity": "2019.1",
+  "author": {
+    "name": "Bean Bag",
+    "author": "Usman Arshad"
+  },
+  "type": "tool",
+  "hideInEditor": true
+}

package/package.json.meta

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