可发布版本202517.25

张世豪

4 小时以前 100f4dcea20a32663a07e91525de111f7515eb79

 src/xitongshezhi/kuaisuquka.java

@@ -18,9 +18,7 @@
    // 屏幕尺寸常量 - 适配7寸竖屏
    private static final int SCREEN_WIDTH = 600;
    private static final int SCREEN_HEIGHT = 1024;
    // 新增：记录进入快速取卡页面前的轮询状态
    private boolean wasPollingRunning = false;
    private boolean wasPollingPaused = false;
    
    // 颜色常量
    private static final Color PRIMARY_COLOR = new Color(52, 152, 219);
    private static final Color PRIMARY_DARK_COLOR = new Color(41, 128, 185);
@@ -60,32 +58,47 @@
    // 统计信息
    private JLabel cardsCountLabel;
    
    // 优化的对话框管理
    private JDialog progressDialog;
    private JDialog resultDialog;
    
    // 共享的事件监听器
    private final SlotButtonListener slotButtonListener;
    
    private SlotManager slotManager;
    private Timer refreshTimer; // 新增：刷新定时器

    public kuaisuquka(JFrame parent) {
        super(parent, "快速取卡", true);
        slotManager = new SlotManager();
        slotButtons = new ArrayList<>(60);
        slotStatuses = new ArrayList<>(60);
        slotButtonListener = new SlotButtonListener();
        
        // 记录进入快速取卡页面前的轮询状态
        recordPollingStateBeforeEntering();
        
        initializeUI();
        initializeSlots();
        startAutoRefresh(); // 新增：启动自动刷新
        startAutoRefresh();
        
        // 进入快速取卡页面时暂停轮询
        pausePollingWhenEntering();
        // 调试信息
        //System.out.println("快速取卡页面初始化完成，开始显示卡槽状态");
        debugSlotStatus();
    }
    
    /**
     * 调试方法：打印卡槽状态信息
     */
    private void debugSlotStatus() {
        Fkj[] slotArray = SlotManager.getSlotArray();
        if (slotArray == null) {
            //System.out.println("SlotManager.getSlotArray() 返回 null");
            return;
        }
        
        //System.out.println("=== 卡槽状态调试信息 ===");
        for (int i = 0; i < Math.min(slotArray.length, 60); i++) {
            Fkj slot = slotArray[i];
            if (slot != null) {
                System.out.printf("卡槽 %d: hasCard=%s, cardNumber=%s%n", 
                    i + 1, slot.getHasCard(), slot.getCardNumber());
            } else {
                System.out.printf("卡槽 %d: null%n", i + 1);
            }
        }
        //System.out.println("======================");
    }
    
    /**
@@ -102,74 +115,113 @@
    }
    
    /**
     * 从SlotManager刷新卡槽状态
     * 从SlotManager刷新卡槽状态 - 彻底重写版本
     */
    private void refreshSlotStatusFromManager() {
        boolean statusChanged = false;
        Fkj[] slotArray = SlotManager.getSlotArray();
        
        for (int i = 0; i < 60; i++) {
            int slotId = i + 1;
            String hasCardStatus = SlotManager.getSlotHasCardStatus(slotId);
        if (slotArray == null) {
            //System.out.println("刷新卡槽状态: slotArray 为 null");
            return;
        }
        
        for (int i = 0; i < 60 && i < slotArray.length; i++) {
            Fkj slotInfo = slotArray[i];
            if (slotInfo == null) {
                // 如果卡槽信息为null，设置为无卡状态
                if (i < slotStatuses.size() && slotStatuses.get(i) != SlotStatus.NO_CARD) {
                    slotStatuses.set(i, SlotStatus.NO_CARD);
                    statusChanged = true;
                }
                continue;
            }
            
            // 检查是否有卡并且有有效的卡号
            String hasCardStatus = slotInfo.getHasCard();
            String cardNumber = slotInfo.getCardNumber();
            
            // 调试单个卡槽
            if (i < 5) { // 只打印前5个卡槽的调试信息
                System.out.printf("刷新卡槽 %d: hasCard=%s, cardNumber=%s%n", 
                    i + 1, hasCardStatus, cardNumber);
            }
            
            // 简化的判断逻辑 - 重点调试
            boolean reallyHasCard = false;
            
            if ("1".equals(hasCardStatus)) {
                Fkj slotInfo = slotManager.getSlotInfo(slotId);
                String cardNumber = slotInfo != null ? slotInfo.getCardNumber() : "-1";
                // 只有当卡号不是-1、null且不为空时，才认为真正有卡
                reallyHasCard = !("-1".equals(cardNumber) && cardNumber != null && !cardNumber.trim().isEmpty());
                // 如果hasCard为"1"，进一步检查卡号
                if (cardNumber != null && !cardNumber.trim().isEmpty()) {
                    // 放宽条件：只要卡号不为空且不是"0000"和"-1"，就认为有卡
                    reallyHasCard = !"0000".equals(cardNumber) && !"-1".equals(cardNumber);
                } else {
                    // 卡号为null或空，但有卡状态为1，显示为有卡但卡号未知
                    reallyHasCard = true;
                }
            }
            
            SlotStatus newStatus = reallyHasCard ? SlotStatus.HAS_CARD : SlotStatus.NO_CARD;
            SlotStatus currentStatus = slotStatuses.get(i);
            
            // 检查状态是否发生变化
            if (newStatus != currentStatus) {
                slotStatuses.set(i, newStatus);
            // 确保slotStatuses有足够的元素
            if (i >= slotStatuses.size()) {
                slotStatuses.add(newStatus);
                statusChanged = true;
            } else {
                SlotStatus currentStatus = slotStatuses.get(i);
                if (newStatus != currentStatus) {
                    slotStatuses.set(i, newStatus);
                    statusChanged = true;
                    
                    // 调试状态变化
                    System.out.printf("卡槽 %d 状态变化: %s -> %s (hasCard=%s, cardNumber=%s)%n",
                        i + 1, currentStatus, newStatus, hasCardStatus, cardNumber);
                }
            }
            
            // 更新按钮显示
            updateSlotButtonDisplay(i, slotInfo, newStatus);
        }
        
        // 如果状态发生变化，更新显示
        // 如果状态发生变化，更新统计信息
        if (statusChanged) {
            updateCardSlotsDisplay();
            updateStatistics();
        } else {
            // 即使状态没变，也要检查卡号是否更新
            updateCardSlotsDisplay();
        }
    }
    /**
     * 记录进入快速取卡页面前的轮询状态
     */
    private void recordPollingStateBeforeEntering() {
        wasPollingRunning = chushihua.lunxun.isPolling();
        wasPollingPaused = chushihua.lunxun.isPaused();
        //System.out.println("进入快速取卡页面，记录轮询状态 - 运行: " + wasPollingRunning + ", 暂停: " + wasPollingPaused);
    }
    
    /**
     * 进入快速取卡页面时暂停轮询
     */
    private void pausePollingWhenEntering() {
        if (chushihua.lunxun.isPolling() && !chushihua.lunxun.isPaused()) {
            chushihua.lunxun.pausePolling();
            System.out.println("进入快速取卡页面，轮询已暂停");
        }
    }
    
    /**
     * 退出快速取卡页面时恢复轮询
     */
    private void resumePollingWhenExiting() {
        // 只有进入快速取卡页面时轮询是运行状态且未被暂停，才恢复轮询
        if (wasPollingRunning && !wasPollingPaused) {
            if (chushihua.lunxun.isPolling() && chushihua.lunxun.isPaused()) {
                chushihua.lunxun.resumePolling();
                System.out.println("退出快速取卡页面，轮询已恢复");
    private void updateSlotButtonDisplay(int index, Fkj slotInfo, SlotStatus status) {
        if (index < 0 || index >= slotButtons.size()) {
            return;
        }
        
        JButton slotButton = slotButtons.get(index);
        
        // 更新按钮背景颜色
        slotButton.setBackground(status.getColor());
        
        // 更新状态标签
        Component[] components = slotButton.getComponents();
        for (Component comp : components) {
            if (comp instanceof JLabel) {
                JLabel label = (JLabel) comp;
                // 找到状态标签（较小的字体）
                if (label.getFont().getSize() == 11) {
                    String displayText;
                    if (status == SlotStatus.HAS_CARD) {
                        // 显示实际卡号，如果卡号无效则显示"有卡"
                        String cardNumber = slotInfo.getCardNumber();
                        if (cardNumber != null && !cardNumber.trim().isEmpty() && 
                            !"0000".equals(cardNumber) && !"-1".equals(cardNumber)) {
                            displayText = cardNumber;
                        } else {
                            displayText = "有卡";
                        }
                    } else {
                        displayText = "无卡";
                    }
                    label.setText(displayText);
                    break;
                }
            }
        } else {
            //System.out.println("退出快速取卡页面，保持原有轮询状态 - 运行: " + wasPollingRunning + ", 暂停: " + wasPollingPaused);
        }
    }
    
@@ -332,53 +384,98 @@
    }
    
    private void initializeSlots() {
        // 从 SlotManager 获取卡槽状态
        for (int i = 0; i < 60; i++) {
            int slotId = i + 1;
            String hasCardStatus = SlotManager.getSlotHasCardStatus(slotId);
            
            // 检查是否有卡并且有有效的卡号
            boolean reallyHasCard = false;
            if ("1".equals(hasCardStatus)) {
                Fkj slotInfo = slotManager.getSlotInfo(slotId);
                String cardNumber = slotInfo != null ? slotInfo.getCardNumber() : "-1";
                // 只有当卡号不是-1、null且不为空时，才认为真正有卡
                reallyHasCard = !("-1".equals(cardNumber) && cardNumber != null && !cardNumber.trim().isEmpty());
        // 清空现有状态
        slotStatuses.clear();
        
        // 直接从 SlotManager 获取最新数据
        Fkj[] slotArray = SlotManager.getSlotArray();
        
        //System.out.println("初始化卡槽状态，slotArray: " + (slotArray != null ? "非空" : "空"));
        
        if (slotArray != null) {
            for (int i = 0; i < 60 && i < slotArray.length; i++) {
                Fkj slotInfo = slotArray[i];
                SlotStatus status = SlotStatus.NO_CARD;
                
                if (slotInfo != null) {
                    String hasCardStatus = slotInfo.getHasCard();
                    String cardNumber = slotInfo.getCardNumber();
                    
                    // 简化的判断逻辑
                    boolean reallyHasCard = false;
                    
                    if ("1".equals(hasCardStatus)) {
                        if (cardNumber != null && !cardNumber.trim().isEmpty()) {
                            reallyHasCard = !"0000".equals(cardNumber) && !"-1".equals(cardNumber);
                        } else {
                            // 卡号为null或空，但有卡状态为1，显示为有卡
                            reallyHasCard = true;
                        }
                    }
                    
                    status = reallyHasCard ? SlotStatus.HAS_CARD : SlotStatus.NO_CARD;
                    
                    // 调试前几个卡槽
                    if (i < 5) {
                        System.out.printf("初始化卡槽 %d: hasCard=%s, cardNumber=%s, 判断为: %s%n",
                            i + 1, hasCardStatus, cardNumber, status);
                    }
                }
                
                slotStatuses.add(status);
            }
            
            SlotStatus status = reallyHasCard ? SlotStatus.HAS_CARD : SlotStatus.NO_CARD;
            slotStatuses.add(status);
        } else {
            // 如果slotArray为null，全部初始化为无卡
            //System.out.println("slotArray为null，全部初始化为无卡");
            for (int i = 0; i < 60; i++) {
                slotStatuses.add(SlotStatus.NO_CARD);
            }
        }
        
        createCardSlots();
        updateStatistics();
        
        // 立即刷新一次状态
        refreshSlotStatusFromManager();
    }
    
    private void createCardSlots() {
        cardSlotsPanel.removeAll();
        slotButtons.clear();
        
        Fkj[] slotArray = SlotManager.getSlotArray();
        
        for (int i = 0; i < 60; i++) {
            final int slotId = i + 1;
            SlotStatus status = slotStatuses.get(i);
            
            // 获取当前卡槽的实际状态
            Fkj slotInfo = null;
            if (slotArray != null && i < slotArray.length) {
                slotInfo = slotArray[i];
            }
            
            SlotStatus currentStatus = i < slotStatuses.size() ? slotStatuses.get(i) : SlotStatus.NO_CARD;
            
            // 创建 final 副本用于内部类
            final SlotStatus finalStatus = currentStatus;
            
            JButton slotButton = new JButton();
            slotButton.setLayout(new BorderLayout());
            slotButton.setBackground(status.getColor());
            slotButton.setBackground(currentStatus.getColor());
            slotButton.setForeground(Color.WHITE);
            slotButton.setFocusPainted(false);
            slotButton.setBorder(BorderFactory.createEmptyBorder(10, 5, 10, 5));
            
            // 添加鼠标悬停效果
            // 添加鼠标悬停效果 - 使用 finalStatus 而不是 status
            slotButton.addMouseListener(new java.awt.event.MouseAdapter() {
                public void mouseEntered(java.awt.event.MouseEvent evt) {
                    if (status == SlotStatus.HAS_CARD) {
                        slotButton.setBackground(brighterColor(status.getColor()));
                    if (finalStatus == SlotStatus.HAS_CARD) {
                        slotButton.setBackground(brighterColor(finalStatus.getColor()));
                    }
                }
                
                public void mouseExited(java.awt.event.MouseEvent evt) {
                    slotButton.setBackground(status.getColor());
                    slotButton.setBackground(finalStatus.getColor());
                }
            });
            
@@ -387,14 +484,16 @@
            slotIdLabel.setFont(new Font("Microsoft YaHei", Font.BOLD, 16));
            slotIdLabel.setForeground(Color.WHITE);
            
            // 卡槽状态 - 修改：有卡时显示卡号，无卡时显示"无卡"
            // 卡槽状态 - 根据实际状态显示
            String displayText;
            if (status == SlotStatus.HAS_CARD) {
                // 从SlotManager获取卡号
                Fkj slotInfo = slotManager.getSlotInfo(slotId);
                String cardNumber = slotInfo != null ? slotInfo.getCardNumber() : "-1";
                // 显示实际卡号
                displayText = cardNumber;
            if (currentStatus == SlotStatus.HAS_CARD && slotInfo != null) {
                String cardNumber = slotInfo.getCardNumber();
                if (cardNumber != null && !cardNumber.trim().isEmpty() && 
                    !"0000".equals(cardNumber) && !"-1".equals(cardNumber)) {
                    displayText = cardNumber;
                } else {
                    displayText = "有卡";
                }
            } else {
                displayText = "无卡";
            }
@@ -442,62 +541,23 @@
        }
    }
    
    
    
    // 优化的卡槽显示更新
 // 修改更新卡槽显示的方法
    private void updateCardSlotsDisplay() {
        for (int i = 0; i < 60; i++) {
            JButton slotButton = slotButtons.get(i);
            SlotStatus status = slotStatuses.get(i);
            
            // 只更新改变的状态
            if (!slotButton.getBackground().equals(status.getColor())) {
                slotButton.setBackground(status.getColor());
            }
            
            // 更新状态标签 - 修改：有卡时显示卡号，无卡时显示"无卡"
            Component[] components = slotButton.getComponents();
            for (Component comp : components) {
                if (comp instanceof JLabel) {
                    JLabel label = (JLabel) comp;
                    // 找到状态标签（较小的字体）
                    if (label.getFont().getSize() == 11) {
                        String displayText;
                        if (status == SlotStatus.HAS_CARD) {
                            // 从SlotManager获取卡号
                            Fkj slotInfo = slotManager.getSlotInfo(i + 1);
                            String cardNumber = slotInfo != null ? slotInfo.getCardNumber() : "-1";
                            // 显示实际卡号
                            displayText = cardNumber;
                        } else {
                            displayText = "无卡";
                        }
                        label.setText(displayText);
                        break;
                    }
                }
            }
        }
        
        cardSlotsPanel.revalidate();
        cardSlotsPanel.repaint();
    }
    
    private void openAllSlots() {        
       Sendmsg.openAllSlots(2);       
        Sendmsg.openAllSlots(2);       
    }
    
    // 优化的统计计算
    private void updateStatistics() {
        int hasCardCount = 0;
        for (SlotStatus status : slotStatuses) {
            if (status == SlotStatus.HAS_CARD) {
        for (int i = 0; i < 60 && i < slotStatuses.size(); i++) {
            if (slotStatuses.get(i) == SlotStatus.HAS_CARD) {
                hasCardCount++;
            }
        }
        
        cardsCountLabel.setText("有卡: " + hasCardCount + "/60");
        
        // 调试统计信息
        //System.out.println("更新统计信息: 有卡 " + hasCardCount + "/60");
    }
    
    private Color brighterColor(Color color) {
@@ -547,19 +607,10 @@
        if (slotStatuses != null) {
            slotStatuses.clear();
        }
        if (progressDialog != null) {
            progressDialog.dispose();
            progressDialog = null;
        }
        if (resultDialog != null) {
            resultDialog.dispose();
            resultDialog = null;
        }
        
        // 恢复轮询状态
        resumePollingWhenExiting();
        
        super.dispose();
        
        //System.out.println("快速取卡页面已关闭");
    }
    
    // 静态方法：从系统设置页面调用