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

package/extensions/creator3/install-native.cjs

@@ -22,6 +22,7 @@ function installNative(buildRoot, extensionRoot, logger = console) {
   buildRoot = path.resolve(buildRoot);
   extensionRoot = path.resolve(extensionRoot);
   if (!fs.existsSync(buildRoot)) return;
+  const dependencyManager = readIosDependencyManager(buildRoot, extensionRoot);
   const nativeSource = path.join(extensionRoot, 'native');
   if (!fs.existsSync(nativeSource)) {
     logger.warn(`[cocos-sdk] Native bridge not found at ${nativeSource}`);
@@ -30,6 +31,11 @@ function installNative(buildRoot, extensionRoot, logger = console) {
   const buildNative = path.join(buildRoot, 'cocos-sdk-native');
   copyDirectory(nativeSource, buildNative);
   const files = findFiles(buildRoot, 7);
+  const replayHeader = path.join(buildNative, 'shared', 'FTReplayFileBridge.h');
+  if (fs.existsSync(replayHeader)) {
+    findReplayEntryFiles(files)
+      .forEach((file) => patchReplayFileBridge(file, replayHeader));
+  }
   const gradlePropertiesFiles = files.filter((file) => path.basename(file) === 'gradle.properties');
   const gradleFiles = uniqueFiles([
     ...files.filter((file) => /(?:^|\/)app\/build\.gradle$/.test(normalize(file))),
@@ -42,7 +48,11 @@ function installNative(buildRoot, extensionRoot, logger = console) {
   const iosApplicationProjects = xcodeProjects
     .map((projectFile) => ({ projectFile, target: findIosApplicationTarget(projectFile) }))
     .filter((project) => project.target);
-  if (podfiles.length === 0) {
+  if (dependencyManager === 'spm' && iosApplicationProjects.length > 0) {
+    migrateManagedPods(podfiles, logger);
+    copyDirectory(path.join(nativeSource, 'ios'), path.join(buildNative, 'FTCocosBridge'));
+  }
+  if (dependencyManager === 'cocoapods' && podfiles.length === 0) {
     iosApplicationProjects.forEach(({ projectFile, target }) => {
       const projectDirectory = path.dirname(path.dirname(projectFile));
       const podfile = path.join(projectDirectory, 'Podfile');
@@ -52,15 +62,67 @@ function installNative(buildRoot, extensionRoot, logger = console) {
   }
   iosApplicationProjects.forEach(({ projectFile, target }) => {
     patchCocos2IosConfiguration(projectFile, target);
+    if (dependencyManager === 'spm') {
+      require('./install-spm.cjs').installSwiftPackage(projectFile, path.join(buildNative, 'FTCocosBridge'), 'FTCocosBridge', target);
+    } else if (fs.readFileSync(projectFile, 'utf8').includes('XCLocalSwiftPackageReference')) {
+      require('./install-spm.cjs').removeSwiftPackages(projectFile);
+    }
   });
   gradleFiles.forEach((file) => patchGradle(file, buildNative));
   gradlePropertiesFiles.forEach(patchGradleProperties);
-  podfiles.forEach((file) => patchPodfile(file, buildNative));
+  if (dependencyManager === 'cocoapods') podfiles.forEach((file) => patchPodfile(file, buildNative));
   logger.info(
-    `[cocos-sdk] Installed native bridge (${gradleFiles.length} Android, ${podfiles.length} iOS project files).`,
+    `[cocos-sdk] Installed native bridge (${gradleFiles.length} Android, ${dependencyManager === 'spm' ? iosApplicationProjects.length : podfiles.length} iOS project files; iOS: ${dependencyManager}).`,
   );
 }
 
+function patchReplayFileBridge(file, header) {
+  const original = fs.readFileSync(file, 'utf8');
+  const includeBegin = '// COCOS_SDK_REPLAY_INCLUDE_BEGIN';
+  const includeEnd = '// COCOS_SDK_REPLAY_INCLUDE_END';
+  const initBegin = '// COCOS_SDK_REPLAY_INIT_BEGIN';
+  const initEnd = '// COCOS_SDK_REPLAY_INIT_END';
+  // Creator 3 shares Game.cpp across iOS/Android builds. Keep its include stable
+  // when another platform's build directory is cleaned or regenerated.
+  const sharedDirectory = path.join(path.dirname(file), 'cocos-sdk-replay');
+  const include = `${includeBegin}\n#include "cocos-sdk-replay/FTReplayFileBridge.h"\n${includeEnd}`;
+  const init = `${initBegin}\n    ft_cocos::installReplayFileBridge();\n    ${initEnd}\n    `;
+  let next = original;
+  if (markedPattern(initBegin, initEnd).test(next)) {
+    next = next.replace(markedPattern(initBegin, initEnd), init.trimEnd());
+  } else {
+    const anchor = path.basename(file) === 'Game.cpp'
+      ? /\b(?:return\s+)?BaseGame::init\(\);/
+      : /\b(?:return\s+)?se->start\(\);/;
+    if (!anchor.test(next)) return;
+    next = next.replace(anchor, (value) => init + value);
+  }
+  next = markedPattern(includeBegin, includeEnd).test(next)
+    ? next.replace(markedPattern(includeBegin, includeEnd), include)
+    : `${include}\n${next}`;
+  copyDirectory(path.dirname(header), sharedDirectory);
+  if (next !== original) fs.writeFileSync(file, next);
+}
+
+function findReplayEntryFiles(files) {
+  const entries = files.filter((file) => ['AppDelegate.cpp', 'Game.cpp'].includes(path.basename(file)));
+  for (const file of files) {
+    let nativeDirectory;
+    if (path.basename(file) === 'gradle.properties') {
+      const value = readProperty(fs.readFileSync(file, 'utf8'), 'NATIVE_DIR');
+      if (value) nativeDirectory = path.resolve(path.dirname(file), value);
+    } else if (path.basename(file) === 'CMakeCache.txt') {
+      const match = fs.readFileSync(file, 'utf8').match(/^CMAKE_HOME_DIRECTORY:INTERNAL=(.+)$/m);
+      if (match) nativeDirectory = match[1].trim();
+    }
+    if (nativeDirectory) {
+      const game = path.resolve(nativeDirectory, '..', 'common', 'Classes', 'Game.cpp');
+      if (fs.existsSync(game)) entries.push(game);
+    }
+  }
+  return uniqueFiles(entries);
+}
+
 function patchCocos2IosConfiguration(projectFile, target) {
   const projectDirectory = path.dirname(path.dirname(projectFile));
   const iosDirectory = path.join(projectDirectory, 'ios');
@@ -200,9 +262,9 @@ function patchGradle(file, nativeRoot) {
     "    maven { url 'https://mvnrepo.guance.com/repository/maven-releases' }",
     '}',
     'dependencies {',
-    "    implementation 'com.cloudcare.ft.mobile.sdk.tracker.agent:ft-sdk:1.7.6-alpha02'",
+    "    implementation 'com.cloudcare.ft.mobile.sdk.tracker.agent:ft-sdk:1.7.6-alpha03'",
     "    implementation 'com.cloudcare.ft.mobile.sdk.tracker.agent:ft-native:1.1.3'",
-    "    implementation 'com.cloudcare.ft.mobile.sdk.tracker.agent:ft-session-replay:0.1.9-alpha02'",
+    "    implementation 'com.cloudcare.ft.mobile.sdk.tracker.agent:ft-session-replay:0.1.9-alpha03'",
     "    implementation 'com.google.code.gson:gson:2.10.1'",
     "    implementation platform('org.jetbrains.kotlin:kotlin-bom:1.8.22')",
     "    implementation 'androidx.appcompat:appcompat:1.1.0'",
@@ -246,6 +308,10 @@ function replaceIndentedMarkedBlock(contents, begin, end, block) {
 
 function findIosApplicationTarget(projectFile) {
   const contents = fs.readFileSync(projectFile, 'utf8');
+  if (contents.includes('COCOS_SDK_XCODE_PROJECT')) {
+    const { readProject, applicationTarget } = require('./install-spm.cjs');
+    return applicationTarget(readProject(projectFile))?.[1].name || null;
+  }
   const nativeTarget = /\/\* ([^*]+) \*\/ = \{\s*isa = PBXNativeTarget;([\s\S]*?)\n\s*\};/g;
   const targets = [];
   let match;
@@ -330,4 +396,58 @@ function escapeGroovy(value) { return value.replace(/\\/g, '\\\\').replace(/'/g,
 function escapeRuby(value) { return value.replace(/\\/g, '\\\\').replace(/'/g, "\\'"); }
 function escapeRegExp(value) { return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); }
 
-module.exports = { installNative };
+function readIosDependencyManager(buildRoot, extensionRoot) {
+  for (const start of [buildRoot, extensionRoot]) {
+    let directory = path.resolve(start);
+    while (true) {
+      const file = path.join(directory, 'cocos-sdk.config.json');
+      if (fs.existsSync(file)) {
+        const config = JSON.parse(fs.readFileSync(file, 'utf8'));
+        const manager = config.ios?.dependencyManager ?? 'cocoapods';
+        if (!['spm', 'cocoapods'].includes(manager)) {
+          throw new Error(`[cocos-sdk] Invalid ios.dependencyManager in ${file}: expected spm or cocoapods.`);
+        }
+        return manager;
+      }
+      const parent = path.dirname(directory);
+      if (parent === directory) break;
+      directory = parent;
+    }
+  }
+  return 'cocoapods';
+}
+
+function migrateManagedPods(podfiles, logger) {
+  for (const file of podfiles) {
+    const original = fs.readFileSync(file, 'utf8');
+    let next = original;
+    for (const [begin, end] of [
+      [POD_BEGIN, POD_END], [LEGACY_POD_BEGIN, LEGACY_POD_END], [LEGACY_BEGIN, LEGACY_END],
+      ['# COCOS_HYBRID_SAMPLE_BEGIN', '# COCOS_HYBRID_SAMPLE_END'],
+    ]) next = next.replace(markedPattern(begin, end), '');
+    if (/^\s*pod\s+['"](?:FTCocosBridge|HybridSampleHost|GuanceSDK)(?:\/[^'"]*)?['"]/m.test(next)) {
+      throw new Error(`[cocos-sdk] Remove the manually declared native SDK Pod from ${file} before switching to SPM.`);
+    }
+    if (next !== original) fs.writeFileSync(file, next);
+    const directory = path.dirname(file);
+    const existingLock = path.join(directory, 'Podfile.lock');
+    const hasSDKPods = fs.existsSync(existingLock)
+      && /^\s*- (?:FTCocosBridge|HybridSampleHost|GuanceSDK)(?:\/|\s|:)/m.test(fs.readFileSync(existingLock, 'utf8'));
+    if (next === original && !hasSDKPods) continue;
+    if (fs.existsSync(path.join(directory, 'Podfile.lock')) || fs.existsSync(path.join(directory, 'Pods'))) {
+      logger.info('[cocos-sdk] Updating existing Pods integration for the SPM switch.');
+      try {
+        execFileSync('pod', ['install'], { cwd: directory, encoding: 'utf8', maxBuffer: 4 * 1024 * 1024 });
+      } catch (error) {
+        fs.writeFileSync(file, original);
+        throw new Error(`[cocos-sdk] Unable to update existing Pods in ${directory}: ${error.message}`);
+      }
+      const lock = path.join(directory, 'Podfile.lock');
+      if (fs.existsSync(lock) && /^\s*- GuanceSDK(?:\/|\s|:)/m.test(fs.readFileSync(lock, 'utf8'))) {
+        throw new Error(`[cocos-sdk] Another Pod still depends on the native SDK in ${lock}; migrate that dependency before using SPM.`);
+      }
+    }
+  }
+}
+
+module.exports = { installNative, readIosDependencyManager };

package/extensions/creator3/install-spm.cjs

@@ -0,0 +1,190 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { createHash } = require('crypto');
+const { execFileSync } = require('child_process');
+
+function readProject(file) {
+  // plutil understands both Xcode's OpenStep format and XML plists, without Ruby/gems.
+  return JSON.parse(execFileSync('/usr/bin/plutil', ['-convert', 'json', '-o', '-', file], {
+    encoding: 'utf8', maxBuffer: 32 * 1024 * 1024,
+  }));
+}
+
+function writeProject(file, project) {
+  const next = `// !$*UTF8*$!\n// COCOS_SDK_XCODE_PROJECT\n${serialize(project)}\n`;
+  if (fs.readFileSync(file, 'utf8') !== next) fs.writeFileSync(file, next);
+}
+
+function serialize(value, depth = 0) {
+  const indent = '\t'.repeat(depth);
+  if (Array.isArray(value)) {
+    return `(\n${value.map((entry) => `${indent}\t${serialize(entry, depth + 1)},\n`).join('')}${indent})`;
+  }
+  if (value && typeof value === 'object') {
+    return `{\n${Object.entries(value).sort(([a], [b]) => a === 'isa' ? -1 : b === 'isa' ? 1 : a.localeCompare(b)).map(([key, entry]) => (
+      `${indent}\t${serialize(key)} = ${serialize(entry, depth + 1)};\n`
+    )).join('')}${indent}}`;
+  }
+  const text = String(value);
+  return /^[A-Za-z0-9_./]+$/.test(text) ? text : JSON.stringify(text);
+}
+
+function applicationTarget(project, preferredName) {
+  const targets = Object.entries(project.objects).filter(([, object]) => (
+    object.isa === 'PBXNativeTarget' && object.productType === 'com.apple.product-type.application'
+  ));
+  return targets.find(([, object]) => object.name === preferredName)
+    || targets.find(([, object]) => /(?:^|[-_.])(?:mobile|ios)$/i.test(object.name))
+    || targets[0];
+}
+
+function add(list, value) {
+  if (!list.includes(value)) list.push(value);
+}
+
+function identifier(value) {
+  return createHash('sha256').update(`cocos-sdk:${value}`).digest('hex').slice(0, 24).toUpperCase();
+}
+
+function installSwiftPackage(projectFile, packageDirectory, productName, targetName) {
+  if (!fs.existsSync(path.join(packageDirectory, 'Package.swift'))) {
+    throw new Error(`[cocos-sdk] Missing Swift package: ${packageDirectory}`);
+  }
+  const project = readProject(projectFile);
+  const selected = applicationTarget(project, targetName);
+  if (!selected) throw new Error(`[cocos-sdk] No application target in ${projectFile}`);
+  const [targetID, target] = selected;
+  const objects = project.objects;
+  const root = objects[project.rootObject];
+  const projectDirectory = path.resolve(path.dirname(path.dirname(projectFile)), root.projectDirPath || '.');
+  const relativePath = path.relative(projectDirectory, packageDirectory).split(path.sep).join('/');
+  const packageID = identifier(`package:${productName}`);
+  const productID = identifier(`product:${targetID}:${productName}`);
+  const buildID = identifier(`framework:${targetID}:${productName}`);
+  const existing = (target.packageProductDependencies || []).find((id) => (
+    id !== productID && objects[id]?.productName === productName
+  ));
+  if (existing) throw new Error(`[cocos-sdk] ${productName} is already managed manually in ${target.name}; remove that reference before automatic installation.`);
+
+  objects[packageID] = { isa: 'XCLocalSwiftPackageReference', relativePath };
+  objects[productID] = { isa: 'XCSwiftPackageProductDependency', productName };
+  objects[buildID] = { isa: 'PBXBuildFile', productRef: productID };
+  add(root.packageReferences ||= [], packageID);
+  add(target.packageProductDependencies ||= [], productID);
+  let phaseID = (target.buildPhases || []).find((id) => objects[id]?.isa === 'PBXFrameworksBuildPhase');
+  if (!phaseID) {
+    phaseID = identifier(`frameworks:${targetID}`);
+    objects[phaseID] = { isa: 'PBXFrameworksBuildPhase', buildActionMask: '2147483647', files: [], runOnlyForDeploymentPostprocessing: '0' };
+    add(target.buildPhases ||= [], phaseID);
+  }
+  add(objects[phaseID].files ||= [], buildID);
+  const configurations = objects[target.buildConfigurationList]?.buildConfigurations || [];
+  for (const configID of configurations) {
+    const settings = objects[configID].buildSettings ||= {};
+    const flags = settings.OTHER_LDFLAGS;
+    if (Array.isArray(flags)) {
+      add(flags, '$(inherited)');
+      add(flags, '-ObjC');
+    } else {
+      const parts = [flags || '$(inherited)'];
+      if (!String(flags || '').includes('$(inherited)')) add(parts, '$(inherited)');
+      if (!/(?:^|\s)-ObjC(?:\s|$)/.test(flags || '')) add(parts, '-ObjC');
+      settings.OTHER_LDFLAGS = parts.join(' ');
+    }
+    if (Number(settings.IPHONEOS_DEPLOYMENT_TARGET || 0) < 12) settings.IPHONEOS_DEPLOYMENT_TARGET = '12.0';
+    settings.CLANG_ENABLE_MODULES = 'YES';
+  }
+  preserveCmakeIntegration(projectFile, project, { packageDirectory, productName, targetName: target.name });
+  writeProject(projectFile, project);
+}
+
+const RESTORE_BEGIN = '# COCOS_SDK_SPM_RESTORE_BEGIN';
+const RESTORE_END = '# COCOS_SDK_SPM_RESTORE_END';
+const restorePattern = /\n?# COCOS_SDK_SPM_RESTORE_BEGIN[\s\S]*?# COCOS_SDK_SPM_RESTORE_END\n?/g;
+
+function shellQuote(value) {
+  return `'${String(value).replace(/'/g, `'\\''`)}'`;
+}
+
+function preserveCmakeIntegration(projectFile, project, entry) {
+  const objects = project.objects;
+  const zeroCheck = Object.values(objects).find((object) => object.name === 'ZERO_CHECK');
+  if (!zeroCheck) return;
+  // CMake's SYMROOT/OBJROOT overrides select Xcode's legacy build locations,
+  // which reject packages. Keep CONFIGURATION_BUILD_DIR (engine archives).
+  const stateFile = path.join(path.dirname(projectFile), 'cocos-sdk-spm.json');
+  const state = fs.existsSync(stateFile)
+    ? JSON.parse(fs.readFileSync(stateFile, 'utf8')) : { packages: [], buildLocations: {} };
+  for (const [id, object] of Object.entries(objects)) {
+    if (object.isa !== 'XCBuildConfiguration') continue;
+    for (const key of ['SYMROOT', 'OBJROOT']) {
+      if (object.buildSettings?.[key] === undefined) continue;
+      (state.buildLocations[id] ||= {})[key] = object.buildSettings[key];
+      delete object.buildSettings[key];
+    }
+  }
+  const relativeDirectory = path.relative(path.dirname(projectFile), entry.packageDirectory);
+  state.packages = state.packages.filter((item) => item.productName !== entry.productName);
+  state.packages.push({ ...entry, packageDirectory: relativeDirectory });
+  state.packages.sort((a, b) => a.productName.localeCompare(b.productName));
+  const helper = path.join(path.dirname(projectFile), 'cocos-sdk-spm.cjs');
+  if (path.resolve(helper) !== path.resolve(__filename)) fs.copyFileSync(__filename, helper);
+  const restore = [
+    RESTORE_BEGIN,
+    `${process.versions.electron ? 'ELECTRON_RUN_AS_NODE=1 ' : ''}${shellQuote(process.execPath)} ${shellQuote(helper)} --restore`,
+    RESTORE_END,
+  ].join('\n');
+  for (const id of zeroCheck.buildPhases || []) {
+    const phase = objects[id];
+    if (phase?.isa !== 'PBXShellScriptBuildPhase') continue;
+    phase.shellScript = `${(phase.shellScript || '').replace(restorePattern, '').trimEnd()}\n${restore}\n`;
+  }
+  const serialized = `${JSON.stringify(state, null, 2)}\n`;
+  if (!fs.existsSync(stateFile) || fs.readFileSync(stateFile, 'utf8') !== serialized) fs.writeFileSync(stateFile, serialized);
+}
+
+function removeSwiftPackages(projectFile) {
+  const project = readProject(projectFile);
+  const objects = project.objects;
+  const removed = new Set();
+  for (const productName of ['FTCocosBridge', 'HybridSampleHost']) {
+    const packageID = identifier(`package:${productName}`);
+    if (!objects[packageID]) continue;
+    removed.add(packageID);
+    for (const [id, object] of Object.entries(objects)) {
+      if (object.isa !== 'PBXNativeTarget') continue;
+      removed.add(identifier(`product:${id}:${productName}`));
+      removed.add(identifier(`framework:${id}:${productName}`));
+    }
+  }
+  if (!removed.size) return;
+  for (const id of removed) delete objects[id];
+  for (const object of Object.values(objects)) {
+    for (const key of ['packageReferences', 'packageProductDependencies', 'files']) {
+      if (Array.isArray(object[key])) object[key] = object[key].filter((id) => !removed.has(id));
+    }
+    if (object.isa === 'PBXShellScriptBuildPhase') object.shellScript = (object.shellScript || '').replace(restorePattern, '');
+  }
+  const stateFile = path.join(path.dirname(projectFile), 'cocos-sdk-spm.json');
+  if (fs.existsSync(stateFile)) {
+    const state = JSON.parse(fs.readFileSync(stateFile, 'utf8'));
+    for (const [id, settings] of Object.entries(state.buildLocations)) {
+      if (objects[id]) Object.assign(objects[id].buildSettings ||= {}, settings);
+    }
+    fs.unlinkSync(stateFile);
+    fs.rmSync(path.join(path.dirname(projectFile), 'cocos-sdk-spm.cjs'), { force: true });
+  }
+  writeProject(projectFile, project);
+}
+
+module.exports = { installSwiftPackage, removeSwiftPackages, readProject, applicationTarget };
+
+if (require.main === module && process.argv[2] === '--restore') {
+  const directory = path.dirname(__filename);
+  const state = JSON.parse(fs.readFileSync(path.join(directory, 'cocos-sdk-spm.json'), 'utf8'));
+  for (const item of state.packages) {
+    installSwiftPackage(path.join(directory, 'project.pbxproj'), path.resolve(directory, item.packageDirectory), item.productName, item.targetName);
+  }
+}

package/native/android/src/main/java/com/ft/sdk/cocos/FTCocosBridge.java

@@ -124,6 +124,10 @@ public final class FTCocosBridge {
 
     private static Object dispatch(String method, JSONObject payload) throws Exception {
         switch (method) {
+            case "replay.beginSaveImage":
+                return FTCocosReplayImageJobs.begin(payload);
+            case "replay.pollSaveImage":
+                return FTCocosReplayImageJobs.poll(payload.getString("job"));
             case "hybrid.attach":
                 attachHybrid(payload);
                 return null;

package/native/android/src/main/java/com/ft/sdk/cocos/FTCocosReplayImageJobs.java

@@ -0,0 +1,55 @@
+package com.ft.sdk.cocos;
+
+import org.json.JSONObject;
+import java.util.UUID;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+/** One image in flight across JS runtimes; the caller polls without waiting on disk/encoding. */
+final class FTCocosReplayImageJobs {
+    private static final ExecutorService worker = Executors.newSingleThreadExecutor(runnable -> {
+        Thread thread = new Thread(runnable, "cocos-replay-image");
+        thread.setDaemon(true);
+        return thread;
+    });
+    private static Job current;
+
+    private static final class Job {
+        final String id = UUID.randomUUID().toString();
+        String response;
+    }
+
+    static synchronized String begin(JSONObject arguments) throws Exception {
+        final String method = arguments.getString("method");
+        if (!"replay.saveImage".equals(method) && !"replay.saveImageV2".equals(method)) {
+            throw new IllegalArgumentException("Unsupported asynchronous Replay method");
+        }
+        final String payload = arguments.getJSONObject("arguments").toString();
+        if (current != null && current.response == null) throw new IllegalStateException("Replay encoder is busy");
+        final Job job = new Job();
+        current = job;
+        try {
+            worker.execute(() -> {
+                String response = FTCocosBridge.invokeLocal(method, payload);
+                synchronized (FTCocosReplayImageJobs.class) {
+                    job.response = response;
+                }
+            });
+        } catch (RuntimeException error) {
+            current = null;
+            throw error;
+        }
+        return job.id;
+    }
+
+    static synchronized JSONObject poll(String id) throws Exception {
+        if (current == null || !current.id.equals(id)) throw new IllegalArgumentException("Replay encoding job is unavailable");
+        JSONObject result = new JSONObject();
+        result.put("pending", current.response == null);
+        if (current.response != null) {
+            result.put("response", current.response);
+            current = null;
+        }
+        return result;
+    }
+}

package/native/ios/FTCocosBridge.m

@@ -1,6 +1,14 @@
 #import "FTCocosBridge.h"
-
-#import "FTMobileSDK.h"
+#import "FTCocosReplayImageJobs.h"
+
+#import "FTMobileAgent.h"
+#import "FTSDKConfig.h"
+#import "FTRumConfig.h"
+#import "FTLoggerConfig.h"
+#import "FTMobileConfig.h"
+#import "FTExternalDataManager.h"
+#import "FTResourceMetricsModel.h"
+#import "FTResourceContentModel.h"
 #import "FTSessionReplay.h"
 #import <UIKit/UIKit.h>
 #import <objc/message.h>
@@ -24,6 +32,10 @@
 }
 
 + (id)dispatch:(NSString *)method arguments:(NSDictionary *)arguments {
+    if ([method isEqualToString:@"replay.beginSaveImage"]) return [self beginSaveImage:arguments];
+    if ([method isEqualToString:@"replay.pollSaveImage"]) {
+        return [FTCocosReplayImageJobs poll:[self requiredText:arguments key:@"job"]];
+    }
     FTExternalDataManager *rum = [FTExternalDataManager sharedManager];
     if ([method isEqualToString:@"hybrid.attach"]) {
         [self ensureNativeHostInitialized];
@@ -254,6 +266,18 @@
     return nil;
 }
 
++ (NSString *)beginSaveImage:(NSDictionary *)arguments {
+    NSString *method = [self requiredText:arguments key:@"method"];
+    if (![method isEqualToString:@"replay.saveImage"] && ![method isEqualToString:@"replay.saveImageV2"]) {
+        [self fail:@"Unsupported asynchronous Replay method"];
+    }
+    NSDictionary *payload = [[self dictionary:arguments[@"arguments"]] copy];
+    if (!payload) [self fail:@"Replay image arguments are required"];
+    return [FTCocosReplayImageJobs beginWithWork:^NSString *{
+        return [self responseWithValue:[self dispatch:method arguments:payload] error:nil];
+    }];
+}
+
 + (void)ensureNativeHostInitialized {
     @try {
         if (![FTMobileAgent sharedInstance]) {

package/native/ios/FTCocosBridge.podspec

@@ -1,18 +1,18 @@
 Pod::Spec.new do |s|
   s.name             = 'FTCocosBridge'
-  s.version          = '0.1.0-alpha.3'
+  s.version          = '0.1.0-alpha.5'
   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
   # reference would otherwise keep the Objective-C category/class in the app.
   s.user_target_xcconfig = { 'OTHER_LDFLAGS' => '$(inherited) -ObjC' }
-  s.dependency 'GuanceSDK/Agent', '1.6.8-alpha.2'
-  s.dependency 'GuanceSDK/FTSessionReplay', '1.6.8-alpha.2'
+  s.dependency 'GuanceSDK/Agent', '1.6.8-alpha.5'
+  s.dependency 'GuanceSDK/FTSessionReplay', '1.6.8-alpha.5'
 end

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/ios/Package.swift

@@ -0,0 +1,26 @@
+// swift-tools-version:5.3
+import PackageDescription
+
+let package = Package(
+    name: "FTCocosBridge",
+    platforms: [.iOS(.v12)],
+    products: [.library(name: "FTCocosBridge", targets: ["FTCocosBridge"])],
+    dependencies: [
+        .package(url: "https://github.com/GuanceCloud/datakit-ios.git", .exact("1.6.8-alpha.5")),
+    ],
+    targets: [
+        .target(
+            name: "FTCocosBridge",
+            dependencies: [
+                .product(name: "GuanceSDK", package: "datakit-ios"),
+                .product(name: "GuanceSessionReplay", package: "datakit-ios"),
+            ],
+            path: ".",
+            exclude: ["FTCocosBridge.podspec"],
+            sources: ["FTCocosBridge.m", "FTCocosReplayImageJobs.m"],
+            publicHeadersPath: "include",
+            cSettings: [.headerSearchPath(".")],
+            linkerSettings: [.linkedFramework("UIKit")]
+        ),
+    ]
+)

package/native/ios/include/FTCocosBridge.h

@@ -0,0 +1,2 @@
+// Keep the public SPM header in sync with the CocoaPods/source integration.
+#import "../FTCocosBridge.h"