《Cocos 游戏开发高级编程》8.2 原生插件与三方 SDK 接入

native/engine/
├── common/Classes/              # C++：跨平台注册与胶水
│   └── blockdash_bridge.cpp     # 把 JS 侧回调名注册进脚本引擎
├── android/app/src/com/example/blockdash/
│   ├── AppActivity.java         # 引擎入口，挂载桥接
│   ├── BlockDashBridge.java     # 桥接类：暴露给 JS 的静态方法
│   └── SdkCallback.java         # SDK 回调的 Java 侧实现
└── ios/
    ├── AppController.mm         # 引擎入口
    └── BlockDashBridge.h/.mm    # 桥接类：暴露给 JS 的 Objective-C 方法

// native/engine/android/app/src/com/example/blockdash/BlockDashBridge.java
package com.example.blockdash;

import android.app.Activity;
import android.util.Log;

public final class BlockDashBridge {
    private static final String TAG = "BlockDashBridge";

    // 只存一个 Activity 引用，避免静态持有导致泄漏
    private static Activity sActivity;

    // JS 侧注册的回调名，如 "BlockDashNative.onLoginResult"
    private static String sLoginCallback = "";

    private BlockDashBridge() {}

    public static void init(Activity activity) {
        sActivity = activity;
    }

    // 由 JS 调用：注册结果回调
    public static void setLoginCallback(String jsCallback) {
        sLoginCallback = jsCallback == null ? "" : jsCallback;
    }

    // 由 JS 调用：发起登录，SDK 结果异步回来
    public static void login(String channel) {
        if (sActivity == null) {
            Log.w(TAG, "login called before init");
            return;
        }
        Log.i(TAG, "login with channel=" + channel);
        // 真实项目里这里调用厂商 SDK，并在其回调里派发到 JS 线程
        SdkCallback.dispatchLoginResult(sActivity, sLoginCallback, "code=0;token=demo");
    }
}

// native/engine/ios/BlockDashBridge.mm
#import <Foundation/Foundation.h>
#import "AppController.h"

@implementation BlockDashBridge

+ (void)setLoginCallback:(NSString *)jsCallback {
    // 把回调名存到单例或静态变量里
    [BlockDashBridge storeCallback:jsCallback];
}

+ (void)login:(NSString *)channel {
    NSLog(@"[BlockDashBridge] login channel=%@", channel);
    // 真实项目里调用厂商 framework，并在其回调里派发回 JS 线程
    [BlockDashBridge dispatchLoginResult:@"code=0;token=demo"];
}

@end

// assets/scripts/platform/native-bridge.ts
export interface LoginResult {
  ok: boolean;
  token: string;
}

export interface ILoginService {
  login(channel: string): Promise<LoginResult>;
}

// 运行时注入的原生对象，未在 cc.d.ts 中声明，自行补最小类型
interface RuntimeReflection {
  callStaticMethod(
    className: string,
    methodName: string,
    signature: string,
    ...args: unknown[]
  ): unknown;
}

function reflection(): RuntimeReflection | undefined {
  const g = globalThis as Record<string, unknown>;
  const n = g.native as { reflection?: RuntimeReflection } | undefined;
  return n?.reflection;
}

// assets/scripts/platform/login-service.ts
import { sys } from 'cc';
import { ILoginService, LoginResult } from './native-bridge';

const ANDROID_CLASS = 'com/example/blockdash/BlockDashBridge';
const IOS_CLASS = 'BlockDashBridge';

export class NativeLoginService implements ILoginService {
  login(channel: string): Promise<LoginResult> {
    const refl = reflection();
    if (!sys.isNative || !refl) {
      return Promise.resolve({ ok: false, token: '' });
    }
    return new Promise<LoginResult>((resolve) => {
      // 把 resolve 注册到一张表里，等原生回调时取出
      const cbName = `BlockDashNative_onLogin_${Date.now()}`;
      registerCallback(cbName, resolve);
      if (sys.platform === sys.Platform.ANDROID) {
        refl.callStaticMethod(ANDROID_CLASS, 'setLoginCallback', '(Ljava/lang/String;)V', cbName);
        refl.callStaticMethod(ANDROID_CLASS, 'login', '(Ljava/lang/String;)V', channel);
      } else {
        refl.callStaticMethod(IOS_CLASS, 'setLoginCallback:', '(NSString*)', cbName);
        refl.callStaticMethod(IOS_CLASS, 'login:', '(NSString*)', channel);
      }
    });
  }
}

// 回调注册表：原生回来时按名字取回 Promise 的 resolve
type Resolver = (r: LoginResult) => void;
const callbacks = new Map<string, Resolver>();

function registerCallback(name: string, r: Resolver): void {
  callbacks.set(name, r);
}

// 引擎会调用这个全局函数（原生侧按名字派发到这里）
export function BlockDashNative_onResult(name: string, payload: string): void {
  const r = callbacks.get(name);
  if (!r) return;
  callbacks.delete(name);
  r(parseResult(payload));
}

function parseResult(payload: string): LoginResult {
  const ok = payload.includes('code=0');
  const token = payload.split(';').find((p) => p.startsWith('token='))?.slice(6) ?? '';
  return { ok, token };
}

// logic/callback-registry.ts —— 与引擎无关，可直接单测
type Resolver<T> = (value: T) => void;

export class CallbackRegistry<T> {
  private readonly map = new Map<string, { resolve: Resolver<T>; timer: unknown }>();

  add(name: string, resolve: Resolver<T>, timeoutMs: number, onTimeout: () => void): void {
    const timer = setTimeout(() => {
      this.map.delete(name);
      onTimeout();
    }, timeoutMs);
    this.map.set(name, { resolve, timer });
  }

  resolve(name: string, value: T): boolean {
    const entry = this.map.get(name);
    if (!entry) return false; // 超时后到达的迟到结果，直接丢弃
    clearTimeout(entry.timer as number);
    this.map.delete(name);
    entry.resolve(value);
    return true;
  }

  get size(): number {
    return this.map.size;
  }
}