moonbridge-ts 0.1.0

package/src/moonbridge-ipc/client/internal/bridge/ipc_client_bridge.ts

@@ -0,0 +1,74 @@
+// IPC 客户端桥接器，对应
+// moonbridge-ipc-flutter/lib/client/internal/bridge/ipc_client_bridge.dart
+
+import { Bridge } from '../../../../moonbridge/kernel/bridge';
+import { Executor } from '../../../../moonbridge/kernel/executor';
+import { ModuleCreator } from '../../../../moonbridge/module/module_creator';
+import { MessageParserManager } from '../../../../moonbridge/message/message_parser_manager';
+import { IpcClientExecutor } from './ipc_client_executor';
+import { IpcCommunicationAgent } from '../ipc/communication/ipc_communication_agent';
+import { MoonBridgeIpcClient } from '../../moonbridge_ipc_client';
+
+/**
+ * IPC 客户端桥接器类。
+ *
+ * 该类实现 Bridge 接口，用于管理 IPC 客户端的模块创建、执行器和消息解析器。
+ */
+export class IpcClientBridge implements Bridge {
+  /** IPC 客户端实例（TS 端使用占位类型） */
+  private readonly _ipcClient: MoonBridgeIpcClient;
+
+  /** IPC 客户端执行器 */
+  private readonly _executor: IpcClientExecutor;
+
+  /** 模块创建器 */
+  private readonly _moduleCreator: ModuleCreator;
+
+  /** 消息解析器管理器 */
+  private readonly _parserManager: MessageParserManager;
+
+  /**
+   * 构造函数。
+   *
+   * @param ipcClient IPC 客户端实例
+   * @param communicationAgent 通信代理实例
+   */
+  constructor(
+    ipcClient: MoonBridgeIpcClient,
+    communicationAgent: IpcCommunicationAgent,
+  ) {
+    this._ipcClient = ipcClient;
+    this._executor = new IpcClientExecutor(this, communicationAgent);
+    this._moduleCreator = new ModuleCreator(this);
+    this._parserManager = new MessageParserManager(undefined);
+  }
+
+  /**
+   * 初始化配置。
+   */
+  initialize(): void {
+    // Do nothing...
+  }
+
+  /** 获取 IPC 客户端实例 */
+  get ipcClient(): MoonBridgeIpcClient {
+    return this._ipcClient;
+  }
+
+  /** 获取执行器实例 */
+  get executor(): Executor {
+    return this._executor;
+  }
+
+  /** 获取模块创建器实例 */
+  get moduleCreator(): ModuleCreator {
+    return this._moduleCreator;
+  }
+
+  /** 获取消息解析器管理器实例 */
+  get parserManager(): MessageParserManager {
+    return this._parserManager;
+  }
+}
+
+

package/src/moonbridge-ipc/client/internal/bridge/ipc_client_executor.ts

@@ -0,0 +1,208 @@
+// IPC 客户端执行器，对应
+// moonbridge-ipc-flutter/lib/client/internal/bridge/ipc_client_executor.dart
+
+import { Executor } from '../../../../moonbridge/kernel/executor';
+import { Bridge } from '../../../../moonbridge/kernel/bridge';
+import { Message } from '../../../../moonbridge/message/message';
+import { InvokerProvider } from '../../../../moonbridge/module/method_invoker';
+import { Request } from '../../../general/message/request';
+import { Response } from '../../../general/message/response';
+import { Error } from '../../../general/message/error';
+import { IpcError } from '../../../general/error/ipc_error';
+import { logger } from '../../../utils/logger';
+import { ResultCallback } from '../../../../moonbridge/kernel/result_callback';
+import { IpcCommunicationAgent } from '../ipc/communication/ipc_communication_agent';
+
+const CALLBACK_PREFIX = '_$_mb_callback_$_';
+
+/**
+ * IPC 客户端执行器类。
+ *
+ * 该类继承自 Executor，用于管理 IPC 客户端的方法调用。
+ */
+export class IpcClientExecutor extends Executor {
+  /** 调用提供者 */
+  private readonly invokerProvider = new InvokerProvider();
+
+  /** 通信代理实例 */
+  private readonly communicationAgent: IpcCommunicationAgent;
+
+  constructor(bridge: Bridge, communicationAgent: IpcCommunicationAgent) {
+    super(bridge);
+    this.communicationAgent = communicationAgent;
+  }
+
+  /**
+   * 调用方法。
+   *
+   * @param metaData 方法元数据
+   * @returns 调用成功返回 true，否则返回 false
+   */
+  override invokeMethod(metaData: unknown): boolean {
+    if (!(metaData instanceof Request)) {
+      return false;
+    }
+
+    const request = metaData as Request;
+    const map = {
+      requestId: request.requestId,
+      fromClient: request.fromClient,
+      toClient: request.toClient,
+      moduleName: request.moduleName,
+      methodName: request.methodName,
+      arguments: request.args ?? [],
+    };
+
+    const bridge = this.bridge;
+    const parserManager = bridge?.parserManager;
+    const parsed = parserManager?.parse(map);
+    if (!parsed || Array.isArray(parsed)) {
+      logger.error(
+        `解析消息失败，数据: ${JSON.stringify(map)}.`,
+        { file: 'ipc_client_executor', func: 'invokeMethod' }
+      );
+      return false;
+    }
+
+    const message = parsed as Message;
+    const moduleName = message.moduleName;
+    const methodName = message.methodName;
+    const args = message.arguments ?? [];
+
+    const concreteModule = bridge?.moduleCreator.getModule(moduleName);
+    if (!concreteModule) {
+      logger.error(
+        `创建模块('${moduleName}')失败!`,
+        { file: 'ipc_client_executor', func: 'invokeMethod' }
+      );
+      return false;
+    }
+
+    const invoker = this.invokerProvider.getInvoker(
+      concreteModule,
+      moduleName,
+      methodName,
+    );
+
+    if (!invoker) {
+      logger.error(
+        `获取调用者失败，模块名称('${moduleName}')，方法名称('${methodName}')`,
+        { file: 'ipc_client_executor', func: 'invokeMethod' }
+      );
+      return false;
+    }
+
+    const convertedArgs = this.convertArguments(args, request);
+
+    try {
+      invoker.invoke(concreteModule, convertedArgs);
+      return true;
+    } catch (e) {
+      logger.fatal(
+        `调用方法异常: ${String(e)}，模块名称('${moduleName}')，方法名称('${methodName}')!`,
+        { file: 'ipc_client_executor', func: 'invokeMethod' }
+      );
+      return false;
+    }
+  }
+
+  /**
+   * 转换参数，将回调 ID 替换为 ResultCallback 实例。
+   */
+  private convertArguments(args: unknown[], request: Request): unknown[] {
+    const convertedArgs: unknown[] = [];
+
+    for (const arg of args) {
+      let convertedArg = arg;
+
+      if (typeof arg === 'string' && arg.startsWith(CALLBACK_PREFIX)) {
+        const callback = new InternalResultCallbackImpl(
+          this,
+          request.requestId,
+          request.fromClient,
+          request.toClient,
+          arg,
+        );
+        convertedArg = callback;
+      }
+
+      convertedArgs.push(convertedArg);
+    }
+
+    return convertedArgs;
+  }
+
+  /**
+   * 调用回调，向对端发送响应。
+   */
+  async invokeCallbackInternal(
+    callback: InternalResultCallbackImpl,
+    response: unknown[],
+    finished: boolean,
+  ): Promise<void> {
+    const resp = new Response(
+      callback.requestId,
+      callback.fromClient,
+      callback.toClient,
+      callback.callbackId,
+      response,
+      finished,
+    );
+
+    const communicationAgent = this.communicationAgent;
+    if (!communicationAgent) {
+      logger.fatal(
+        'communicationAgent 为 null，调用回调失败!',
+        { file: 'ipc_client_executor', func: 'invokeCallbackInternal' }
+      );
+      return;
+    }
+
+    const result = await Promise.resolve(communicationAgent.sendResponse(resp));
+    if (!result) {
+      void communicationAgent.sendError(
+        new Error(
+          callback.requestId,
+          callback.fromClient,
+          callback.toClient,
+          IpcError.ERROR_SEND_RESPONSE_FAILED,
+          '发送响应失败!',
+        ),
+      );
+    }
+  }
+}
+
+/**
+ * 内部回调实现类，对应 Flutter _ResultCallbackImpl。
+ *
+ * 该类实现 ResultCallback，用于处理回调。
+ */
+class InternalResultCallbackImpl implements ResultCallback {
+  private readonly executor: IpcClientExecutor;
+
+  constructor(
+    executor: IpcClientExecutor,
+    public readonly requestId: string,
+    public readonly fromClient: string,
+    public readonly toClient: string,
+    public readonly callbackId: string,
+  ) {
+    this.executor = executor;
+  }
+
+  invoke(args: unknown[], finished: boolean = true): void {
+    const executor = this.executor;
+    if (!executor) {
+      logger.fatal(
+        'executor 为 null，但尝试调用 invokeCallback!',
+        { file: 'ipc_client_executor', func: 'invoke' }
+      );
+      return;
+    }
+
+    void executor.invokeCallbackInternal(this, args, finished);
+  }
+}
+
+

package/src/moonbridge-ipc/client/internal/ipc/communication/ipc_communication_agent.ts

@@ -0,0 +1,226 @@
+// 对应：
+// moonbridge-ipc-flutter/lib/client/internal/ipc/communication/ipc_communication_agent.dart
+//
+// IPC 通信代理类，负责管理 IPC 通信的数据收发与分发。
+// 012 US5：sendResponse、sendError 等公开方法签名与返回值（Promise<boolean>）与 Flutter 一致。
+// 握手消息由 ConnectionManager 在 performHandshake 阶段临时接管 onMessage 处理，不在此处分支。
+
+import { IpcClientComponentProvider } from '../ipc_client_component_provider';
+import { IpcClientSettings } from '../../settings/ipc_client_settings';
+import { IpcMessageStrategy } from '../../../types/ipc_message_strategy';
+import { IpcConnectionCompletionHandler, MessageInterceptor } from '../../../types/ipc_types';
+import { TransportClient } from '../../../../general/transport/interface/transport_client';
+import { Request } from '../../../../general/message/request';
+import { Response } from '../../../../general/message/response';
+import { Error as IpcMessageError } from '../../../../general/message/error';
+import { IpcSessionSetupResponse } from '../../../../general/message/session_setup';
+import { Registration } from '../../../../general/message/registration';
+import { Unregistration } from '../../../../general/message/unregistration';
+import { Event } from '../../../../general/message/event';
+import { IpcError } from '../../../../general/error/ipc_error';
+import { MessageType } from '../../../../general/message/constants/message_types';
+import { IpcMessageDecoder } from '../../../../general/encode/ipc_message_decoder';
+import { logger } from '../../../../utils/logger';
+import { IpcConnectionManager, IpcSessionSetupCallback } from '../connect/ipc_connection_manager';
+import { IpcRequestCoordinator } from '../coordinator/ipc_request_coordinator';
+import { IpcEventBus } from '../eventbus/ipc_event_bus';
+import { postEvent, registerClient, sendError, sendRequest, sendResponse, unregisterClient } from '../../../../general/transport/interface/transport_client_extension';
+
+/**
+ * 具体实现类，对应 Dart IpcCommunicationAgent。
+ */
+export class IpcCommunicationAgent {
+  private readonly componentProvider: IpcClientComponentProvider;
+  private readonly settings: IpcClientSettings;
+
+  private clientName = '';
+  private messageInterceptor?: MessageInterceptor;
+
+  constructor(componentProvider: IpcClientComponentProvider) {
+    this.componentProvider = componentProvider;
+    this.settings = componentProvider.settings;
+  }
+
+  initialize(): void {
+    this.clientName = this.settings.clientName;
+    this.messageInterceptor = this.settings.messageInterceptor;
+
+    const connectionManager = this.connectionManager;
+    connectionManager.onMessageReceived((message: string) => {
+      const msgType = this.getMessageType(message);
+      logger.info(`[收] type=${msgType} client=${this.clientName} msg=${message}`);
+
+      try {
+        if (message.includes(MessageType.EVENT)) {
+          this.onEvent(IpcMessageDecoder.decodeEvent(message));
+        } else if (message.includes(MessageType.ERROR)) {
+          this.onError(IpcMessageDecoder.decodeError(message));
+        } else if (message.includes(MessageType.REQUEST)) {
+          this.onRequest(IpcMessageDecoder.decodeRequest(message));
+        } else if (message.includes(MessageType.RESPONSE)) {
+          this.onResponse(IpcMessageDecoder.decodeResponse(message));
+        } /*else if (message.includes(MessageType.SESSION_SETUP_REQUEST)) {
+          logger.info(`[收] SESSION_SETUP_REQUEST 本客户端为响应端，忽略`);
+        }*/ else if (message.includes(MessageType.SESSION_SETUP_RESPONSE)) {
+          this.onSessionSetupResponse(IpcMessageDecoder.decodeSessionSetupResponse(message));
+        } else if (message.includes(MessageType.PING)) {
+          logger.debug(`[收] PING fromClient=${IpcMessageDecoder.decodePing(message).fromClient}`);
+        } else if (message.includes(MessageType.REGISTRATION) || message.includes(MessageType.UNREGISTRATION)) {
+          logger.debug(`[收] ${msgType} 服务端内部消息，本客户端忽略`);
+        } else if (message.includes(MessageType.HANDSHAKE)) {
+          logger.debug(`[收] HANDSHAKE 握手阶段由 ConnectionManager 处理`);
+        } else {
+          logger.info(`[收] 未处理消息类型 raw=${message.slice(0, 120)}${message.length > 120 ? '...' : ''}`);
+        }
+      } catch (e) {
+        logger.error(`[收] 处理消息异常 type=${msgType} error=${String(e)}`);
+      }
+    });
+  }
+
+  // PUBLIC API
+
+  sendRequestAfterSetupSession(
+    request: Request,
+    strategy: IpcMessageStrategy | undefined,
+    callback: IpcConnectionCompletionHandler | undefined,
+  ): void {
+    const onSessionSetupCallback: IpcSessionSetupCallback = async (
+      success,
+      error,
+    ) => {
+      if (!success) {
+        logger.error(
+          `客户端(${this.clientName})构建 IPC 运行环境失败，error: ${String(
+            error,
+          )}!`,
+        );
+        if (callback && error) {
+          callback(false, error);
+        }
+        return;
+      }
+
+      logger.info(
+        `客户端(${this.clientName})构建 IPC 运行环境成功，将要发送请求: ${request.requestId}`,
+      );
+      if (await this.sendRequest(request)) {
+        logger.info(
+          `客户端(${this.clientName})发送请求成功: ${request.requestId}`,
+        );
+        return;
+      }
+
+      if (callback) {
+        callback(
+          false,
+          new IpcError(IpcError.ERROR_SEND_REQUEST_FAILED, 'Send request failed!'),
+        );
+      }
+    };
+
+    logger.info(
+      `请求端(${this.clientName})构建与响应端(${request.toClient}) IPC 会话.`,
+    );
+    const shouldWakeUp = strategy ?? this.settings.messageStrategy;
+    this.connectionManager.setupSession(
+      request,
+      onSessionSetupCallback,
+      shouldWakeUp.autoLaunch,
+    );
+  }
+
+  async register(): Promise<boolean> {
+    return await registerClient(this.socketClient, new Registration(this.clientName));
+  }
+
+  async unregister(): Promise<boolean> {
+    return await unregisterClient(this.socketClient, new Unregistration(this.clientName));
+  }
+
+  async sendRequest(request: Request): Promise<boolean> {
+    return await sendRequest(this.socketClient, request);
+  }
+
+  async sendResponse(response: Response): Promise<boolean> {
+    return await sendResponse(this.socketClient, response);
+  }
+
+  async sendError(error: IpcMessageError): Promise<boolean> {
+    return await sendError(this.socketClient, error);
+  }
+
+  async postEvent(event: Event): Promise<void> {
+    await await postEvent(this.socketClient, event);
+  }
+
+  // MESSAGE HANDLERS
+
+  private onEvent(event: Event): void {
+    this.eventBus.onEvent(event);
+  }
+
+  private onError(error: IpcMessageError): void {
+    if (
+      this.messageInterceptor?.interceptError &&
+      this.messageInterceptor.interceptError(error)
+    ) {
+      return;
+    }
+    this.requestCoordinator.onError(error);
+  }
+
+  private onRequest(request: Request): void {
+    if (
+      this.messageInterceptor?.interceptRequest &&
+      this.messageInterceptor.interceptRequest(request)
+    ) {
+      return;
+    }
+    this.bridge.executor.invokeMethod(request);
+  }
+
+  private onResponse(response: Response): void {
+    if (
+      this.messageInterceptor?.interceptResponse &&
+      this.messageInterceptor.interceptResponse(response)
+    ) {
+      return;
+    }
+    this.requestCoordinator.onResponse(response);
+  }
+
+  private onSessionSetupResponse(response: IpcSessionSetupResponse): void {
+    this.connectionManager.onSessionSetupCallback(response);
+  }
+
+  // PRIVATE HELPERS / GETTERS
+
+  private getMessageType(message: string): string {
+    for (const v of Object.values(MessageType)) {
+      if (message.includes(v)) return v;
+    }
+    return 'UNKNOWN';
+  }
+
+  private get socketClient(): TransportClient {
+    return this.connectionManager.transportClientInstance;
+  }
+
+  private get connectionManager(): IpcConnectionManager {
+    return this.componentProvider.connectionManager;
+  }
+
+  private get requestCoordinator(): IpcRequestCoordinator {
+    return this.componentProvider.requestCoordinator;
+  }
+
+  private get bridge(): import('../../bridge/ipc_client_bridge').IpcClientBridge {
+    return this.componentProvider.bridge;
+  }
+
+  private get eventBus(): IpcEventBus {
+    return this.componentProvider.ipcEventBus;
+  }
+}
+