package PublicPannel;
|
|
import javax.swing.*;
|
|
import Ymodem.YModem;
|
import home.*;
|
import jiexi.DellTag55AA03;
|
|
import java.awt.*;
|
import java.awt.event.ActionListener;
|
import java.io.*;
|
import java.net.Socket;
|
|
public class UpgradePanel extends JPanel {
|
/**
|
*
|
*/
|
private static final long serialVersionUID = 1L;
|
private MainFrame mainFrame;
|
private JButton upgradeBtn;
|
private JTextField filePathField;
|
private JButton selectBinBtn;
|
private JProgressBar progressBar;
|
private JLabel selectFileLabel;
|
private JLabel progressLabel;
|
|
// 新增：通信方式选择
|
private JComboBox<String> communicationTypeCombo;
|
private JLabel communicationTypeLabel;
|
|
// 串口服务实例
|
private SerialPortService serialService;
|
// 网络通信面板引用
|
private NetworkCommunicationPanel networkPanel;
|
|
// 新增：升级相关状态
|
private volatile boolean upgradeInProgress = false;
|
private volatile boolean cancelUpgrade = false;
|
|
public UpgradePanel(MainFrame mainFrame) {
|
this.mainFrame = mainFrame;
|
this.serialService = SerialCommunicationPanel.getSerialService();
|
initializeUI();
|
}
|
|
private void initializeUI() {
|
setLayout(new BoxLayout(this, BoxLayout.Y_AXIS));
|
|
// 内容面板
|
JPanel contentPanel = new JPanel();
|
contentPanel.setLayout(new BoxLayout(contentPanel, BoxLayout.Y_AXIS));
|
|
// 通信方式选择面板
|
JPanel communicationPanel = new JPanel(new FlowLayout(FlowLayout.LEFT, 10, 0));
|
communicationTypeLabel = new JLabel(mainFrame.getString("communication.type"));
|
communicationTypeCombo = new JComboBox<>(new String[]{
|
mainFrame.getString("serial"),
|
mainFrame.getString("tcp.client"),
|
mainFrame.getString("tcp.server"),
|
mainFrame.getString("udp")
|
});
|
communicationPanel.add(communicationTypeLabel);
|
communicationPanel.add(communicationTypeCombo);
|
|
// 文件选择面板
|
JPanel filePanel = new JPanel(new FlowLayout(FlowLayout.LEFT, 10, 0));
|
filePathField = new JTextField();
|
filePathField.setEditable(false);
|
filePathField.setPreferredSize(new Dimension(200, 25));
|
|
selectBinBtn = ButtonUtils.createBlueButton(mainFrame.getString("select.bin.file"));
|
selectBinBtn.addActionListener(e -> selectBinFile());
|
|
selectFileLabel = new JLabel(mainFrame.getString("select.bin.file"));
|
|
filePanel.add(selectFileLabel);
|
filePanel.add(filePathField);
|
filePanel.add(selectBinBtn);
|
|
// 进度条和升级按钮面板
|
JPanel progressButtonPanel = new JPanel(new FlowLayout(FlowLayout.LEFT, 10, 0));
|
progressBar = new JProgressBar(0, 100);
|
progressBar.setStringPainted(true);
|
progressBar.setVisible(false);
|
progressBar.setPreferredSize(new Dimension(200, 25));
|
|
upgradeBtn = ButtonUtils.createBlueButton(mainFrame.getString("start.upgrade"));
|
upgradeBtn.addActionListener(e -> startUpgrade());
|
|
progressLabel = new JLabel(mainFrame.getString("upgrade.progress"));
|
|
progressButtonPanel.add(progressLabel);
|
progressButtonPanel.add(progressBar);
|
progressButtonPanel.add(upgradeBtn);
|
|
// 设置固定高度
|
communicationPanel.setMaximumSize(new Dimension(Integer.MAX_VALUE, 35));
|
filePanel.setMaximumSize(new Dimension(Integer.MAX_VALUE, 35));
|
progressButtonPanel.setMaximumSize(new Dimension(Integer.MAX_VALUE, 35));
|
|
// 将所有组件添加到内容面板
|
contentPanel.add(Box.createVerticalStrut(10));
|
contentPanel.add(communicationPanel);
|
contentPanel.add(filePanel);
|
contentPanel.add(progressButtonPanel);
|
|
add(contentPanel);
|
}
|
|
private void selectBinFile() {
|
JFileChooser fileChooser = new JFileChooser();
|
fileChooser.setFileSelectionMode(JFileChooser.FILES_ONLY);
|
fileChooser.setDialogTitle(mainFrame.getString("select.bin.file"));
|
fileChooser.setFileFilter(new javax.swing.filechooser.FileNameExtensionFilter("BIN files (*.bin)", "bin"));
|
|
int result = fileChooser.showOpenDialog(this);
|
if (result == JFileChooser.APPROVE_OPTION) {
|
String selectedFile = fileChooser.getSelectedFile().getAbsolutePath();
|
filePathField.setText(selectedFile);
|
|
JOptionPane.showMessageDialog(this,
|
mainFrame.getString("selected.file") + ": " + selectedFile,
|
mainFrame.getString("file.selected"),
|
JOptionPane.INFORMATION_MESSAGE);
|
}
|
}
|
|
private void startUpgrade() {
|
// 检查升级条件
|
if (filePathField.getText().isEmpty()) {
|
JOptionPane.showMessageDialog(this,
|
mainFrame.getString("please.select.file.first"),
|
mainFrame.getString("warning"),
|
JOptionPane.WARNING_MESSAGE);
|
return;
|
}
|
|
// 检查通信连接状态
|
String communicationType = (String) communicationTypeCombo.getSelectedItem();
|
if (!checkCommunicationStatus(communicationType)) {
|
return;
|
}
|
|
// 对于网络升级，检查是否选择了客户端
|
if (!communicationType.equals(mainFrame.getString("serial"))) {
|
if (!checkSelectedClient()) {
|
return;
|
}
|
}
|
|
// 确认升级
|
int result = JOptionPane.showConfirmDialog(this,
|
mainFrame.getString("upgrade.confirm.message"),
|
mainFrame.getString("confirm.upgrade"),
|
JOptionPane.YES_NO_OPTION,
|
JOptionPane.QUESTION_MESSAGE);
|
|
if (result != JOptionPane.YES_OPTION) {
|
return;
|
}
|
|
upgradeBtn.setEnabled(false);
|
selectBinBtn.setEnabled(false);
|
progressBar.setVisible(true);
|
progressBar.setValue(0);
|
upgradeInProgress = true;
|
cancelUpgrade = false;
|
|
String filePath = filePathField.getText();
|
|
new Thread(() -> {
|
int retryCount = 0;
|
final int maxRetries = 3;
|
|
try {
|
// 发送升级命令
|
boolean success = sendUpgradeCommand(communicationType);
|
if (!success) {
|
throw new IOException("Failed to send upgrade command");
|
}
|
|
// 等待设备准备升级
|
Thread.sleep(1000);
|
|
// 执行升级
|
if (communicationType.equals(mainFrame.getString("serial"))) {
|
performSerialUpgrade(filePath);
|
} else {
|
performNetworkUpgrade(filePath, communicationType);
|
}
|
|
} catch (Exception e) {
|
if (retryCount < maxRetries && !cancelUpgrade) {
|
retryCount++;
|
try {
|
Thread.sleep(1000);
|
// 可以在这里添加重试逻辑
|
} catch (InterruptedException ie) {
|
Thread.currentThread().interrupt();
|
}
|
} else {
|
SwingUtilities.invokeLater(() -> {
|
if (!cancelUpgrade) {
|
JOptionPane.showMessageDialog(this,
|
"升级失败" + ": " + e.getMessage(),
|
"错误",
|
JOptionPane.ERROR_MESSAGE);
|
}
|
restoreUIAfterUpgrade();
|
});
|
}
|
} finally {
|
restoreUIAfterUpgrade();
|
}
|
}).start();
|
}
|
|
/**
|
* 检查通信连接状态
|
*/
|
private boolean checkCommunicationStatus(String communicationType) {
|
if (communicationType.equals(mainFrame.getString("serial"))) {
|
if (!serialService.isOpen()) {
|
JOptionPane.showMessageDialog(this,
|
"请先打开串口连接",
|
"错误",
|
JOptionPane.ERROR_MESSAGE);
|
return false;
|
}
|
} else {
|
// 获取网络通信面板
|
if (networkPanel == null) {
|
networkPanel = mainFrame.getNetworkCommunicationPanel();
|
}
|
if (networkPanel == null || !networkPanel.isOpen()) {
|
JOptionPane.showMessageDialog(this,
|
"请先打开网络连接",
|
"错误",
|
JOptionPane.ERROR_MESSAGE);
|
return false;
|
}
|
}
|
return true;
|
}
|
|
/**
|
* 检查是否选择了客户端（针对网络升级）
|
*/
|
private boolean checkSelectedClient() {
|
if (networkPanel == null) {
|
networkPanel = mainFrame.getNetworkCommunicationPanel();
|
}
|
|
// 获取当前选中的客户端
|
String selectedClient = networkPanel.getSelectedClient();
|
if (selectedClient == null || selectedClient.isEmpty()) {
|
JOptionPane.showMessageDialog(this,
|
"请先选择要升级的客户端",
|
"错误",
|
JOptionPane.ERROR_MESSAGE);
|
return false;
|
}
|
return true;
|
}
|
|
/**
|
* 发送升级命令
|
*/
|
private boolean sendUpgradeCommand(String communicationType) {
|
byte[] upgradeCommand = DellTag55AA03.shengjizhiling();
|
|
if (communicationType.equals(mainFrame.getString("serial"))) {
|
// 串口升级期间停止数据捕获
|
serialService.stopCapture();
|
return serialService.send(upgradeCommand);
|
} else {
|
// 网络升级
|
return sendNetworkData(upgradeCommand, "发送升级指令");
|
}
|
}
|
|
/**
|
* 执行串口升级
|
*/
|
private void performSerialUpgrade(String filePath) throws Exception {
|
InputStream inputStream = serialService.getInputStream();
|
OutputStream outputStream = serialService.getOutputStream();
|
|
if (inputStream == null || outputStream == null) {
|
throw new IOException("串口不可用");
|
}
|
|
YModem ymodem = new YModem(inputStream, outputStream);
|
File file = new File(filePath);
|
|
YModem.ProgressCallback progressCallback = new YModem.ProgressCallback() {
|
@Override
|
public void onProgress(int currentBlock, int totalBlocks) {
|
int progress = (int) ((currentBlock * 100.0) / totalBlocks);
|
SwingUtilities.invokeLater(() -> {
|
progressBar.setValue(progress);
|
});
|
}
|
};
|
|
ymodem.send(file.toPath(), progressCallback);
|
|
SwingUtilities.invokeLater(() -> {
|
JOptionPane.showMessageDialog(this, "升级成功", "成功", JOptionPane.INFORMATION_MESSAGE);
|
});
|
}
|
|
/**
|
* 执行网络升级
|
*/
|
private void performNetworkUpgrade(String filePath, String communicationType) throws Exception {
|
File file = new File(filePath);
|
|
// 获取选中的客户端信息
|
String selectedClient = networkPanel.getSelectedClient();
|
if (selectedClient == null || selectedClient.isEmpty()) {
|
throw new IOException("未选择客户端");
|
}
|
|
// 解析客户端地址
|
String[] clientParts = selectedClient.split(":");
|
if (clientParts.length != 2) {
|
throw new IOException("客户端地址格式错误: " + selectedClient);
|
}
|
|
String clientIp = clientParts[0];
|
int clientPort;
|
try {
|
clientPort = Integer.parseInt(clientParts[1]);
|
} catch (NumberFormatException e) {
|
throw new IOException("客户端端口格式错误: " + clientParts[1]);
|
}
|
|
// 创建网络输入输出流适配器
|
NetworkStreamAdapter streamAdapter = new NetworkStreamAdapter(networkPanel, communicationType, clientIp, clientPort);
|
InputStream inputStream = streamAdapter.getInputStream();
|
OutputStream outputStream = streamAdapter.getOutputStream();
|
|
if (inputStream == null || outputStream == null) {
|
throw new IOException("网络流不可用");
|
}
|
|
YModem ymodem = new YModem(inputStream, outputStream);
|
|
YModem.ProgressCallback progressCallback = new YModem.ProgressCallback() {
|
@Override
|
public void onProgress(int currentBlock, int totalBlocks) {
|
int progress = (int) ((currentBlock * 100.0) / totalBlocks);
|
SwingUtilities.invokeLater(() -> {
|
progressBar.setValue(progress);
|
});
|
}
|
};
|
|
try {
|
ymodem.send(file.toPath(), progressCallback);
|
|
if (!cancelUpgrade) {
|
SwingUtilities.invokeLater(() -> {
|
JOptionPane.showMessageDialog(UpgradePanel.this,
|
"网络升级成功", "成功", JOptionPane.INFORMATION_MESSAGE);
|
});
|
}
|
} catch (Exception e) {
|
if (!cancelUpgrade) {
|
throw e;
|
}
|
} finally {
|
streamAdapter.close();
|
}
|
}
|
|
/**
|
* 发送网络数据
|
*/
|
private boolean sendNetworkData(byte[] data, String description) {
|
if (networkPanel == null) {
|
networkPanel = mainFrame.getNetworkCommunicationPanel();
|
}
|
|
if (networkPanel != null) {
|
// 使用NetworkCommunicationPanel的发送方法
|
return networkPanel.sendNetworkDataInternal(data, description);
|
}
|
|
return false;
|
}
|
|
/**
|
* 恢复UI状态
|
*/
|
private void restoreUIAfterUpgrade() {
|
SwingUtilities.invokeLater(() -> {
|
upgradeInProgress = false;
|
upgradeBtn.setEnabled(true);
|
selectBinBtn.setEnabled(true);
|
progressBar.setVisible(false);
|
progressBar.setValue(0);
|
|
// 重新启动串口数据捕获（如果是串口升级）
|
if (serialService != null) {
|
serialService.startCapture();
|
}
|
});
|
}
|
|
/**
|
* 取消升级
|
*/
|
public void cancelUpgrade() {
|
if (upgradeInProgress) {
|
cancelUpgrade = true;
|
upgradeInProgress = false;
|
}
|
}
|
|
/**
|
* 设置网络通信面板引用
|
*/
|
public void setNetworkCommunicationPanel(NetworkCommunicationPanel networkPanel) {
|
this.networkPanel = networkPanel;
|
}
|
|
public void updateLanguage() {
|
// 更新通信方式选择
|
communicationTypeLabel.setText(mainFrame.getString("communication.type"));
|
communicationTypeCombo.removeAllItems();
|
communicationTypeCombo.addItem(mainFrame.getString("serial"));
|
communicationTypeCombo.addItem(mainFrame.getString("tcp.client"));
|
communicationTypeCombo.addItem(mainFrame.getString("tcp.server"));
|
communicationTypeCombo.addItem(mainFrame.getString("udp"));
|
|
// 更新按钮文本
|
selectBinBtn.setText(mainFrame.getString("select.bin.file"));
|
upgradeBtn.setText(mainFrame.getString("start.upgrade"));
|
|
// 更新标签文本
|
selectFileLabel.setText(mainFrame.getString("select.bin.file"));
|
progressLabel.setText(mainFrame.getString("upgrade.progress"));
|
|
revalidate();
|
repaint();
|
}
|
/**
|
* 网络流适配器 - 内部类
|
* 用于将网络通信适配为YModem所需的InputStream和OutputStream
|
*/
|
private class NetworkStreamAdapter {
|
private NetworkCommunicationPanel networkPanel;
|
private String communicationType;
|
private String clientIp;
|
private int clientPort;
|
private PipedInputStream inputStream;
|
private PipedOutputStream outputStream;
|
private boolean isConnected = false;
|
|
// 用于数据接收的管道
|
private PipedInputStream receiverInputStream;
|
private PipedOutputStream receiverOutputStream;
|
|
// 保存原始的数据监听器
|
private NetworkBase.NetworkDataListener originalDataListener;
|
|
public NetworkStreamAdapter(NetworkCommunicationPanel networkPanel, String communicationType,
|
String clientIp, int clientPort) {
|
this.networkPanel = networkPanel;
|
this.communicationType = communicationType;
|
this.clientIp = clientIp;
|
this.clientPort = clientPort;
|
initializeStreams();
|
setupNetworkDataListener();
|
}
|
|
private void initializeStreams() {
|
try {
|
// 创建管道流用于数据发送
|
inputStream = new PipedInputStream(8192); // 增加缓冲区大小
|
outputStream = new PipedOutputStream(inputStream);
|
|
// 创建管道流用于数据接收
|
receiverInputStream = new PipedInputStream(8192);
|
receiverOutputStream = new PipedOutputStream(receiverInputStream);
|
|
isConnected = true;
|
System.out.println("网络流适配器初始化成功");
|
} catch (Exception e) {
|
System.err.println("初始化网络流失败: " + e.getMessage());
|
isConnected = false;
|
throw new RuntimeException("网络流初始化失败", e);
|
}
|
}
|
|
/**
|
* 设置网络数据监听器
|
*/
|
private void setupNetworkDataListener() {
|
try {
|
// 获取网络通信面板的当前网络实例
|
NetworkBase currentNetwork = networkPanel.getCurrentNetwork();
|
if (currentNetwork == null) {
|
System.err.println("网络连接未建立");
|
return;
|
}
|
|
// 保存原来的数据监听器
|
originalDataListener = currentNetwork.getDataListener();
|
|
// 创建升级专用的数据监听器
|
NetworkBase.NetworkDataListener upgradeDataListener = new NetworkBase.NetworkDataListener() {
|
@Override
|
public void onDataReceived(byte[] data, String fromAddress) {
|
// 检查数据是否来自目标客户端
|
String expectedAddress = clientIp + ":" + clientPort;
|
if (expectedAddress.equals(fromAddress)) {
|
try {
|
// 将接收到的数据写入接收管道，供YModem读取
|
if (receiverOutputStream != null && !cancelUpgrade) {
|
receiverOutputStream.write(data);
|
receiverOutputStream.flush();
|
|
// 调试信息
|
System.out.println("接收到升级响应数据，长度: " + data.length + "，来自: " + fromAddress);
|
}
|
} catch (IOException e) {
|
System.err.println("写入接收管道失败: " + e.getMessage());
|
if (!cancelUpgrade) {
|
SwingUtilities.invokeLater(() -> {
|
JOptionPane.showMessageDialog(UpgradePanel.this,
|
"升级数据接收失败: " + e.getMessage(),
|
"错误", JOptionPane.ERROR_MESSAGE);
|
});
|
}
|
}
|
} else {
|
// 非目标客户端的数据，可以记录日志但忽略
|
System.out.println("忽略非目标客户端数据，来自: " + fromAddress + "，期望: " + expectedAddress);
|
}
|
|
// 同时调用原来的监听器，保持其他功能正常
|
if (originalDataListener != null) {
|
originalDataListener.onDataReceived(data, fromAddress);
|
}
|
}
|
|
@Override
|
public void onStatusChanged(String status, boolean isConnected) {
|
// 传递状态变化给原来的监听器
|
if (originalDataListener != null) {
|
originalDataListener.onStatusChanged(status, isConnected);
|
}
|
|
// 如果连接断开且正在升级，需要处理
|
if (!isConnected && upgradeInProgress) {
|
System.err.println("网络连接断开，升级可能失败");
|
if (!cancelUpgrade) {
|
SwingUtilities.invokeLater(() -> {
|
JOptionPane.showMessageDialog(UpgradePanel.this,
|
"网络连接已断开，升级失败",
|
"错误", JOptionPane.ERROR_MESSAGE);
|
cancelUpgrade = true;
|
});
|
}
|
}
|
}
|
|
@Override
|
public void onError(String errorMessage) {
|
// 传递错误给原来的监听器
|
if (originalDataListener != null) {
|
originalDataListener.onError(errorMessage);
|
}
|
|
// 如果正在升级，需要处理错误
|
if (upgradeInProgress && !cancelUpgrade) {
|
System.err.println("升级过程中发生网络错误: " + errorMessage);
|
SwingUtilities.invokeLater(() -> {
|
JOptionPane.showMessageDialog(UpgradePanel.this,
|
"网络错误: " + errorMessage,
|
"错误", JOptionPane.ERROR_MESSAGE);
|
});
|
}
|
}
|
};
|
|
// 设置新的数据监听器
|
currentNetwork.setDataListener(upgradeDataListener);
|
|
System.out.println("升级数据监听器已设置，目标客户端: " + clientIp + ":" + clientPort);
|
|
} catch (Exception e) {
|
System.err.println("设置网络数据监听器失败: " + e.getMessage());
|
throw new RuntimeException("网络数据监听器初始化失败", e);
|
}
|
}
|
|
public InputStream getInputStream() {
|
return receiverInputStream;
|
}
|
|
public OutputStream getOutputStream() {
|
return new NetworkOutputStream();
|
}
|
|
public void close() {
|
try {
|
// 恢复原始的数据监听器
|
if (networkPanel != null && networkPanel.getCurrentNetwork() != null && originalDataListener != null) {
|
networkPanel.getCurrentNetwork().setDataListener(originalDataListener);
|
System.out.println("已恢复原始数据监听器");
|
}
|
|
if (inputStream != null) inputStream.close();
|
if (outputStream != null) outputStream.close();
|
if (receiverInputStream != null) receiverInputStream.close();
|
if (receiverOutputStream != null) receiverOutputStream.close();
|
|
System.out.println("网络流适配器已关闭");
|
} catch (IOException e) {
|
System.err.println("关闭网络流失败: " + e.getMessage());
|
}
|
}
|
|
/**
|
* 网络输出流实现
|
* 将YModem写入的数据通过网络发送到指定客户端
|
*/
|
private class NetworkOutputStream extends OutputStream {
|
@Override
|
public void write(int b) throws IOException {
|
write(new byte[]{(byte) b}, 0, 1);
|
}
|
|
@Override
|
public void write(byte[] b, int off, int len) throws IOException {
|
if (cancelUpgrade) {
|
throw new IOException("升级已取消");
|
}
|
|
byte[] dataToSend = new byte[len];
|
System.arraycopy(b, off, dataToSend, 0, len);
|
|
boolean success = false;
|
|
if (communicationType.equals(mainFrame.getString("udp"))) {
|
// UDP模式发送
|
success = networkPanel.sendUdpData(dataToSend, clientIp, clientPort, "升级数据");
|
} else if (communicationType.equals(mainFrame.getString("tcp.server"))) {
|
// TCP Server模式发送到指定客户端
|
String clientKey = clientIp + ":" + clientPort;
|
success = networkPanel.sendTcpDataToClient(clientKey, dataToSend, "升级数据");
|
}
|
|
if (!success) {
|
throw new IOException("网络发送失败");
|
}
|
|
// 调试信息
|
System.out.println("发送升级数据，长度: " + len);
|
}
|
|
@Override
|
public void flush() throws IOException {
|
// 网络发送立即生效，无需特殊处理
|
}
|
|
@Override
|
public void close() throws IOException {
|
// 不关闭底层网络连接
|
}
|
}
|
}
|
|
}
|
