#include "mainwidget.h"
#include "ui_mainwidget.h"
#include "Data_Ctrl.h"


MainWidget::MainWidget(QWidget *parent)
    : QWidget(parent)
    , ui(new Ui::MainWidget)
{
    ui->setupUi(this);

    ui->serialCB_3->clear();
    m_USBCtrl.SerialPortInit();
    connect(Data_Ctrl::getData()->serialPort,SIGNAL(readyRead()),this,SLOT(manual_serialPortReadyRead()));/*手动连接槽函数*/

    InitUI();
    InitConnect();

    //QString currentPath = QDir::currentPath();
    m_TotalCHNum=14;
    for (int i=0;i<64;i++) {
        m_PDUCHInfo[i].CHNum=i+1;
        m_PDUCHInfo[i].CHName=QString("CH%1").arg(i+1);

        m_chWidget[i].chid=i+1;
    }

    m_DevFile="";//"/dev/bus/usb/001/003";
    _timer_update_info = new QTimer(this);
    _timer_update_info->setInterval(1000);
    connect(_timer_update_info, SIGNAL(timeout()), this, SLOT(UpdateStatusInfo()));
    connect(_timer_update_info, SIGNAL(timeout()), this, SLOT(on_Button_checkserial_clicked()));
    connect(_timer_update_info, SIGNAL(timeout()), this, SLOT(on_Button_openserial_clicked()));
    //on_Button_checkserial_clicked();
    //on_Button_openserial_clicked();
    _timer_update_info->start();

    QTimer* timSend = new QTimer(this);
    timSend->setInterval(1000);// 设置默认定时时长1000ms

    // 定时查询PDU状态
    m_SerialInfo=new SerialInfo();
    QObject::connect(m_SerialInfo, &SerialInfo::addPDUInfo,this, &MainWidget::on_add_PDUStatus,Qt::QueuedConnection);

    QThread* pduthread = new QThread;
    m_SerialInfo->moveToThread(pduthread);
    QObject::connect(pduthread, &QThread::started, m_SerialInfo, &SerialInfo::on_startWork);
    QObject::connect(pduthread, &QThread::finished, m_SerialInfo, &SerialInfo::on_closeWork);
    pduthread->start();

}

MainWidget::~MainWidget()
{
    delete ui;
}

void MainWidget::InitUI()
{

    // 发送、接收计数清零
    sendNum = 0;
    recvNum = 0;
    // 状态栏的收、发计数标签
    lblSendNum = new QLabel(this);
    lblRecvNum = new QLabel(this);
    lblPortState = new QLabel(this);
    lblPortState->setText("Connected");
    //设置串口状态标签为绿色 表示已连接状态
    lblPortState->setStyleSheet("color:red");

    // 设置标签最小大小
    lblSendNum->setMinimumSize(100, 20);
    lblRecvNum->setMinimumSize(100, 20);
    lblPortState->setMinimumSize(550, 20);
    setNumOnLabel(lblSendNum, "S: ", sendNum);
    setNumOnLabel(lblRecvNum, "R: ", recvNum);

    // 从右往左依次添加
    ui->horizontalLayout_15->addWidget(lblPortState);
    ui->horizontalLayout_15->addWidget(lblSendNum);
    ui->horizontalLayout_15->addWidget(lblRecvNum);

    ui->pb_Debug->setIcon(QIcon(":/resource/Serial.png"));

    ui->label_INT->setStyleSheet("color: rgb(0, 218, 205);");
    ui->label_26->setStyleSheet("color: rgb(0, 218, 205);");
    ui->label_OUTT->setStyleSheet("color: orange;");
    ui->label_29->setStyleSheet("color: orange;");
    // 创建一个 QWidget，并添加一些内容

    ui->gridLayout->setContentsMargins(1, 1, 1, 1);
     ui->gridLayout->setHorizontalSpacing(20);
     ui->gridLayout->setVerticalSpacing(8);
     m_TotalCHNum=14;
     for (int i=0;i<m_TotalCHNum;i++) {
        ui->gridLayout->addWidget(&m_chWidget[i], i%((m_TotalCHNum+1)/2), i/((m_TotalCHNum+1)/2));

     }
     QString styleSheet = "QWidget { background-color: #rgb(11, 17, 45); }";
     //ui->MainWidget->setStyleSheet(styleSheet);
}


void MainWidget::InitConnect()
{
    connect(ui->pb_Debug,SIGNAL(clicked()),this,SLOT(slot_changeDebugMode()));
    connect(ui->Button_checkserial_3,SIGNAL(clicked()),this,SLOT(on_Button_checkserial_clicked()));
    connect(ui->Button_openserial_3,SIGNAL(clicked()),this,SLOT(on_Button_openserial_clicked()));
    connect(ui->Button_clearrecive_3,SIGNAL(clicked()),this,SLOT(on_Button_clearrecive_clicked()));
    connect(ui->Button_tx_4,SIGNAL(clicked()),this,SLOT(on_Button_tx_clicked()));
    connect(ui->Button_cleartx_4,SIGNAL(clicked()),this,SLOT(on_Button_cleartx_clicked()));
}

void MainWidget::manual_serialPortReadyRead()
{
    QByteArray recBuf = Data_Ctrl::getData()->serialPort->readAll();;
    QString str_rev;

    // 接收字节计数
    recvNum += recBuf.size();
    // 状态栏显示计数值
    setNumOnLabel(lblRecvNum, "R: ", recvNum);

    if(ui->check_hex_recive_3->checkState() == false){
        if(ui->check_timestamp_3->checkState() == Qt::Checked){
            QDateTime nowtime = QDateTime::currentDateTime();
            str_rev = "[" + nowtime.toString("yyyy-MM-dd hh:mm:ss") + "] ";
            str_rev += QString(recBuf).append("\r\n");
        }
        else{
            // 在当前位置插入文本，不会发生换行。如果没有移动光标到文件结尾，会导致文件超出当前界面显示范围，界面也不会向下滚动。
            //ui->recvEdit->appendPlainText(buf);

            if(ui->check_changeline_3->checkState() == Qt::Checked){
                str_rev = QString(recBuf).append("\r\n");
            }
            else
            {
                str_rev = QString(recBuf);
            }
        }
    }else{

        // 16进制显示，并转换为大写
        QString str1 = recBuf.toHex().toUpper();//.data();
        // 添加空格
        QString str2;
        for(int i = 0; i<str1.length (); i+=2)
        {
            str2 += str1.mid (i,2);
            str2 += " ";
        }
        if(ui->check_timestamp_3->checkState() == Qt::Checked)
        {
            QDateTime nowtime = QDateTime::currentDateTime();
            str_rev = "[" + nowtime.toString("yyyy-MM-dd hh:mm:ss") + "] ";
            str_rev += str2.append("\r\n");
        }
        else
        {
            if(ui->check_changeline_3->checkState() == Qt::Checked)
                str_rev += str2.append("\r\n");
            else
                str_rev = str2;

        }
    }
    ui->recive_Edit_4->insertPlainText(str_rev);
    ui->recive_Edit_4->moveCursor(QTextCursor::End);
}

void MainWidget::on_Button_openserial_clicked()
{
    if (!use_java)
    {
        if(ui->baudrate_CB_3->currentText()=="1200")
            Data_Ctrl::getData()->baudRate=QSerialPort::Baud1200;
        else if(ui->baudrate_CB_3->currentText()=="2400")
            Data_Ctrl::getData()->baudRate=QSerialPort::Baud2400;
        else if(ui->baudrate_CB_3->currentText()=="4800")
            Data_Ctrl::getData()->baudRate=QSerialPort::Baud4800;
        else if(ui->baudrate_CB_3->currentText()=="9600")
            Data_Ctrl::getData()->baudRate=QSerialPort::Baud9600;
        else if(ui->baudrate_CB_3->currentText()=="19200")
            Data_Ctrl::getData()->baudRate=QSerialPort::Baud19200;
        else if(ui->baudrate_CB_3->currentText()=="38400")
            Data_Ctrl::getData()->baudRate=QSerialPort::Baud38400;
        else if(ui->baudrate_CB_3->currentText()=="57600")
            Data_Ctrl::getData()->baudRate=QSerialPort::Baud57600;
        else if(ui->baudrate_CB_3->currentText()=="115200")
            Data_Ctrl::getData()->baudRate=QSerialPort::Baud115200;

        // 获取串口数据位
        if(ui->databit_CB_3->currentText()=="8")
            Data_Ctrl::getData()->dataBits=QSerialPort::Data5;
        else if(ui->databit_CB_3->currentText()=="7")
            Data_Ctrl::getData()->dataBits=QSerialPort::Data6;
        else if(ui->databit_CB_3->currentText()=="6")
            Data_Ctrl::getData()->dataBits=QSerialPort::Data7;
        else if(ui->databit_CB_3->currentText()=="5")
            Data_Ctrl::getData()->dataBits=QSerialPort::Data8;

        // 获取串口停止位
        if(ui->stopbit_CB_3->currentText()=="1")
            Data_Ctrl::getData()->stopBits=QSerialPort::OneStop;
        else if(ui->stopbit_CB_3->currentText()=="1.5")
            Data_Ctrl::getData()->stopBits=QSerialPort::OneAndHalfStop;
        else if(ui->stopbit_CB_3->currentText()=="2")
            Data_Ctrl::getData()->stopBits=QSerialPort::TwoStop;

        // 获取串口奇偶校验位
        if(ui->checkbit_CB_3->currentText() == "None"){
            Data_Ctrl::getData()->checkBits = QSerialPort::NoParity;
        }else if(ui->checkbit_CB_3->currentText() == "Odd"){
            Data_Ctrl::getData()->checkBits = QSerialPort::OddParity;
        }else if(ui->checkbit_CB_3->currentText() == "Even"){
            Data_Ctrl::getData()->checkBits = QSerialPort::EvenParity;
        }

        // 初始化串口属性，设置 端口号、波特率、数据位、停止位、奇偶校验位数
        Data_Ctrl::getData()->serialPort->setPortName(m_DevFile);




        //申请USB设备权限
        //QMessageBox::information(this, "确认", "申请权限："+m_DevFile);
        requestUsbPermission(m_DevFile);


        // 根据初始化好的串口属性，打开串口
        // 如果打开成功，反转打开按钮显示和功能。打开失败，无变化，并且弹出错误对话框。
        if(ui->Button_openserial_3->text() == "打开串口"){
            if(m_USBCtrl.SeralPortCtrl(SeralCtrlType::Seral_Open)){
                //QMessageBox::
                ui->Button_openserial_3->setText("关闭串口");
                // 让端口号下拉框不可选，避免误操作（选择功能不可用，控件背景为灰色）
                ui->serialCB_3->setEnabled(false);
            }else{
                QMessageBox::critical(this, "错误提示", "串口打开失败！！！\r\n该串口可能被占用\r\n请选择正确的串口");
            }
            //statusBar 状态栏显示端口状态
            QString sm = "%1 OPENED, %2, 8, NONE, 1";
            QString status = sm.arg(Data_Ctrl::getData()->serialPort->portName()).arg(Data_Ctrl::getData()->serialPort->baudRate());
            lblPortState->setText(status);
            lblPortState->setStyleSheet("color:green");
        }
        else
        {
            m_USBCtrl.SeralPortCtrl(SeralCtrlType::Seral_Close);
            ui->Button_openserial_3->setText("打开串口");
            // 端口号下拉框恢复可选，避免误操作
            ui->serialCB_3->setEnabled(true);
            //statusBar 状态栏显示端口状态
            QString sm = "%1 CLOSED";
            QString status = sm.arg(Data_Ctrl::getData()->serialPort->portName());
            lblPortState->setText(status);
            lblPortState->setStyleSheet("color:red");
        }
    }

    else
    { 
        if(m_openflag)
        {
            if(m_PreDevFile!=m_DevFile || m_DevFile=="")
            {
                m_openflag=false;
                if(m_PreDevFile!="")
                {
                    QAndroidJniObject javaString = QAndroidJniObject::fromString(m_PreDevFile);
                    jboolean res = QAndroidJniObject::callStaticMethod<jboolean>(
                                "usb/USBListActivity",
                                "closeSerial",
                                "(Ljava/lang/String;)Z",
                                javaString.object<jstring>());
                }
            }
        }

        if(!m_openflag)
        {
            if( m_DevFile!="")
            {
                requestUsbPermission(m_DevFile);

                QAndroidJniObject javaString = QAndroidJniObject::fromString(m_DevFile);
                jboolean res = QAndroidJniObject::callStaticMethod<jboolean>(
                                "usb/USBListActivity",
                                "OpenSerial",
                                "(Ljava/lang/String;)Z",
                                javaString.object<jstring>());
                 if (res==true)
                 {
                      m_openflag=true;
                      //QMessageBox::information(this, "确认", "打开成功！");
                  }
            }

        }

        m_PreDevFile=m_DevFile;

        if(!m_openflag)
        {
            lblPortState->setText("disconnected");
            lblPortState->setStyleSheet("color:red");
            ui->Button_openserial_3->setText("打开串口");
        }
        else
        {
            lblPortState->setText("connected");
            lblPortState->setStyleSheet("color:green");
            ui->Button_openserial_3->setText("关闭串口");
        }
    }
}
/*发送数据*/
void MainWidget::on_Button_tx_clicked()
{
    if(!use_java)
    {
        QByteArray array;

        //Hex复选框
        if(ui->check_hexsend_4->checkState() == Qt::Checked){
            //array = QString2Hex(data);  //HEX 16进制
            array = QByteArray::fromHex(ui->send_Edit_3->toPlainText().toUtf8()).data();
        }else{
            //array = data.toLatin1();    //ASCII
            array = ui->send_Edit_3->toPlainText().toLocal8Bit().data();
        }

        if(ui->check_sendnewline_4->checkState() == Qt::Checked){
            array.append("\r\n");
        }

        int a = Data_Ctrl::getData()->serialPort->write(array);
        // 发送字节计数并显示
        if(a > 0)
        {
            // 发送字节计数
            sendNum += a;
            // 状态栏显示计数值
            setNumOnLabel(lblSendNum, "S: ", sendNum);
        }
        else
        {
            ui->recive_Edit_4->insertPlainText("发送失败！！！！！");
        }
    }
    else
    {
        // 如发送成功，会返回发送的字符串，失败返回空字符串
        if(!m_openflag)
        {
            QMessageBox::information(this, "确认", " 发送失败！串口未打开！");
            return;
        }

        //int a = Data_Ctrl::getData()->serialPort->write(array);
        char OrderArray[8];
        OrderArray[0]=0x01;
        OrderArray[1]=0x03;
        OrderArray[2]=0x17;
        OrderArray[3]=0x70;
        OrderArray[4]=0x00;
        OrderArray[5]=0x02;
        OrderArray[6]=0xC0;
        OrderArray[7]=0x64;

        // 创建一个JNI环境并调用Java静态方法
        QAndroidJniEnvironment env;
        jbyteArray byteArray = env->NewByteArray(sizeof(OrderArray));
        env->SetByteArrayRegion(byteArray, 0, sizeof(OrderArray), reinterpret_cast<const jbyte*>(OrderArray));
        QAndroidJniObject sendbacktring = QAndroidJniObject::callStaticObjectMethod(
            "usb/USBListActivity",
            "writeData",
            "([B)Ljava/lang/String;", // 方法签名：接收字节数组并返回字符串
            byteArray              // 参数
            );

        QString recsendinfo=sendbacktring.toString();
        // 发送字节计数并显示
        if(recsendinfo!="")
        {
            // 发送字节计数
            sendNum += 1;
            // 状态栏显示计数值
            setNumOnLabel(lblSendNum, "S: ", sendNum);

            QString hexString;
            QByteArray byteArray = recsendinfo.toLatin1(); // 将 QString 转换为 QByteArray，使用 UTF-8 编码
            for (char byte : byteArray) {
                // 使用 printf 格式化输出或 qDebug() 输出每个字节的十六进制表示
                 hexString += QString("%1 ").arg(static_cast<unsigned char>(byte), 2, 16, QChar('0'));
            }
            ui->send_Edit_3->insertPlainText(hexString+"\n");
        }
        else
        {
            ui->send_Edit_3->insertPlainText("发送失败！！！！！\n");
        }

        on_Read_PDUStatus();

    }
}

void MainWidget::on_Button_clearrecive_clicked()
{
    on_Read_PDUStatus();
}

void MainWidget::on_Button_cleartx_clicked()
{
    ui->send_Edit_3->clear();
    ui->recive_Edit_4->clear();
    // 清除发送、接收字节计数
    sendNum = 0;
    recvNum = 0;
    // 状态栏显示计数值
    setNumOnLabel(lblSendNum, "S: ", sendNum);
    setNumOnLabel(lblRecvNum, "R: ", recvNum);
}

void MainWidget::on_check_autosend_stateChanged(int arg1)
{
    // 获取复选框状态，未选为0，选中为2
    if(arg1 == 0){
        timSend->stop();
        // 时间输入框恢复可选
        ui->spin_sendtime_4->setEnabled(true);
    }else{
        // 对输入的值做限幅，小于10ms会弹出对话框提示
        if(ui->spin_sendtime_4->text().toInt() >= 10){
            timSend->start(ui->spin_sendtime_4->text().toInt());// 设置定时时长，重新计数
            // 让时间输入框不可选，避免误操作（输入功能不可用，控件背景为灰色）
            ui->spin_sendtime_4->setEnabled(false);
        }else{
            ui->check_autosend_4->setCheckState(Qt::Unchecked);
            QMessageBox::critical(this, "错误提示", "定时发送的最小间隔为 10ms\r\n请确保输入的值 >=10");
        }
    }
}

void MainWidget::on_Button_checkserial_clicked()
{
    ui->serialCB_3->clear();
    if(!use_java)
    {
        //扫描串口设备文件

        foreach(const QSerialPortInfo &info, QSerialPortInfo::availablePorts())
        {
            ui->serialCB_3->addItem(info.portName());
        }
    }
    else
    {

        // 检查USB串口设备
        bool  findFlag=false;
        QAndroidJniObject usbService = QAndroidJniObject::getStaticObjectField("android/content/Context",
                                                                               "USB_SERVICE",
                                                                               "Ljava/lang/String;");
        if (!usbService.isValid())
        {
            //logger("fail to get usb service");
            return;
        }

        //QAndroidJniObject appContext = QJniObject(QNativeInterface::QAndroidApplication::context());
        QAndroidJniObject activity = QtAndroid::androidActivity();

        QAndroidJniObject usbManager = activity.callObjectMethod("getSystemService",
                                                                 "(Ljava/lang/String;)Ljava/lang/Object;",
                                                                 usbService.object<jstring>());
        if (!usbManager.isValid())
        {
            //logger("fail to get usb manager");
            return;
        }

        QAndroidJniObject usbDeviceListHashMap = usbManager.callObjectMethod("getDeviceList",
                                                                             "()Ljava/util/HashMap;");
        QAndroidJniObject devListKeySet = usbDeviceListHashMap.callObjectMethod("keySet",
                                                                                "()Ljava/util/Set;");
        QAndroidJniObject devListIter = devListKeySet.callObjectMethod("iterator",
                                                                       "()Ljava/util/Iterator;");
        jint devListSize = usbDeviceListHashMap.callMethod<jint>("size", "()I");

        QAndroidJniObject usbDevObj;
        QAndroidJniObject usbDevObjIter;
        if(devListSize<1)
        {
            m_DevFile="";
        }
        else
        {
            for (int i = 0; i < devListSize; ++i)
            {
                usbDevObjIter = devListIter.callObjectMethod("next",
                                                         "()Ljava/lang/Object;");
                usbDevObj = usbDeviceListHashMap.callObjectMethod("get",
                                                              "(Ljava/lang/Object;)Ljava/lang/Object;",
                                                              usbDevObjIter.object());
                m_DevVid = usbDevObj.callMethod<jint>("getVendorId", "()I");
                m_DevPid = usbDevObj.callMethod<jint>("getProductId", "()I");
                //QAndroidJniObject str((usbDevObj.callMethod<jstring>("getDeviceName", "()Ljava/lang/String;"));
                QAndroidJniObject str( usbDevObj.callObjectMethod(
                                       "getDeviceName",
                                       "()Ljava/lang/String;"
                                       ).object<jstring>());
                m_DevFile = str.toString();
                findFlag=true;
                ui->serialCB_3->addItem(m_DevFile);
                modifyUsbDeviceXml("device_filter.xml",QString::number(m_DevVid),QString::number(m_DevPid));
            }
        }
        //if(findFlag) QMessageBox::information(this, "确认", "检测到USB设备："+m_DevFile);
    }
}

void MainWidget::slot_changeDebugMode()
{
    int nIndex=ui->stackedWidget_3->currentIndex();
    if(nIndex<1)
    {
        ui->stackedWidget_3->setCurrentIndex(1);
    }else
    {
        ui->stackedWidget_3->setCurrentIndex(0);
    }
}

void MainWidget::setNumOnLabel(QLabel *lbl, QString strS, long num)
{
    // 标签显示
    QString strN;
    strN=QString("%1").arg(num);
    QString str = strS + strN;
    lbl->setText(str);
}


void MainWidget::UpdateStatusInfo()
{

    QString strTemp;
    //更新传感器及日期时间
    //m_PDUAllInfo.Sensor_Temperature=24.5;
    //m_PDUAllInfo.Sensor_Humidity=66.72;
   // m_PDUAllInfo.Sensor_INTemperature=82.33;
    //m_PDUAllInfo.Sensor_OUTTemperature=53.89;

    strTemp=QString::number(m_PDUAllInfo.Sensor_Temperature, 'f', 2);
    ui->label_temperature->setText(strTemp);
    strTemp=QString::number(m_PDUAllInfo.Sensor_Humidity, 'f', 2);
    ui->label_humidity->setText(strTemp);
    if(!m_PDUAllInfo.Sensor_LeakFlag)
    {
        ui->label_water->setText("未浸入");
        ui->label_water->setStyleSheet("color: rgb(10, 197, 50);");
    }
    else
    {
        ui->label_water->setText("浸入");
        // 切换颜色
        QColor currentColor = ui->label_water->palette().color(QPalette::WindowText);
        if (currentColor == Qt::white) {
            ui->label_water->setStyleSheet("color: red;");
        } else {
            ui->label_water->setStyleSheet("color: white;");
        }
    }

    strTemp=QString::number(m_PDUAllInfo.Sensor_INTemperature, 'f', 2);//进液温度
    ui->label_INT->setText(strTemp);
    strTemp=QString::number(m_PDUAllInfo.Sensor_OUTTemperature, 'f', 2);//出液温度
    ui->label_OUTT->setText(strTemp);

    QDateTime currentDateTime = QDateTime::currentDateTime();
    QDate currentDate = currentDateTime.date();
    QTime currentTime = currentDateTime.time();

    // 以字符串形式显示当前日期和时间
    QString dateString = currentDate.toString("yyyy-MM-dd");
    QString timeString = currentTime.toString("HH:mm:ss");
    ui->label_Date->setText(dateString);
    ui->label_Time->setText(timeString);


    //更新总体电源状态
    //m_PDUAllInfo.AllVoltage_L1+=0.2;
    //m_PDUAllInfo.AllVoltage_L2+=0.6;
    //m_PDUAllInfo.AllVoltage_L3+=0.3;
    //m_PDUAllInfo.AllCurrent_L1+=0.1;
    //m_PDUAllInfo.AllCurrent_L2+=0.2;
    //m_PDUAllInfo.AllCurrent_L3+=0.3;
    //m_PDUAllInfo.AllPower_L1+=0.01;
    //m_PDUAllInfo.AllPower_L2+=0.02;
   // m_PDUAllInfo.AllPower_L3+=0.03;
    //m_PDUAllInfo.AllConsumption_L1+=0.05;
    //m_PDUAllInfo.AllConsumption_L2+=0.09;
    //m_PDUAllInfo.AllConsumption_L3+=0.03;


    strTemp=QString::number(m_PDUAllInfo.AllVoltage_L1, 'f', 2);
    ui->label_V1->setText(strTemp);
    strTemp=QString::number(m_PDUAllInfo.AllCurrent_L1, 'f', 2);
    ui->label_I1->setText(strTemp);
    strTemp=QString::number(m_PDUAllInfo.AllPower_L1, 'f', 2);
    //ui->label_P1->setText(strTemp);
    strTemp=QString::number(m_PDUAllInfo.AllConsumption_L1, 'f', 2);
    //ui->label_C1->setText(strTemp);

    strTemp=QString::number(m_PDUAllInfo.AllVoltage_L2, 'f', 2);
    ui->label_V2->setText(strTemp);
    strTemp=QString::number(m_PDUAllInfo.AllCurrent_L2, 'f', 2);
    ui->label_I2->setText(strTemp);
    strTemp=QString::number(m_PDUAllInfo.AllPower_L2, 'f', 2);
    //ui->label_P2->setText(strTemp);
    strTemp=QString::number(m_PDUAllInfo.AllConsumption_L2, 'f', 2);
    //ui->label_C2->setText(strTemp);

    strTemp=QString::number(m_PDUAllInfo.AllVoltage_L3, 'f', 2);
    ui->label_V3->setText(strTemp);
    strTemp=QString::number(m_PDUAllInfo.AllCurrent_L3, 'f', 2);
    ui->label_I3->setText(strTemp);
    strTemp=QString::number(m_PDUAllInfo.AllPower_L3, 'f', 2);
    //ui->label_P3->setText(strTemp);
    strTemp=QString::number(m_PDUAllInfo.AllConsumption_L3, 'f', 2);
    //ui->label_C3->setText(strTemp);


    //更新通道信息
    /*
    for (int i=0;i<64;i++) {
        m_PDUCHInfo[i].CHVoltage+=0.432;
        m_PDUCHInfo[i].CHPower+=0.343;
        m_PDUCHInfo[i].CHCurrent+=0.112;
        m_PDUCHInfo[i].CHConsumption+=0.063;
        m_PDUCHInfo[i].CHFactor=0.983;
        if(i%2==0)m_PDUCHInfo[i].CHStatus=true;
    }*/


    for (int i=0;i<m_TotalCHNum;i++) {
       m_chWidget[i].chid=i+1;
       m_chWidget[i].chV=m_PDUCHInfo[i].CHVoltage;
       m_chWidget[i].chI=m_PDUCHInfo[i].CHCurrent;
       m_chWidget[i].chStatus=m_PDUCHInfo[i].CHStatus;
       m_chWidget[i].UpdateStatusInfo();
    }

}




void MainWidget::requestUsbPermission(const QString &devicePath)
{
    QAndroidJniObject activity = QtAndroid::androidActivity();
    if (!activity.isValid()) {
        qDebug() << "Failed to get Android activity.";
        return;
    }

    QAndroidJniObject context = activity.callObjectMethod("getApplicationContext", "()Landroid/content/Context;");
    if (!context.isValid()) {
        qDebug() << "Failed to get application context.";
        return;
    }

    // Get the USB manager from the system service.
    QAndroidJniObject usbServiceName = QAndroidJniObject::getStaticObjectField(
                "android/content/Context",
                "USB_SERVICE",
                "Ljava/lang/String;"
                );

    QAndroidJniObject usbManager = context.callObjectMethod(
                "getSystemService",
                "(Ljava/lang/String;)Ljava/lang/Object;",
                usbServiceName.object<jstring>());

    if (!usbManager.isValid()) {
        qDebug() << "Failed to get UsbManager.";
        return;
    }

    // Find the USB device by its path.
    QAndroidJniObject usbDevice = usbManager.callObjectMethod(
                "getDeviceList",
                "()Ljava/util/HashMap;"
                ).callObjectMethod(
                "get",
                "(Ljava/lang/Object;)Ljava/lang/Object;",
                QAndroidJniObject::fromString(devicePath).object<jobject>()
                );

    if (!usbDevice.isValid()) {
        qDebug() << "USB device not found: " << devicePath;
        QMessageBox::information(this, "确认", "USB device not found: " + devicePath);
        return;
    }

    // Check if we already have permission for this device.
    bool hasPermission = QAndroidJniObject::callStaticMethod<jboolean>(
                "android/hardware/usb/UsbManager",
                "hasPermission",
                "(Landroid/hardware/usb/UsbDevice;)Z",
                usbDevice.object<jobject>());

    if (hasPermission) {
        qDebug() << "USB device opened successfully.";
        //QMessageBox::information(this, "确认", "USB device opened successfully: " + devicePath);
    } else {
        qDebug() << "Requesting permission for USB device.";
        //QMessageBox::information(this, "确认", "Requesting permission for USB device: " + devicePath);

        // Create a PendingIntent to receive the result of the permission request.
        QAndroidJniObject intentFilter = QAndroidJniObject::fromString("com.example.ACTION_USB_PERMISSION");
        QAndroidJniObject intent("android/content/Intent", "(Ljava/lang/String;)V", intentFilter.object<jstring>());

        QAndroidJniObject pendingIntent = QAndroidJniObject::callStaticObjectMethod("android/app/PendingIntent",
                                                                                    "getBroadcast",
                                                                                    "(Landroid/content/Context;ILandroid/content/Intent;I)Landroid/app/PendingIntent;",
                                                                                    context.object<jobject>(),
                                                                                    0,
                                                                                    intent.object<jobject>(),
                                                                                    0x00000080); // FLAG_MUTABLE or FLAG_IMMUTABLE based on your target SDK

        usbManager.callMethod<void>("requestPermission",
                                    "(Landroid/hardware/usb/UsbDevice;Landroid/app/PendingIntent;)V",
                                    usbDevice.object<jobject>(),
                                    pendingIntent.object<jobject>());
    }
}
bool MainWidget::modifyUsbDeviceXml(const QString &filePath, const QString &newVendorId, const QString &newProductId)
{
    QFile file(filePath);
    if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
        qWarning() << "Failed to open file for reading:" << file.errorString();
        return false;
    }

    // 读取文件内容到QDomDocument
    QDomDocument doc;
    if (!doc.setContent(&file)) {
        qWarning() << "Failed to parse XML file:" << file.errorString();
        file.close();
        return false;
    }
    file.close();

    // 查找<usb-device>元素并修改其属性
    QDomElement root = doc.firstChildElement("resources");
    QDomElement usbDevice = root.firstChildElement("usb-device");
    if (!usbDevice.isNull()) {
        usbDevice.setAttribute("vendor-id", newVendorId);
        usbDevice.setAttribute("product-id", newProductId);
    } else {
        qWarning() << "No <usb-device> element found in the XML file.";
        return false;
    }

    // 将修改后的内容写回文件
    if (!file.open(QIODevice::WriteOnly | QIODevice::Text)) {
        qWarning() << "Failed to open file for writing:" << file.errorString();
        return false;
    }
    QTextStream out(&file);
    out << doc.toString(4); // 使用4个空格进行缩进，以便格式化输出
    file.close();

    return true;
}
QString MainWidget::on_Read_PDUStatus()
{
    // 如接收成功，会返回接收的字符串，失败返回空字符串
    QString Allrecinfo="";
    for (int i=0;i<10;i++)
    {
        QAndroidJniObject  recbacktring = QAndroidJniObject::callStaticObjectMethod(
            "usb/USBListActivity",
            "readData",
            "()Ljava/lang/String;");

        QString recinfo=recbacktring.toString();
        // 发送字节计数并显示
        if(recinfo!="")
        {
            QString hexString;
            QByteArray byteArray = recinfo.toLatin1(); // 将 QString 转换为 QByteArray，使用 UTF-8 编码
            for (char byte : byteArray) {
                // 使用 printf 格式化输出或 qDebug() 输出每个字节的十六进制表示
                 hexString += QString("%1 ").arg(static_cast<unsigned char>(byte), 2, 16, QChar('0'));
                }
            Allrecinfo+=hexString;
        }
        else
        {
            break;
        }
    }

    // 发送字节计数并显示
    if(Allrecinfo!="")
    {
        // 发送字节计数
        recvNum += 1;
        // 状态栏显示计数值
        setNumOnLabel(lblRecvNum, "R: ", recvNum);
        ui->recive_Edit_4->insertPlainText(Allrecinfo+"\n");
    }
    else
    {
        //ui->recive_Edit_4->insertPlainText("接收失败！！！！！\n");
    }

    return Allrecinfo;
}
void MainWidget::on_add_PDUStatus(const QString &sendstr, const QString &recstr)
{
    // 发送字节计数并显示
    if(sendstr!="")
    {
        // 发送字节计数
        sendNum += 1;
        // 状态栏显示计数值
        setNumOnLabel(lblSendNum, "S: ", sendNum);

        ui->send_Edit_3->insertPlainText(sendstr+"\n");
    }
    else
    {
        //ui->send_Edit_3->insertPlainText("发送失败！！！！！\n");
    }

    // 接收字节计数并显示
    if(recstr!="")
    {
        // 发送字节计数
        recvNum += 1;
        // 状态栏显示计数值
        setNumOnLabel(lblRecvNum, "R: ", recvNum);
        ui->recive_Edit_4->insertPlainText(recstr+"\n");
    }
    else
    {
        //ui->recive_Edit_4->insertPlainText("接收失败！！！！！\n");
    }
}

void MainWidget::on_check_autoprintf_stateChanged(int arg1)
{
    // 获取复选框状态，未选为0，选中为2
    if(arg1 == 0){
        m_printflag=false;
    }else{
         m_printflag=true;
    }
}