public void onPreviewFrame(byte[] data, Camera camera) {

     Point cameraResolution = configManager.getCameraResolution();

     if (!useOneShotPreviewCallback) {

       camera.setPreviewCallback(null);

     }

     if (previewHandler != null) {

         //从这里传递 message 参数  ,创建Message对象,其Handler.obtainMessage可以调用Message.obtain来创建消息。

       Message message = previewHandler.obtainMessage(previewMessage, cameraResolution.x,

 9           cameraResolution.y, data);

       //Sends this Message to the Handler specified by getTarget().

       //Throws a null pointer exception if this field has not been set.

       //who use the getTarget() function?

       //通过Message.sendToTarget向消息队列插入消息；

       message.sendToTarget();

       previewHandler = null;

     } else {

       Log.d(TAG, "Got preview callback, but no handler for it");

     }

   }

 private void decode(byte[] data, int width, int height) {

         .........

          Message message = Message.obtain(activity.getHandler(), R.id.decode_succeeded, rawResult);

         .........

 }

 if (attempt == 1) { // trying again?

           row.reverse(); // reverse the row and continue

           // This means we will only ever draw result points *once* in the life of this method

           // since we want to avoid drawing the wrong points after flipping the row, and,

           // don't want to clutter with noise from every single row scan -- just the scans

           // that start on the center line.

           if (hints != null && hints.containsKey(DecodeHintType.NEED_RESULT_POINT_CALLBACK)) {

             Map<DecodeHintType,Object> newHints = new EnumMap<DecodeHintType,Object>(DecodeHintType.class);

             newHints.putAll(hints);

             newHints.remove(DecodeHintType.NEED_RESULT_POINT_CALLBACK);

             hints = newHints;

           }

         }

 public BitArray getBlackRow(int y, BitArray row) throws NotFoundException {

     LuminanceSource source = getLuminanceSource();

     int width = source.getWidth();

     if (row == null || row.getSize() < width) {

       row = new BitArray(width);

     } else {

       row.clear();

     }

     initArrays(width);

     //在这里 luminances  被赋值

     //y=180;

     byte[] localLuminances = source.getRow(y, luminances);

     //统计并建立直方图

     int[] localBuckets = buckets;

     /*---------modify here ,just for analysis .--------------------*/

     int i_row[] = new int [width];

     for(int x=0;x<width;x++){

         i_row[x]=localLuminances[x] & 0xff;

     }

     /*-------------------------------------------------------------*/

     for (int x = 0; x < width; x++) {

       int pixel = localLuminances[x] & 0xff;

       localBuckets[pixel >> LUMINANCE_SHIFT]++;

     }

     //According to the histogram, find the threshold.

     int blackPoint = estimateBlackPoint(localBuckets);

     //Based on threshold ,set 1 bit.  21.1.2014

     int left = localLuminances[0] & 0xff;

     int center = localLuminances[1] & 0xff;

     for (int x = 1; x < width - 1; x++) {

       int right = localLuminances[x + 1] & 0xff;

       // A simple -1 4 -1 box filter with a weight of 2.

       int luminance = ((center << 2) - left - right) >> 1;

       if (luminance < blackPoint) {

         row.set(x);

       }

       left = center;

       center = right;

     }

     return row;

   }

  private static int estimateBlackPoint(int[] buckets) throws NotFoundException {

     // Find the tallest peak in the histogram.

     int numBuckets = buckets.length;

     int maxBucketCount = 0;

     int firstPeak = 0;

     int firstPeakSize = 0;

     //找到  数组中最多像素点的个数(maxBucketCount)  和  对应的 序号,序号其实就是亮度值(区间)firstPeak.

     //这里的 firstPeak 即可能是  黑色的区间,也可能是白色的区间.

     for (int x = 0; x < numBuckets; x++) {

       if (buckets[x] > firstPeakSize) {

         firstPeak = x;

         firstPeakSize = buckets[x];

       }

       if (buckets[x] > maxBucketCount) {

         maxBucketCount = buckets[x];

       }

     }

     // Find the second-tallest peak which is somewhat far from the tallest peak.

     int secondPeak = 0;

     int secondPeakScore = 0;

     for (int x = 0; x < numBuckets; x++) {

       int distanceToBiggest = x - firstPeak;

       // Encourage more distant second peaks by multiplying by square of distance.

       int score = buckets[x] * distanceToBiggest * distanceToBiggest;

       if (score > secondPeakScore) {

         secondPeak = x;

         secondPeakScore = score;

       }

     }

     // Make sure firstPeak corresponds to the black peak.

     if (firstPeak > secondPeak) {

       int temp = firstPeak;

       firstPeak = secondPeak;

       secondPeak = temp;

     }

     // If there is too little contrast in the image to pick a meaningful black point, throw rather

     // than waste time trying to decode the image, and risk false positives.

     if (secondPeak - firstPeak <= numBuckets >> 4) {

       throw NotFoundException.getNotFoundInstance();

     }

     // Find a valley between them that is low and closer to the white peak.

     int bestValley = secondPeak - 1;

     int bestValleyScore = -1;

     for (int x = secondPeak - 1; x > firstPeak; x--) {

       int fromFirst = x - firstPeak;

       //这里找 到两个峰比较远,同时又点少的区间.这里  fromFist 采用平方的形式,可以理解更接近于白色.

       int score = fromFirst * fromFirst * (secondPeak - x) * (maxBucketCount - buckets[x]);

       if (score > bestValleyScore) {

         bestValley = x;

         bestValleyScore = score;

       }

     }

     return bestValley << LUMINANCE_SHIFT;

   }