HarmonyOS鸿蒙Next模拟器做tcp/IP服务器，我用PAD程序跟它不能连接

HarmonyOS鸿蒙Next模拟器做tcp/IP服务器，我用PAD程序跟它不能连接 用的是鸿蒙API20，一直不能连接到，估计是IP地址问题，现在服务器监看的是“0.0.0.0”，监看“127.0.0.1”也不行，如果用电脑的IP地址“192.168.0.101”初始化就报错。以下是代码。客户端程序连接我用别的开发的电脑程序一切正常，就是跟模拟器的客户端不能成功连接通讯。

// TcpServerPage.ets
import { TcpServerManager, ClientInfo, ReceivedMessage } from '../TcpServerManager';
import { util } from '[@kit](/user/kit).ArkTS';
import { abilityAccessCtrl, Permissions } from '[@kit](/user/kit).AbilityKit';
import { BusinessError } from '[@kit](/user/kit).BasicServicesKit';

@Entry
@Component
struct TcpServerPage {
  // TCP服务管理器实例
  private serverManager: TcpServerManager = new TcpServerManager();

  // 状态变量
  @State serverStatus: string = '未启动';
  @State serverPort: string = '5798';
  @State isRunning: boolean = false;
  @State clientList: ClientInfo[] = [];
  @State selectedClientId: string = '';
  @State logMessages: string[] = [];
  @State inputMessage: string = '';
  @State broadcastMessage: string = '';

  // 权限列表
  private requiredPermissions: Array<Permissions> = ['ohos.permission.INTERNET'];

  aboutToAppear(): void {
    // 请求权限
    this.requestPermissions();

    // 设置服务端回调
    this.setupServerCallbacks();
  }

  aboutToDisappear(): void {
    // 页面销毁时停止服务
    this.stopServer();
  }

  /**
   * 请求必要权限
   */
  private requestPermissions(): void {
    const atManager = abilityAccessCtrl.createAtManager();
    atManager.requestPermissionsFromUser(getContext(this), this.requiredPermissions)
      .then((data) => {
        this.addLog('权限申请成功');
      })
      .catch((err: BusinessError) => {
        this.addLog(`权限申请失败: ${err.message}`);
      });
  }

  /**
   * 设置服务端事件回调
   */
  private setupServerCallbacks(): void {
    // 客户端连接回调
    this.serverManager.setOnClientConnected((clientInfo: ClientInfo) => {
      this.addLog(`[连接] 客户端 ${clientInfo.id} (${clientInfo.remoteAddress}:${clientInfo.remotePort}) 已连接`);
      this.refreshClientList();
    });

    // 客户端断开回调
    this.serverManager.setOnClientDisconnected((clientId: string) => {
      this.addLog(`[断开] 客户端 ${clientId} 已断开`);
      if (this.selectedClientId === clientId) {
        this.selectedClientId = '';
      }
      this.refreshClientList();
    });

    // 消息接收回调
    this.serverManager.setOnMessageReceived((message: ReceivedMessage) => {
      const text = this.serverManager.arrayBufferToString(message.message);
      this.addLog(`[收到] 来自 ${message.clientId}: ${text}`);
    });

    // 服务端错误回调
    this.serverManager.setOnServerError((error: Error) => {
      this.addLog(`[错误] ${error.message}`);
    });

    // 服务启动回调
    this.serverManager.setOnServerStarted((address: string, port: number) => {
      this.serverStatus = `运行中 - ${address}:${port}`;
      this.isRunning = true;
      this.addLog(`[系统] 服务已启动，监听 ${address}:${port}`);
    });

    // 服务停止回调
    this.serverManager.setOnServerStopped(() => {
      this.serverStatus = '未启动';
      this.isRunning = false;
      this.clientList = [];
      this.selectedClientId = '';
      this.addLog('[系统] 服务已停止');
    });
  }

  /**
   * 刷新客户端列表
   */
  private refreshClientList(): void {
    this.clientList = this.serverManager.getClients();
  }

  /**
   * 添加日志信息
   */
  private addLog(message: string): void {
    const timestamp = new Date().toLocaleTimeString();
    this.logMessages.unshift(`[${timestamp}] ${message}`);
    // 限制日志条数，防止内存溢出
    if (this.logMessages.length > 100) {
      this.logMessages.pop();
    }
  }

  /**
   * 启动服务
   */
  private async startServer(): Promise<void> {
    const port = parseInt(this.serverPort);
    if (isNaN(port) || port < 1 || port > 65535) {
      this.addLog('[错误] 端口号无效，请输入 1-65535 之间的数字');
      return;
    }

    try {
      await this.serverManager.start(port,"0.0.0.0");
    } catch (error) {
      this.addLog(`[错误] 启动失败: ${JSON.stringify(error)}`);
    }
  }

  /**
   * 停止服务
   */
  private async stopServer(): Promise<void> {
    try {
      await this.serverManager.stop();
    } catch (error) {
      this.addLog(`[错误] 停止失败: ${JSON.stringify(error)}`);
    }
  }

  /**
   * 发送消息给选中的客户端
   */
  private async sendToSelectedClient(): Promise<void> {
    if (!this.selectedClientId) {
      this.addLog('[提示] 请先选择一个客户端');
      return;
    }
    if (!this.inputMessage.trim()) {
      this.addLog('[提示] 消息内容不能为空');
      return;
    }

    try {
      const data = this.serverManager.stringToArrayBuffer(this.inputMessage);
      await this.serverManager.sendToClient(this.selectedClientId, data);
      this.addLog(`[发送] 向 ${this.selectedClientId}: ${this.inputMessage}`);
      this.inputMessage = '';
    } catch (error) {
      this.addLog(`[错误] 发送失败: ${JSON.stringify(error)}`);
    }
  }

  /**
   * 广播消息
   */
  private async broadcastToAll(): Promise<void> {
    if (!this.broadcastMessage.trim()) {
      this.addLog('[提示] 广播内容不能为空');
      return;
    }

    try {
      const data = this.serverManager.stringToArrayBuffer(this.broadcastMessage);
      const count = await this.serverManager.broadcast(data);
      this.addLog(`[广播] 已向 ${count} 个客户端发送: ${this.broadcastMessage}`);
      this.broadcastMessage = '';
    } catch (error) {
      this.addLog(`[错误] 广播失败: ${JSON.stringify(error)}`);
    }
  }

  /**
   * 断开指定客户端
   */
  private disconnectClient(clientId: string): void {
    this.serverManager.disconnectClient(clientId);
    this.addLog(`[操作] 主动断开客户端 ${clientId}`);
    this.refreshClientList();
    if (this.selectedClientId === clientId) {
      this.selectedClientId = '';
    }
  }

  build() {
    Column() {
      // 标题栏
      Text('TCP 服务端')
        .fontSize(24)
        .fontWeight(FontWeight.Bold)
        .width('100%')
        .padding({ top: 20, bottom: 10, left: 16, right: 16 })
        .textAlign(TextAlign.Center)

      // 服务控制区
      Column() {
        Row() {
          Text('端口:')
            .fontSize(16)
            .width(60)
          TextInput({ text: this.serverPort, placeholder: '端口号' })
            .type(InputType.Number)
            .fontSize(16)
            .layoutWeight(1)
            .onChange((value: string) => {
              this.serverPort = value;
            })
            .enabled(!this.isRunning)
        }
        .width('100%')
        .padding({ left: 16, right: 16, bottom: 10 })

        Row() {
          Text(`状态: ${this.serverStatus}`)
            .fontSize(14)
            .fontColor(this.isRunning ? '#00AA00' : '#666666')
            .layoutWeight(1)

          if (!this.isRunning) {
            Button('启动服务')
              .fontSize(14)
              .onClick(() => this.startServer())
          } else {
            Button('停止服务')
              .fontSize(14)
              .backgroundColor('#FF4444')
              .onClick(() => this.stopServer())
          }
        }
        .width('100%')
        .padding({ left: 16, right: 16, bottom: 10 })
        .justifyContent(FlexAlign.SpaceBetween)
      }
      .width('100%')
      .padding({ bottom: 10 })
      .backgroundColor('#F1F3F5')
      .borderRadius(8)
      .margin({ left: 16, right: 16, bottom: 10 })

      // 客户端列表
      Column() {
        Row() {
          Text('已连接客户端')
            .fontSize(16)
            .fontWeight(FontWeight.Medium)
          Text(`(${this.clientList.length})`)
            .fontSize(14)
            .fontColor('#666666')
            .margin({ left: 5 })
        }
        .width('100%')
        .padding({ left: 16, right: 16, top: 10, bottom: 5 })

        if (this.clientList.length === 0) {
          Text('暂无客户端连接')
            .fontSize(14)
            .fontColor('#999999')
            .width('100%')
            .textAlign(TextAlign.Center)
            .padding({ top: 20, bottom: 20 })
        } else {
          List() {
            ForEach(this.clientList, (client: ClientInfo) => {
              ListItem() {
                Row() {
                  Column() {
                    Text(client.id)
                      .fontSize(14)
                      .fontWeight(FontWeight.Medium)
                      .maxLines(1)
                      .textOverflow({ overflow: TextOverflow.Ellipsis })
                    Text(`${client.remoteAddress}:${client.remotePort}`)
                      .fontSize(12)
                      .fontColor('#666666')
                  }
                  .alignItems(HorizontalAlign.Start)
                  .layoutWeight(1)

                  Button('断开')
                    .fontSize(12)
                    .height(30)
                    .backgroundColor('#FF8888')
                    .onClick(() => this.disconnectClient(client.id))
                }
                .width('100%')
                .padding(10)
                .backgroundColor(this.selectedClientId === client.id ? '#E3F2FD' : '#FFFFFF')
                .borderRadius(4)
                .onClick(() => {
                  this.selectedClientId = client.id;
                })
              }
              .margin({ bottom: 5 })
            })
          }
          .width('100%')
          .height(200)
          .padding({ left: 16, right: 16 })
        }
      }
      .width('100%')
      .margin({ left: 16, right: 16, bottom: 10 })
      .backgroundColor('#F1F3F5')
      .borderRadius(8)

      // 消息发送区
      Column() {
        Text('发送消息')
          .fontSize(16)
          .fontWeight(FontWeight.Medium)
          .width('100%')
          .padding({ left: 16, right: 16, top: 10, bottom: 5 })

        // 定向发送
        Row() {
          Text('目标:')
            .fontSize(14)
            .width(50)
          Text(this.selectedClientId || '未选择')
            .fontSize(14)
            .fontColor(this.selectedClientId ? '#333333' : '#999999')
            .layoutWeight(1)
            .maxLines(1)
            .textOverflow({ overflow: TextOverflow.Ellipsis })
        }
        .width('100%')
        .padding({ left: 16, right: 16, bottom: 5 })

        Row() {
          TextInput({ text: this.inputMessage, placeholder: '输入消息内容' })
            .fontSize(14)
            .layoutWeight(1)
            .onChange((value: string) => {
              this.inputMessage = value;
            })
            .enabled(this.isRunning && !!this.selectedClientId)

          Button('发送')
            .fontSize(14)
            .margin({ left: 10 })
            .enabled(this.isRunning && !!this.selectedClientId)
            .onClick(() => this.sendToSelectedClient())
        }
        .width('100%')
        .padding({ left: 16, right: 16, bottom: 10 })

        // 广播发送
        Row() {
          TextInput({ text: this.broadcastMessage, placeholder: '广播消息内容' })
            .fontSize(14)
            .layoutWeight(1)
            .onChange((value: string) => {
              this.broadcastMessage = value;
            })
            .enabled(this.isRunning && this.clientList.length > 0)

          Button('广播')
            .fontSize(14)
            .margin({ left: 10 })
            .enabled(this.isRunning && this.clientList.length > 0)
            .onClick(() => this.broadcastToAll())
        }
        .width('100%')
        .padding({ left: 16, right: 16, bottom: 10 })
      }
      .width('100%')
      .margin({ left: 16, right: 16, bottom: 10 })
      .backgroundColor('#F1F3F5')
      .borderRadius(8)

      // 日志区域
      Column() {
        Row() {
          Text('消息日志')
            .fontSize(16)
            .fontWeight(FontWeight.Medium)
          Blank()
          Button('清空')
            .fontSize(12)
            .height(28)
            .onClick(() => {
              this.logMessages = [];
            })
        }
        .width('100%')
        .padding({ left: 16, right: 16, top: 10, bottom: 5 })

        List() {
          ForEach(this.logMessages, (log: string) => {
            ListItem() {
              Text(log)
                .fontSize(12)
                .fontColor('#333333')
                .padding({ left: 10, right: 10, top: 5, bottom: 5 })
                .width('100%')
            }
          })
        }
        .width('100%')
        .layoutWeight(1)
        .padding({ left: 16, right: 16, bottom: 10 })
      }
      .width('100%')
      .layoutWeight(1)
      .margin({ left: 16, right: 16, bottom: 16 })
      .backgroundColor('#F1F3F5')
      .borderRadius(8)
    }
    .width('100%')
    .height('100%')
    .backgroundColor('#FFFFFF')
  }
}

TcpServerManager.ets

import { socket } from '[@kit](/user/kit).NetworkKit';
import { BusinessError } from '[@kit](/user/kit).BasicServicesKit';
import { util } from '[@kit](/user/kit).ArkTS';

export interface ClientInfo {
  id: string;
  connection: socket.TCPSocketConnection;
  remoteAddress: string;
  remotePort: number;
  connectTime: number;
}

export interface ReceivedMessage {
  clientId: string;
  message: ArrayBuffer;
  timestamp: number;
}

export class TcpServerManager {
  private server: socket.TCPSocketServer | null = null;
  private clients: Map<string, ClientInfo> = new Map();
  private isRunning: boolean = false;
  private serverPort: number = 0;
  private serverAddress: string = '0.0.0.0';

  private onClientConnectedCallback?: (clientInfo: ClientInfo) => void;
  private onClientDisconnectedCallback?: (clientId: string) => void;
  private onMessageReceivedCallback?: (message: ReceivedMessage) => void;
  private onServerErrorCallback?: (error: Error) => void;
  private onServerStartedCallback?: (address: string, port: number) => void;
  private onServerStoppedCallback?: () => void;

  private generateClientId(address: string, port: number): string {
    return `${address}:${port}_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
  }

  arrayBufferToString(buffer: ArrayBuffer): string {
    const decoder: util.TextDecoder = new util.TextDecoder('utf-8');
    const uint8Array: Uint8Array = new Uint8Array(buffer);
    return decoder.decodeWithStream(uint8Array, { stream: false });
  }

  stringToArrayBuffer(str: string): ArrayBuffer {
    const encoder: util.TextEncoder = new util.TextEncoder();
    return encoder.encodeInto(str).buffer as ArrayBuffer;
  }

  async start(port: number, address: string = '0.0.0.0'): Promise<void> {
    if (this.isRunning) {
      console.warn('服务器已在运行中');
      return;
    }

    try {
      this.serverPort = port;
      this.serverAddress = address;
      this.server = socket.constructTCPSocketServerInstance();

      // ✅ 关键修正：回调函数使用 async
      this.server.on('connect', async (connection: socket.TCPSocketConnection) => {
        await this.handleClientConnection(connection);
      });

      this.server.on('error', (err: BusinessError) => {
        console.error('服务端错误', JSON.stringify(err));
        this.onServerErrorCallback?.(new Error(err.message));
      });

      const netAddress: socket.NetAddress = {
        address: this.serverAddress,
        port: this.serverPort,
        family: 1
      };

      await this.server.listen(netAddress);
      this.isRunning = true;
      console.info(`服务器已启动 ${this.serverAddress}:${this.serverPort}`);
      this.onServerStartedCallback?.(this.serverAddress, this.serverPort);

    } catch (error) {
      console.error('启动服务器失败', JSON.stringify(error));
      throw new Error(`启动失败: ${JSON.stringify(error)}`);
    }
  }

  private async handleClientConnection(connection: socket.TCPSocketConnection): Promise<void> {
    try {
      // ✅ 使用 await 获取异步结果
      const remoteAddress: socket.NetAddress = await connection.getRemoteAddress();
      // 端口校验
      console.error('获取客户端端口失败，连接将被拒绝5');
      if (remoteAddress.port === undefined) {
        console.error('获取客户端端口失败，连接将被拒绝');
        connection.close();