@cloudcare/cocos-sdk 0.1.0-alpha.2 → 0.1.0-alpha.4

package/native/ios/FTCocosBridge.podspec

@@ -1,13 +1,13 @@
 Pod::Spec.new do |s|
   s.name             = 'FTCocosBridge'
-  s.version          = '0.1.0-alpha.2'
+  s.version          = '0.1.0-alpha.4'
   s.summary          = 'CloudCare Mobile SDK native bridge for Cocos Creator.'
   s.homepage         = 'https://github.com/GuanceCloud/datakit-cocos'
   s.license          = { :type => 'Apache-2.0' }
   s.author           = { 'Guance Cloud' => 'support@guance.com' }
   s.source           = { :path => '.' }
   s.platform         = :ios, '12.0'
-  s.source_files     = 'FTCocosBridge.{h,m}'
+  s.source_files     = 'FTCocosBridge.{h,m}', 'FTCocosReplayImageJobs.{h,m}'
   s.public_header_files = 'FTCocosBridge.h'
   s.requires_arc     = true
   # Cocos resolves FTCocosBridge by class name at runtime, so no direct symbol

package/native/ios/FTCocosReplayImageJobs.h

@@ -0,0 +1,11 @@
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/** One background image operation, with nonblocking result retrieval from JSB. */
+@interface FTCocosReplayImageJobs : NSObject
++ (NSString *)beginWithWork:(NSString *(^)(void))work;
++ (NSDictionary *)poll:(NSString *)identifier;
+@end
+
+NS_ASSUME_NONNULL_END

package/native/ios/FTCocosReplayImageJobs.m

@@ -0,0 +1,54 @@
+#import "FTCocosReplayImageJobs.h"
+
+@interface FTCocosReplayImageJob : NSObject
+@property (nonatomic, copy) NSString *identifier;
+@property (nonatomic, copy) NSString *response;
+@end
+@implementation FTCocosReplayImageJob
+@end
+
+static FTCocosReplayImageJob *currentJob;
+
+@implementation FTCocosReplayImageJobs
+
++ (NSString *)beginWithWork:(NSString *(^)(void))work {
+    FTCocosReplayImageJob *job = [FTCocosReplayImageJob new];
+    job.identifier = NSUUID.UUID.UUIDString;
+    @synchronized (self) {
+        if (currentJob && !currentJob.response) {
+            [NSException raise:NSInternalInconsistencyException format:@"Replay encoder is busy"];
+        }
+        currentJob = job;
+    }
+    dispatch_async(dispatch_get_global_queue(QOS_CLASS_UTILITY, 0), ^{
+        @autoreleasepool {
+            NSString *response;
+            @try {
+                response = work();
+            } @catch (NSException *exception) {
+                NSData *data = [NSJSONSerialization dataWithJSONObject:@{
+                    @"ok": @NO, @"error": exception.reason ?: @"Replay encoding failed"
+                } options:0 error:nil];
+                response = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
+            }
+            @synchronized (self) {
+                job.response = response ?: @"{\"ok\":false,\"error\":\"Empty Replay encoding result\"}";
+            }
+        }
+    });
+    return job.identifier;
+}
+
++ (NSDictionary *)poll:(NSString *)identifier {
+    @synchronized (self) {
+        if (![currentJob.identifier isEqualToString:identifier]) {
+            [NSException raise:NSInvalidArgumentException format:@"Replay encoding job is unavailable"];
+        }
+        if (!currentJob.response) return @{ @"pending": @YES };
+        NSDictionary *result = @{ @"pending": @NO, @"response": currentJob.response };
+        currentJob = nil;
+        return result;
+    }
+}
+
+@end

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.2",
+  "version": "0.1.0-alpha.4",
   "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",