• 首页
  • 栏目
  • ERP
  • 安卓开发实现获取扫码枪扫码二维码、条形码后的内容

安卓开发实现获取扫码枪扫码二维码、条形码后的内容

  • 2021-12-28
  • Admin

扫码枪是如何工作的，安卓如何怎么获取扫码枪的内容。本文将介绍安卓获取和处理商米收银机扫码枪扫描后的内容。包括：“安卓开发获取扫码枪扫描后的内容”、“处理扫码枪扫描后的内容”、“在Fragment中使用ScanGun类”。

1、安卓开发获取扫码枪扫描后的内容。

扫码枪会将扫描出来的内容转化为键盘事件KeyEvent，所以我们在fragment类中重写onKeyDownChild方法，就可以捕获扫码事件，进而获取扫码内容：

  1. public void onKeyDownChild(int keyCode, KeyEvent event) {
  2.     log.info("---------------------------------onKeyDown:    KeyCode:" + keyCode + "------event:" + event + "------------------------------------");
  3.     scanGun.isMaybeScanning(keyCode, event);
  4. }

2、处理扫码枪扫描后的内容。

SanGun类定义一个isMayBeScanning方法，扫码枪扫描后触发键盘事件，在键盘事件中调用isMayBeScanning方法，进而解析获取扫码内容：

查看代码 
  1. package com.bx.erp.helper;
  2.  
  3. import android.view.KeyEvent;
  4.  
  5. import org.apache.log4j.Logger;
  6.  
  7. public class ScanGun {
  8.     private Logger log = Logger.getLogger(this.getClass());
  9.     /**
  10.      * 默认按键之间时间间隔
  11.      */
  12.     public final static int MAX_KEYS_INTERVAL_DEFAULT = 200;
  13.  
  14.     private long currentTime = 0;
  15.     private boolean isKeySHIFT = false;
  16.     private StringBuilder stringBuilder = new StringBuilder();
  17.     private ScanGunCallBack callBack = null;
  18.  
  19.     private static int maxKeysInterval = MAX_KEYS_INTERVAL_DEFAULT;
  20.  
  21.     /**
  22.      * 设置按键事件的最大时间间隔(部分扫描枪稍大，建议范围20--100)
  23.      *
  24.      * @param interval 时间间隔
  25.      */
  26.     public static void setMaxKeysInterval(int interval) {
  27.         maxKeysInterval = interval;
  28.     }
  29.  
  30.     public ScanGun(ScanGunCallBack callBack) {
  31.         this.callBack = callBack;
  32.     }
  33.  
  34.     public ScanGun() {}
  35.  
  36.     public boolean isMaybeScanning(int keyCode, KeyEvent event) {
  37.         log.info("isMaybeScanning--");
  38.  
  39.         log.info("event.getFlags:" + event.getFlags());
  40.         if (event.getFlags() != 0x8 && event.getFlags() != 0x6) {
  41.             return false;
  42.         }
  43.         if (currentTime == 0) {
  44.             if (stringBuilder.length() > 0) {
  45.                 stringBuilder = stringBuilder.delete(0, stringBuilder.length());
  46.             }
  47.             currentTime = System.currentTimeMillis();
  48.         } else {
  49.             if ((System.currentTimeMillis() - currentTime) > maxKeysInterval) {
  50.                 if (stringBuilder.length() > 0) {
  51.                     stringBuilder = stringBuilder.delete(0,
  52.                             stringBuilder.length());
  53.                 }
  54.             }
  55.             currentTime = System.currentTimeMillis();
  56.         }
  57.         // Shift
  58.         if (keyCode == KeyEvent.KEYCODE_SHIFT_RIGHT || keyCode == KeyEvent.KEYCODE_SHIFT_LEFT) {
  59.             if (event.getAction() == KeyEvent.ACTION_DOWN) {
  60.                 //按着shift键，表示大写
  61.                 isKeySHIFT = true;
  62.             } else {
  63.                 //松开shift键，表示小写
  64.                 isKeySHIFT = false;
  65.             }
  66.         }
  67.         // Enter
  68.         if (keyCode == KeyEvent.KEYCODE_ENTER) {
  69.             isKeySHIFT = false;
  70.             currentTime = 0;
  71.             if (callBack != null) {
  72.                 log.info("stringBuilder:" + stringBuilder);
  73.                 callBack.onScanFinish(stringBuilder.toString());
  74.             }
  75.             return true;
  76.         }
  77.         if (keyCode >= KeyEvent.KEYCODE_0 && keyCode <= KeyEvent.KEYCODE_9) {
  78.             // 数字键(键盘上方横条数字，需要考虑Shift)
  79.             handleTopNumKeys(keyCode);
  80.  
  81.         } else if (keyCode >= 29 && keyCode <= 54) {
  82.             // 字母键(需要考虑Shift)ww
  83.             checkShift((char) (keyCode + 68), (char) (keyCode + 36));
  84.         } else if (keyCode >= 144 && keyCode <= 158) {
  85.             // 数字键盘区
  86.             handleNumPadKeys(keyCode);
  87.             log.info("数字：" + stringBuilder);
  88.         } else {
  89.             // 键盘主键区其他双字符键位
  90.             switch (keyCode) {
  91.                 case KeyEvent.KEYCODE_GRAVE: {
  92.                     checkShift(ASCII.CHAR_SIGN_BACKTICK, ASCII.CHAR_SIGN_TILDE);
  93.                     break;
  94.                 }
  95.                 case KeyEvent.KEYCODE_MINUS: {
  96.                     checkShift(ASCII.CHAR_SIGN_MINUS, ASCII.CHAR_SIGN_UNDERSCORE);
  97.                     break;
  98.                 }
  99.                 case KeyEvent.KEYCODE_EQUALS: {
  100.                     checkShift(ASCII.CHAR_SIGN_EQUALS, ASCII.CHAR_SIGN_PLUS);
  101.                     break;
  102.                 }
  103.  
  104.                 case KeyEvent.KEYCODE_LEFT_BRACKET: {
  105.                     checkShift(ASCII.CHAR_SIGN_BRACKET_LEFT,
  106.                             ASCII.CHAR_SIGN_BRACE_LEFT);
  107.                     break;
  108.                 }
  109.                 case KeyEvent.KEYCODE_RIGHT_BRACKET: {
  110.                     checkShift(ASCII.CHAR_SIGN_BRACKET_RIGHT,
  111.                             ASCII.CHAR_SIGN_BRACE_RIGHT);
  112.                     break;
  113.                 }
  114.                 case KeyEvent.KEYCODE_BACKSLASH: {
  115.                     checkShift(ASCII.CHAR_SIGN_BACKSLASH, ASCII.CHAR_SIGN_BAR);
  116.                     break;
  117.                 }
  118.                 case KeyEvent.KEYCODE_SEMICOLON: {
  119.                     checkShift(ASCII.CHAR_SIGN_SEMICOLON, ASCII.CHAR_SIGN_COLON);
  120.                     break;
  121.                 }
  122.                 case KeyEvent.KEYCODE_APOSTROPHE: {
  123.                     checkShift(ASCII.CHAR_SIGN_QUOTE, ASCII.CHAR_SIGN_DOUBLE_QUOTE);
  124.                     break;
  125.                 }
  126.                 case KeyEvent.KEYCODE_COMMA: {
  127.                     checkShift(ASCII.CHAR_SIGN_COMMA, ASCII.CHAR_SIGN_LESS);
  128.                     break;
  129.                 }
  130.                 case KeyEvent.KEYCODE_PERIOD: {
  131.                     checkShift(ASCII.CHAR_SIGN_PERIOD, ASCII.CHAR_SIGN_GREATER);
  132.                     break;
  133.                 }
  134.                 case KeyEvent.KEYCODE_SLASH: {
  135.                     checkShift(ASCII.CHAR_SIGN_SLASH, ASCII.CHAR_SIGN_QUESTION);
  136.                     break;
  137.                 }
  138.                 // 其他单字符键位
  139.                 case KeyEvent.KEYCODE_SPACE: {
  140.                     stringBuilder.append(ASCII.CHAR_SIGN_SPACE);
  141.                     log.info("Other StringBuilder:" + stringBuilder);
  142.                     break;
  143.                 }
  144.                 default: {
  145.                     return false;
  146.                 }
  147.             }
  148.             return true;
  149.         }
  150.  
  151.         return true;
  152.  
  153.     }
  154.  
  155.     /**
  156.      * 判断是否同时按下Shift键
  157.      *
  158.      * @param ascallNoShift
  159.      * @param ascallOnShift
  160.      */
  161.     private void checkShift(char ascallNoShift, char ascallOnShift) {
  162.         if (isKeySHIFT) {
  163.             stringBuilder.append(ascallOnShift);
  164.             isKeySHIFT = false;
  165.         } else {
  166.             stringBuilder.append(ascallNoShift);
  167.         }
  168.     }
  169.  
  170.     /**
  171.      * 数字键盘区按键
  172.      *
  173.      * @param keyCode
  174.      */
  175.     public void handleNumPadKeys(int keyCode) {
  176.         if (keyCode <= 153) {
  177.             stringBuilder.append((char) (keyCode - 96));
  178.         } else if (keyCode == KeyEvent.KEYCODE_NUMPAD_DIVIDE) {
  179.             stringBuilder.append(ASCII.CHAR_SIGN_SLASH);
  180.         } else if (keyCode == KeyEvent.KEYCODE_NUMPAD_MULTIPLY) {
  181.             stringBuilder.append(ASCII.CHAR_SIGN_STAR);
  182.         } else if (keyCode == KeyEvent.KEYCODE_NUMPAD_SUBTRACT) {
  183.             stringBuilder.append(ASCII.CHAR_SIGN_MINUS);
  184.         } else if (keyCode == KeyEvent.KEYCODE_NUMPAD_ADD) {
  185.             stringBuilder.append(ASCII.CHAR_SIGN_PLUS);
  186.         } else if (keyCode == KeyEvent.KEYCODE_NUMPAD_DOT) {
  187.             stringBuilder.append(ASCII.CHAR_SIGN_PERIOD);
  188.         }
  189.     }
  190.  
  191.     /**
  192.      * 键盘上方数字键
  193.      *
  194.      * @param keyCode
  195.      */
  196.     private void handleTopNumKeys(int keyCode) {
  197.         if (keyCode < 7 || keyCode > 16) {
  198.             return;
  199.         }
  200.         switch (keyCode) {
  201.             case KeyEvent.KEYCODE_0:
  202.                 checkShift(ASCII.CHAR_NUM_0, ASCII.CHAR_SIGN_PAREN_RIGHT);
  203.                 break;
  204.             case KeyEvent.KEYCODE_1:
  205.                 checkShift(ASCII.CHAR_NUM_1, ASCII.CHAR_SIGN_EXCLAM);
  206.                 break;
  207.             case KeyEvent.KEYCODE_2:
  208.                 checkShift(ASCII.CHAR_NUM_2, ASCII.CHAR_SIGN_AT);
  209.                 break;
  210.             case KeyEvent.KEYCODE_3:
  211.                 checkShift(ASCII.CHAR_NUM_3, ASCII.CHAR_SIGN_HASH);
  212.                 break;
  213.             case KeyEvent.KEYCODE_4:
  214.                 checkShift(ASCII.CHAR_NUM_4, ASCII.CHAR_SIGN_DOLLAR);
  215.                 break;
  216.             case KeyEvent.KEYCODE_5:
  217.                 checkShift(ASCII.CHAR_NUM_5, ASCII.CHAR_SIGN_PERCENT);
  218.                 break;
  219.             case KeyEvent.KEYCODE_6:
  220.                 checkShift(ASCII.CHAR_NUM_6, ASCII.CHAR_SIGN_CARET);
  221.                 break;
  222.             case KeyEvent.KEYCODE_7:
  223.                 checkShift(ASCII.CHAR_NUM_7, ASCII.CHAR_SIGN_AMPERSAND);
  224.                 break;
  225.             case KeyEvent.KEYCODE_8:
  226.                 checkShift(ASCII.CHAR_NUM_8, ASCII.CHAR_SIGN_STAR);
  227.                 break;
  228.             case KeyEvent.KEYCODE_9:
  229.                 checkShift(ASCII.CHAR_NUM_9, ASCII.CHAR_SIGN_PAREN_LEFT);
  230.                 break;
  231.             default:
  232.                 break;
  233.         }
  234.     }
  235.  
  236.     public interface ScanGunCallBack {
  237.         public void onScanFinish(String data);
  238.     }
  239. }

3、在Fragment中使用ScanGun类。

ScanGun类定义了一个内部类接口，data就是扫描完成后的内容：

  1. public interface ScanGunCallBack {
  2.     public void onScanFinish(String data);
  3. }

扫码完成后，调用该接口的onScanFinish方法：

  1. // Enter
  2. if (keyCode == KeyEvent.KEYCODE_ENTER) {
  3.     isKeySHIFT = false;
  4.     currentTime = 0;
  5.     if (callBack != null) {
  6.         log.info("stringBuilder:" + stringBuilder);
  7.         callBack.onScanFinish(stringBuilder.toString());
  8.     }
  9.     return true;
  10. }

所以在Fragment获取扫描结果，需要创建Scan的实例，并且实现这个onScanFinish方法：

  1. /* 初始化扫码枪 */
  2. private void initScanGun() {
  3.     // 设置key事件最大间隔，默认20ms，部分低端扫码枪效率低
  4.     ScanGun.setMaxKeysInterval(50);
  5.     scanGun = new ScanGun(new ScanGun.ScanGunCallBack() {
  6.         @RequiresApi(api = Build.VERSION_CODES.JELLY_BEAN_MR1)
  7.         @Override
  8.         public void onScanFinish(String scanResult) {
  9.             if (payment.getVisibility() != View.GONE
			
    原文：https://blog.csdn.net/weixin_44071138/article/details/122184346
    		
    
		
    
			
    
	
    
		
    免费ERP
    
	
    
		
    61ebf17978942.jpg
     注册    登录 
    用户名: demo; 密码: 123456
    
	
    

    
	
    
		
    最新
    
	
    
			
	
    

    
	
    
		
    最热

ERP

联系站长

QQ：769220720

Copyright © SibooSoft All right reserved 津ICP备19011444号