wms_app.git - Gitblit

/**
 * RFID输入框自动填入助手
 * 全局监听RFID扫描按键（189、190、191），自动读取标签并填入当前焦点输入框
 */
 
// #ifdef APP-PLUS
let uhfModel = null;
let globalEvent = null;
let modal = null;
let isPowerOn = false;
let isScanning = false; // 是否正在扫描中
let scanKeyHandler = null; // 按键监听器引用
 
/**
 * 初始化RFID助手（只初始化插件引用和事件监听，不初始化RFID模块）
 * RFID模块由App.vue全局初始化，这里只负责监听按键和读取标签
 * 注意：即使初始化失败，也不抛出异常，确保不影响页面使用
 */
function initRFIDForInput() {
    try {
        uhfModel = uni.requireNativePlugin("iData-UHFPlugin-UHFModule");
        globalEvent = uni.requireNativePlugin('globalEvent');
        modal = uni.requireNativePlugin('modal');
        
        if (!uhfModel) {
            console.warn('[RFIDInputHelper] ⚠ RFID插件未找到，RFID扫描功能不可用，但页面可正常使用');
            return false;
        }
        
        // 监听上电事件（监听全局上电状态，RFID模块由App.vue初始化）
        try {
            globalEvent.addEventListener('POWEREvent', function(e) {
                console.log('[RFIDInputHelper] POWEREvent:', JSON.stringify(e));
                if (e && e.status === 'connected') {
                    isPowerOn = true;
                    console.log('[RFIDInputHelper] ✓ RFID模块已上电');
                } else {
                    isPowerOn = false;
                    console.log('[RFIDInputHelper] ✗ RFID模块未上电');
                }
            });
        } catch (eventError) {
            console.warn('[RFIDInputHelper] ⚠ 添加POWEREvent监听失败:', eventError);
            console.warn('[RFIDInputHelper] ⚠ RFID扫描功能可能不可用，但页面可正常使用');
        }
        
        // 注意：RFID模块由App.vue在onLaunch时全局初始化
        // 这里只负责监听按键和读取标签，不初始化RFID模块
        
        return true;
    } catch (error) {
        console.error('[RFIDInputHelper] ⚠ 初始化失败:', error);
        console.warn('[RFIDInputHelper] ⚠ RFID扫描功能不可用，但页面可正常使用');
        return false;
    }
}
 
/**
 * 检查当前页面是否是测试页面
 */
function isTestPage() {
    try {
        const pages = getCurrentPages();
        if (pages.length > 0) {
            const currentPage = pages[pages.length - 1];
            const route = currentPage.route || '';
            // 如果是测试页面，不启用全局RFID扫描
            return route.includes('rfid/uhftest') || route.includes('rfid/uhftest2');
        }
        return false;
    } catch (error) {
        console.error('[RFIDInputHelper] 检查页面失败:', error);
        return false;
    }
}
 
/**
 * 播放提示音
 * @param {String} type - 提示音类型：'success'=成功（滴1声），'error'=错误（滴2声），'warning'=警告（滴3声），'short'=短促（快速滴1声）
 */
function playBeepSound(type = 'success') {
    // #ifdef APP-PLUS
    try {
        // 使用设备蜂鸣器播放提示音
        if (typeof plus !== 'undefined' && plus.device && plus.device.beep) {
            let beepCount = 1; // 默认播放1次
            
            // 根据类型设置不同的提示音
            switch(type) {
                case 'success':
                    beepCount = 1; // 成功：滴1声
                    break;
                case 'error':
                    beepCount = 2; // 错误：滴2声
                    break;
                case 'warning':
                    beepCount = 3; // 警告：滴3声
                    break;
                case 'short':
                    beepCount = 1; // 短促：快速滴1声
                    break;
                default:
                    beepCount = 1;
            }
            
            plus.device.beep(beepCount); // 播放指定次数
            
            // 如果是错误或警告，可以添加震动反馈
            if (type === 'error' || type === 'warning') {
                if (typeof plus !== 'undefined' && plus.device && plus.device.vibrate) {
                    setTimeout(() => {
                        plus.device.vibrate(200); // 震动200ms
                    }, 100);
                }
            }
        } else {
            // 如果设备不支持beep，尝试使用vibrate（震动）作为替代
            if (typeof plus !== 'undefined' && plus.device && plus.device.vibrate) {
                let vibrateDuration = 100; // 默认震动100ms
                if (type === 'error') {
                    vibrateDuration = 300; // 错误：震动300ms
                } else if (type === 'warning') {
                    vibrateDuration = 200; // 警告：震动200ms
                }
                plus.device.vibrate(vibrateDuration);
            }
        }
    } catch (error) {
        console.warn('[RFIDInputHelper] 播放提示音失败:', error);
    }
    // #endif
}
 
/**
 * 读取RFID标签（单标签读，无过滤）
 */
function readRFIDTag() {
    try {
        if (!uhfModel) {
            // 如果模块未初始化，尝试初始化
            try {
                uhfModel = uni.requireNativePlugin("iData-UHFPlugin-UHFModule");
            } catch (e) {
                console.warn('[RFIDInputHelper] ⚠ RFID模块未找到:', e);
            }
            if (!uhfModel) {
                console.warn('[RFIDInputHelper] RFID模块未找到');
                if (modal) {
                    modal.toast({
                        message: 'RFID模块未找到',
                        duration: 1.5
                    });
                }
                return;
            }
        }
        
        // 检查RFID是否已上电（RFID模块由App.vue全局初始化）
        if (!isPowerOn) {
            console.warn('[RFIDInputHelper] RFID未上电，无法扫描');
            if (modal) {
                modal.toast({
                    message: 'RFID正在上电，请稍候...',
                    duration: 1.5
                });
            }
            return;
        }
    } catch (error) {
        console.error('[RFIDInputHelper] ⚠ 读取RFID标签前检查失败:', error);
        console.warn('[RFIDInputHelper] ⚠ RFID扫描功能不可用，但页面可正常使用');
        if (modal) {
            modal.toast({
                message: 'RFID扫描功能不可用',
                duration: 1.5
            });
        }
        return;
    }
    
    if (isScanning) {
        console.log('[RFIDInputHelper] 正在扫描中，跳过');
        return;
    }
    
    isScanning = true;
    console.log('[RFIDInputHelper] 开始读取RFID标签...');
    
    /**
     * readBank:0->RESERVED,1->EPC,2->TID,3->USR
     * startBlock:读取的起始地址(Word类型)
     * len:读取的数据长度(Word类型，大于0)
     * pwd:访问密码，默认密码为：00000000
     * 注意：Word类型，一个长度表示标签存储4位字符
     * len=1表示读取4位，len=2表示读取8位，len=8表示读取32位
     * 使用len=1读取4位数据（如果标签是4位）
     */
    const readLen = 8; // 读取长度：1个Word = 4个字符
    uhfModel.readTagWithoutFilter(1, 2, readLen, "00000000", (ret) => {
        isScanning = false;
        console.log('[RFIDInputHelper] readTagWithoutFilter result:', ret);
        
        if (ret && typeof ret === 'string') {
            // 解析返回结果，提取EPC（不追加，不截断，使用实际长度）
            // 返回格式可能是：success EPC:XXXXXXXX 或类似格式
            let epc = '';
            if (ret.includes('success') || ret.includes('EPC')) {
                // 尝试提取EPC值（提取完整的16进制字符串，不限制长度）
                const epcMatch = ret.match(/EPC[:\s]+([A-F0-9]+)/i);
                if (epcMatch && epcMatch[1]) {
                    epc = epcMatch[1]; // 使用实际长度，不追加
                } else {
                    // 如果没有匹配到，尝试提取16进制字符串（不限制最小长度）
                    const hexMatch = ret.match(/([A-F0-9]+)/i);
                    if (hexMatch && hexMatch[1]) {
                        epc = hexMatch[1]; // 使用实际长度，不追加
                    }
                }
            }
            
            if (epc) {
                // 根据读取长度截取数据（len=1表示4位，len=2表示8位）
                const maxLength = readLen * 4; // Word长度 × 4 = 字符数
                if (epc.length > maxLength) {
                    console.log(`[RFIDInputHelper] 数据过长(${epc.length}位)，截取前${maxLength}位`);
                    epc = epc.substring(0, maxLength);
                }
                
                // 去除前导0（如果插件返回了固定长度的数据，前面可能有0填充）
                // 但保留至少1位（如果全部是0，保留一个0）
                const originalLength = epc.length;
                epc = epc.replace(/^0+/, '') || '0';
                if (originalLength !== epc.length) {
                    console.log('[RFIDInputHelper] 去除前导0: 原始长度=' + originalLength + ', 去除后长度=' + epc.length);
                }
                
                console.log('[RFIDInputHelper] ✓ 读取到标签EPC (长度' + epc.length + '位):', epc);
                // 播放提示音（滴一声）
                // playBeepSound(); // 已注释，后续自己决定是否启用
                // 自动填入当前焦点输入框（不追加，使用实际长度）
                fillCurrentInput(epc);
                modal.toast({
                    message: '已读取标签',
                    duration: 1.5
                });
            } else {
                console.warn('[RFIDInputHelper] 无法解析EPC，返回结果:', ret);
                // 如果返回的是失败消息，直接显示
                if (ret.includes('fail') || ret.includes('失败')) {
                    modal.toast({
                        message: '读取失败，请重试',
                        duration: 1.5
                    });
                } else {
                    // 尝试直接使用返回的字符串作为EPC（不限制最小长度）
                    const cleanRet = ret.trim();
                    // 移除可能的"success"等前缀，只保留16进制字符
                    let hexOnly = cleanRet.replace(/[^A-F0-9]/gi, '');
                    if (hexOnly.length > 0) {
                        // 去除前导0（如果插件返回了固定长度的数据，前面可能有0填充）
                        const originalLength = hexOnly.length;
                        hexOnly = hexOnly.replace(/^0+/, '') || '0';
                        if (originalLength !== hexOnly.length) {
                            console.log('[RFIDInputHelper] 去除前导0: 原始长度=' + originalLength + ', 去除后长度=' + hexOnly.length);
                        }
                        // 播放提示音（滴一声）
                        // playBeepSound(); // 已注释，后续自己决定是否启用
                        fillCurrentInput(hexOnly); // 使用实际长度，不追加
                        modal.toast({
                            message: '已读取标签',
                            duration: 1.5
                        });
                    } else {
                        modal.toast({
                            message: '读取失败，请重试',
                            duration: 1.5
                        });
                    }
                }
            }
        } else if (ret && typeof ret === 'object') {
            // 如果返回的是对象格式
            if (ret.code === 'success' && ret.data) {
                let epc = '';
                if (typeof ret.data === 'string') {
                    // 如果是字符串，提取16进制部分（不追加，不截断）
                    epc = ret.data.trim().replace(/[^A-F0-9]/gi, '');
                } else if (ret.data.epc) {
                    epc = String(ret.data.epc).trim().replace(/[^A-F0-9]/gi, '');
                } else {
                    epc = String(ret.data).trim().replace(/[^A-F0-9]/gi, '');
                }
                
                // 根据读取长度截取数据（len=1表示4位，len=2表示8位）
                if (epc) {
                    const maxLength = readLen * 4; // Word长度 × 4 = 字符数
                    if (epc.length > maxLength) {
                        console.log(`[RFIDInputHelper] 数据过长(${epc.length}位)，截取前${maxLength}位`);
                        epc = epc.substring(0, maxLength);
                    }
                    
                    // 去除前导0（如果插件返回了固定长度的数据，前面可能有0填充）
                    // 但保留至少1位（如果全部是0，保留一个0）
                    const originalLength = epc.length;
                    epc = epc.replace(/^0+/, '') || '0';
                    if (originalLength !== epc.length) {
                        console.log('[RFIDInputHelper] 去除前导0: 原始长度=' + originalLength + ', 去除后长度=' + epc.length);
                    }
                    
                    console.log('[RFIDInputHelper] ✓ 读取到标签EPC (长度' + epc.length + '位):', epc);
                    // 播放提示音（滴一声）
                    // playBeepSound(); // 已注释，后续自己决定是否启用
                    fillCurrentInput(epc); // 使用实际长度，不追加
                    modal.toast({
                        message: '已读取标签',
                        duration: 1.5
                    });
                } else {
                    modal.toast({
                        message: '读取失败，请重试',
                        duration: 1.5
                    });
                }
            } else {
                modal.toast({
                    message: '读取失败，请重试',
                    duration: 1.5
                });
            }
        } else {
            console.warn('[RFIDInputHelper] 读取失败:', ret);
            modal.toast({
                message: '读取失败，请重试',
                duration: 1.5
            });
        }
    });
}
 
/**
 * 自动填入当前焦点输入框
 */
function fillCurrentInput(epc) {
    try {
        console.log('[RFIDInputHelper] 尝试填入EPC到输入框:', epc);
        
        // 获取当前页面实例
        const pages = getCurrentPages();
        if (pages.length === 0) {
            console.warn('[RFIDInputHelper] 没有页面实例');
            return;
        }
        
        const currentPage = pages[pages.length - 1];
        if (!currentPage || !currentPage.$vm) {
            console.warn('[RFIDInputHelper] 页面实例无效');
            return;
        }
        
        const vm = currentPage.$vm;
        console.log('[RFIDInputHelper] 当前页面:', currentPage.route);
        
        // 定义输入框字段和对应的焦点状态字段（预定义的常见字段）
        // 格式：{ 字段名: 焦点状态字段名 }
        const predefinedFieldMap = [
            { field: 'barcode', focusField: 'barcodeFocus' },
            { field: 'matnr', focusField: 'matFocus' },
            { field: 'sourceSite', focusField: 'sourceSiteFocus' },
            { field: 'orderNo', focusField: 'orderNoFocus' },
            { field: 'targetSite', focusField: 'targetSiteFocus' },
            { field: 'locNo', focusField: 'locNoFocus' },
            { field: 'batch', focusField: 'batchFocus' },
            { field: 'userName', focusField: 'userNameFocus' },
            { field: 'password', focusField: 'passwordFocus' }
        ];
        
        // 自动检测所有可能的输入框字段（从vm.$data中查找所有字符串类型的属性）
        const autoDetectedFields = [];
        if (vm.$data) {
            for (let key in vm.$data) {
                // 跳过以$开头的Vue内部属性，跳过函数，跳过focus字段本身
                if (key.startsWith('$') || typeof vm.$data[key] === 'function' || key.endsWith('Focus')) {
                    continue;
                }
                // 如果是字符串类型，认为是可能的输入框字段
                if (typeof vm.$data[key] === 'string' || vm.$data[key] === null || vm.$data[key] === undefined) {
                    // 检查是否有对应的focusField（字段名 + Focus）
                    const focusFieldName = key + 'Focus';
                    if (vm.$data[focusFieldName] !== undefined) {
                        autoDetectedFields.push({ field: key, focusField: focusFieldName });
                    }
                }
            }
        }
        
        // 合并预定义字段和自动检测的字段（去重）
        const allFieldsMap = [...predefinedFieldMap];
        for (let autoField of autoDetectedFields) {
            // 检查是否已存在
            const exists = allFieldsMap.some(item => item.field === autoField.field);
            if (!exists) {
                allFieldsMap.push(autoField);
            }
        }
        
        // 调试：打印所有输入框的焦点状态
        console.log('[RFIDInputHelper] ========== 检查输入框焦点状态 ==========');
        for (let item of allFieldsMap) {
            if (vm[item.field] !== undefined) {
                const focusValue = vm[item.focusField];
                console.log(`[RFIDInputHelper]   ${item.field}: focus=${focusValue}, value="${vm[item.field]}"`);
            }
        }
        
        // 只查找有焦点的输入框（光标所在的输入框）
        let focusedField = null;
        for (let item of allFieldsMap) {
            if (vm[item.field] !== undefined) {
                // 检查是否有焦点状态字段，并且焦点为true
                const focusValue = vm[item.focusField];
                console.log(`[RFIDInputHelper] 检查 ${item.field}: focusField=${item.focusField}, focusValue=${focusValue}, type=${typeof focusValue}`);
                if (focusValue === true) {
                    focusedField = item.field;
                    console.log(`[RFIDInputHelper] ✓✓✓ 找到有焦点的输入框: ${item.field} (focus=${focusValue})`);
                    break;
                }
            }
        }
        
        // 只填入有焦点的输入框，如果没有焦点则不填入
        if (focusedField) {
            // 根据字段类型截断RFID数据长度
            let finalEpc = epc;
            const fieldLengthMap = {
                'barcode': 8,      // 托盘码：保留前8位
                'matnr': 16,        // 物料码/物料号：保留前16位
                'sourceSite': 9,    // 暂存位：保留前9位
                'locNo': 7          // 库位号：保留前7位
            };
            
            if (fieldLengthMap[focusedField]) {
                const maxLength = fieldLengthMap[focusedField];
                if (finalEpc.length > maxLength) {
                    console.log(`[RFIDInputHelper] ${focusedField}字段数据长度(${finalEpc.length}位)超过限制(${maxLength}位)，截取前${maxLength}位`);
                    finalEpc = finalEpc.substring(0, maxLength);
                }
            }
            
            console.log(`[RFIDInputHelper] 填入有焦点的输入框 ${focusedField}:`, finalEpc);
            vm[focusedField] = finalEpc;
            // 触发input事件，确保页面逻辑能响应
            if (vm.$nextTick) {
                vm.$nextTick(() => {
                    // 如果页面有对应的input处理方法，可以手动触发
                    if (focusedField === 'barcode' && typeof vm.barcodeInput === 'function') {
                        vm.barcodeInput();
                    } else if (focusedField === 'matnr' && typeof vm.findMat === 'function') {
                        vm.findMat();
                    }
                });
            }
        } else {
            console.warn('[RFIDInputHelper] ✗ 未找到有焦点的输入框，不填入任何输入框');
            console.warn('[RFIDInputHelper] 请先点击输入框获得焦点，然后再按扫码按键');
            modal.toast({
                message: '请先点击输入框获得焦点',
                duration: 1.5
            });
        }
    } catch (error) {
        console.error('[RFIDInputHelper] 自动填入失败:', error);
    }
}
 
/**
 * 监听扫码按键
 */
function setupScanKeyListener() {
    if (scanKeyHandler) {
        console.log('[RFIDInputHelper] 按键监听器已存在');
        return;
    }
    
    if (typeof plus === 'undefined' || !plus.key) {
        console.warn('[RFIDInputHelper] plus对象未初始化，无法添加按键监听');
        return;
    }
    
    scanKeyHandler = function(e) {
        const keyCode = e.keyCode;
        
        // 扫码按键：189、190、191
        if (keyCode === 189 || keyCode === 190 || keyCode === 191) {
            // 如果是测试页面，不处理（让测试页面自己处理）
            if (isTestPage()) {
                console.log('[RFIDInputHelper] 测试页面，跳过全局RFID扫描');
                return;
            }
            
            console.log('[RFIDInputHelper] 扫码按键按下（键值' + keyCode + '），触发RFID扫描');
            readRFIDTag();
        }
    };
    
    plus.key.addEventListener('keydown', scanKeyHandler);
    console.log('[RFIDInputHelper] ✓ 按键监听器已添加');
}
 
/**
 * 移除按键监听
 */
function removeScanKeyListener() {
    if (scanKeyHandler && typeof plus !== 'undefined' && plus.key) {
        plus.key.removeEventListener('keydown', scanKeyHandler);
        scanKeyHandler = null;
        console.log('[RFIDInputHelper] ✓ 按键监听器已移除');
    }
}
 
/**
 * 关闭RFID模块（注意：RFID模块由App.vue管理，这里不关闭）
 */
function closeRFID() {
    // RFID模块由App.vue在onExit时关闭，这里不需要关闭
    console.log('[RFIDInputHelper] RFID模块由App.vue管理，不在此处关闭');
}
 
/**
 * 启动全局RFID输入助手
 */
export function startRFIDInputHelper() {
    // #ifdef APP-PLUS
    console.log('[RFIDInputHelper] 启动RFID输入助手...');
    
    // 初始化RFID模块
    if (initRFIDForInput()) {
        // 延迟添加按键监听，确保初始化完成
        setTimeout(() => {
            setupScanKeyListener();
        }, 500);
    }
    // #endif
}
 
/**
 * 停止全局RFID输入助手
 */
export function stopRFIDInputHelper() {
    // #ifdef APP-PLUS
    console.log('[RFIDInputHelper] 停止RFID输入助手...');
    removeScanKeyListener();
    // 注意：不关闭RFID模块，因为测试页面可能在使用
    // closeRFID();
    // #endif
}
 
// #endif