wms_app.git - Gitblit

/**
 * RFID扫描管理器
 * 用于在扫码时自动启动RFID扫描
 * 全局单例，应用启动时自动初始化，应用退出时才清理
 */
import idataRFID from '@/common/idata-rfid.js';
 
class RFIDScanner {
    constructor() {
        this.isInitialized = false;
        this.isInitializing = false; // 正在初始化标志
        this.isScanning = false;
        this.powerStatus = 'disconnected';
        this.scanCallback = null;
        this.currentInputRef = null; // 当前输入框的引用（用于自动填入）
        this.moduleTypeIndex = 0; // 当前尝试的模块类型索引：0=UM, 1=SLR, 2=GX
        this.moduleTypes = [0, 1, 2]; // 模块类型列表
        this.moduleTypeNames = ['UM模块', 'SLR模块', 'GX模块'];
        this.initRetryCount = 0;
        this.maxRetryCount = 3; // 每种模块类型最多尝试3次
        this.autoStopTimer = null; // 自动停止定时器
        this.autoStopDelay = 30000; // 30秒后自动停止扫描（延长，避免频繁停止）
        this.powerCheckTimer = null; // 上电检查定时器
        this.currentPageInstance = null; // 当前页面实例（用于自动填入）
        this.globalScanMode = false; // 全局扫描模式（不依赖输入框焦点）
        this.scanDebounceTimer = null; // 防抖定时器
        this.scanDebounceDelay = 300; // 防抖延迟300ms
    }
 
    /**
     * 初始化RFID模块（应用启动时调用，全局只初始化一次）
     */
    init() {
        if (this.isInitialized) {
            console.log('[RFIDScanner] 模块已初始化，跳过');
            return;
        }
 
        if (this.isInitializing) {
            console.log('[RFIDScanner] 正在初始化中，跳过');
            return;
        }
 
        this.isInitializing = true;
        console.log('[RFIDScanner] ========== 开始初始化RFID模块 ==========');
        
        // 监听上电事件
        idataRFID.onPowerEvent((e) => {
            console.log('[RFIDScanner] POWEREvent:', JSON.stringify(e));
            if (e && e.status === 'connected') {
                this.powerStatus = 'connected';
                this.isInitialized = true;
                this.isInitializing = false;
                console.log('[RFIDScanner] ✓✓✓ 模块已上电成功！');
                // 清除重试定时器
                if (this.powerCheckTimer) {
                    clearTimeout(this.powerCheckTimer);
                    this.powerCheckTimer = null;
                }
            } else {
                this.powerStatus = 'disconnected';
                console.log('[RFIDScanner] ✗ 模块未上电:', e ? e.msg : '未知错误');
            }
        });
 
        // 监听扫描事件
        idataRFID.onScanEvent((e) => {
            console.log('[RFIDScanner] ========== 扫描到标签 ==========');
            console.log('[RFIDScanner] EPC:', e ? e.epc : 'undefined');
            console.log('[RFIDScanner] TID:', e ? e.tid : 'undefined');
            
            // 调用回调函数（回调函数中会更新输入框）
            if (this.scanCallback) {
                this.scanCallback(e);
            }
            
            // 全局扫描模式：自动填入当前焦点输入框
            if (this.globalScanMode && e && e.epc) {
                this.fillCurrentInput(e.epc);
            }
        });
 
        // 开始尝试初始化
        this.tryInitModule();
    }
 
    /**
     * 尝试初始化模块（自动尝试不同模块类型）
     */
    tryInitModule() {
        if (this.isInitialized) {
            return;
        }
 
        const moduleType = this.moduleTypes[this.moduleTypeIndex];
        console.log(`[RFIDScanner] 尝试初始化 ${this.moduleTypeNames[this.moduleTypeIndex]} (类型${moduleType})...`);
 
        idataRFID.initUHF(moduleType, (ret) => {
            console.log(`[RFIDScanner] initUHF(${moduleType}) result:`, ret);
            
            // 等待上电结果（最多等待3秒）
            this.powerCheckTimer = setTimeout(() => {
                if (!this.isInitialized && this.powerStatus !== 'connected') {
                    console.log(`[RFIDScanner] ${this.moduleTypeNames[this.moduleTypeIndex]} 初始化超时，尝试下一个模块类型`);
                    this.initRetryCount++;
                    
                    if (this.initRetryCount >= this.maxRetryCount) {
                        // 当前模块类型尝试次数用完，切换到下一个
                        this.moduleTypeIndex = (this.moduleTypeIndex + 1) % this.moduleTypes.length;
                        this.initRetryCount = 0;
                        console.log(`[RFIDScanner] 切换到 ${this.moduleTypeNames[this.moduleTypeIndex]}`);
                    }
                    
                    // 延迟后重试
                    setTimeout(() => {
                        if (!this.isInitialized) {
                            this.tryInitModule();
                        }
                    }, 2000);
                }
            }, 3000);
        });
    }
 
    /**
     * 开始扫描（在扫码输入框获得焦点时调用，或扫码按键触发）
     * @param {Object} inputRef - 输入框引用对象，用于自动填入扫描结果 {epc: ''}
     * @param {Function} callback - 扫描到标签时的回调函数（可选）
     */
    startScan(inputRef = null, callback = null) {
        // 防抖处理，避免快速点击
        if (this.scanDebounceTimer) {
            clearTimeout(this.scanDebounceTimer);
        }
        
        this.scanDebounceTimer = setTimeout(() => {
            this._doStartScan(inputRef, callback);
        }, this.scanDebounceDelay);
    }
 
    /**
     * 实际执行开始扫描
     */
    _doStartScan(inputRef = null, callback = null) {
        console.log('[RFIDScanner] ========== 开始扫描 ==========');
        console.log('[RFIDScanner] 当前状态 - isScanning:', this.isScanning, 'powerStatus:', this.powerStatus);
        
        // 如果未初始化，先初始化（确保模块已上电）
        if (!this.isInitialized && !this.isInitializing) {
            console.log('[RFIDScanner] 模块未初始化，开始初始化...');
            this.init();
        }
 
        // 如果已经在扫描，直接返回
        if (this.isScanning) {
            console.log('[RFIDScanner] 已在扫描中，跳过');
            return;
        }
 
        // 设置扫描回调和输入框引用
        this.scanCallback = callback;
        this.currentInputRef = inputRef;
        
        // 如果不是全局扫描模式，设置当前页面实例
        if (!this.globalScanMode && typeof getCurrentPages === 'function') {
            const pages = getCurrentPages();
            if (pages.length > 0) {
                this.currentPageInstance = pages[pages.length - 1].$vm;
            }
        }
 
        // 检查上电状态
        if (this.powerStatus !== 'connected') {
            console.log('[RFIDScanner] ⚠ RFID正在上电，请稍候...');
            idataRFID.showToast('RFID正在上电，请稍候...', 1);
            // 等待上电完成后再开始扫描
            const checkPowerAndStart = () => {
                if (this.powerStatus === 'connected' && !this.isScanning) {
                    console.log('[RFIDScanner] 模块已上电，开始扫描...');
                    this.doStartScan();
                } else if (!this.isScanning) {
                    console.log('[RFIDScanner] 等待模块上电...');
                    // 如果未上电，等待1秒后重试（最多等待10秒）
                    setTimeout(() => {
                        if (!this.isScanning && this.powerStatus !== 'connected') {
                            checkPowerAndStart();
                        }
                    }, 1000);
                }
            };
            setTimeout(() => {
                checkPowerAndStart();
            }, 500);
            return;
        }
 
        // 如果已上电，直接开始扫描
        this.doStartScan();
    }
 
    /**
     * 执行开始扫描操作
     */
    doStartScan() {
        // 如果已经在扫描，不重复调用
        if (this.isScanning) {
            console.log('[RFIDScanner] 已在扫描中，跳过');
            return;
        }
        
        console.log('[RFIDScanner] 模块已上电，开始扫描...');
        idataRFID.startOrStopRFID((ret) => {
            console.log('[RFIDScanner] startOrStopRFID result:', JSON.stringify(ret));
            if (ret && ret.code === 'success') {
                if (ret.msg === 'start') {
                    // 成功启动
                    this.isScanning = true;
                    console.log('[RFIDScanner] ✓ RFID扫描已启动');
                    idataRFID.showToast('RFID扫描已启动', 1);
                    
                    // 设置自动停止定时器（30秒后自动停止，避免频繁停止）
                    if (this.autoStopTimer) {
                        clearTimeout(this.autoStopTimer);
                    }
                    this.autoStopTimer = setTimeout(() => {
                        console.log('[RFIDScanner] 自动停止扫描（超时）');
                        this.stopScan();
                    }, this.autoStopDelay);
                } else if (ret.msg === 'stop') {
                    // 如果返回stop，说明当前状态是启动的，调用后变成了停止
                    // 这种情况不应该发生，但需要处理
                    console.log('[RFIDScanner] ⚠ 扫描状态异常，收到stop消息');
                    this.isScanning = false;
                } else {
                    console.log('[RFIDScanner] ⚠ 未知的扫描状态:', ret.msg);
                }
            } else {
                console.log('[RFIDScanner] ⚠ 启动扫描失败:', ret ? ret.msg : '未知错误');
                idataRFID.showToast('启动扫描失败', 1);
            }
        });
    }
 
    /**
     * 停止扫描（在扫码输入框失去焦点或输入完成时调用）
     * 注意：只停止扫描，不下电，保持模块上电状态
     */
    stopScan() {
        // 防抖处理
        if (this.scanDebounceTimer) {
            clearTimeout(this.scanDebounceTimer);
            this.scanDebounceTimer = null;
        }
        
        if (!this.isScanning) {
            console.log('[RFIDScanner] 当前未在扫描，跳过停止操作');
            return;
        }
 
        console.log('[RFIDScanner] ========== 停止扫描 ==========');
        
        // 清除自动停止定时器
        if (this.autoStopTimer) {
            clearTimeout(this.autoStopTimer);
            this.autoStopTimer = null;
        }
 
        // 先设置状态为false，避免重复调用
        this.isScanning = false;
 
        idataRFID.startOrStopRFID((ret) => {
            console.log('[RFIDScanner] stop scan result:', JSON.stringify(ret));
            if (ret && ret.code === 'success') {
                if (ret.msg === 'stop') {
                    console.log('[RFIDScanner] ✓ RFID扫描已停止（模块保持上电状态）');
                } else if (ret.msg === 'start') {
                    // 如果返回start，说明当前状态是停止的，调用后变成了启动
                    // 这种情况不应该发生，但需要处理
                    console.log('[RFIDScanner] ⚠ 扫描状态异常，收到start消息，重新设置为停止');
                    this.isScanning = true;
                    // 立即再次停止
                    setTimeout(() => {
                        this.stopScan();
                    }, 100);
                }
            }
        });
 
        // 清除回调和输入框引用（但不清除globalScanMode，因为可能还需要继续扫描）
        this.scanCallback = null;
        this.currentInputRef = null;
    }
 
    /**
     * 获取上电状态
     */
    getPowerStatus() {
        return this.powerStatus;
    }
 
    /**
     * 获取扫描状态
     */
    getScanningStatus() {
        return this.isScanning;
    }
 
    /**
     * 全局扫描模式：为当前焦点输入框启动扫描（扫码按键触发）
     */
    startScanForCurrentInput() {
        console.log('[RFIDScanner] ========== 全局扫描模式启动 ==========');
        
        // 如果正在扫描，先停止
        if (this.isScanning) {
            console.log('[RFIDScanner] 当前正在扫描，先停止');
            this.stopScan();
            // 等待停止完成后再启动
            setTimeout(() => {
                this._startScanForCurrentInput();
            }, 500);
            return;
        }
        
        this._startScanForCurrentInput();
    }
 
    /**
     * 实际执行全局扫描
     */
    _startScanForCurrentInput() {
        // 确保设置了当前页面实例
        if (typeof getCurrentPages === 'function') {
            const pages = getCurrentPages();
            if (pages.length > 0) {
                this.currentPageInstance = pages[pages.length - 1].$vm;
                console.log('[RFIDScanner] 已设置当前页面实例:', pages[pages.length - 1].route);
            }
        }
        
        this.globalScanMode = true;
        this.startScan(null, (tagData) => {
            if (tagData && tagData.epc) {
                console.log('[RFIDScanner] 扫描到标签，自动填入当前输入框:', tagData.epc);
                this.fillCurrentInput(tagData.epc);
                // 扫描成功后停止（延迟一下，确保填入完成）
                setTimeout(() => {
                    this.stopScan();
                }, 500);
            }
        });
    }
 
    /**
     * 自动填入当前焦点输入框
     */
    fillCurrentInput(epc) {
        try {
            console.log('[RFIDScanner] ========== 尝试自动填入EPC:', epc);
            
            // 优先使用保存的页面实例
            let vm = null;
            if (this.currentPageInstance) {
                vm = this.currentPageInstance;
                console.log('[RFIDScanner] 使用保存的页面实例');
            } else if (typeof getCurrentPages === 'function') {
                // 如果保存的实例没有找到，尝试从getCurrentPages获取
                const pages = getCurrentPages();
                if (pages.length > 0) {
                    const currentPage = pages[pages.length - 1];
                    console.log('[RFIDScanner] 当前页面:', currentPage.route);
                    if (currentPage && currentPage.$vm) {
                        vm = currentPage.$vm;
                        // 更新保存的实例
                        this.currentPageInstance = vm;
                    }
                }
            }
            
            if (!vm) {
                console.log('[RFIDScanner] 未找到页面实例，无法自动填入');
                return;
            }
            
            // 检查常见的输入框变量名（按优先级）
            // 优先查找可能有焦点的输入框
            const inputFields = ['barcode', 'matnr', 'locNo', 'orderNo', 'sourceSite', 'targetSite'];
            let filled = false;
            
            for (let field of inputFields) {
                if (vm[field] !== undefined) {
                    console.log(`[RFIDScanner] 找到输入框变量 ${field}，当前值:`, vm[field]);
                    vm[field] = epc;
                    console.log(`[RFIDScanner] ✓✓✓ 已自动填入EPC到 ${field}:`, epc);
                    idataRFID.showToast('已自动填入', 1);
                    filled = true;
                    break; // 只填入第一个找到的
                }
            }
            
            if (!filled) {
                console.log('[RFIDScanner] 未找到输入框变量，无法自动填入');
                console.log('[RFIDScanner] 页面实例data:', Object.keys(vm.$data || {}));
            }
        } catch (error) {
            console.error('[RFIDScanner] 自动填入失败:', error);
        }
    }
 
    /**
     * 单标签读无过滤（在输入框获得焦点时调用）
     * @param {String} fieldName - 要填入的字段名（如 'barcode', 'matnr' 等）
     * @param {Function} callback - 读取成功后的回调函数（可选）
     */
    readSingleTagWithoutFilter(fieldName = null, callback = null) {
        console.log('[RFIDScanner] ========== 单标签读无过滤 ==========');
        console.log('[RFIDScanner] 字段名:', fieldName);
        
        // 如果未初始化，先初始化（确保模块已上电）
        if (!this.isInitialized && !this.isInitializing) {
            console.log('[RFIDScanner] 模块未初始化，开始初始化...');
            this.init();
        }
 
        // 检查上电状态
        if (this.powerStatus !== 'connected') {
            console.log('[RFIDScanner] ⚠ RFID正在上电，请稍候...');
            idataRFID.showToast('RFID正在上电，请稍候...', 1);
            // 等待上电完成后再读取
            const checkPowerAndRead = () => {
                if (this.powerStatus === 'connected') {
                    console.log('[RFIDScanner] 模块已上电，开始单标签读取...');
                    this._doReadSingleTag(fieldName, callback);
                } else {
                    console.log('[RFIDScanner] 等待模块上电...');
                    setTimeout(() => {
                        if (this.powerStatus !== 'connected') {
                            checkPowerAndRead();
                        }
                    }, 1000);
                }
            };
            setTimeout(() => {
                checkPowerAndRead();
            }, 500);
            return;
        }
 
        // 如果已上电，直接读取
        this._doReadSingleTag(fieldName, callback);
    }
 
    /**
     * 执行单标签读取操作
     */
    _doReadSingleTag(fieldName = null, callback = null) {
        // 确保设置了当前页面实例
        if (typeof getCurrentPages === 'function') {
            const pages = getCurrentPages();
            if (pages.length > 0) {
                this.currentPageInstance = pages[pages.length - 1].$vm;
            }
        }
 
        // 调用单标签读无过滤
        // readBank: 1->EPC, startBlock: 2, len: 6, pwd: "00000000"
        idataRFID.readTagWithoutFilter(1, 2, 6, "00000000", (ret) => {
            console.log('[RFIDScanner] readTagWithoutFilter result:', JSON.stringify(ret));
            
            if (ret && ret.code === 'success' && ret.data) {
                const epc = ret.data.trim();
                console.log('[RFIDScanner] ✓✓✓ 成功读取到标签 EPC:', epc);
                
                // 如果有回调函数，先调用回调
                if (callback && typeof callback === 'function') {
                    callback({ epc: epc, tid: '' });
                }
                
                // 如果指定了字段名，自动填入
                if (fieldName) {
                    this.fillFieldByName(fieldName, epc);
                } else {
                    // 如果没有指定字段名，自动填入当前焦点输入框
                    this.fillCurrentInput(epc);
                }
                
                idataRFID.showToast('读取成功', 1);
            } else {
                console.log('[RFIDScanner] ✗ 读取失败:', ret ? ret.msg : '未知错误');
                if (ret && ret.code === 'fail') {
                    idataRFID.showToast('读取失败: ' + (ret.msg || '未知错误'), 1);
                }
            }
        });
    }
 
    /**
     * 根据字段名填入值
     */
    fillFieldByName(fieldName, value) {
        try {
            console.log(`[RFIDScanner] 尝试填入字段 ${fieldName}:`, value);
            
            // 优先使用保存的页面实例
            let vm = null;
            if (this.currentPageInstance) {
                vm = this.currentPageInstance;
            } else if (typeof getCurrentPages === 'function') {
                const pages = getCurrentPages();
                if (pages.length > 0 && pages[pages.length - 1].$vm) {
                    vm = pages[pages.length - 1].$vm;
                    this.currentPageInstance = vm;
                }
            }
            
            if (!vm) {
                console.log('[RFIDScanner] 未找到页面实例，无法填入');
                return;
            }
            
            if (vm[fieldName] !== undefined) {
                vm[fieldName] = value;
                console.log(`[RFIDScanner] ✓✓✓ 已填入字段 ${fieldName}:`, value);
                idataRFID.showToast('已自动填入', 1);
            } else {
                console.log(`[RFIDScanner] 字段 ${fieldName} 不存在`);
            }
        } catch (error) {
            console.error('[RFIDScanner] 填入字段失败:', error);
        }
    }
 
    /**
     * 设置当前页面实例（页面onShow时调用）
     */
    setCurrentPageInstance(pageInstance) {
        this.currentPageInstance = pageInstance;
    }
 
    /**
     * 清理资源（应用退出时调用，全局只调用一次）
     */
    cleanup() {
        console.log('[RFIDScanner] ========== 清理RFID资源（应用退出） ==========');
        this.stopScan();
        idataRFID.closeUHF();
        idataRFID.removeEventListeners();
        this.isInitialized = false;
        this.isInitializing = false;
        this.isScanning = false;
        this.powerStatus = 'disconnected';
        this.scanCallback = null;
        this.currentInputRef = null;
        if (this.powerCheckTimer) {
            clearTimeout(this.powerCheckTimer);
            this.powerCheckTimer = null;
        }
        console.log('[RFIDScanner] ✓ RFID资源已清理');
    }
}
 
// 创建单例实例
const rfidScanner = new RFIDScanner();
 
export default rfidScanner;