安卓实现二维码生成和扫描功能，扫描支持直接拍照扫码和相册图片扫码，还加了照明功能

 1  //要转换的地址或字符串,可以是中文，输入内容生成二维码
 2     public Bitmap createQRImage(String string) {
 3         try {
 4             Hashtable<EncodeHintType, String> hints = new Hashtable<EncodeHintType, String>();
 5             hints.put(EncodeHintType.CHARACTER_SET, "utf-8");
 6             //图像数据转换，使用了矩阵转换
 7             BitMatrix bitMatrix = new QRCodeWriter().encode(string, BarcodeFormat.QR_CODE, QR_WIDTH, QR_HEIGHT, hints);
 8             int[] pixels = new int[QR_WIDTH * QR_HEIGHT];
 9             //下面这里按照二维码的算法，逐个生成二维码的图片，
10             //两个for循环是图片横列扫描的结果
11             for (int y = 0; y < QR_HEIGHT; y++) {
12                 for (int x = 0; x < QR_WIDTH; x++) {
13                     if (bitMatrix.get(x, y)) {
14                         pixels[y * QR_WIDTH + x] = 0xff000000;
15                     } else {
16                         pixels[y * QR_WIDTH + x] = 0xffffffff;
17                     }
18                 }
19             }
20             //生成二维码图片的格式，使用ARGB_8888
21             Bitmap bitmap = Bitmap.createBitmap(QR_WIDTH, QR_HEIGHT, Bitmap.Config.ARGB_8888);
22             bitmap.setPixels(pixels, 0, QR_WIDTH, 0, 0, QR_WIDTH, QR_HEIGHT);
23             return bitmap;
24         } catch (WriterException e) {
25             e.printStackTrace();
26         }
27 
28 
29         return null;
30     }

  1     private static final String TAG = "log";
  2     /**
  3      * 刷新界面的时间
  4      */
  5     private static final long ANIMATION_DELAY = 30L;
  6     private static final int OPAQUE = 0xFF;
  7 
  8     /**
  9      * 四个绿色边角对应的长度
 10      */
 11     private int ScreenRate;
 12 
 13     /**
 14      * 四个绿色边角对应的宽度
 15      */
 16     private static final int CORNER_WIDTH = 10;
 17     /**
 18      * 扫描框中的中间线的宽度
 19      */
 20     private static final int MIDDLE_LINE_WIDTH = 6;
 21 
 22     /**
 23      * 扫描框中的中间线的与扫描框左右的间隙
 24      */
 25     private static final int MIDDLE_LINE_PADDING = 5;
 26 
 27     /**
 28      * 中间那条线每次刷新移动的距离
 29      */
 30     private static final int SPEEN_DISTANCE = 5;
 31 
 32     /**
 33      * 手机的屏幕密度
 34      */
 35     private static float density;
 36     /**
 37      * 字体大小
 38      */
 39     private static final int TEXT_SIZE = 16;
 40     /**
 41      * 字体距离扫描框下面的距离
 42      */
 43     private static final int TEXT_PADDING_TOP = 30;
 44 
 45     /**
 46      * 画笔对象的引用
 47      */
 48     private Paint paint;
 49 
 50     /**
 51      * 中间滑动线的最顶端位置
 52      */
 53     private int slideTop;
 54 
 55     /**
 56      * 中间滑动线的最底端位置
 57      */
 58     private int slideBottom;
 59 
 60     private Bitmap resultBitmap;
 61     private final int maskColor;
 62     private final int resultColor;
 63     private final int frameColor;
 64     private final int resultPointColor;
 65     private Collection<ResultPoint> possibleResultPoints;
 66     private Collection<ResultPoint> lastPossibleResultPoints;
 67 
 68     boolean isFirst;
 69 
 70     public ViewfinderView(Context context, AttributeSet attrs) {
 71         super(context, attrs);
 72 
 73         density = context.getResources().getDisplayMetrics().density;
 74         //将像素转换成dp
 75         ScreenRate = (int) (20 * density);
 76 
 77         paint = new Paint();
 78         Resources resources = getResources();
 79         maskColor = resources.getColor(R.color.viewfinder_mask);
 80         resultColor = resources.getColor(R.color.result_view);
 81         frameColor = resources.getColor(R.color.viewfinder_frame);
 82         resultPointColor = resources.getColor(R.color.possible_result_points);
 83         possibleResultPoints = new HashSet<ResultPoint>(5);
 84     }
 85 
 86     @Override
 87     public void onDraw(Canvas canvas) {
 88         //中间的扫描框，你要修改扫描框的大小，去CameraManager里面修改
 89         Rect frame = CameraManager.get().getFramingRect();
 90         if (frame == null) {
 91             return;
 92         }
 93 
 94         //初始化中间线滑动的最上边和最下边
 95         if (!isFirst) {
 96             isFirst = true;
 97             slideTop = frame.top;
 98             slideBottom = frame.bottom;
 99         }
100 
101         //获取屏幕的宽和高
102         int width = canvas.getWidth();
103         int height = canvas.getHeight();
104 
105         paint.setColor(resultBitmap != null ? resultColor : maskColor);
106 
107         //画出扫描框外面的阴影部分，共四个部分，扫描框的上面到屏幕上面，扫描框的下面到屏幕下面
108         //扫描框的左边面到屏幕左边，扫描框的右边到屏幕右边
109         canvas.drawRect(0, 0, width, frame.top, paint);
110         canvas.drawRect(0, frame.top, frame.left, frame.bottom + 1, paint);
111         canvas.drawRect(frame.right + 1, frame.top, width, frame.bottom + 1,
112                 paint);
113         canvas.drawRect(0, frame.bottom + 1, width, height, paint);
114 
115 
116         if (resultBitmap != null) {
117             // Draw the opaque result bitmap over the scanning rectangle
118             paint.setAlpha(OPAQUE);
119             canvas.drawBitmap(resultBitmap, frame.left, frame.top, paint);
120         } else {
121 //这是我自己加的扫描框内部的白线，让扫描框看起来更好看
122             paint.setColor(frameColor);
123             canvas.drawRect(frame.left + CORNER_WIDTH, frame.top + CORNER_WIDTH, frame.right + 1 - CORNER_WIDTH, frame.top + 2 + CORNER_WIDTH, paint);
124             canvas.drawRect(frame.left + CORNER_WIDTH, frame.top + 2 + CORNER_WIDTH, frame.left + 2 + CORNER_WIDTH, frame.bottom - 1 - CORNER_WIDTH, paint);
125             canvas.drawRect(frame.right - 1 - CORNER_WIDTH, frame.top + CORNER_WIDTH, frame.right + 1 - CORNER_WIDTH, frame.bottom - 1 - CORNER_WIDTH, paint);
126             canvas.drawRect(frame.left + CORNER_WIDTH, frame.bottom - 1 - CORNER_WIDTH, frame.right + 1 - CORNER_WIDTH, frame.bottom + 1 - CORNER_WIDTH, paint);
127 
128             //画扫描框边上的角，总共8个部分
129             paint.setColor(Color.parseColor("#FF038CF7"));
130             //左上
131             canvas.drawRect(frame.left, frame.top - CORNER_WIDTH, frame.left + ScreenRate,
132                     frame.top + CORNER_WIDTH - CORNER_WIDTH, paint);
133             canvas.drawRect(frame.left - CORNER_WIDTH, frame.top - CORNER_WIDTH, frame.left + CORNER_WIDTH - CORNER_WIDTH, frame.top
134                     + ScreenRate - CORNER_WIDTH + CORNER_WIDTH, paint);
135             //右上
136             canvas.drawRect(frame.right - ScreenRate, frame.top - CORNER_WIDTH, frame.right + CORNER_WIDTH,
137                     frame.top + CORNER_WIDTH - CORNER_WIDTH, paint);
138             canvas.drawRect(frame.right - CORNER_WIDTH + CORNER_WIDTH, frame.top, frame.right + CORNER_WIDTH, frame.top
139                     + ScreenRate, paint);
140             //左下
141             canvas.drawRect(frame.left - CORNER_WIDTH, frame.bottom - ScreenRate, frame.left + CORNER_WIDTH - CORNER_WIDTH
142                     , frame.bottom, paint);
143             canvas.drawRect(frame.left - CORNER_WIDTH, frame.bottom,
144                     frame.left + ScreenRate, frame.bottom + CORNER_WIDTH, paint);
145             //右下
146             canvas.drawRect(frame.right, frame.bottom - ScreenRate,
147                     frame.right + CORNER_WIDTH, frame.bottom, paint);
148             canvas.drawRect(frame.right - ScreenRate, frame.bottom,
149                     frame.right + CORNER_WIDTH, frame.bottom + CORNER_WIDTH, paint);
150 
151 
152             //绘制中间的线,每次刷新界面，中间的线往下移动SPEEN_DISTANCE
153             slideTop += SPEEN_DISTANCE;
154             if (slideTop >= frame.bottom) {
155                 slideTop = frame.top;
156             }
157             canvas.drawRect(frame.left + MIDDLE_LINE_PADDING, slideTop - MIDDLE_LINE_WIDTH / 2, frame.right - MIDDLE_LINE_PADDING, slideTop + MIDDLE_LINE_WIDTH / 2, paint);
158 
159 
160             //画扫描框下面的字
161             paint.setColor(Color.WHITE);
162             paint.setTextSize(TEXT_SIZE * density);
163             paint.setAlpha(0x40);
164             paint.setTypeface(Typeface.create("System", Typeface.BOLD));
165             canvas.drawText(getResources().getString(R.string.scan_text), frame.left, (float) (frame.bottom + (float) TEXT_PADDING_TOP * density), paint);
166 
167 
168             Collection<ResultPoint> currentPossible = possibleResultPoints;
169             Collection<ResultPoint> currentLast = lastPossibleResultPoints;
170             if (currentPossible.isEmpty()) {
171                 lastPossibleResultPoints = null;
172             } else {
173                 possibleResultPoints = new HashSet<ResultPoint>(5);
174                 lastPossibleResultPoints = currentPossible;
175                 paint.setAlpha(OPAQUE);
176                 paint.setColor(resultPointColor);
177                 for (ResultPoint point : currentPossible) {
178                     canvas.drawCircle(frame.left + point.getX(), frame.top
179                             + point.getY(), 6.0f, paint);
180                 }
181             }
182             if (currentLast != null) {
183                 paint.setAlpha(OPAQUE / 2);
184                 paint.setColor(resultPointColor);
185                 for (ResultPoint point : currentLast) {
186                     canvas.drawCircle(frame.left + point.getX(), frame.top
187                             + point.getY(), 3.0f, paint);
188                 }
189             }
190 
191 
192             //只刷新扫描框的内容，其他地方不刷新
193             postInvalidateDelayed(ANIMATION_DELAY, frame.left, frame.top,
194                     frame.right, frame.bottom);
195 
196         }
197     }
198 
199     public void drawViewfinder() {
200         resultBitmap = null;
201         invalidate();
202     }
203 
204     /**
205      * Draw a bitmap with the result points highlighted instead of the live
206      * scanning display.
207      *
208      * @param barcode An image of the decoded barcode.
209      */
210     public void drawResultBitmap(Bitmap barcode) {
211         resultBitmap = barcode;
212         invalidate();
213     }
214 
215     public void addPossibleResultPoint(ResultPoint point) {
216         possibleResultPoints.add(point);
217     }

  1 private static final String TAG = CameraManager.class.getSimpleName();
  2 
  3   private static final int MIN_FRAME_WIDTH = 240;
  4   private static final int MIN_FRAME_HEIGHT = 240;
  5   private static final int MAX_FRAME_WIDTH = 720;
  6   private static final int MAX_FRAME_HEIGHT = 480;
  7 
  8   private static CameraManager cameraManager;
  9 
 10   static final int SDK_INT; // Later we can use Build.VERSION.SDK_INT
 11   static {
 12     int sdkInt;
 13     try {
 14       sdkInt = Integer.parseInt(Build.VERSION.SDK);
 15     } catch (NumberFormatException nfe) {
 16       // Just to be safe
 17       sdkInt = 10000;
 18     }
 19     SDK_INT = sdkInt;
 20   }
 21 
 22   private final Context context;
 23   private final CameraConfigurationManager configManager;
 24   private Camera camera;
 25   private Rect framingRect;
 26   private Rect framingRectInPreview;
 27   private boolean initialized;
 28   private boolean previewing;
 29   private final boolean useOneShotPreviewCallback;
 30   /**
 31    * Preview frames are delivered here, which we pass on to the registered handler. Make sure to
 32    * clear the handler so it will only receive one message.
 33    */
 34   private final PreviewCallback previewCallback;
 35   /** Autofocus callbacks arrive here, and are dispatched to the Handler which requested them. */
 36   private final AutoFocusCallback autoFocusCallback;
 37 
 38   /**
 39    * Initializes this static object with the Context of the calling Activity.
 40    *
 41    * @param context The Activity which wants to use the camera.
 42    */
 43   public static void init(Context context) {
 44     if (cameraManager == null) {
 45       cameraManager = new CameraManager(context);
 46     }
 47   }
 48 
 49   /**
 50    * Gets the CameraManager singleton instance.
 51    *
 52    * @return A reference to the CameraManager singleton.
 53    */
 54   public static CameraManager get() {
 55     return cameraManager;
 56   }
 57 
 58   private CameraManager(Context context) {
 59 
 60     this.context = context;
 61     this.configManager = new CameraConfigurationManager(context);
 62 
 63     // Camera.setOneShotPreviewCallback() has a race condition in Cupcake, so we use the older
 64     // Camera.setPreviewCallback() on 1.5 and earlier. For Donut and later, we need to use
 65     // the more efficient one shot callback, as the older one can swamp the system and cause it
 66     // to run out of memory. We can‘t use SDK_INT because it was introduced in the Donut SDK.
 67     //useOneShotPreviewCallback = Integer.parseInt(Build.VERSION.SDK) > Build.VERSION_CODES.CUPCAKE;
 68     useOneShotPreviewCallback = Integer.parseInt(Build.VERSION.SDK) > 3; // 3 = Cupcake
 69 
 70     previewCallback = new PreviewCallback(configManager, useOneShotPreviewCallback);
 71     autoFocusCallback = new AutoFocusCallback();
 72   }
 73   //控制开启闪光灯
 74   public void flashHandler() {
 75     //camera.startPreview();
 76     Camera.Parameters parameters = camera.getParameters();
 77     // 判断闪光灯当前状态來修改
 78     if (Camera.Parameters.FLASH_MODE_OFF.equals(parameters.getFlashMode())) {
 79       turnOn(parameters);
 80     } else if (Camera.Parameters.FLASH_MODE_TORCH.equals(parameters.getFlashMode())) {
 81       turnOff(parameters);
 82     }
 83   }
 84   //开
 85   private void turnOn(Camera.Parameters parameters) {
 86     parameters.setFlashMode(Camera.Parameters.FLASH_MODE_TORCH);
 87     camera.setParameters(parameters);
 88   }
 89   //关
 90   private void turnOff(Camera.Parameters parameters) {
 91     parameters.setFlashMode(Camera.Parameters.FLASH_MODE_OFF);
 92     camera.setParameters(parameters);
 93   }
 94   /**
 95    * Opens the camera driver and initializes the hardware parameters.
 96    *
 97    * @param holder The surface object which the camera will draw preview frames into.
 98    * @throws IOException Indicates the camera driver failed to open.
 99    */
100   public void openDriver(SurfaceHolder holder) throws IOException {
101 
102     if (camera == null) {
103       System.out.println("wanggsx openDriver camera = null");
104       camera = Camera.open();
105       if (camera == null) {
106         throw new IOException();
107       }
108       camera.setPreviewDisplay(holder);
109 
110       if (!initialized) {
111         initialized = true;
112         configManager.initFromCameraParameters(camera);
113       }
114       configManager.setDesiredCameraParameters(camera);
115       FlashlightManager.enableFlashlight();
116     } else {
117       System.out.println("wangying openDriver camera != null");
118       camera.setPreviewDisplay(holder);//此处为新增方法
119     }
120 /***
121  * 以上内容为更改内容，经实践结果我们发现，viewfinder会出现黑屏的情况，以上内容就是解决的方法，
122  * 我遇到的情况是我从相册中选取图片进行扫描的时候，返回扫描界面的时候就出现viewFinder黑屏，大家复制上面
123  * 的内容，放到这个方法就可以啦！
124  */
125 
126 //    if (camera == null) {
127 //      camera = Camera.open();
128 //      if (camera == null) {
129 //        throw new IOException();
130 //      }
131 //      camera.setPreviewDisplay(holder);
132 //
133 //      if (!initialized) {
134 //        initialized = true;
135 //        configManager.initFromCameraParameters(camera);
136 //      }
137 //      configManager.setDesiredCameraParameters(camera);
138 
139       //FIXME
140  //     SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context);
141       //?????????
142 //      if (prefs.getBoolean(PreferencesActivity.KEY_FRONT_LIGHT, false)) {
143 //        FlashlightManager.enableFlashlight();
144 //      }
145 //      FlashlightManager.enableFlashlight();
146 //    }
147   }
148 
149   /**
150    * Closes the camera driver if still in use.
151    */
152   public void closeDriver() {
153     if (camera != null) {
154       FlashlightManager.disableFlashlight();
155       camera.release();
156       camera = null;
157     }
158   }
159 
160   /**
161    * Asks the camera hardware to begin drawing preview frames to the screen.
162    */
163   public void startPreview() {
164     if (camera != null && !previewing) {
165       camera.startPreview();
166       previewing = true;
167     }
168   }
169 
170   /**
171    * Tells the camera to stop drawing preview frames.
172    */
173   public void stopPreview() {
174     if (camera != null && previewing) {
175       if (!useOneShotPreviewCallback) {
176         camera.setPreviewCallback(null);
177       }
178       camera.stopPreview();
179       previewCallback.setHandler(null, 0);
180       autoFocusCallback.setHandler(null, 0);
181       previewing = false;
182     }
183   }
184 
185   /**
186    * A single preview frame will be returned to the handler supplied. The data will arrive as byte[]
187    * in the message.obj field, with width and height encoded as message.arg1 and message.arg2,
188    * respectively.
189    *
190    * @param handler The handler to send the message to.
191    * @param message The what field of the message to be sent.
192    */
193   public void requestPreviewFrame(Handler handler, int message) {
194     if (camera != null && previewing) {
195       previewCallback.setHandler(handler, message);
196       if (useOneShotPreviewCallback) {
197         camera.setOneShotPreviewCallback(previewCallback);
198       } else {
199         camera.setPreviewCallback(previewCallback);
200       }
201     }
202   }
203 
204   /**
205    * Asks the camera hardware to perform an autofocus.
206    *
207    * @param handler The Handler to notify when the autofocus completes.
208    * @param message The message to deliver.
209    */
210   public void requestAutoFocus(Handler handler, int message) {
211     if (camera != null && previewing) {
212       autoFocusCallback.setHandler(handler, message);
213       //Log.d(TAG, "Requesting auto-focus callback");
214       camera.autoFocus(autoFocusCallback);
215     }
216   }
217 
218   /**
219    * Calculates the framing rect which the UI should draw to show the user where to place the
220    * barcode. This target helps with alignment as well as forces the user to hold the device
221    * far enough away to ensure the image will be in focus.
222    *
223    * @return The rectangle to draw on screen in window coordinates.
224    */
225   public Rect getFramingRect() {
226     Point screenResolution = configManager.getScreenResolution();
227     if (framingRect == null) {
228       if (camera == null) {
229         return null;
230       }
231       int width = screenResolution.x * 3 / 4;
232       if (width < MIN_FRAME_WIDTH) {
233         width = MIN_FRAME_WIDTH;
234       } else if (width > MAX_FRAME_WIDTH) {
235         width = MAX_FRAME_WIDTH;
236       }
237       int height = screenResolution.y * 3 / 6;
238       if (height < MIN_FRAME_HEIGHT) {
239         height = MIN_FRAME_HEIGHT;
240       } else if (height > MAX_FRAME_HEIGHT) {
241         height = MAX_FRAME_HEIGHT;
242       }
243       int leftOffset = (screenResolution.x - width) / 2;
244       int topOffset = (screenResolution.y - height) / 2;
245       framingRect = new Rect(leftOffset, topOffset, leftOffset + width, topOffset + height);
246       Log.d(TAG, "Calculated framing rect: " + framingRect);
247     }
248     return framingRect;
249   }
250 
251   /**
252    * Like {@link #getFramingRect} but coordinates are in terms of the preview frame,
253    * not UI / screen.
254    */
255   public Rect getFramingRectInPreview() {
256     if (framingRectInPreview == null) {
257       Rect rect = new Rect(getFramingRect());
258       Point cameraResolution = configManager.getCameraResolution();
259       Point screenResolution = configManager.getScreenResolution();
260       //modify here
261 //      rect.left = rect.left * cameraResolution.x / screenResolution.x;
262 //      rect.right = rect.right * cameraResolution.x / screenResolution.x;
263 //      rect.top = rect.top * cameraResolution.y / screenResolution.y;
264 //      rect.bottom = rect.bottom * cameraResolution.y / screenResolution.y;
265       rect.left = rect.left * cameraResolution.y / screenResolution.x;
266       rect.right = rect.right * cameraResolution.y / screenResolution.x;
267       rect.top = rect.top * cameraResolution.x / screenResolution.y;
268       rect.bottom = rect.bottom * cameraResolution.x / screenResolution.y;
269       framingRectInPreview = rect;
270     }
271     return framingRectInPreview;
272   }
273 
274   /**
275    * Converts the result points from still resolution coordinates to screen coordinates.
276    *
277    * @param points The points returned by the Reader subclass through Result.getResultPoints().
278    * @return An array of Points scaled to the size of the framing rect and offset appropriately
279    *         so they can be drawn in screen coordinates.
280    */
281   /*
282   public Point[] convertResultPoints(ResultPoint[] points) {
283     Rect frame = getFramingRectInPreview();
284     int count = points.length;
285     Point[] output = new Point[count];
286     for (int x = 0; x < count; x++) {
287       output[x] = new Point();
288       output[x].x = frame.left + (int) (points[x].getX() + 0.5f);
289       output[x].y = frame.top + (int) (points[x].getY() + 0.5f);
290     }
291     return output;
292   }
293    */
294 
295   /**
296    * A factory method to build the appropriate LuminanceSource object based on the format
297    * of the preview buffers, as described by Camera.Parameters.
298    *
299    * @param data A preview frame.
300    * @param width The width of the image.
301    * @param height The height of the image.
302    * @return A PlanarYUVLuminanceSource instance.
303    */
304   public PlanarYUVLuminanceSource buildLuminanceSource(byte[] data, int width, int height) {
305     Rect rect = getFramingRectInPreview();
306     int previewFormat = configManager.getPreviewFormat();
307     String previewFormatString = configManager.getPreviewFormatString();
308     switch (previewFormat) {
309       // This is the standard Android format which all devices are REQUIRED to support.
310       // In theory, it‘s the only one we should ever care about.
311       case PixelFormat.YCbCr_420_SP:
312       // This format has never been seen in the wild, but is compatible as we only care
313       // about the Y channel, so allow it.
314       case PixelFormat.YCbCr_422_SP:
315         return new PlanarYUVLuminanceSource(data, width, height, rect.left, rect.top,
316             rect.width(), rect.height());
317       default:
318         // The Samsung Moment incorrectly uses this variant instead of the ‘sp‘ version.
319         // Fortunately, it too has all the Y data up front, so we can read it.
320         if ("yuv420p".equals(previewFormatString)) {
321           return new PlanarYUVLuminanceSource(data, width, height, rect.left, rect.top,
322             rect.width(), rect.height());
323         }
324     }
325     throw new IllegalArgumentException("Unsupported picture format: " +
326         previewFormat + ‘/‘ + previewFormatString);
327   }
328 
329     public Context getContext() {
330         return context;
331     }

  1 <?xml version="1.0" encoding="utf-8"?>
  2 <FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
  3     android:layout_width="fill_parent"
  4     android:layout_height="fill_parent" >
  5 
  6     <SurfaceView
  7         android:id="@+id/preview_view"
  8         android:layout_width="wrap_content"
  9         android:layout_height="wrap_content"
 10         android:layout_gravity="center" />
 11 
 12     <com.wangy.mycode.Zxing.view.ViewfinderView
 13         android:id="@+id/viewfinder_view"
 14         android:layout_width="wrap_content"
 15         android:layout_height="wrap_content" />
 16     <RelativeLayout
 17         android:layout_width="fill_parent"
 18         android:layout_height="fill_parent"
 19         android:layout_gravity="center"
 20         android:orientation="vertical" >
 21 
 22         <TextView
 23             android:layout_width="fill_parent"
 24             android:layout_height="wrap_content"
 25             android:layout_alignParentTop="true"
 26             android:layout_centerInParent="true"
 27             android:background="#038cf7"
 28             android:gravity="center"
 29             android:paddingBottom="10dp"
 30             android:paddingTop="10dp"
 31             android:text="二维码扫描"
 32             android:textColor="@android:color/white"
 33             android:textSize="18sp"
 34             android:textStyle="bold" />
 35         <ImageView
 36             android:id="@+id/result_back"
 37             android:layout_width="wrap_content"
 38             android:layout_height="wrap_content"
 39             android:src="@drawable/icon_back"
 40             android:layout_margin="10dp"
 41             android:layout_alignParentLeft="true"
 42             />
 43         <TextView
 44             android:layout_width="match_parent"
 45             android:layout_height="wrap_content"
 46             android:minHeight="60dp"
 47             android:text="将取景框对准二维码，\n即可自动扫描。"
 48             android:textColor="#fff"
 49             android:gravity="center"
 50             android:textSize="16sp"
 51             android:layout_above="@+id/ll_type"
 52             />
 53         <LinearLayout
 54             android:layout_width="wrap_content"
 55             android:layout_height="200dp"
 56             android:layout_alignParentRight="true"
 57             android:gravity="center"
 58             android:orientation="vertical">
 59             <TextView
 60                 android:id="@+id/btn_shine"
 61                 android:layout_width="wrap_content"
 62                 android:layout_height="wrap_content"
 63                 android:layout_margin="10dp"
 64                 android:padding="5dp"
 65                 android:background="@drawable/white"
 66                 android:text="照明"
 67                 android:textColor="#fff"
 68                 android:textSize="15sp"
 69                 />
 70         </LinearLayout>
 71 
 72         <LinearLayout
 73             android:id="@+id/ll_type"
 74             android:layout_width="match_parent"
 75             android:layout_marginTop="10dp"
 76             android:layout_alignParentBottom="true"
 77             android:gravity="center"
 78             android:layout_height="wrap_content">
 79         <Button
 80             android:id="@+id/btn_scan"
 81             android:layout_width="70dp"
 82             android:layout_height="70dp"
 83             android:layout_margin="20dp"
 84             android:background="@drawable/blueroll"
 85             android:layout_alignParentBottom="true"
 86             android:layout_marginBottom="75dp"
 87             android:text="扫码"
 88             android:textColor="#fff"
 89             android:textSize="15sp"
 90              />
 91         <Button
 92             android:id="@+id/btn_phone"
 93             android:layout_width="70dp"
 94             android:layout_height="70dp"
 95             android:layout_margin="20dp"
 96             android:background="@drawable/tranroll"
 97             android:layout_alignParentBottom="true"
 98             android:layout_marginBottom="75dp"
 99             android:text="相册"
100             android:textColor="#fff"
101             android:textSize="15sp"
102             />
103         </LinearLayout>
104     </RelativeLayout>
105 
106 </FrameLayout>

  1 package com.wangy.mycode.Zxing;
  2 
  3 import android.content.Intent;
  4 import android.content.res.AssetFileDescriptor;
  5 import android.database.Cursor;
  6 import android.graphics.Bitmap;
  7 import android.graphics.BitmapFactory;
  8 import android.graphics.Color;
  9 import android.media.AudioManager;
 10 import android.media.MediaPlayer;
 11 import android.os.Bundle;
 12 import android.os.Handler;
 13 import android.os.Vibrator;
 14 import android.provider.MediaStore;
 15 import android.view.KeyEvent;
 16 import android.view.SurfaceHolder;
 17 import android.view.SurfaceView;
 18 import android.view.View;
 19 import android.widget.Button;
 20 import android.widget.ImageView;
 21 import android.widget.TextView;
 22 import android.widget.Toast;
 23 
 24 import com.google.zxing.BarcodeFormat;
 25 import com.google.zxing.BinaryBitmap;
 26 import com.google.zxing.DecodeHintType;
 27 import com.google.zxing.Result;
 28 import com.google.zxing.common.HybridBinarizer;
 29 import com.google.zxing.qrcode.QRCodeReader;
 30 import com.wangy.mycode.Base.BaseActivity;
 31 import com.wangy.mycode.R;
 32 import com.wangy.mycode.RGBLuminanceSource;
 33 import com.wangy.mycode.ScanResultActivity;
 34 import com.wangy.mycode.Zxing.camera.CameraManager;
 35 import com.wangy.mycode.Zxing.decoding.CaptureActivityHandler;
 36 import com.wangy.mycode.Zxing.decoding.InactivityTimer;
 37 import com.wangy.mycode.Zxing.view.ViewfinderView;
 38 import com.wangy.mycode.utils.IntentUtils;
 39 
 40 import java.io.IOException;
 41 import java.util.Hashtable;
 42 import java.util.Vector;
 43 
 44 /**
 45  * Created by xhb on 2016/12/28.
 46  */
 47 public class CaptureActivity extends BaseActivity implements SurfaceHolder.Callback, View.OnClickListener {
 48     private CaptureActivityHandler handler;
 49     private ViewfinderView viewfinderView;
 50     private boolean hasSurface;
 51     private Vector<BarcodeFormat> decodeFormats;
 52     private String characterSet;
 53     private InactivityTimer inactivityTimer;
 54     private MediaPlayer mediaPlayer;
 55     private boolean playBeep;
 56     private static final float BEEP_VOLUME = 0.10f;
 57     private boolean vibrate;
 58     private ImageView result_back;
 59     private Button btn_scan;
 60     private Button btn_phone;
 61     private static final int CHOOSE_PIC = 0;
 62     private TextView btn_shine;
 63     private boolean isopen;
 64 
 65     /**
 66      * Called when the activity is first created.
 67      */
 68     @Override
 69     public void onCreate(Bundle savedInstanceState) {
 70         super.onCreate(savedInstanceState);
 71         setContentView(R.layout.camera);
 72         //ViewUtil.addTopView(getApplicationContext(), this, R.string.scan_card);
 73         CameraManager.init(getApplication());
 74         initview();
 75         viewfinderView = (ViewfinderView) findViewById(R.id.viewfinder_view);
 76         hasSurface = false;
 77         inactivityTimer = new InactivityTimer(this);
 78     }
 79 
 80     private void initview() {
 81         result_back = (ImageView) findViewById(R.id.result_back);
 82         btn_scan = (Button) findViewById(R.id.btn_scan);
 83         btn_phone = (Button) findViewById(R.id.btn_phone);
 84         btn_shine = (TextView)findViewById(R.id.btn_shine);
 85         result_back.setOnClickListener(this);
 86         btn_scan.setOnClickListener(this);
 87         btn_phone.setOnClickListener(this);
 88         btn_shine.setOnClickListener(this);
 89     }
 90 
 91     @Override
 92     protected void onResume() {
 93         super.onResume();
 94         SurfaceView surfaceView = (SurfaceView) findViewById(R.id.preview_view);
 95         SurfaceHolder surfaceHolder = surfaceView.getHolder();
 96         if (hasSurface) {
 97             initCamera(surfaceHolder);
 98         } else {
 99             surfaceHolder.addCallback(this);
100             surfaceHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
101         }
102         decodeFormats = null;
103         characterSet = null;
104 
105         playBeep = true;
106         AudioManager audioService = (AudioManager) getSystemService(AUDIO_SERVICE);
107         if (audioService.getRingerMode() != AudioManager.RINGER_MODE_NORMAL) {
108             playBeep = false;
109         }
110         initBeepSound();
111         vibrate = true;
112 
113     }
114 
115     @Override
116     protected void onPause() {
117         super.onPause();
118         if (handler != null) {
119             handler.quitSynchronously();
120             handler = null;
121         }
122         CameraManager.get().closeDriver();
123     }
124 
125     @Override
126     protected void onDestroy() {
127         inactivityTimer.shutdown();
128         super.onDestroy();
129     }
130 
131     /**
132      * Handler scan result
133      * @param result
134      * @param barcode
135      */
136     public void handleDecode(Result result, Bitmap barcode) {
137         inactivityTimer.onActivity();
138         playBeepSoundAndVibrate();
139         String resultString = result.getText();
140         //FIXME
141         if (resultString.equals("")) {
142             Toast.makeText(CaptureActivity.this, "扫描失败！", Toast.LENGTH_SHORT).show();
143         } else {
144             Intent intent = new Intent(CaptureActivity.this, ScanResultActivity.class);
145             intent.putExtra("result", resultString);
146             IntentUtils.enterIntent(CaptureActivity.this, intent);
147         }
148 //        CaptureActivity.this.finish();
149     }
150 
151     private void initCamera(SurfaceHolder surfaceHolder) {
152         try {
153             CameraManager.get().openDriver(surfaceHolder);
154         } catch (IOException ioe) {
155             return;
156         } catch (RuntimeException e) {
157             return;
158         }
159         if (handler == null) {
160             handler = new CaptureActivityHandler(this, decodeFormats,
161                     characterSet);
162         }
163     }
164 
165     @Override
166     public void surfaceChanged(SurfaceHolder holder, int format, int width,
167                                int height) {
168 
169     }
170 
171     @Override
172     public void surfaceCreated(SurfaceHolder holder) {
173         if (!hasSurface) {
174             hasSurface = true;
175             initCamera(holder);
176         }
177     }
178 
179     @Override
180     public void surfaceDestroyed(SurfaceHolder holder) {
181         hasSurface = false;
182     }
183 
184     public ViewfinderView getViewfinderView() {
185         return viewfinderView;
186     }
187 
188     public Handler getHandler() {
189         return handler;
190     }
191 
192     public void drawViewfinder() {
193         viewfinderView.drawViewfinder();
194     }
195 
196     private void initBeepSound() {
197         if (playBeep && mediaPlayer == null) {
198             // The volume on STREAM_SYSTEM is not adjustable, and users found it
199             // too loud,
200             // so we now play on the music stream.
201             setVolumeControlStream(AudioManager.STREAM_MUSIC);
202             mediaPlayer = new MediaPlayer();
203             mediaPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC);
204             mediaPlayer.setOnCompletionListener(beepListener);
205 
206             AssetFileDescriptor file = getResources().openRawResourceFd(
207                     R.raw.beep);
208             try {
209                 mediaPlayer.setDataSource(file.getFileDescriptor(),
210                         file.getStartOffset(), file.getLength());
211                 file.close();
212                 mediaPlayer.setVolume(BEEP_VOLUME, BEEP_VOLUME);
213                 mediaPlayer.prepare();
214             } catch (IOException e) {
215                 mediaPlayer = null;
216             }
217         }
218     }
219 
220     private static final long VIBRATE_DURATION = 200L;
221 
222     private void playBeepSoundAndVibrate() {
223         if (playBeep && mediaPlayer != null) {
224             mediaPlayer.start();
225         }
226         if (vibrate) {
227             Vibrator vibrator = (Vibrator) getSystemService(VIBRATOR_SERVICE);
228             vibrator.vibrate(VIBRATE_DURATION);
229         }
230     }
231 
232     /**
233      * When the beep has finished playing, rewind to queue up another one.
234      */
235     private final MediaPlayer.OnCompletionListener beepListener = new MediaPlayer.OnCompletionListener() {
236         public void onCompletion(MediaPlayer mediaPlayer) {
237             mediaPlayer.seekTo(0);
238         }
239     };
240 
241     @Override
242     public void onClick(View v) {
243         switch (v.getId()) {
244             case R.id.btn_scan: {
245                 btn_scan.setBackgroundResource(R.drawable.blueroll);
246                 btn_phone.setBackgroundResource(R.drawable.tranroll);
247                 break;
248             }
249             case R.id.btn_phone: {
250                 btn_phone.setBackgroundResource(R.drawable.blueroll);
251                 btn_scan.setBackgroundResource(R.drawable.tranroll);
252                 //跳转到图片选择界面去选择一张二维码图片
253                 Intent intent1 = new Intent();
254                 intent1.setAction(Intent.ACTION_PICK);
255 
256                 intent1.setType("image/*");
257 
258                 Intent intent2 = Intent.createChooser(intent1, "选择二维码图片");
259                 startActivityForResult(intent2, CHOOSE_PIC);
260                 break;
261             }
262             case R.id.result_back: {
263                 overridePendingTransition(R.anim.in_from_left, R.anim.out_to_right);
264                 finish();
265                 break;
266             }
267             case R.id.btn_shine:{
268                 if (isopen){
269                     btn_shine.setTextColor(Color.WHITE);
270                     btn_shine.setBackgroundResource(R.drawable.white);
271                 }else {
272                     btn_shine.setTextColor(Color.parseColor("#038cf7"));
273                     btn_shine.setBackgroundResource(R.drawable.blue);
274                 }
275                 isopen=!isopen;
276                 //控制开启和关闭闪光灯
277                 CameraManager.get().flashHandler();
278             }
279             default: {
280                 break;
281             }
282         }
283     }
284 
285     @Override
286     protected void onActivityResult(int requestCode, int resultCode, Intent data) {
287         super.onActivityResult(requestCode, resultCode, data);
288         String imgPath = null;
289         if (resultCode == RESULT_OK) {
290             switch (requestCode) {
291                 case CHOOSE_PIC:
292                     try {
293                         String[] proj = new String[]{MediaStore.Images.Media.DATA};
294                         Cursor cursor = CaptureActivity.this.getContentResolver().query(data.getData(), proj, null, null, null);
295 
296                         if (cursor.moveToFirst()) {
297                             int columnIndex = cursor.getColumnIndex(MediaStore.Images.Media.DATA);
298                             System.out.println(columnIndex);
299                             //获取到用户选择的二维码图片的绝对路径
300                             imgPath = cursor.getString(columnIndex);
301                         }
302                         cursor.close();
303                         //获取解析结果
304                         final String finalImgPath = imgPath;
305                         new Thread(new Runnable() {
306                             @Override
307                             public void run() {
308                                 Result ret = parseQRcodeBitmap(finalImgPath);
309                                 Intent intent = new Intent(CaptureActivity.this, ScanResultActivity.class);
310                                 intent.putExtra("result", ret.toString());
311                                 IntentUtils.enterIntent(CaptureActivity.this, intent);
312                             }
313                         }).start();
314 
315                     } catch (Exception e) {
316                         Toast.makeText(CaptureActivity.this,  "扫描失败", Toast.LENGTH_LONG).show();
317                     }
318 
319                     break;
320             }
321         }
322     }
323     //解析二维码图片,返回结果封装在Result对象中
324     private com.google.zxing.Result  parseQRcodeBitmap(String bitmapPath){
325         //解析转换类型UTF-8
326         Hashtable<DecodeHintType, String> hints = new Hashtable<DecodeHintType, String>();
327         hints.put(DecodeHintType.CHARACTER_SET, "utf-8");
328         //获取到待解析的图片
329         BitmapFactory.Options options = new BitmapFactory.Options();
330         //如果我们把inJustDecodeBounds设为true，那么BitmapFactory.decodeFile(String path, Options opt)
331         //并不会真的返回一个Bitmap给你，它仅仅会把它的宽，高取回来给你
332         options.inJustDecodeBounds = true;
333         //此时的bitmap是null，这段代码之后，options.outWidth 和 options.outHeight就是我们想要的宽和高了
334         Bitmap bitmap = BitmapFactory.decodeFile(bitmapPath,options);
335         //我们现在想取出来的图片的边长（二维码图片是正方形的）设置为400像素
336         /**
337          options.outHeight = 400;
338          options.outWidth = 400;
339          options.inJustDecodeBounds = false;
340          bitmap = BitmapFactory.decodeFile(bitmapPath, options);
341          */
342         //以上这种做法，虽然把bitmap限定到了我们要的大小，但是并没有节约内存，如果要节约内存，我们还需要使用inSimpleSize这个属性
343         options.inSampleSize = options.outHeight / 400;
344         if(options.inSampleSize <= 0){
345             options.inSampleSize = 1; //防止其值小于或等于0
346         }
347         /**
348          * 辅助节约内存设置
349          *
350          * options.inPreferredConfig = Bitmap.Config.ARGB_4444;    // 默认是Bitmap.Config.ARGB_8888
351          * options.inPurgeable = true;
352          * options.inInputShareable = true;
353          */
354         options.inJustDecodeBounds = false;
355         bitmap = BitmapFactory.decodeFile(bitmapPath, options);
356         //新建一个RGBLuminanceSource对象，将bitmap图片传给此对象
357         RGBLuminanceSource rgbLuminanceSource = new RGBLuminanceSource(bitmap);
358         //将图片转换成二进制图片
359         BinaryBitmap binaryBitmap = new BinaryBitmap(new HybridBinarizer(rgbLuminanceSource));
360         //初始化解析对象
361         QRCodeReader reader = new QRCodeReader();
362         //开始解析
363         Result result = null;
364         try {
365             result = reader.decode(binaryBitmap, hints);
366         } catch (Exception e) {
367             // TODO: handle exception
368         }
369 
370         return result;
371     }
372 
373     @Override
374     public boolean onKeyDown(int keyCode, KeyEvent event) {
375         if (keyCode == KeyEvent.KEYCODE_BACK) {
376             overridePendingTransition(R.anim.in_from_left, R.anim.out_to_right);
377             finish();
378             return false;
379         } else {
380             return super.onKeyDown(keyCode, event);
381         }
382     }
383 }

  1 package com.wangy.mycode;
  2 
  3 import android.content.Intent;
  4 import android.os.Bundle;
  5 import android.view.Gravity;
  6 import android.view.KeyEvent;
  7 import android.view.View;
  8 import android.webkit.WebChromeClient;
  9 import android.webkit.WebSettings;
 10 import android.webkit.WebView;
 11 import android.webkit.WebViewClient;
 12 import android.widget.ImageView;
 13 import android.widget.LinearLayout;
 14 import android.widget.TextView;
 15 import android.widget.Toast;
 16 
 17 import com.wangy.mycode.Base.BaseActivity;
 18 import com.wangy.mycode.Zxing.CaptureActivity;
 19 
 20 /**
 21  * Created by xhb on 2016/12/28.
 22  */
 23 public class ScanResultActivity extends BaseActivity {
 24 
 25     private ImageView result_back;
 26     private TextView scanresult_word;
 27     private WebView scanresult_webview;
 28     private String result;
 29     private LinearLayout ll_result_word;
 30 
 31     @Override
 32     protected void onCreate(Bundle savedInstanceState) {
 33         super.onCreate(savedInstanceState);
 34         setContentView(R.layout.scanresultlayout);
 35         Intent intent = getIntent();
 36         if (intent != null) {
 37             result = intent.getStringExtra("result");
 38         }
 39         initView();
 40     }
 41 
 42     private void initView() {
 43         result_back = (ImageView) findViewById(R.id.result_back);
 44         result_back.setOnClickListener(new View.OnClickListener() {
 45             @Override
 46             public void onClick(View v) {
 47 //                startActivity(new Intent(ScanResultActivity.this,CaptureActivity.class));
 48 //                overridePendingTransition(R.anim.in_from_left, R.anim.out_to_right);
 49                 finish();
 50             }
 51         });
 52         ll_result_word = (LinearLayout)findViewById(R.id.ll_result_word);
 53         scanresult_word = (TextView) findViewById(R.id.scanresult_word);
 54         scanresult_webview = (WebView) findViewById(R.id.scanresult_webview);
 55         if ((result.contains("http://") || result.contains("https://"))) {
 56             scanresult_webview.setVisibility(View.VISIBLE);
 57             ll_result_word.setVisibility(View.GONE);
 58             setScanresult_webview();
 59         }else {
 60             scanresult_webview.setVisibility(View.GONE);
 61             ll_result_word.setVisibility(View.VISIBLE);
 62             scanresult_word.setText(result);
 63         }
 64 
 65     }
 66 private void setScanresult_webview(){
 67     if ((result.contains("http://") || result.contains("https://"))) {
 68         //加载需要显示的网页
 69         scanresult_webview.loadUrl(result);
 70     }
 71 
 72     //覆盖WebView默认使用第三方或系统默认浏览器打开网页的行为，使网页用WebView打开
 73     scanresult_webview.setWebViewClient(new WebViewClient() {
 74         @Override
 75         public boolean shouldOverrideUrlLoading(WebView view, String url) {
 76             // TODO Auto-generated method stub
 77             //返回值是true的时候控制去WebView打开，为false调用系统浏览器或第三方浏览器
 78             view.loadUrl(url);
 79             return true;
 80         }
 81     });
 82     WebSettings webSettings = scanresult_webview.getSettings();
 83     //设置可以访问文件
 84     webSettings.setAllowFileAccess(true);
 85     webSettings.setJavaScriptEnabled(true);//支持js
 86     webSettings.setJavaScriptCanOpenWindowsAutomatically(true);
 87     webSettings.setDomStorageEnabled(true);
 88     //设置支持缩放
 89     webSettings.setBuiltInZoomControls(true);
 90    // 优先使用缓存
 91     scanresult_webview.getSettings().setCacheMode(WebSettings.LOAD_CACHE_ELSE_NETWORK);
 92     scanresult_webview.setWebChromeClient(new WebChromeClient() {
 93         @Override
 94         public void onProgressChanged(WebView view, int newProgress) {
 95             // TODO Auto-generated method stub
 96             if (newProgress == 100) {
 97                 // 网页加载完成
 98                 showCustomToast("网页加载完成");
 99             } else {
100                 // 加载中
101 //                showCustomToast("网页加载中...");
102             }
103 
104         }
105     });
106 //    scanresult_webview.setDownloadListener(new DownloadListener() {
107 //        @Override
108 //        public void onDownloadStart(String s, String s1, String s2, String s3, long l) {
109 //            String html = "<a href=‘" + s + "‘>" + s + "</a>";
110 //            scanresult_webview.loadData(html, "text/html", "UTF-8");
111 //        }
112 //    });
113 
114 
115 }
116     //弹出警告框
117     public void showCustomToast(String text) {
118         Toast toast = Toast.makeText(ScanResultActivity.this,
119                 text, Toast.LENGTH_SHORT);
120         toast.setGravity(Gravity.CENTER, 20, 20);
121         LinearLayout toastView = (LinearLayout) toast.getView();
122         ImageView imageCodeProject = new ImageView(ScanResultActivity.this);
123         imageCodeProject.setImageResource(R.drawable.ico_warning);
124         toastView.addView(imageCodeProject, 0);
125         toastView.setPadding(100, 85, 100, 85);
126         toast.show();
127     }
128 
129 //    返回上一次浏览的页面
130 
131     //改写物理按键——返回的逻辑
132     @Override
133     public boolean onKeyDown(int keyCode, KeyEvent event) {
134         // TODO Auto-generated method stub
135         if(keyCode==KeyEvent.KEYCODE_BACK)
136         {
137             if(scanresult_webview.canGoBack())
138             {
139                 scanresult_webview.goBack();//返回上一页面
140                 return true;
141             }
142             else
143             {
144 //                startActivity(new Intent(ScanResultActivity.this,CaptureActivity.class));
145 //                overridePendingTransition(R.anim.in_from_left, R.anim.out_to_right);
146                 finish();
147                 return false;
148             }
149         }
150         return super.onKeyDown(keyCode, event);
151     }
152 }

 1 <?xml version="1.0" encoding="utf-8"?>
 2 <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
 3     android:layout_width="match_parent"
 4     android:layout_height="match_parent"
 5     android:orientation="vertical">
 6     <RelativeLayout
 7         android:layout_width="match_parent"
 8         android:layout_height="wrap_content"
 9         android:minHeight="50dp"
10         android:background="#038cf7"
11         >
12         <TextView
13             android:layout_width="wrap_content"
14             android:layout_height="wrap_content"
15             android:layout_centerInParent="true"
16             android:text="二维码扫描结果"
17             android:textSize="18sp"
18             android:textColor="#fff"
19             />
20         <ImageView
21             android:id="@+id/result_back"
22             android:layout_width="wrap_content"
23             android:layout_height="wrap_content"
24             android:src="@drawable/icon_back"
25             android:layout_margin="10dp"
26             android:layout_centerVertical="true"
27             android:layout_alignParentLeft="true"
28             />
29     </RelativeLayout>
30     <LinearLayout
31         android:id="@+id/ll_result_word"
32         android:layout_width="match_parent"
33         android:orientation="vertical"
34         android:visibility="gone"
35         android:layout_height="wrap_content">
36    <TextView
37        android:layout_width="match_parent"
38        android:layout_height="wrap_content"
39       android:layout_marginTop="30dp"
40        android:textColor="#e78727"
41        android:text="以下内容非本app提供，请谨慎使用"
42        android:gravity="center"
43        />
44     <TextView
45         android:layout_width="match_parent"
46         android:layout_height="wrap_content"
47         android:layout_marginTop="5dp"
48         android:text="如需使用请复制"
49         android:textColor="#e78727"
50         android:gravity="center"
51         />
52 
53     <TextView
54         android:id="@+id/scanresult_word"
55         android:layout_width="wrap_content"
56         android:layout_height="wrap_content"
57         android:minWidth="300dp"
58         android:minHeight="100dp"
59         android:background="@drawable/yellow"
60         android:layout_marginTop="50dp"
61         android:layout_gravity="center_horizontal"
62         android:text="如需使用请复制"
63         android:textColor="#f5262121"
64         android:textStyle="normal"
65         android:gravity="center"
66         />
67     </LinearLayout>
68 
69     <WebView
70         android:id="@+id/scanresult_webview"
71         android:layout_width="match_parent"
72         android:visibility="gone"
73         android:layout_height="match_parent">
74 
75     </WebView>
76 </LinearLayout>