鸿蒙常见问题分析七：UDPSocket广播网络限制

本文探讨了HarmonyOS中UDPSocket广播在多网络环境下的常见问题及解决方案。当设备同时连接WiFi和蜂窝网络时，系统默认可能通过蜂窝网络发送广播包，导致局域网设备无法接收。核心解决方案是通过bindSocket方法将Socket明确绑定到WiFi网络接口，并提供了完整的实现代码，包括网络绑定、广播发送/接收等功能模块。文章还分析了网络状态变化处理、多网络选择策略等进阶问题，提出了错误重

m0_59315734

6人浏览 · 2026-03-09 20:09:32

m0_59315734 · 2026-03-09 20:09:32 发布

引言：智能家居配网中的网络选择困境

周末在家调试新买的智能灯泡，需要通过手机App给设备发送广播包进行配网。我打开App，点击"搜索设备"，却发现设备列表迟迟没有反应。查看日志才发现，广播包竟然通过蜂窝网络发出去了，而我的手机和智能设备都连接在同一个WiFi网络下。

这让我想起之前开发智能家居应用时遇到的类似问题：在多网络环境下，UDPSocket广播默认可能选择蜂窝网络，导致局域网设备无法收到广播包。这不仅影响用户体验，还可能造成不必要的流量消耗。

今天我们就来深入分析这个常见问题，并给出完整的解决方案。

一、问题现象与背景分析

1.1 问题表现

在HarmonyOS应用开发中，当设备同时连接WiFi和蜂窝网络时，使用UDPSocket发送广播包可能会出现以下现象：

广播包发送失败：目标设备在同一WiFi网络下，但收不到广播
网络选择错误：广播包通过蜂窝网络发出，无法到达局域网设备
流量消耗：不必要的蜂窝数据使用，可能产生额外费用

1.2 根本原因分析

HarmonyOS的网络栈在默认情况下，可能会根据系统策略选择"最佳"网络接口发送数据。对于广播包，系统可能：

优先选择默认数据网络：如果蜂窝网络是默认数据连接，广播可能通过蜂窝发出
缺乏网络绑定机制：没有明确指定使用哪个网络接口
广播地址限制：广播包（如255.255.255.255）在蜂窝网络中可能被限制或无法正确路由

1.3 技术背景

在深入解决方案前，先了解几个关键概念：

UDPSocket：用户数据报协议套接字，支持无连接的数据传输
广播地址：向同一子网所有主机发送数据的IP地址
- 直接广播地址：如192.168.43.255（192.168.43.0/24子网）
- 受限广播地址：255.255.255.255
网络句柄（NetHandle）：代表一个网络连接的抽象对象
网络承载类型（NetBearType）：标识网络类型，如WiFi、蜂窝等

二、解决方案架构设计

2.1 核心思路

解决问题的关键在于明确指定UDPSocket使用的网络接口。HarmonyOS提供了bindSocket方法，可以将Socket绑定到特定的网络句柄上。

2.2 实现步骤

整个解决方案可以分为四个步骤：

创建并配置UDPSocket
获取当前网络连接信息
筛选出WiFi网络句柄
将Socket绑定到WiFi网络

2.3 技术选型对比

方案	优点	缺点	适用场景
bindSocket绑定	精确控制网络接口，性能好	需要手动管理网络状态变化	需要稳定网络连接的应用
网络监听+重绑	自动适应网络变化	实现复杂，资源消耗大	需要高可用性的应用
双Socket方案	同时支持多网络	资源占用翻倍，管理复杂	需要多网络并发的特殊场景

三、完整代码实现

3.1 基础配置与类型定义

import { connection, socket } from '@kit.NetworkKit';
import { BusinessError } from '@kit.BasicServicesKit';

// 广播配置
interface BroadcastConfig {
  broadcastIp: string;    // 广播地址
  broadcastPort: number;  // 广播端口
  localPort: number;      // 本地绑定端口
}

// 默认配置
const DEFAULT_CONFIG: BroadcastConfig = {
  broadcastIp: '255.255.255.255',  // 受限广播地址
  broadcastPort: 18256,            // 广播端口
  localPort: 8000                  // 本地端口
};

3.2 UDPSocket管理器

export class UDPSocketManager {
  private udpClient: socket.UDPSocket;
  private config: BroadcastConfig;
  private currentNetHandle: connection.NetHandle | null = null;

  constructor(config?: Partial<BroadcastConfig>) {
    this.config = { ...DEFAULT_CONFIG, ...config };
    this.udpClient = socket.constructUDPSocketInstance();
  }

  /**
   * 初始化UDPSocket并绑定到WiFi网络
   */
  async initialize(): Promise<boolean> {
    try {
      // 1. 绑定Socket到本地地址
      await this.bindSocket();
      
      // 2. 配置广播选项
      await this.configureBroadcast();
      
      // 3. 绑定到WiFi网络
      await this.bindToWiFi();
      
      console.info('UDPSocket初始化成功');
      return true;
    } catch (error) {
      console.error('UDPSocket初始化失败:', error);
      return false;
    }
  }

  /**
   * 绑定Socket到本地地址
   */
  private async bindSocket(): Promise<void> {
    return new Promise((resolve, reject) => {
      const netAddress: socket.NetAddress = {
        address: '0.0.0.0',      // 绑定到所有接口
        port: this.config.localPort,
        family: 1                // IPv4
      };

      this.udpClient.bind(netAddress, (error: Error) => {
        if (error) {
          console.error(`UDPSocket绑定失败: ${JSON.stringify(error)}`);
          reject(error);
          return;
        }
        console.info('UDPSocket绑定成功');
        resolve();
      });
    });
  }

  /**
   * 配置广播选项
   */
  private async configureBroadcast(): Promise<void> {
    return new Promise((resolve, reject) => {
      const udpExtraOptions: socket.UDPExtraOptions = {
        receiveBufferSize: 8192,   // 接收缓冲区大小
        sendBufferSize: 8192,      // 发送缓冲区大小
        reuseAddress: false,       // 是否重用地址
        socketTimeout: 6000,       // Socket超时时间（毫秒）
        broadcast: true            // 开启广播功能
      };

      // 注意：setExtraOptions需要在bind成功之后调用
      this.udpClient.setExtraOptions(udpExtraOptions, (err: BusinessError) => {
        if (err) {
          console.error(`设置广播选项失败: ${JSON.stringify(err)}`);
          reject(err);
          return;
        }
        console.info('广播选项设置成功');
        resolve();
      });
    });
  }
}

3.3 网络绑定核心实现

export class NetworkBinder {
  /**
   * 将Socket绑定到指定类型的网络
   */
  async bindSocketToNetwork(
    socketParam: socket.TCPSocket | socket.UDPSocket,
    bearType: connection.NetBearType
  ): Promise<connection.NetHandle | null> {
    if (!bearType) {
      console.error('网络类型不能为空');
      return null;
    }

    return new Promise((resolve) => {
      let targetNetHandle: connection.NetHandle | undefined = undefined;

      // 1. 获取所有网络连接
      connection.getAllNets((error: BusinessError, netHandles: connection.NetHandle[]) => {
        if (error) {
          console.error(`获取网络列表失败: ${JSON.stringify(error)}`);
          resolve(null);
          return;
        }

        console.info(`发现 ${netHandles.length} 个网络连接`);

        // 2. 遍历网络连接，查找目标类型
        for (let index = 0; index < netHandles.length; index++) {
          try {
            const netHandle = netHandles[index];
            const capabilities = connection.getNetCapabilitiesSync(netHandle);
            
            console.info(`网络 ${index} 能力: ${JSON.stringify(capabilities)}`);
            
            // 检查网络类型是否匹配
            if (capabilities.bearerTypes && capabilities.bearerTypes.includes(bearType)) {
              targetNetHandle = netHandle;
              console.info(`找到目标网络: ${bearType}`);
              break;
            }
          } catch (error) {
            console.error(`获取网络能力失败: ${error.code}, ${error.message}`);
          }
        }

        // 3. 绑定Socket到目标网络
        if (targetNetHandle) {
          this.performSocketBinding(targetNetHandle, socketParam, resolve);
        } else {
          console.error(`未找到 ${bearType} 类型的网络连接`);
          resolve(null);
        }
      });
    });
  }

  /**
   * 执行Socket绑定
   */
  private performSocketBinding(
    netHandle: connection.NetHandle,
    socketParam: socket.TCPSocket | socket.UDPSocket,
    resolve: (value: connection.NetHandle | null) => void
  ): void {
    netHandle.bindSocket(socketParam, (error: BusinessError, data: void) => {
      if (error) {
        console.error(`Socket绑定失败: ${error.code}, ${error.message}`);
        resolve(null);
        return;
      }
      
      console.info('Socket绑定到网络成功');
      resolve(netHandle);
    });
  }

  /**
   * 绑定到WiFi网络（便捷方法）
   */
  async bindToWiFi(socketParam: socket.TCPSocket | socket.UDPSocket): Promise<connection.NetHandle | null> {
    return this.bindSocketToNetwork(socketParam, connection.NetBearType.BEARER_WIFI);
  }

  /**
   * 绑定到蜂窝网络（便捷方法）
   */
  async bindToCellular(socketParam: socket.TCPSocket | socket.UDPSocket): Promise<connection.NetHandle | null> {
    return this.bindSocketToNetwork(socketParam, connection.NetBearType.BEARER_CELLULAR);
  }
}

3.4 广播发送与接收

export class BroadcastHandler {
  private udpClient: socket.UDPSocket;
  private config: BroadcastConfig;

  constructor(udpClient: socket.UDPSocket, config: BroadcastConfig) {
    this.udpClient = udpClient;
    this.config = config;
  }

  /**
   * 发送广播数据
   */
  async sendBroadcast(data: string): Promise<boolean> {
    return new Promise((resolve) => {
      const netAddress: socket.NetAddress = {
        address: this.config.broadcastIp,
        port: this.config.broadcastPort
      };

      const sendOptions: socket.UDPSendOptions = {
        data: data,
        address: netAddress
      };

      this.udpClient.send(sendOptions, (err: BusinessError) => {
        if (err) {
          console.error(`广播发送失败: ${JSON.stringify(err)}`);
          resolve(false);
          return;
        }
        
        console.info('广播发送成功');
        resolve(true);
      });
    });
  }

  /**
   * 开始接收广播
   */
  startReceiving(onMessage: (data: socket.SocketMessageInfo) => void): void {
    this.udpClient.on('message', (data: socket.SocketMessageInfo) => {
      console.info(`收到广播数据: ${JSON.stringify(data)}`);
      
      // 解析数据
      try {
        const decoder = new TextDecoder('utf-8');
        const str = decoder.decode(new Uint8Array(data.message));
        console.info(`广播内容: ${str}`);
      } catch (error) {
        console.error('数据解析失败:', error);
      }
      
      // 回调处理
      if (onMessage) {
        onMessage(data);
      }
    });

    console.info('广播接收已启动');
  }

  /**
   * 停止接收广播
   */
  stopReceiving(): void {
    this.udpClient.off('message');
    console.info('广播接收已停止');
  }

  /**
   * 发送带时间戳的广播（用于设备发现）
   */
  async sendDiscoveryBroadcast(): Promise<boolean> {
    const timestamp = new Date().getTime();
    const deviceInfo = {
      timestamp: timestamp,
      deviceId: this.getDeviceId(),
      protocol: 'v1.0',
      type: 'discovery'
    };

    const data = JSON.stringify(deviceInfo);
    return this.sendBroadcast(data);
  }

  private getDeviceId(): string {
    // 实际开发中应从系统获取设备ID
    return `device_${Math.random().toString(36).substr(2, 9)}`;
  }
}

3.5 完整示例组件

import { connection, socket } from '@kit.NetworkKit';
import { BusinessError } from '@kit.BasicServicesKit';
import { util } from '@kit.ArkTS';

@Entry
@Component
struct UDPSocketBroadcastDemo {
  // Socket管理器
  private socketManager: UDPSocketManager;
  private networkBinder: NetworkBinder;
  private broadcastHandler: BroadcastHandler | null = null;
  
  // 状态变量
  @State isInitialized: boolean = false;
  @State isSending: boolean = false;
  @State receivedMessages: string[] = [];
  @State currentNetwork: string = '未知';

  // 配置
  private config: BroadcastConfig = {
    broadcastIp: '255.255.255.255',
    broadcastPort: 18256,
    localPort: 8000
  };

  aboutToAppear(): void {
    this.socketManager = new UDPSocketManager(this.config);
    this.networkBinder = new NetworkBinder();
    
    this.initializeSocket();
  }

  /**
   * 初始化Socket
   */
  async initializeSocket(): Promise<void> {
    try {
      // 1. 初始化UDPSocket
      const initSuccess = await this.socketManager.initialize();
      if (!initSuccess) {
        prompt.showToast({ message: 'Socket初始化失败' });
        return;
      }

      // 2. 绑定到WiFi网络
      const netHandle = await this.networkBinder.bindToWiFi(this.socketManager.getSocket());
      if (!netHandle) {
        prompt.showToast({ message: 'WiFi网络绑定失败' });
        return;
      }

      // 3. 创建广播处理器
      this.broadcastHandler = new BroadcastHandler(
        this.socketManager.getSocket(),
        this.config
      );

      // 4. 开始接收广播
      this.broadcastHandler.startReceiving((data) => {
        this.handleReceivedMessage(data);
      });

      // 5. 更新状态
      this.isInitialized = true;
      this.currentNetwork = 'WiFi';
      prompt.showToast({ message: 'Socket初始化成功，已绑定到WiFi网络' });

    } catch (error) {
      console.error('初始化过程出错:', error);
      prompt.showToast({ message: '初始化失败，请检查网络连接' });
    }
  }

  /**
   * 处理接收到的消息
   */
  private handleReceivedMessage(data: socket.SocketMessageInfo): void {
    try {
      const decoder = util.TextDecoder.create('utf-8');
      const message = decoder.decodeToString(new Uint8Array(data.message));
      
      // 添加到消息列表
      this.receivedMessages = [message, ...this.receivedMessages.slice(0, 9)];
      
      // 解析JSON数据
      const parsed = JSON.parse(message);
      console.info('收到广播消息:', parsed);
      
    } catch (error) {
      console.error('消息处理失败:', error);
    }
  }

  /**
   * 发送测试广播
   */
  async sendTestBroadcast(): Promise<void> {
    if (!this.isInitialized || !this.broadcastHandler) {
      prompt.showToast({ message: '请先初始化Socket' });
      return;
    }

    this.isSending = true;
    
    try {
      const success = await this.broadcastHandler.sendDiscoveryBroadcast();
      
      if (success) {
        prompt.showToast({ message: '广播发送成功' });
      } else {
        prompt.showToast({ message: '广播发送失败' });
      }
    } catch (error) {
      console.error('发送广播出错:', error);
      prompt.showToast({ message: '发送过程出错' });
    } finally {
      this.isSending = false;
    }
  }

  /**
   * 切换网络类型
   */
  async switchNetwork(networkType: string): Promise<void> {
    if (!this.isInitialized) {
      prompt.showToast({ message: '请先初始化Socket' });
      return;
    }

    let bearType: connection.NetBearType;
    
    switch (networkType) {
      case 'wifi':
        bearType = connection.NetBearType.BEARER_WIFI;
        break;
      case 'cellular':
        bearType = connection.NetBearType.BEARER_CELLULAR;
        break;
      default:
        prompt.showToast({ message: '不支持的网络类型' });
        return;
    }

    try {
      const netHandle = await this.networkBinder.bindSocketToNetwork(
        this.socketManager.getSocket(),
        bearType
      );

      if (netHandle) {
        this.currentNetwork = networkType === 'wifi' ? 'WiFi' : '蜂窝网络';
        prompt.showToast({ message: `已切换到${this.currentNetwork}` });
      } else {
        prompt.showToast({ message: '网络切换失败' });
      }
    } catch (error) {
      console.error('切换网络出错:', error);
      prompt.showToast({ message: '切换过程出错' });
    }
  }

  build() {
    Column({ space: 20 }) {
      // 标题
      Text('UDPSocket广播网络限制演示')
        .fontSize(24)
        .fontWeight(FontWeight.Bold)
        .margin({ top: 30, bottom: 20 })

      // 状态显示
      Row({ space: 15 }) {
        Text('当前状态:')
          .fontSize(16)
        
        if (this.isInitialized) {
          Text('已初始化')
            .fontSize(16)
            .fontColor(Color.Green)
        } else {
          Text('未初始化')
            .fontSize(16)
            .fontColor(Color.Red)
        }
      }
      .width('100%')
      .justifyContent(FlexAlign.Center)

      // 网络信息
      Text(`当前网络: ${this.currentNetwork}`)
        .fontSize(16)
        .margin({ bottom: 20 })

      // 控制按钮
      Column({ space: 12 }) {
        // 初始化按钮
        Button(this.isInitialized ? '重新初始化' : '初始化Socket')
          .width('80%')
          .height(40)
          .onClick(() => this.initializeSocket())
          .stateEffect(!this.isInitialized)

        // 网络切换
        Row({ space: 10 }) {
          Button('切换到WiFi')
            .width('45%')
            .height(40)
            .onClick(() => this.switchNetwork('wifi'))
            .stateEffect(this.currentNetwork !== 'WiFi')

          Button('切换到蜂窝')
            .width('45%')
            .height(40)
            .onClick(() => this.switchNetwork('cellular'))
            .stateEffect(this.currentNetwork !== '蜂窝网络')
        }
        .width('80%')

        // 发送广播
        Button(this.isSending ? '发送中...' : '发送测试广播')
          .width('80%')
          .height(40)
          .onClick(() => this.sendTestBroadcast())
          .stateEffect(!this.isSending && this.isInitialized)
          .enabled(!this.isSending && this.isInitialized)
      }
      .width('100%')
      .alignItems(HorizontalAlign.Center)

      // 接收消息区域
      if (this.receivedMessages.length > 0) {
        Text('最近收到的广播:')
          .fontSize(18)
          .fontWeight(FontWeight.Medium)
          .margin({ top: 30, bottom: 10 })
          .width('90%')
          .textAlign(TextAlign.Start)

        List({ space: 8 }) {
          ForEach(this.receivedMessages, (message, index) => {
            ListItem() {
              Column({ space: 4 }) {
                Text(`消息 ${index + 1}:`)
                  .fontSize(14)
                  .fontColor(Color.Gray)
                  
                Text(message.length > 50 ? message.substring(0, 50) + '...' : message)
                  .fontSize(16)
                  .textAlign(TextAlign.Start)
                  .width('100%')
              }
              .padding(12)
              .backgroundColor(Color.White)
              .borderRadius(8)
              .shadow({ radius: 4, color: '#10000000', offsetX: 0, offsetY: 2 })
            }
          })
        }
        .height(300)
        .width('90%')
        .margin({ bottom: 30 })
      }
    }
    .width('100%')
    .height('100%')
    .backgroundColor('#F5F5F5')
    .alignItems(HorizontalAlign.Center)
  }
}

四、常见问题与解决方案

4.1 网络状态变化处理

问题：设备网络状态变化（如WiFi断开）时，绑定的Socket可能失效。

解决方案：

export class NetworkStateMonitor {
  private listeners: Array<(state: connection.NetworkState) => void> = [];

  constructor() {
    this.startMonitoring();
  }

  private startMonitoring(): void {
    // 监听网络状态变化
    connection.on('netStateChange', (data: connection.NetworkState) => {
      console.info('网络状态变化:', data);
      
      // 通知所有监听器
      this.listeners.forEach(listener => {
        try {
          listener(data);
        } catch (error) {
          console.error('监听器执行失败:', error);
        }
      });

      // 根据状态采取相应措施
      this.handleNetworkChange(data);
    });
  }

  private handleNetworkChange(state: connection.NetworkState): void {
    if (!state.isConnected) {
      console.warn('网络连接断开');
      // 可以在这里触发重连逻辑
    } else if (state.netInfo) {
      console.info(`网络类型: ${state.netInfo.networkType}`);
      
      // 如果切换到非WiFi网络，可能需要重新绑定
      if (state.netInfo.networkType !== connection.NetworkType.WIFI) {
        console.warn('当前网络不是WiFi，广播可能无法正常工作');
      }
    }
  }

  // 添加监听器
  addListener(listener: (state: connection.NetworkState) => void): void {
    this.listeners.push(listener);
  }

  // 移除监听器
  removeListener(listener: (state: connection.NetworkState) => void): void {
    const index = this.listeners.indexOf(listener);
    if (index !== -1) {
      this.listeners.splice(index, 1);
    }
  }
}

4.2 多网络环境下的策略

问题：设备同时连接多个WiFi网络（如2.4G和5G）时，如何选择正确的网络？

解决方案：

export class MultiNetworkSelector {
  /**
   * 选择最佳WiFi网络
   */
  async selectBestWiFiNetwork(): Promise<connection.NetHandle | null> {
    return new Promise((resolve) => {
      connection.getAllNets((error: BusinessError, netHandles: connection.NetHandle[]) => {
        if (error) {
          console.error('获取网络失败:', error);
          resolve(null);
          return;
        }

        let bestNetwork: connection.NetHandle | null = null;
        let bestScore = -1;

        // 评估每个WiFi网络
        for (const netHandle of netHandles) {
          try {
            const capabilities = connection.getNetCapabilitiesSync(netHandle);
            
            // 只考虑WiFi网络
            if (capabilities.bearerTypes?.includes(connection.NetBearType.BEARER_WIFI)) {
              const score = this.evaluateNetworkScore(capabilities);
              
              if (score > bestScore) {
                bestScore = score;
                bestNetwork = netHandle;
              }
            }
          } catch (error) {
            console.warn('网络评估失败:', error);
          }
        }

        if (bestNetwork) {
          console.info(`选择最佳WiFi网络，评分: ${bestScore}`);
        } else {
          console.warn('未找到可用的WiFi网络');
        }

        resolve(bestNetwork);
      });
    });
  }

  /**
   * 评估网络质量分数
   */
  private evaluateNetworkScore(capabilities: connection.NetCapabilities): number {
    let score = 0;

    // 1. 信号强度（如果有）
    if (capabilities.linkUpBandwidthKbps && capabilities.linkDownBandwidthKbps) {
      const bandwidth = Math.min(capabilities.linkUpBandwidthKbps, capabilities.linkDownBandwidthKbps);
      score += Math.min(bandwidth / 1000, 30); // 最高30分
    }

    // 2. 网络能力
    if (capabilities.networkCapabilities) {
      // 支持局域网通信
      if (capabilities.networkCapabilities.includes(connection.NetCap.NET_CAPABILITY_NOT_RESTRICTED)) {
        score += 20;
      }
      
      // 网络已验证
      if (capabilities.networkCapabilities.includes(connection.NetCap.NET_CAPABILITY_VALIDATED)) {
        score += 20;
      }
    }

    // 3. SSID信息（如果是已知网络）
    if (capabilities.SSID) {
      // 可以根据SSID前缀、已知网络列表等加分
      score += 10;
    }

    return score;
  }
}

4.3 错误处理与重试机制

问题：网络不稳定时，广播发送可能失败，需要自动重试。

解决方案：

export class RobustBroadcastSender {
  private maxRetries: number = 3;
  private retryDelay: number = 1000; // 1秒

  constructor(
    private broadcastHandler: BroadcastHandler,
    private config: { maxRetries?: number; retryDelay?: number } = {}
  ) {
    if (config.maxRetries !== undefined) {
      this.maxRetries = config.maxRetries;
    }
    if (config.retryDelay !== undefined) {
      this.retryDelay = config.retryDelay;
    }
  }

  /**
   * 发送广播（带重试机制）
   */
  async sendWithRetry(data: string): Promise<{ success: boolean; attempts: number; lastError?: Error }> {
    let lastError: Error | undefined;
    let attempts = 0;

    for (attempts = 1; attempts <= this.maxRetries; attempts++) {
      try {
        console.info(`尝试发送广播 (第${attempts}次)`);
        
        const success = await this.broadcastHandler.sendBroadcast(data);
        
        if (success) {
          console.info(`广播发送成功 (第${attempts}次尝试)`);
          return { success: true, attempts };
        } else {
          throw new Error('广播发送返回失败');
        }
      } catch (error) {
        lastError = error as Error;
        console.warn(`第${attempts}次发送失败:`, error);

        // 如果不是最后一次尝试，等待后重试
        if (attempts < this.maxRetries) {
          console.info(`等待 ${this.retryDelay}ms 后重试`);
          await this.sleep(this.retryDelay);
          
          // 指数退避
          this.retryDelay *= 1.5;
        }
      }
    }

    console.error(`广播发送失败，已尝试 ${attempts - 1} 次`);
    return { 
      success: false, 
      attempts: attempts - 1, 
      lastError 
    };
  }

  /**
   * 发送设备发现广播（带智能重试）
   */
  async sendDiscoveryWithSmartRetry(): Promise<boolean> {
    const deviceInfo = {
      timestamp: Date.now(),
      deviceId: this.generateDeviceId(),
      action: 'discover',
      retryCount: 0
    };

    const data = JSON.stringify(deviceInfo);
    const result = await this.sendWithRetry(data);

    if (!result.success) {
      console.error('设备发现广播发送失败，可能的原因:');
      console.error('1. 网络未连接或绑定失败');
      console.error('2. 防火墙或路由器设置阻止了广播');
      console.error('3. 目标端口被占用');
      
      // 可以在这里触发更高级的恢复逻辑
      await this.tryAlternativeStrategies();
    }

    return result.success;
  }

  private async tryAlternativeStrategies(): Promise<void> {
    console.info('尝试备用策略...');
    
    // 策略1: 尝试使用子网广播地址
    const subnetBroadcast = await this.trySubnetBroadcast();
    if (subnetBroadcast) {
      console.info('子网广播成功');
      return;
    }

    // 策略2: 尝试多播
    const multicast = await this.tryMulticast();
    if (multicast) {
      console.info('多播成功');
      return;
    }

    // 策略3: 回退到单播扫描
    console.info('回退到单播扫描模式');
    await this.fallbackToUnicastScan();
  }

  private async trySubnetBroadcast(): Promise<boolean> {
    // 获取当前子网广播地址
    // 实际实现需要获取网络配置信息
    return false;
  }

  private async tryMulticast(): Promise<boolean> {
    // 尝试使用多播地址（如224.0.0.1）
    return false;
  }

  private async fallbackToUnicastScan(): Promise<void> {
    // 扫描常见IP段，使用单播通信
    console.info('开始单播扫描...');
  }

  private sleep(ms: number): Promise<void> {
    return new Promise(resolve => setTimeout(resolve, ms));
  }

  private generateDeviceId(): string {
    return `dev_${Date.now()}_${Math.random().toString(36).substr(2, 6)}`;
  }
}