deepChartVueApp/api/tcpConnection.js

/**
 * TCP连接工具类
 * 用于处理TCP连接、发送消息和断开连接
 *
 * @format
 */

// 引用TCP插件
const TCPSocket = uni.requireNativePlugin("Aimer-TCPPlugin");

// TCP连接配置
const TCP_CONFIG = {
  ip: "192.168.1.9",
  port: "8080",
  channel: "1", // 可选 1~20
  charsetname: "UTF-8", // 默认UTF-8，可选GBK
};

/**
 * TCP连接管理类
 */
class TCPConnection {
  constructor() {
    this.isConnected = false;
    this.connectionCallbacks = [];
    this.messageCallbacks = [];
  }

  /**
   * TCP初始化连接
   * @param {Object} config - 连接配置 {ip, port, channel, charsetname}
   * @param {Function} callback - 连接状态回调函数
   */
  connect(config = {}, callback = null) {
    // 如果已经连接，先断开现有连接
    if (this.isConnected) {
      console.log("检测到现有TCP连接，先断开...");
      this.disconnect(config);
      // 等待断开完成后再连接
      setTimeout(() => {
        this._performConnect(config, callback);
      }, 300);
    } else {
      // 直接连接
      this._performConnect(config, callback);
    }
  }

  /**
   * 执行TCP连接
   * @param {Object} config - 连接配置
   * @param {Function} callback - 连接状态回调函数
   */
  _performConnect(config = {}, callback = null) {
    const connectionConfig = {
      channel: config.channel || TCP_CONFIG.channel,
      ip: config.ip || TCP_CONFIG.ip,
      port: config.port || TCP_CONFIG.port,
    };

    // 如果指定了字符集，添加到配置中
    if (config.charsetname || TCP_CONFIG.charsetname) {
      connectionConfig.charsetname = config.charsetname || TCP_CONFIG.charsetname;
    }

    console.log("开始建立TCP连接:", connectionConfig);
    TCPSocket.connect(connectionConfig, (result) => {
      /**
       * status : 0 连接成功
       * status : 1 断开连接
       * receivedMsg : 服务器返回字符串(普通的字符串交互)
       * receivedHexMsg : 服务器返回字节数组(单片机、智能家居等硬件数据交互)
       */
      if (result.status == "0") {
        // TCP连接成功
        this.isConnected = true;
        console.log("TCP连接成功");
        this._notifyConnectionCallbacks("connected", result);
      } else if (result.status == "1") {
        // TCP断开连接
        this.isConnected = false;
        console.log("TCP断开连接");
        this._notifyConnectionCallbacks("disconnected", result);
      }

      if (result.receivedMsg) {
        // 服务器返回字符串
        console.log("收到字符串消息:", result.receivedMsg);
        this._notifyMessageCallbacks("string", result.receivedMsg);
      }

      // if (result.receivedHexMsg) {
      //     // 硬件服务器返回16进制数据
      //     console.log('收到16进制消息:', result.receivedHexMsg);
      //     let msg = result.receivedHexMsg;
      //     let sum = msg.length / 2;
      //     let arr = [];
      //     for (let k = 0; k < sum; k++) {
      //         let i = msg.substring(k * 2, k * 2 + 2);
      //         arr.push(i);
      //     }
      //     console.log('解析后的16进制数组:', arr);
      //     this._notifyMessageCallbacks('hex', result.receivedHexMsg, arr);
      // }

      // 执行回调函数
      if (callback && typeof callback === "function") {
        callback(result);
      }
    });
  }

  /**
   * TCP发送消息(普通的字符串交互)
   * @param {String|Object} message - 要发送的消息，如果是对象会自动转换为JSON字符串
   * @param {Object} config - 发送配置 {channel, charsetname}
   */
  send(message, config = {}) {
    if (!this.isConnected) {
      console.warn("TCP未连接，无法发送消息");
      return false;
    }

    // 如果message是对象，转换为JSON字符串
    let messageStr = message;
    if (typeof message === "object") {
      messageStr = JSON.stringify(message) + "\n";
    }

    const sendConfig = {
      channel: config.channel || "1", // 注意：channel应该是字符串
      message: messageStr,
    };

    // 如果指定了字符编码，添加到配置中
    if (config.charsetname) {
      sendConfig.charsetname = config.charsetname;
    }

    TCPSocket.send(sendConfig);
    console.log("js成功发送TCP消息:", messageStr);
    return true;
  }

  /**
   * TCP断开连接
   * @param {Object} config - 断开配置 {channel}
   */
  disconnect(config = {}) {
    const disconnectConfig = {
      channel: config.channel || TCP_CONFIG.channel,
    };

    TCPSocket.disconnect(disconnectConfig);
    this.isConnected = false;
    console.log("TCP连接已断开", disconnectConfig);
  }

  /**
   * 添加连接状态监听器
   * @param {Function} callback - 回调函数 (status, result) => {}
   */
  onConnectionChange(callback) {
    if (typeof callback === "function") {
      this.connectionCallbacks.push(callback);
    }
  }

  /**
   * 添加消息监听器
   * @param {Function} callback - 回调函数 (type, message, parsedArray) => {}
   */
  onMessage(callback) {
    if (typeof callback === "function") {
      this.messageCallbacks.push(callback);
    }
  }

  /**
   * 移除连接状态监听器
   * @param {Function} callback - 要移除的回调函数
   */
  removeConnectionListener(callback) {
    const index = this.connectionCallbacks.indexOf(callback);
    if (index > -1) {
      this.connectionCallbacks.splice(index, 1);
    }
  }

  /**
   * 移除消息监听器
   * @param {Function} callback - 要移除的回调函数
   */
  removeMessageListener(callback) {
    const index = this.messageCallbacks.indexOf(callback);
    if (index > -1) {
      this.messageCallbacks.splice(index, 1);
    }
  }

  /**
   * 获取连接状态
   * @returns {Boolean} 连接状态
   */
  getConnectionStatus() {
    return this.isConnected;
  }

  /**
   * 通知连接状态回调
   * @private
   */
  _notifyConnectionCallbacks(status, result) {
    this.connectionCallbacks.forEach((callback) => {
      try {
        callback(status, result);
      } catch (error) {
        console.error("连接状态回调执行错误:", error);
      }
    });
  }

  /**
   * 通知消息回调
   * @private
   */
  _notifyMessageCallbacks(type, message, parsedArray = null) {
    this.messageCallbacks.forEach((callback) => {
      try {
        callback(type, message, parsedArray);
      } catch (error) {
        console.error("消息回调执行错误:", error);
      }
    });
  }
}

// 创建TCP连接实例
const tcpConnection = new TCPConnection();

// 导出TCP连接实例和类
export default tcpConnection;
export { TCPConnection, TCP_CONFIG };