鸿蒙NEXT开发网络相关工具类（ArkTs）

鸿蒙布道师2025-04-25 19:48
复制代码 
import { connection } from '@kit.NetworkKit';
import { BusinessError, Callback } from '@kit.BasicServicesKit';
import { wifiManager } from '@kit.ConnectivityKit';
import { LogUtil } from './LogUtil';
import { data, radio, sim } from '@kit.TelephonyKit';

// 网络类型枚举
export enum NetworkType {
  NETWORK_TYPE_UNKNOWN = 0,
  NETWORK_TYPE_WIFI = 1,
  NETWORK_TYPE_2G = 2,
  NETWORK_TYPE_3G = 3,
  NETWORK_TYPE_4G = 4,
  NETWORK_TYPE_5G = 5,
}

/**
 * 网络相关工具类
 * 需要 ohos.permission.GET_NETWORK_INFO、ohos.permission.GET_WIFI_INFO 权限。
 * author: CSDN-鸿蒙布道师
 * since: 2025/04/23
 */
export class NetworkUtil {
  private static netConnection: connection.NetConnection | null = null;

  /**
   * 检查默认网络是否按流量计费
   */
  static async isDefaultNetMetered(): Promise<boolean> {
    try {
      return await connection.isDefaultNetMetered();
    } catch (error) {
      LogUtil.error('Failed to check default network metering:', error);
      throw new Error(error);
    }
  }

  static isDefaultNetMeteredSync(): boolean {
    return connection.isDefaultNetMeteredSync();
  }

  /**
   * 检查是否有默认网络
   */
  static async hasDefaultNet(): Promise<boolean> {
    try {
      return await connection.hasDefaultNet();
    } catch (error) {
      LogUtil.error('Failed to check if there is a default network:', error);
      // 确保抛出的是 Error 类型
      throw new Error(error);
    }
  }

  static hasDefaultNetSync(): boolean {
    return connection.hasDefaultNetSync();
  }

  /**
   * 获取默认网络句柄
   */
  static async getDefaultNet(): Promise<connection.NetHandle> {
    try {
      return await connection.getDefaultNet();
    } catch (error) {
      LogUtil.error('Failed to get default network handle:', error);
      throw new Error(error);
    }
  }

  static getDefaultNetSync(): connection.NetHandle {
    return connection.getDefaultNetSync();
  }

  /**
   * 获取应用当前网络句柄
   */
  static async getAppNet(): Promise<connection.NetHandle> {
    try {
      return await connection.getAppNet();
    } catch (error) {
      LogUtil.error('Failed to get app network handle:', error);
      throw new Error(error);
    }
  }

  static getAppNetSync(): connection.NetHandle {
    return connection.getAppNetSync();
  }

  /**
   * 获取所有可用网络句柄
   */
  static async getAllNets(): Promise<Array<connection.NetHandle>> {
    try {
      return await connection.getAllNets();
    } catch (error) {
      LogUtil.error('Failed to get all network handles:', error);
      throw new Error(error);
    }
  }

  static getAllNetsSync(): Array<connection.NetHandle> {
    return connection.getAllNetsSync();
  }

  /**
   * 检查是否有可用网络
   */
  static isNetworkAvailable(): boolean {
    const allNets = NetworkUtil.getAllNetsSync();
    return Array.isArray(allNets) && allNets.length > 0;
  }

  /**
   * 检查是否有指定类型的网络连接
   */
  static hasNetBearType(netType: connection.NetBearType): boolean {
    const bearTypes = NetworkUtil.getNetBearTypes();
    return bearTypes.includes(netType);
  }

  static hasNetMobile(): boolean {
    return NetworkUtil.hasNetBearType(connection.NetBearType.BEARER_CELLULAR);
  }

  static hasNetWiFi(): boolean {
    return NetworkUtil.hasNetBearType(connection.NetBearType.BEARER_WIFI);
  }

  static hasNetEthernet(): boolean {
    return NetworkUtil.hasNetBearType(connection.NetBearType.BEARER_ETHERNET);
  }

  static hasNetVPN(): boolean {
    return NetworkUtil.hasNetBearType(connection.NetBearType.BEARER_VPN);
  }

  /**
   * 获取网络承载类型列表
   */
  static getNetBearTypes(): Array<connection.NetBearType> {
    const netCapabilities = NetworkUtil.getNetCapabilitiesSync(NetworkUtil.getDefaultNetSync());
    return netCapabilities?.bearerTypes || [];
  }

  static getNetBearType(): connection.NetBearType {
    const bearTypes = NetworkUtil.getNetBearTypes();
    return bearTypes[0] || connection.NetBearType.BEARER_CELLULAR;
  }

  /**
   * 获取网络能力
   */
  static async getNetCapabilities(
    netHandle: connection.NetHandle = NetworkUtil.getDefaultNetSync()
  ): Promise<connection.NetCapabilities> {
    try {
      return await connection.getNetCapabilities(netHandle);
    } catch (error) {
      LogUtil.error('Failed to get network capabilities:', error);
      throw new Error(error);
    }
  }

  static getNetCapabilitiesSync(
    netHandle: connection.NetHandle = NetworkUtil.getDefaultNetSync()
  ): connection.NetCapabilities {
    return connection.getNetCapabilitiesSync(netHandle);
  }

  /**
   * 获取网络连接属性
   */
  static async getConnectionProperties(
    netHandle: connection.NetHandle = NetworkUtil.getDefaultNetSync()
  ): Promise<connection.ConnectionProperties> {
    try {
      return await connection.getConnectionProperties(netHandle);
    } catch (error) {
      LogUtil.error('Failed to get connection properties:', error);
      throw new Error(error);
    }
  }

  static getConnectionPropertiesSync(
    netHandle: connection.NetHandle = NetworkUtil.getDefaultNetSync()
  ): connection.ConnectionProperties {
    return connection.getConnectionPropertiesSync(netHandle);
  }

  /**
   * 获取当前设备的IP地址
   */
  static getIpAddress(): string {
    try {
      const ipAddress = wifiManager.getIpInfo().ipAddress;
      return [
        (ipAddress >>> 24) & 0xFF,
        (ipAddress >>> 16) & 0xFF,
        (ipAddress >>> 8) & 0xFF,
        ipAddress & 0xFF,
      ].join('.');
    } catch (error) {
      LogUtil.error('Failed to get IP address:', error);
      return '0.0.0.0';
    }
  }

  /**
   * 注册网络事件监听器
   */
  static register(
    netAvailableCallback?: Callback<connection.NetHandle>,
    netUnavailableCallback?: Callback<void>,
    netCapabilitiesChangeCallback?: Callback<connection.NetCapabilityInfo>,
    netConnectionPropertiesChangeCallback?: Callback<connection.NetConnectionPropertyInfo>,
    netBlockStatusChangeCallback?: Callback<connection.NetBlockStatusInfo>,
    netLostCallback?: Callback<connection.NetHandle>
  ): void {
    if (!NetworkUtil.netConnection) {
      NetworkUtil.netConnection = connection.createNetConnection();
    }

    // 注册默认网络回调
    connection.getDefaultNet((error: BusinessError, netHandle: connection.NetHandle) => {
      if (error) {
        LogUtil.error('Failed to get default network:', error);
      } else if (netHandle && netAvailableCallback) {
        netAvailableCallback(netHandle);
      }
    });

    // 注册网络事件监听器
    NetworkUtil.netConnection.register((error: BusinessError) => {
      if (error) {
        LogUtil.error('Failed to register network events:', error);
      }
    });

    if (netAvailableCallback) {
      NetworkUtil.netConnection.on('netAvailable', netAvailableCallback);
    }
    if (netUnavailableCallback) {
      NetworkUtil.netConnection.on('netUnavailable', netUnavailableCallback);
    }
    if (netCapabilitiesChangeCallback) {
      NetworkUtil.netConnection.on('netCapabilitiesChange', netCapabilitiesChangeCallback);
    }
    if (netConnectionPropertiesChangeCallback) {
      NetworkUtil.netConnection.on('netConnectionPropertiesChange', netConnectionPropertiesChangeCallback);
    }
    if (netBlockStatusChangeCallback) {
      NetworkUtil.netConnection.on('netBlockStatusChange', netBlockStatusChangeCallback);
    }
    if (netLostCallback) {
      NetworkUtil.netConnection.on('netLost', netLostCallback);
    }
  }

  /**
   * 取消注册网络事件监听器
   */
  static unregister(): void {
    if (NetworkUtil.netConnection) {
      NetworkUtil.netConnection.unregister((error: BusinessError) => {
        if (error) {
          LogUtil.error('Failed to unregister network events:', error);
        }
      });
      NetworkUtil.netConnection = null;
    }
  }

  /**
   * 检查是否支持NR（5G）
   */
  static isNRSupported(slotId?: number): boolean {
    try {
      return slotId ? radio.isNRSupported(slotId) : radio.isNRSupported();
    } catch (error) {
      LogUtil.error('Failed to check NR support:', error);
      return false;
    }
  }

  /**
   * 检查无线电是否开启
   */
  static async isRadioOn(slotId?: number): Promise<boolean> {
    try {
      return slotId ? await radio.isRadioOn(slotId) : await radio.isRadioOn();
    } catch (error) {
      LogUtil.error('Failed to check radio status:', error);
      return false;
    }
  }

  /**
   * 获取主卡槽ID
   */
  static async getPrimarySlotId(): Promise<number> {
    try {
      return await radio.getPrimarySlotId();
    } catch (error) {
      LogUtil.error('Failed to get primary slot ID:', error);
      throw new Error(error);
    }
  }

  /**
   * 获取运营商名称
   */
  static async getOperatorName(slotId?: number): Promise<string> {
    try {
      slotId = slotId ?? (await NetworkUtil.getPrimarySlotId());
      return await radio.getOperatorName(slotId);
    } catch (error) {
      LogUtil.error('Failed to get operator name:', error);
      throw new Error(error);
    }
  }

  /**
   * 获取网络状态
   */
  static async getNetworkState(slotId?: number): Promise<radio.NetworkState> {
    try {
      slotId = slotId ?? (await NetworkUtil.getPrimarySlotId());
      return await radio.getNetworkState(slotId);
    } catch (error) {
      LogUtil.error('Failed to get network state:', error);
      throw new Error(error);
    }
  }

  /**
   * 获取网络选择模式
   */
  static async getNetworkSelectionMode(slotId?: number): Promise<radio.NetworkSelectionMode> {
    try {
      slotId = slotId ?? (await NetworkUtil.getPrimarySlotId());
      return await radio.getNetworkSelectionMode(slotId);
    } catch (error) {
      LogUtil.error('Failed to get network selection mode:', error);
      throw new Error(error);
    }
  }

  /**
   * 获取信号信息
   */
  static async getSignalInformation(slotId?: number): Promise<Array<radio.SignalInformation>> {
    try {
      slotId = slotId ?? (await NetworkUtil.getPrimarySlotId());
      return await radio.getSignalInformation(slotId);
    } catch (error) {
      LogUtil.error('Failed to get signal information:', error);
      throw new Error(error);
    }
  }

  /**
   * 获取当前网络类型
   */
  static async getNetworkType(): Promise<NetworkType> {
    try {
      if (NetworkUtil.hasNetWiFi()) {
        return NetworkType.NETWORK_TYPE_WIFI;
      }
      if (NetworkUtil.hasNetMobile()) {
        const signalInfo = await NetworkUtil.getSignalInformation();
        for (const item of signalInfo) {
          switch (item.signalType) {
            case radio.NetworkType.NETWORK_TYPE_GSM:
            case radio.NetworkType.NETWORK_TYPE_CDMA:
              return NetworkType.NETWORK_TYPE_2G;
            case radio.NetworkType.NETWORK_TYPE_WCDMA:
            case radio.NetworkType.NETWORK_TYPE_TDSCDMA:
              return NetworkType.NETWORK_TYPE_3G;
            case radio.NetworkType.NETWORK_TYPE_LTE:
              return NetworkType.NETWORK_TYPE_4G;
            case radio.NetworkType.NETWORK_TYPE_NR:
              return NetworkType.NETWORK_TYPE_5G;
            default:
              break;
          }
        }
      }
    } catch (error) {
      LogUtil.error('Failed to determine network type:', error);
    }
    return NetworkType.NETWORK_TYPE_UNKNOWN;
  }

  /**
   * 获取当前网络类型字符串
   */
  static async getNetworkTypeStr(): Promise<string> {
    const networkType = await NetworkUtil.getNetworkType();
    switch (networkType) {
      case NetworkType.NETWORK_TYPE_WIFI:
        return 'Wi-Fi';
      case NetworkType.NETWORK_TYPE_2G:
        return '2G';
      case NetworkType.NETWORK_TYPE_3G:
        return '3G';
      case NetworkType.NETWORK_TYPE_4G:
        return '4G';
      case NetworkType.NETWORK_TYPE_5G:
        return '5G';
      default:
        return 'UNKNOWN';
    }
  }

  /**
   * 获取默认蜂窝数据卡槽ID（异步）
   */
  static async getDefaultCellularDataSlotId(): Promise<number> {
    try {
      return await data.getDefaultCellularDataSlotId();
    } catch (error) {
      LogUtil.error('Failed to get default cellular data slot ID:', error);
      throw new Error(error);
    }
  }

  /**
   * 获取默认蜂窝数据卡槽ID（同步）
   */
  static getDefaultCellularDataSlotIdSync(): number {
    try {
      return data.getDefaultCellularDataSlotIdSync();
    } catch (error) {
      LogUtil.error('Failed to get default cellular data slot ID (sync):', error);
      throw new Error(error);
    }
  }

  /**
   * 获取蜂窝数据流量类型
   */
  static async getCellularDataFlowType(): Promise<data.DataFlowType> {
    try {
      return await data.getCellularDataFlowType();
    } catch (error) {
      LogUtil.error('Failed to get cellular data flow type:', error);
      throw new Error(error);
    }
  }

  /**
   * 获取蜂窝数据连接状态
   */
  static async getCellularDataState(): Promise<data.DataConnectState> {
    try {
      return await data.getCellularDataState();
    } catch (error) {
      LogUtil.error('Failed to get cellular data state:', error);
      throw new Error(error);
    }
  }

  /**
   * 检查蜂窝数据是否启用（异步）
   */
  static async isCellularDataEnabled(): Promise<boolean> {
    try {
      return await data.isCellularDataEnabled();
    } catch (error) {
      LogUtil.error('Failed to check if cellular data is enabled:', error);
      return false;
    }
  }

  /**
   * 检查蜂窝数据是否启用（同步）
   */
  static isCellularDataEnabledSync(): boolean {
    try {
      return data.isCellularDataEnabledSync();
    } catch (error) {
      LogUtil.error('Failed to check if cellular data is enabled (sync):', error);
      return false;
    }
  }

  /**
   * 检查漫游是否启用（异步）
   */
  static async isCellularDataRoamingEnabled(slotId?: number): Promise<boolean> {
    try {
      slotId = slotId ?? (await NetworkUtil.getDefaultCellularDataSlotId());
      return await data.isCellularDataRoamingEnabled(slotId);
    } catch (error) {
      LogUtil.error('Failed to check if cellular data roaming is enabled:', error);
      return false;
    }
  }

  /**
   * 检查漫游是否启用（同步）
   */
  static isCellularDataRoamingEnabledSync(slotId?: number): boolean {
    try {
      slotId = slotId ?? NetworkUtil.getDefaultCellularDataSlotIdSync();
      return data.isCellularDataRoamingEnabledSync(slotId);
    } catch (error) {
      LogUtil.error('Failed to check if cellular data roaming is enabled (sync):', error);
      return false;
    }
  }

  /**
   * 获取默认蜂窝数据SIM卡ID
   */
  static getDefaultCellularDataSimId(): number {
    try {
      return data.getDefaultCellularDataSimId();
    } catch (error) {
      LogUtil.error('Failed to get default cellular data SIM ID:', error);
      throw new Error(error);
    }
  }

  /**
   * 检查SIM卡是否激活（异步）
   */
  static async isSimActive(slotId: number): Promise<boolean> {
    try {
      return await sim.isSimActive(slotId);
    } catch (error) {
      LogUtil.error(`Failed to check if SIM card at slot ${slotId} is active:`, error);
      return false;
    }
  }

  /**
   * 检查SIM卡是否激活（同步）
   */
  static isSimActiveSync(slotId: number): boolean {
    try {
      return sim.isSimActiveSync(slotId);
    } catch (error) {
      LogUtil.error(`Failed to check if SIM card at slot ${slotId} is active (sync):`, error);
      return false;
    }
  }

  /**
   * 检查是否有SIM卡（异步）
   */
  static async hasSimCard(slotId: number): Promise<boolean> {
    try {
      return await sim.hasSimCard(slotId);
    } catch (error) {
      LogUtil.error(`Failed to check if SIM card exists at slot ${slotId}:`, error);
      return false;
    }
  }

  /**
   * 检查是否有SIM卡（同步）
   */
  static hasSimCardSync(slotId: number): boolean {
    try {
      return sim.hasSimCardSync(slotId);
    } catch (error) {
      LogUtil.error(`Failed to check if SIM card exists at slot ${slotId} (sync):`, error);
      return false;
    }
  }

  /**
   * 获取最大支持的SIM卡数量
   */
  static getMaxSimCount(): number {
    try {
      return sim.getMaxSimCount();
    } catch (error) {
      LogUtil.error('Failed to get maximum SIM count:', error);
      throw new Error(error);
    }
  }

  /**
   * 获取SIM卡运营商编号（异步）
   */
  static async getSimOperatorNumeric(slotId?: number): Promise<string> {
    try {
      slotId = slotId ?? (await NetworkUtil.getDefaultCellularDataSlotId());
      return await sim.getSimOperatorNumeric(slotId);
    } catch (error) {
      LogUtil.error('Failed to get SIM operator numeric:', error);
      throw new Error(error);
    }
  }

  /**
   * 获取SIM卡运营商编号（同步）
   */
  static getSimOperatorNumericSync(slotId?: number): string {
    try {
      slotId = slotId ?? NetworkUtil.getDefaultCellularDataSlotIdSync();
      return sim.getSimOperatorNumericSync(slotId);
    } catch (error) {
      LogUtil.error('Failed to get SIM operator numeric (sync):', error);
      throw new Error(error);
    }
  }

  /**
   * 获取SIM卡服务提供商名称（异步）
   */
  static async getSimSpn(slotId?: number): Promise<string> {
    try {
      slotId = slotId ?? (await NetworkUtil.getDefaultCellularDataSlotId());
      return await sim.getSimSpn(slotId);
    } catch (error) {
      LogUtil.error('Failed to get SIM SPN:', error);
      throw new Error(error);
    }
  }

  /**
   * 获取SIM卡服务提供商名称（同步）
   */
  static getSimSpnSync(slotId?: number): string {
    try {
      slotId = slotId ?? NetworkUtil.getDefaultCellularDataSlotIdSync();
      return sim.getSimSpnSync(slotId);
    } catch (error) {
      LogUtil.error('Failed to get SIM SPN (sync):', error);
      throw new Error(error);
    }
  }

  /**
   * 获取SIM卡状态（异步）
   */
  static async getSimState(slotId?: number): Promise<sim.SimState> {
    try {
      slotId = slotId ?? (await NetworkUtil.getDefaultCellularDataSlotId());
      return await sim.getSimState(slotId);
    } catch (error) {
      LogUtil.error('Failed to get SIM state:', error);
      throw new Error(error);
    }
  }

  /**
   * 获取SIM卡状态（同步）
   */
  static getSimStateSync(slotId?: number): sim.SimState {
    try {
      slotId = slotId ?? NetworkUtil.getDefaultCellularDataSlotIdSync();
      return sim.getSimStateSync(slotId);
    } catch (error) {
      LogUtil.error('Failed to get SIM state (sync):', error);
      throw new Error(error);
    }
  }

  /**
   * 获取SIM卡类型（异步）
   */
  static async getCardType(slotId?: number): Promise<sim.CardType> {
    try {
      slotId = slotId ?? (await NetworkUtil.getDefaultCellularDataSlotId());
      return await sim.getCardType(slotId);
    } catch (error) {
      LogUtil.error('Failed to get SIM card type:', error);
      throw new Error(error);
    }
  }

  /**
   * 获取SIM卡类型（同步）
   */
  static getCardTypeSync(slotId?: number): sim.CardType {
    try {
      slotId = slotId ?? NetworkUtil.getDefaultCellularDataSlotIdSync();
      return sim.getCardTypeSync(slotId);
    } catch (error) {
      LogUtil.error('Failed to get SIM card type (sync):', error);
      throw new Error(error);
    }
  }
}
代码如下：
TypeScript 复制代码 
import { connection } from '@kit.NetworkKit';
import { BusinessError, Callback } from '@kit.BasicServicesKit';
import { wifiManager } from '@kit.ConnectivityKit';
import { LogUtil } from './LogUtil';
import { data, radio, sim } from '@kit.TelephonyKit';

// 网络类型枚举
export enum NetworkType {
  NETWORK_TYPE_UNKNOWN = 0,
  NETWORK_TYPE_WIFI = 1,
  NETWORK_TYPE_2G = 2,
  NETWORK_TYPE_3G = 3,
  NETWORK_TYPE_4G = 4,
  NETWORK_TYPE_5G = 5,
}

/**
 * 网络相关工具类
 * 需要 ohos.permission.GET_NETWORK_INFO、ohos.permission.GET_WIFI_INFO 权限。
 * author: CSDN-鸿蒙布道师
 * since: 2025/04/23
 */
export class NetworkUtil {
  private static netConnection: connection.NetConnection | null = null;

  /**
   * 检查默认网络是否按流量计费
   */
  static async isDefaultNetMetered(): Promise<boolean> {
    try {
      return await connection.isDefaultNetMetered();
    } catch (error) {
      LogUtil.error('Failed to check default network metering:', error);
      throw new Error(error);
    }
  }

  static isDefaultNetMeteredSync(): boolean {
    return connection.isDefaultNetMeteredSync();
  }

  /**
   * 检查是否有默认网络
   */
  static async hasDefaultNet(): Promise<boolean> {
    try {
      return await connection.hasDefaultNet();
    } catch (error) {
      LogUtil.error('Failed to check if there is a default network:', error);
      // 确保抛出的是 Error 类型
      throw new Error(error);
    }
  }

  static hasDefaultNetSync(): boolean {
    return connection.hasDefaultNetSync();
  }

  /**
   * 获取默认网络句柄
   */
  static async getDefaultNet(): Promise<connection.NetHandle> {
    try {
      return await connection.getDefaultNet();
    } catch (error) {
      LogUtil.error('Failed to get default network handle:', error);
      throw new Error(error);
    }
  }

  static getDefaultNetSync(): connection.NetHandle {
    return connection.getDefaultNetSync();
  }

  /**
   * 获取应用当前网络句柄
   */
  static async getAppNet(): Promise<connection.NetHandle> {
    try {
      return await connection.getAppNet();
    } catch (error) {
      LogUtil.error('Failed to get app network handle:', error);
      throw new Error(error);
    }
  }

  static getAppNetSync(): connection.NetHandle {
    return connection.getAppNetSync();
  }

  /**
   * 获取所有可用网络句柄
   */
  static async getAllNets(): Promise<Array<connection.NetHandle>> {
    try {
      return await connection.getAllNets();
    } catch (error) {
      LogUtil.error('Failed to get all network handles:', error);
      throw new Error(error);
    }
  }

  static getAllNetsSync(): Array<connection.NetHandle> {
    return connection.getAllNetsSync();
  }

  /**
   * 检查是否有可用网络
   */
  static isNetworkAvailable(): boolean {
    const allNets = NetworkUtil.getAllNetsSync();
    return Array.isArray(allNets) && allNets.length > 0;
  }

  /**
   * 检查是否有指定类型的网络连接
   */
  static hasNetBearType(netType: connection.NetBearType): boolean {
    const bearTypes = NetworkUtil.getNetBearTypes();
    return bearTypes.includes(netType);
  }

  static hasNetMobile(): boolean {
    return NetworkUtil.hasNetBearType(connection.NetBearType.BEARER_CELLULAR);
  }

  static hasNetWiFi(): boolean {
    return NetworkUtil.hasNetBearType(connection.NetBearType.BEARER_WIFI);
  }

  static hasNetEthernet(): boolean {
    return NetworkUtil.hasNetBearType(connection.NetBearType.BEARER_ETHERNET);
  }

  static hasNetVPN(): boolean {
    return NetworkUtil.hasNetBearType(connection.NetBearType.BEARER_VPN);
  }

  /**
   * 获取网络承载类型列表
   */
  static getNetBearTypes(): Array<connection.NetBearType> {
    const netCapabilities = NetworkUtil.getNetCapabilitiesSync(NetworkUtil.getDefaultNetSync());
    return netCapabilities?.bearerTypes || [];
  }

  static getNetBearType(): connection.NetBearType {
    const bearTypes = NetworkUtil.getNetBearTypes();
    return bearTypes[0] || connection.NetBearType.BEARER_CELLULAR;
  }

  /**
   * 获取网络能力
   */
  static async getNetCapabilities(
    netHandle: connection.NetHandle = NetworkUtil.getDefaultNetSync()
  ): Promise<connection.NetCapabilities> {
    try {
      return await connection.getNetCapabilities(netHandle);
    } catch (error) {
      LogUtil.error('Failed to get network capabilities:', error);
      throw new Error(error);
    }
  }

  static getNetCapabilitiesSync(
    netHandle: connection.NetHandle = NetworkUtil.getDefaultNetSync()
  ): connection.NetCapabilities {
    return connection.getNetCapabilitiesSync(netHandle);
  }

  /**
   * 获取网络连接属性
   */
  static async getConnectionProperties(
    netHandle: connection.NetHandle = NetworkUtil.getDefaultNetSync()
  ): Promise<connection.ConnectionProperties> {
    try {
      return await connection.getConnectionProperties(netHandle);
    } catch (error) {
      LogUtil.error('Failed to get connection properties:', error);
      throw new Error(error);
    }
  }

  static getConnectionPropertiesSync(
    netHandle: connection.NetHandle = NetworkUtil.getDefaultNetSync()
  ): connection.ConnectionProperties {
    return connection.getConnectionPropertiesSync(netHandle);
  }

  /**
   * 获取当前设备的IP地址
   */
  static getIpAddress(): string {
    try {
      const ipAddress = wifiManager.getIpInfo().ipAddress;
      return [
        (ipAddress >>> 24) & 0xFF,
        (ipAddress >>> 16) & 0xFF,
        (ipAddress >>> 8) & 0xFF,
        ipAddress & 0xFF,
      ].join('.');
    } catch (error) {
      LogUtil.error('Failed to get IP address:', error);
      return '0.0.0.0';
    }
  }

  /**
   * 注册网络事件监听器
   */
  static register(
    netAvailableCallback?: Callback<connection.NetHandle>,
    netUnavailableCallback?: Callback<void>,
    netCapabilitiesChangeCallback?: Callback<connection.NetCapabilityInfo>,
    netConnectionPropertiesChangeCallback?: Callback<connection.NetConnectionPropertyInfo>,
    netBlockStatusChangeCallback?: Callback<connection.NetBlockStatusInfo>,
    netLostCallback?: Callback<connection.NetHandle>
  ): void {
    if (!NetworkUtil.netConnection) {
      NetworkUtil.netConnection = connection.createNetConnection();
    }

    // 注册默认网络回调
    connection.getDefaultNet((error: BusinessError, netHandle: connection.NetHandle) => {
      if (error) {
        LogUtil.error('Failed to get default network:', error);
      } else if (netHandle && netAvailableCallback) {
        netAvailableCallback(netHandle);
      }
    });

    // 注册网络事件监听器
    NetworkUtil.netConnection.register((error: BusinessError) => {
      if (error) {
        LogUtil.error('Failed to register network events:', error);
      }
    });

    if (netAvailableCallback) {
      NetworkUtil.netConnection.on('netAvailable', netAvailableCallback);
    }
    if (netUnavailableCallback) {
      NetworkUtil.netConnection.on('netUnavailable', netUnavailableCallback);
    }
    if (netCapabilitiesChangeCallback) {
      NetworkUtil.netConnection.on('netCapabilitiesChange', netCapabilitiesChangeCallback);
    }
    if (netConnectionPropertiesChangeCallback) {
      NetworkUtil.netConnection.on('netConnectionPropertiesChange', netConnectionPropertiesChangeCallback);
    }
    if (netBlockStatusChangeCallback) {
      NetworkUtil.netConnection.on('netBlockStatusChange', netBlockStatusChangeCallback);
    }
    if (netLostCallback) {
      NetworkUtil.netConnection.on('netLost', netLostCallback);
    }
  }

  /**
   * 取消注册网络事件监听器
   */
  static unregister(): void {
    if (NetworkUtil.netConnection) {
      NetworkUtil.netConnection.unregister((error: BusinessError) => {
        if (error) {
          LogUtil.error('Failed to unregister network events:', error);
        }
      });
      NetworkUtil.netConnection = null;
    }
  }

  /**
   * 检查是否支持NR（5G）
   */
  static isNRSupported(slotId?: number): boolean {
    try {
      return slotId ? radio.isNRSupported(slotId) : radio.isNRSupported();
    } catch (error) {
      LogUtil.error('Failed to check NR support:', error);
      return false;
    }
  }

  /**
   * 检查无线电是否开启
   */
  static async isRadioOn(slotId?: number): Promise<boolean> {
    try {
      return slotId ? await radio.isRadioOn(slotId) : await radio.isRadioOn();
    } catch (error) {
      LogUtil.error('Failed to check radio status:', error);
      return false;
    }
  }

  /**
   * 获取主卡槽ID
   */
  static async getPrimarySlotId(): Promise<number> {
    try {
      return await radio.getPrimarySlotId();
    } catch (error) {
      LogUtil.error('Failed to get primary slot ID:', error);
      throw new Error(error);
    }
  }

  /**
   * 获取运营商名称
   */
  static async getOperatorName(slotId?: number): Promise<string> {
    try {
      slotId = slotId ?? (await NetworkUtil.getPrimarySlotId());
      return await radio.getOperatorName(slotId);
    } catch (error) {
      LogUtil.error('Failed to get operator name:', error);
      throw new Error(error);
    }
  }

  /**
   * 获取网络状态
   */
  static async getNetworkState(slotId?: number): Promise<radio.NetworkState> {
    try {
      slotId = slotId ?? (await NetworkUtil.getPrimarySlotId());
      return await radio.getNetworkState(slotId);
    } catch (error) {
      LogUtil.error('Failed to get network state:', error);
      throw new Error(error);
    }
  }

  /**
   * 获取网络选择模式
   */
  static async getNetworkSelectionMode(slotId?: number): Promise<radio.NetworkSelectionMode> {
    try {
      slotId = slotId ?? (await NetworkUtil.getPrimarySlotId());
      return await radio.getNetworkSelectionMode(slotId);
    } catch (error) {
      LogUtil.error('Failed to get network selection mode:', error);
      throw new Error(error);
    }
  }

  /**
   * 获取信号信息
   */
  static async getSignalInformation(slotId?: number): Promise<Array<radio.SignalInformation>> {
    try {
      slotId = slotId ?? (await NetworkUtil.getPrimarySlotId());
      return await radio.getSignalInformation(slotId);
    } catch (error) {
      LogUtil.error('Failed to get signal information:', error);
      throw new Error(error);
    }
  }

  /**
   * 获取当前网络类型
   */
  static async getNetworkType(): Promise<NetworkType> {
    try {
      if (NetworkUtil.hasNetWiFi()) {
        return NetworkType.NETWORK_TYPE_WIFI;
      }
      if (NetworkUtil.hasNetMobile()) {
        const signalInfo = await NetworkUtil.getSignalInformation();
        for (const item of signalInfo) {
          switch (item.signalType) {
            case radio.NetworkType.NETWORK_TYPE_GSM:
            case radio.NetworkType.NETWORK_TYPE_CDMA:
              return NetworkType.NETWORK_TYPE_2G;
            case radio.NetworkType.NETWORK_TYPE_WCDMA:
            case radio.NetworkType.NETWORK_TYPE_TDSCDMA:
              return NetworkType.NETWORK_TYPE_3G;
            case radio.NetworkType.NETWORK_TYPE_LTE:
              return NetworkType.NETWORK_TYPE_4G;
            case radio.NetworkType.NETWORK_TYPE_NR:
              return NetworkType.NETWORK_TYPE_5G;
            default:
              break;
          }
        }
      }
    } catch (error) {
      LogUtil.error('Failed to determine network type:', error);
    }
    return NetworkType.NETWORK_TYPE_UNKNOWN;
  }

  /**
   * 获取当前网络类型字符串
   */
  static async getNetworkTypeStr(): Promise<string> {
    const networkType = await NetworkUtil.getNetworkType();
    switch (networkType) {
      case NetworkType.NETWORK_TYPE_WIFI:
        return 'Wi-Fi';
      case NetworkType.NETWORK_TYPE_2G:
        return '2G';
      case NetworkType.NETWORK_TYPE_3G:
        return '3G';
      case NetworkType.NETWORK_TYPE_4G:
        return '4G';
      case NetworkType.NETWORK_TYPE_5G:
        return '5G';
      default:
        return 'UNKNOWN';
    }
  }

  /**
   * 获取默认蜂窝数据卡槽ID（异步）
   */
  static async getDefaultCellularDataSlotId(): Promise<number> {
    try {
      return await data.getDefaultCellularDataSlotId();
    } catch (error) {
      LogUtil.error('Failed to get default cellular data slot ID:', error);
      throw new Error(error);
    }
  }

  /**
   * 获取默认蜂窝数据卡槽ID（同步）
   */
  static getDefaultCellularDataSlotIdSync(): number {
    try {
      return data.getDefaultCellularDataSlotIdSync();
    } catch (error) {
      LogUtil.error('Failed to get default cellular data slot ID (sync):', error);
      throw new Error(error);
    }
  }

  /**
   * 获取蜂窝数据流量类型
   */
  static async getCellularDataFlowType(): Promise<data.DataFlowType> {
    try {
      return await data.getCellularDataFlowType();
    } catch (error) {
      LogUtil.error('Failed to get cellular data flow type:', error);
      throw new Error(error);
    }
  }

  /**
   * 获取蜂窝数据连接状态
   */
  static async getCellularDataState(): Promise<data.DataConnectState> {
    try {
      return await data.getCellularDataState();
    } catch (error) {
      LogUtil.error('Failed to get cellular data state:', error);
      throw new Error(error);
    }
  }

  /**
   * 检查蜂窝数据是否启用（异步）
   */
  static async isCellularDataEnabled(): Promise<boolean> {
    try {
      return await data.isCellularDataEnabled();
    } catch (error) {
      LogUtil.error('Failed to check if cellular data is enabled:', error);
      return false;
    }
  }

  /**
   * 检查蜂窝数据是否启用（同步）
   */
  static isCellularDataEnabledSync(): boolean {
    try {
      return data.isCellularDataEnabledSync();
    } catch (error) {
      LogUtil.error('Failed to check if cellular data is enabled (sync):', error);
      return false;
    }
  }

  /**
   * 检查漫游是否启用（异步）
   */
  static async isCellularDataRoamingEnabled(slotId?: number): Promise<boolean> {
    try {
      slotId = slotId ?? (await NetworkUtil.getDefaultCellularDataSlotId());
      return await data.isCellularDataRoamingEnabled(slotId);
    } catch (error) {
      LogUtil.error('Failed to check if cellular data roaming is enabled:', error);
      return false;
    }
  }

  /**
   * 检查漫游是否启用（同步）
   */
  static isCellularDataRoamingEnabledSync(slotId?: number): boolean {
    try {
      slotId = slotId ?? NetworkUtil.getDefaultCellularDataSlotIdSync();
      return data.isCellularDataRoamingEnabledSync(slotId);
    } catch (error) {
      LogUtil.error('Failed to check if cellular data roaming is enabled (sync):', error);
      return false;
    }
  }

  /**
   * 获取默认蜂窝数据SIM卡ID
   */
  static getDefaultCellularDataSimId(): number {
    try {
      return data.getDefaultCellularDataSimId();
    } catch (error) {
      LogUtil.error('Failed to get default cellular data SIM ID:', error);
      throw new Error(error);
    }
  }

  /**
   * 检查SIM卡是否激活（异步）
   */
  static async isSimActive(slotId: number): Promise<boolean> {
    try {
      return await sim.isSimActive(slotId);
    } catch (error) {
      LogUtil.error(`Failed to check if SIM card at slot ${slotId} is active:`, error);
      return false;
    }
  }

  /**
   * 检查SIM卡是否激活（同步）
   */
  static isSimActiveSync(slotId: number): boolean {
    try {
      return sim.isSimActiveSync(slotId);
    } catch (error) {
      LogUtil.error(`Failed to check if SIM card at slot ${slotId} is active (sync):`, error);
      return false;
    }
  }

  /**
   * 检查是否有SIM卡（异步）
   */
  static async hasSimCard(slotId: number): Promise<boolean> {
    try {
      return await sim.hasSimCard(slotId);
    } catch (error) {
      LogUtil.error(`Failed to check if SIM card exists at slot ${slotId}:`, error);
      return false;
    }
  }

  /**
   * 检查是否有SIM卡（同步）
   */
  static hasSimCardSync(slotId: number): boolean {
    try {
      return sim.hasSimCardSync(slotId);
    } catch (error) {
      LogUtil.error(`Failed to check if SIM card exists at slot ${slotId} (sync):`, error);
      return false;
    }
  }

  /**
   * 获取最大支持的SIM卡数量
   */
  static getMaxSimCount(): number {
    try {
      return sim.getMaxSimCount();
    } catch (error) {
      LogUtil.error('Failed to get maximum SIM count:', error);
      throw new Error(error);
    }
  }

  /**
   * 获取SIM卡运营商编号（异步）
   */
  static async getSimOperatorNumeric(slotId?: number): Promise<string> {
    try {
      slotId = slotId ?? (await NetworkUtil.getDefaultCellularDataSlotId());
      return await sim.getSimOperatorNumeric(slotId);
    } catch (error) {
      LogUtil.error('Failed to get SIM operator numeric:', error);
      throw new Error(error);
    }
  }

  /**
   * 获取SIM卡运营商编号（同步）
   */
  static getSimOperatorNumericSync(slotId?: number): string {
    try {
      slotId = slotId ?? NetworkUtil.getDefaultCellularDataSlotIdSync();
      return sim.getSimOperatorNumericSync(slotId);
    } catch (error) {
      LogUtil.error('Failed to get SIM operator numeric (sync):', error);
      throw new Error(error);
    }
  }

  /**
   * 获取SIM卡服务提供商名称（异步）
   */
  static async getSimSpn(slotId?: number): Promise<string> {
    try {
      slotId = slotId ?? (await NetworkUtil.getDefaultCellularDataSlotId());
      return await sim.getSimSpn(slotId);
    } catch (error) {
      LogUtil.error('Failed to get SIM SPN:', error);
      throw new Error(error);
    }
  }

  /**
   * 获取SIM卡服务提供商名称（同步）
   */
  static getSimSpnSync(slotId?: number): string {
    try {
      slotId = slotId ?? NetworkUtil.getDefaultCellularDataSlotIdSync();
      return sim.getSimSpnSync(slotId);
    } catch (error) {
      LogUtil.error('Failed to get SIM SPN (sync):', error);
      throw new Error(error);
    }
  }

  /**
   * 获取SIM卡状态（异步）
   */
  static async getSimState(slotId?: number): Promise<sim.SimState> {
    try {
      slotId = slotId ?? (await NetworkUtil.getDefaultCellularDataSlotId());
      return await sim.getSimState(slotId);
    } catch (error) {
      LogUtil.error('Failed to get SIM state:', error);
      throw new Error(error);
    }
  }

  /**
   * 获取SIM卡状态（同步）
   */
  static getSimStateSync(slotId?: number): sim.SimState {
    try {
      slotId = slotId ?? NetworkUtil.getDefaultCellularDataSlotIdSync();
      return sim.getSimStateSync(slotId);
    } catch (error) {
      LogUtil.error('Failed to get SIM state (sync):', error);
      throw new Error(error);
    }
  }

  /**
   * 获取SIM卡类型（异步）
   */
  static async getCardType(slotId?: number): Promise<sim.CardType> {
    try {
      slotId = slotId ?? (await NetworkUtil.getDefaultCellularDataSlotId());
      return await sim.getCardType(slotId);
    } catch (error) {
      LogUtil.error('Failed to get SIM card type:', error);
      throw new Error(error);
    }
  }

  /**
   * 获取SIM卡类型（同步）
   */
  static getCardTypeSync(slotId?: number): sim.CardType {
    try {
      slotId = slotId ?? NetworkUtil.getDefaultCellularDataSlotIdSync();
      return sim.getCardTypeSync(slotId);
    } catch (error) {
      LogUtil.error('Failed to get SIM card type (sync):', error);
      throw new Error(error);
    }
  }
}
相关推荐
似霰10 分钟前
安卓adb shell串口基础指令
android·adb
NapleC1 小时前
HarmonyOS：一多能力介绍：一次开发，多端部署
华为·harmonyos
fatiaozhang95272 小时前
中兴云电脑W102D_晶晨S905X2_2+16G_mt7661无线_安卓9.0_线刷固件包
android·adb·电视盒子·魔百盒刷机·魔百盒固件
CYRUS_STUDIO3 小时前
Android APP 热修复原理
android·app·hotfix
我爱学习_zwj3 小时前
【鸿蒙HarmonyOS】深入理解router与Navigation
华为·harmonyos
NapleC4 小时前
HarmonyOS：1.7
harmonyos
鸿蒙布道师4 小时前
鸿蒙NEXT开发通知工具类（ArkTs）
android·ios·华为·harmonyos·arkts·鸿蒙系统·huawei
大耳猫4 小时前
【解决】Android Gradle Sync 报错 Could not read workspace metadata
android·gradle·android studio
热门推荐
01KGG转MP3工具|非KGM文件|解密音频02从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑03我决定放弃搞 Java 了04Coze扣子平台完整体验和实践（附国内和国际版对比）05YOLOv8入门 | 重要性能衡量指标、训练结果评价及分析及影响mAP的因素【发论文关注的指标】06苍穹外卖面试总结07✨分享我在飞书多维表格中使用DeepSeek的经历✨08yolov8，yolo11，yolo12 服务器训练到部署全流程 笔记09DeepSeek各版本说明与优缺点分析10如何在WPS和Word/Excel中直接使用DeepSeek功能