@cloudcare/cocos-sdk 0.1.0-alpha.3 → 0.1.0-alpha.5

package/native/shared/FTReplayFileBridge.h

@@ -0,0 +1,62 @@
+#pragma once
+
+#if __has_include("bindings/jswrapper/SeApi.h")
+#define FT_COCOS_CREATOR3 1
+#include "bindings/jswrapper/SeApi.h"
+#else
+#include "cocos/scripting/js-bindings/jswrapper/SeApi.h"
+#endif
+#include "FTReplayFileWorker.h"
+
+namespace ft_cocos {
+
+static ReplayFileWorker replayFiles;
+
+static bool writeReplayFile(se::State& state) {
+    const auto& args = state.args();
+    if (args.size() != 2 || !args[0].isObject() || !args[1].isString()) return false;
+    auto* object = args[0].toObject();
+    if (!object->isTypedArray()) return false;
+    uint8_t* bytes = nullptr;
+    size_t size = 0;
+    if (!object->getTypedArrayData(&bytes, &size)) return false;
+    state.rval().setBoolean(replayFiles.write(bytes, size, args[1].toString()));
+    return true;
+}
+SE_BIND_FUNC(writeReplayFile)
+
+static bool pollReplayFile(se::State& state) {
+    state.rval().setString(replayFiles.poll());
+    return true;
+}
+SE_BIND_FUNC(pollReplayFile)
+
+static bool removeReplayFile(se::State& state) {
+    const auto& args = state.args();
+    if (args.size() != 1 || !args[0].isString()) return false;
+    state.rval().setBoolean(replayFiles.remove(args[0].toString()));
+    return true;
+}
+SE_BIND_FUNC(removeReplayFile)
+
+static bool registerReplayFileBridge(se::Object* global) {
+    replayFiles.cancel();
+    const se::HandleObject bridge(se::Object::createPlainObject());
+    bridge->defineFunction("write", _SE(writeReplayFile));
+    bridge->defineFunction("poll", _SE(pollReplayFile));
+    bridge->defineFunction("remove", _SE(removeReplayFile));
+    global->setProperty("__ftCocosReplayFile", se::Value(bridge));
+    se::ScriptEngine::getInstance()->addBeforeCleanupHook([]() { replayFiles.cancel(); });
+    return true;
+}
+
+static void installReplayFileBridge() {
+#if FT_COCOS_CREATOR3
+    se::ScriptEngine::getInstance()->addPermanentRegisterCallback(registerReplayFileBridge);
+#else
+    // Creator 2 calls AppDelegate again when restarting its script VM.
+    se::ScriptEngine::getInstance()->addRegisterCallback(registerReplayFileBridge);
+#endif
+}
+
+} // namespace ft_cocos

package/native/shared/FTReplayFileWorker.h

@@ -0,0 +1,88 @@
+#pragma once
+
+#include <atomic>
+#include <cerrno>
+#include <cstdio>
+#include <memory>
+#include <string>
+#include <thread>
+#include <vector>
+
+namespace ft_cocos {
+
+// Accessed only by the script thread. Workers own their buffers and never touch JS.
+class ReplayFileWorker {
+    enum Status { Pending, Written, Removed, Error };
+    struct Job {
+        std::string path;
+        std::atomic<Status> status{Pending};
+        std::atomic<bool> cancelled{false};
+    };
+    std::shared_ptr<Job> current;
+
+public:
+    bool write(const unsigned char* bytes, size_t size, const std::string& path) {
+        if (current && current->cancelled.load() && current->status.load() != Pending) current.reset();
+        if (current || !bytes || size == 0 || size > 2048U * 2048U * 4U || path.empty()) return false;
+        try {
+            auto job = std::make_shared<Job>();
+            job->path = path;
+            // This bounded copy is necessary because the JS buffer can be collected/reused.
+            std::vector<unsigned char> pixels(bytes, bytes + size);
+            current = job;
+            std::thread([job](std::vector<unsigned char> data) {
+                FILE* file = std::fopen(job->path.c_str(), "wb");
+                bool ok = false;
+                if (file) {
+                    const bool written = std::fwrite(data.data(), 1, data.size(), file) == data.size();
+                    ok = std::fclose(file) == 0 && written;
+                }
+                if (!ok || job->cancelled.load()) std::remove(job->path.c_str());
+                job->status.store(ok ? Written : Error);
+                // Covers cleanup racing with the final status transition.
+                if (job->cancelled.load()) std::remove(job->path.c_str());
+            }, std::move(pixels)).detach();
+        } catch (...) {
+            current.reset();
+            return false;
+        }
+        return true;
+    }
+
+    bool remove(const std::string& path) {
+        if (!current || current->path != path || current->status.load() != Written) return false;
+        auto job = current;
+        job->status.store(Pending);
+        try {
+            std::thread([job]() {
+                const bool ok = std::remove(job->path.c_str()) == 0 || errno == ENOENT;
+                job->status.store(ok ? Removed : Error);
+            }).detach();
+        } catch (...) {
+            job->status.store(Written);
+            return false;
+        }
+        return true;
+    }
+
+    const char* poll() {
+        if (!current) return "error";
+        switch (current->status.load()) {
+            case Pending: return "pending";
+            case Written: return "written";
+            case Removed: current.reset(); return "removed";
+            case Error: current.reset(); return "error";
+        }
+        return "error";
+    }
+
+    void cancel() {
+        if (!current) return;
+        auto job = current;
+        job->cancelled.store(true);
+        if (job->status.load() == Written) remove(job->path);
+        // Keep the slot occupied until its worker exits, including across VM restarts.
+    }
+};
+
+} // namespace ft_cocos

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cloudcare/cocos-sdk",
-  "version": "0.1.0-alpha.3",
+  "version": "0.1.0-alpha.5",
   "description": "Observability SDK integration for Cocos Creator 2.4 and 3.x",
   "license": "Apache-2.0",
   "author": "Guance Cloud",
@@ -37,6 +37,7 @@
     "creator2",
     "creator3",
     "dist",
+    "components",
     "extensions",
     "native",
     "bin",