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

news2025/4/25 12:45:01 
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);
    }
  }
}
代码如下：

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);
    }
  }
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2342428.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

【UVM项目实战】异步fifo—uvm项目结构以及uvm环境搭建

【UVM项目实战】异步fifo—uvm项目结构以及uvm环境搭建

本文章同步到我的个人博客网站&#xff1a;ElemenX-King&#xff1a;【UVM项目实战】异步fifo—uvm项目结构以及uvm环境搭建 希望大家能使用此网站来进行浏览效果更佳&#xff01;&#xff01;&#xff01; 目录 一、异步FIFO1.1 异步FIFO的定义1.2 亚稳态1.3 异步FIFO关键技术…
阅读更多...
【通关函数的递归】--递归思想的形成与应用

【通关函数的递归】--递归思想的形成与应用

目录 一.递归的概念与思想 1.定义 2.递归的思想 3.递归的限制条件 二.递归举例 1.求n的阶乘 2.顺序打印一个整数的每一位 三.递归与迭代 前言:上篇博文分享了扫雷游戏的实现&#xff0c;这篇文章将会继续分享函数的递归相关知识点&#xff0c;让大家了解并掌握递归的思…
阅读更多...
【FAQ】针对于消费级NVIDIA GPU的说明

【FAQ】针对于消费级NVIDIA GPU的说明

概述 本文概述 HP Anyware 在配备消费级 NVIDIA GPU 的物理工作站上的关​​键组件、安装说明和重要注意事项。 注意&#xff1a;本文档适用于 NVIDIA 消费级 GPU。NVIDIA Quadro 和 Tesla GPU 也支持 HP Anyware 在公有云、虚拟化或物理工作站环境中运行。请参阅PCoIP Graphi…
阅读更多...
MyBatis操作数据库---从入门到理解

MyBatis操作数据库---从入门到理解

文章目录 关于MyBatis操作数据库MyBatis⼊⻔&#xff08;使用&#xff09;Mybatis操作数据库的步骤&#xff1a;配置数据库连接字符串使⽤MyBatis完成简单的增删改查操作注解xml 单元测试开启驼峰命名(推荐) 打印日志 关于MyBatis操作数据库 在之前的学习,我们了解到web应⽤程…
阅读更多...
【HFP】蓝牙语音通话控制深度解析：来电拒接与通话终止协议

【HFP】蓝牙语音通话控制深度解析：来电拒接与通话终止协议

目录 一、来电拒接的核心流程与信令交互 1.1 拒接场景的分类与触发条件 1.2 HF 端拒接流程 1.3 AG 端拒接流程 二、通话终止流程&#xff1a;主动断开与异常中断 2.1 终止场景的界定 2.2 HF 端终止流程 2.3 AG 端终止流程 三、信令协议的核心要素&#xff1a;AT 命令与…
阅读更多...
使用QML Tumbler 实现时间日期选择器

使用QML Tumbler 实现时间日期选择器

目录 引言相关阅读项目结构示例实现与代码解析示例一&#xff1a;时间选择器&#xff08;TimePicker&#xff09;示例二&#xff1a;日期时间选择器&#xff08;DateTimePicker&#xff09; 主窗口整合运行效果总结下载链接 引言 在现代应用程序开发中&#xff0c;时间与日期选…
阅读更多...
智能吸顶灯/摄影补光灯专用！FP7195双通道LED驱动，高效节能省空间 ！

智能吸顶灯/摄影补光灯专用！FP7195双通道LED驱动，高效节能省空间 ！

一、双路调光技术背景与市场需求 随着LED照明技术的快速发展和智能照明需求的激增&#xff0c;双路调光技术正成为照明行业的重要发展方向。传统单路调光方案只能实现整体亮度的统一调节&#xff0c;而双路调光则能够实现对两个独立通道的精确控制。今天&#xff0c;由我来为大…
阅读更多...
YOLOv11改进-双Backbone架构：利用双backbone提高yolo11目标检测的精度

YOLOv11改进-双Backbone架构：利用双backbone提高yolo11目标检测的精度

一、引言&#xff1a;为什么我们需要双Backbone&#xff1f; 在目标检测任务中&#xff0c;YOLO系列模型因其高效的端到端检测能力而备受青睐。然而&#xff0c;传统YOLO模型大多采用单一Backbone结构&#xff0c;即利用一个卷积神经网络&#xff08;CNN&#xff09;作为特征提…
阅读更多...
《逃离云端束缚，拥抱GPT本地部署》

《逃离云端束缚，拥抱GPT本地部署》

《逃离云端束缚，拥抱GPT本地部署》 一、GPT 热潮与本地部署的兴起 自 OpenAI 推出 ChatGPT 以来，全球范围内掀起了一股人工智能的热潮，其强大的自然语言处理能力和广泛的应用场景，让人们对人工智能的未来充满了想象。GPT（Generative Pretrained Transformer）作为一种基于…
阅读更多...
头歌之动手学人工智能-机器学习 --- PCA

头歌之动手学人工智能-机器学习 --- PCA

目录 第1关&#xff1a;维数灾难与降维 第2关&#xff1a;PCA算法流程 任务描述 编程要求 测试说明 第3关&#xff1a;sklearn中的PCA 任务描述 编程要求 测试说明 第1关&#xff1a;维数灾难与降维 第2关&#xff1a;PCA算法流程 任务描述 本关任务&#xff1a;补充…
阅读更多...
研0调研入门

研0调研入门

一、Web of Science 使用教程 1. 访问与注册 访问入口&#xff1a;通过高校图书馆官网进入&#xff08;需IP权限&#xff09;&#xff0c;或直接访问 Web of Science官网。注册/登录&#xff1a;若机构已订阅&#xff0c;用学校账号登录&#xff1b;个人用户可申请试用或付费…
阅读更多...
神经网络基础[ANN网络的搭建]

神经网络基础[ANN网络的搭建]

神经网络 人工神经网络&#xff08; Artificial Neural Network&#xff0c; 简写为ANN&#xff09;也简称为神经网络&#xff08;NN&#xff09;&#xff0c;是一种模仿生物神经网络结构和功能的计算模型。各个神经元传递复杂的电信号&#xff0c;树突接收到输入信号&#xf…
阅读更多...
五、web自动化测试01

五、web自动化测试01

目录 一、HTML基础1、HTML介绍2、常用标签3、基础案例3.1 前端代码3.2 自动化测试 二、CSS定位1、css介绍2、案例3、代码优化 三、表单自动化1、案例2、元素属性定位 四、后台基础数据自动化1、登录1.1 id与class定位1.2 定位一组元素 2、商品新增 一、HTML基础 可参考学习 链…
阅读更多...
数据库监控 | MongoDB监控全解析

数据库监控 | MongoDB监控全解析

PART 01 MongoDB&#xff1a;灵活、可扩展的文档数据库 MongoDB作为一款开源的NoSQL数据库&#xff0c;凭借其灵活的数据模型&#xff08;基于BSON的文档存储&#xff09;、水平扩展能力&#xff08;分片集群&#xff09;和高可用性&#xff08;副本集架构&#xff09;&#x…
阅读更多...
STM32F407使用ESP8266实现阿里云OTA（中）

STM32F407使用ESP8266实现阿里云OTA（中）

文章目录 前言一、程序分析二、程序讲解1. main函数2. Get_Version()函数3. esp_Init()函数4. Check_Updata()函数结语前言 从上一章STM32F407使用ESP8266实现阿里云OTA（上）中我们已经对连接阿里云和从阿里云获取升级包的流程非常的熟悉了。所以本章我们进行STM32的程序开发…
阅读更多...
微信小程序 tabbar底部导航栏

微信小程序 tabbar底部导航栏

官方文档&#xff1a;https://developers.weixin.qq.com/miniprogram/dev/reference/configuration/app.html#tabBar 一、常规菜单格式 在app.json 文件中配置&#xff0c;其他关键点详见官方文档&#xff0c;后续更新不规则图标的写法
阅读更多...
Unity InputSystem触摸屏问题

Unity InputSystem触摸屏问题

最近把Unity打包后的windows软件放到windows触摸屏一体机上测试&#xff0c;发现部分屏幕触摸点击不了按钮&#xff0c;测试了其他应用程序都正常。 这个一体机是这样的&#xff0c;一个电脑机箱&#xff0c;外接一个可以触摸的显示屏&#xff0c;然后UGUI的按钮就间歇性点不了…
阅读更多...
Linux Awk 深度解析：10个生产级自动化与云原生场景

Linux Awk 深度解析：10个生产级自动化与云原生场景

看图猜诗&#xff0c;你有任何想法都可以在评论区留言哦~ 摘要 Awk 作为 Linux 文本处理三剑客中的“数据工程师”&#xff0c;凭借字段分割、模式匹配和数学运算三位一体的能力&#xff0c;成为处理结构化文本&#xff08;日志、CSV、配置文件&#xff09;的终极工具。本文聚…
阅读更多...
免费版还是专业版？Dynadot 域名邮箱服务选择指南

免费版还是专业版？Dynadot 域名邮箱服务选择指南

关于Dynadot Dynadot是通过ICANN认证的域名注册商&#xff0c;自2002年成立以来&#xff0c;服务于全球108个国家和地区的客户&#xff0c;为数以万计的客户提供简洁&#xff0c;优惠&#xff0c;安全的域名注册以及管理服务。 Dynadot平台操作教程索引&#xff08;包括域名邮…
阅读更多...
旋转磁体产生的场-对导航姿态的影响

旋转磁体产生的场-对导航姿态的影响

pitch、yaw、roll是描述物体在空间中旋转的术语&#xff0c;通常用于计算机图形学或航空航天领域中。这些术语描述了物体绕不同轴旋转的方式&#xff1a; Pitch&#xff08;俯仰&#xff09;&#xff1a;绕横轴旋转&#xff0c;使物体向前或向后倾斜。俯仰角度通常用来描述物体…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023