import com.google.zxing.camera.CameraManager; //导入依赖的package包/类
CaptureActivityHandler(CaptureActivity activity,
                       Collection<BarcodeFormat> decodeFormats,
                       Map<DecodeHintType,?> baseHints,
                       String characterSet,
                       CameraManager cameraManager) {
  this.activity = activity;
  decodeThread = new DecodeThread(activity, decodeFormats, baseHints, characterSet,
          new ViewfinderResultPointCallback(activity.getViewfinderView()));
  decodeThread.start();
  state = State.SUCCESS;

  // Start ourselves capturing previews and decoding.
  this.cameraManager = cameraManager;
  cameraManager.startPreview();
  restartPreviewAndDecode();
}
 

import com.google.zxing.camera.CameraManager; //导入依赖的package包/类
public CaptureActivityHandler(DefaultCaptureActivity activity,
                              Collection<BarcodeFormat> decodeFormats,
                              Map<DecodeHintType, ?> baseHints, String characterSet,
                              CameraManager cameraManager) {
    this.activity = activity;
    decodeThread = new DecodeThread(activity, decodeFormats, baseHints,
            characterSet, null);
    decodeThread.start();
    state = State.SUCCESS;

    // Start ourselves capturing previews and decoding.
    // 开始拍摄预览和解码
    this.cameraManager = cameraManager;
    cameraManager.startPreview();
    restartPreviewAndDecode();
}
 

import com.google.zxing.camera.CameraManager; //导入依赖的package包/类
@Override
protected void onResume() {
    super.onResume();

    // CameraManager必须在这里初始化，而不是在onCreate()中。
    // 这是必须的，因为当我们第一次进入时需要显示帮助页，我们并不想打开Camera,测量屏幕大小
    // 当扫描框的尺寸不正确时会出现bug
    cameraManager = new CameraManager(getApplication());

    handler = null;

    SurfaceHolder surfaceHolder = surfaceView.getHolder();
    if (hasSurface) {
        // activity在paused时但不会stopped,因此surface仍旧存在；
        // surfaceCreated()不会调用，因此在这里初始化camera
        initCamera(surfaceHolder);
    } else {
        // 重置callback，等待surfaceCreated()来初始化camera
        surfaceHolder.addCallback(this);
    }

    decodeFormats = null;
    characterSet = null;
}
 

import com.google.zxing.camera.CameraManager; //导入依赖的package包/类
@Override
public void onCreate(Bundle savedInstanceState)
{
    super.onCreate(savedInstanceState);
    requestWindowFeature(Window.FEATURE_NO_TITLE);
    setContentView(R.layout.activity_capture);
    isOpen = false;
    prompt1 = (TextView) findViewById(R.id.prompt1);
    prompt2 = (TextView) findViewById(R.id.prompt2);
    photo = (Button) findViewById(R.id.photo);
    flash = (Button) findViewById(R.id.flash);
    myqrcode = (Button) findViewById(R.id.myqrcode);
    photo.setOnClickListener(this);
    flash.setOnClickListener(this);
    myqrcode.setOnClickListener(this);
    resetTextView();
    CameraManager.init(getApplication());
    initControl();

    hasSurface = false;
    inactivityTimer = new InactivityTimer(this);
}
 

import com.google.zxing.camera.CameraManager; //导入依赖的package包/类
void start(CameraManager cameraManager) {
  this.cameraManager = cameraManager;
  SharedPreferences sharedPrefs = PreferenceManager.getDefaultSharedPreferences(context);
  if (FrontLightMode.readPref(sharedPrefs) == FrontLightMode.AUTO) {
    SensorManager sensorManager = (SensorManager) context.getSystemService(Context.SENSOR_SERVICE);
    lightSensor = sensorManager.getDefaultSensor(Sensor.TYPE_LIGHT);
    if (lightSensor != null) {
      sensorManager.registerListener(this, lightSensor, SensorManager.SENSOR_DELAY_NORMAL);
    }
  }
}
 

import com.google.zxing.camera.CameraManager; //导入依赖的package包/类
public CaptureActivityHandler(CaptureActivity activity, CameraManager cameraManager, int decodeMode) {
	this.activity = activity;
	decodeThread = new DecodeThread(activity, decodeMode);
	decodeThread.start();
	state = State.SUCCESS;

	// Start ourselves capturing previews and decoding.
	this.cameraManager = cameraManager;
	cameraManager.startPreview();
	restartPreviewAndDecode();
}
 

import com.google.zxing.camera.CameraManager; //导入依赖的package包/类
@Override
protected void onResume() {
	super.onResume();

	// CameraManager must be initialized here, not in onCreate(). This is
	// necessary because we don't
	// want to open the camera driver and measure the screen size if we're
	// going to show the help on
	// first launch. That led to bugs where the scanning rectangle was the
	// wrong size and partially
	// off screen.
	cameraManager = new CameraManager(getApplication());

	handler = null;

	if (isHasSurface) {
		// The activity was paused but not stopped, so the surface still
		// exists. Therefore
		// surfaceCreated() won't be called, so init the camera here.
		initCamera(scanPreview.getHolder());
	} else {
		// Install the callback and wait for surfaceCreated() to init the
		// camera.
		scanPreview.getHolder().addCallback(this);
	}

	inactivityTimer.onResume();
}
 

import com.google.zxing.camera.CameraManager; //导入依赖的package包/类
@Override
protected void onPause()
{
    super.onPause();
    if (handler != null)
    {
        handler.quitSynchronously();
        handler = null;
    }
    CameraManager.get().closeDriver();
}
 

import com.google.zxing.camera.CameraManager; //导入依赖的package包/类
public CaptureActivityHandler(CaptureActivity activity, Vector<BarcodeFormat> decodeFormats,
        String characterSet) {
    this.activity = activity;
    decodeThread = new DecodeThread(activity, decodeFormats, characterSet,
            new ViewfinderResultPointCallback(activity.getViewfinderView()));
    decodeThread.start();
    state = State.SUCCESS;
    // Start ourselves capturing previews and decoding.
    CameraManager.get().startPreview();
    restartPreviewAndDecode();
}
 

import com.google.zxing.camera.CameraManager; //导入依赖的package包/类
public void quitSynchronously() {
    state = State.DONE;
    CameraManager.get().stopPreview();
    Message quit = Message.obtain(decodeThread.getHandler(), R.id.quit);
    quit.sendToTarget();
    try {
        decodeThread.join();
    } catch (InterruptedException e) {
        // continue
    }

    // Be absolutely sure we don't send any queued up messages
    removeMessages(R.id.decode_succeeded);
    removeMessages(R.id.decode_failed);
}
 

import com.google.zxing.camera.CameraManager; //导入依赖的package包/类
private void restartPreviewAndDecode() {
    if (state == State.SUCCESS) {
        state = State.PREVIEW;
        CameraManager.get().requestPreviewFrame(decodeThread.getHandler(), R.id.decode);
        CameraManager.get().requestAutoFocus(this, R.id.auto_focus);
        activity.drawViewfinder();
    }
}
 

import com.google.zxing.camera.CameraManager; //导入依赖的package包/类
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    requestWindowFeature(Window.FEATURE_NO_TITLE);
    setContentView(R.layout.qr_code_scan);

    CameraManager.init(getApplication());
    initControl();

    hasSurface = false;
    inactivityTimer = new InactivityTimer(this);
}
 

import com.google.zxing.camera.CameraManager; //导入依赖的package包/类
@Override
protected void onPause() {
    super.onPause();
    if (handler != null) {
        handler.quitSynchronously();
        handler = null;
    }
    CameraManager.get().closeDriver();
}
 

import com.google.zxing.camera.CameraManager; //导入依赖的package包/类
CameraManager getCameraManager() {
    return cameraManager;
}
 

import com.google.zxing.camera.CameraManager; //导入依赖的package包/类
@Override
protected void onResume() {
    super.onResume();

    // historyManager must be initialized here to update the history preference

    // CameraManager must be initialized here, not in onCreate(). This is necessary because
    // we don't
    // want to open the camera driver and measure the screen size if we're going to show the
    // help on
    // first launch. That led to bugs where the scanning rectangle was the wrong size and
    // partially
    // off screen.
    cameraManager = new CameraManager(getApplication());

    viewfinderView = (ViewfinderView) findViewById(R.id.viewfinder_view);
    viewfinderView.setCameraManager(cameraManager);

    handler = null;

    setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_SENSOR_PORTRAIT);

    beepManager.updatePrefs();
    ambientLightManager.start(cameraManager);

    inactivityTimer.onResume();

    decodeFormats = EnumSet.noneOf(BarcodeFormat.class);
    decodeFormats.addAll(DecodeFormatManager.QR_CODE_FORMATS);
    decodeFormats.addAll(DecodeFormatManager.ONE_D_FORMATS);
    characterSet = null;

    SurfaceView surfaceView = (SurfaceView) findViewById(R.id.preview_view);
    SurfaceHolder surfaceHolder = surfaceView.getHolder();
    if (hasSurface) {
        // The activity was paused but not stopped, so the surface still exists. Therefore
        // surfaceCreated() won't be called, so init the camera here.
        initCamera(surfaceHolder);
    } else {
        // Install the callback and wait for surfaceCreated() to init the camera.
        surfaceHolder.addCallback(this);
    }
}
 

import com.google.zxing.camera.CameraManager; //导入依赖的package包/类
public void setCameraManager(CameraManager cameraManager) {
    this.cameraManager = cameraManager;
}
 

import com.google.zxing.camera.CameraManager; //导入依赖的package包/类
public CameraManager getCameraManager() {
	return cameraManager;
}
 

import com.google.zxing.camera.CameraManager; //导入依赖的package包/类
public CameraManager getCameraManager() {
    return cameraManager;
}
 

import com.google.zxing.camera.CameraManager; //导入依赖的package包/类
@Override
public void handleMessage(Message message) {
    switch (message.what) {
        case R.id.auto_focus:
            // Log.d(TAG, "Got auto-focus message");
            // When one auto focus pass finishes, start another. This is the
            // closest thing to
            // continuous AF. It does seem to hunt a bit, but I'm not sure
            // what else to do.
            if (state == State.PREVIEW) {
                CameraManager.get().requestAutoFocus(this, R.id.auto_focus);
            }
            break;
        case R.id.restart_preview:
            Log.d(TAG, "Got restart preview message");
            restartPreviewAndDecode();
            break;
        case R.id.decode_succeeded:
            Log.d(TAG, "Got decode succeeded message");
            state = State.SUCCESS;
            Bundle bundle = message.getData();

            /***********************************************************************/
            Bitmap barcode = bundle == null ? null :
                    (Bitmap) bundle.getParcelable(DecodeThread.BARCODE_BITMAP);

            activity.handleDecode((Result) message.obj, barcode);
            /***********************************************************************/
            break;
        case R.id.decode_failed:
            // We're decoding as fast as possible, so when one decode fails,
            // start another.
            state = State.PREVIEW;
            CameraManager.get().requestPreviewFrame(decodeThread.getHandler(), R.id.decode);
            break;
        case R.id.return_scan_result:
            Log.d(TAG, "Got return scan result message");
            activity.setResult(Activity.RESULT_OK, (Intent) message.obj);
            activity.finish();
            break;
        case R.id.launch_product_query:
            Log.d(TAG, "Got product query message");
            String url = (String) message.obj;
            Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse(url));
            intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET);
            activity.startActivity(intent);
            break;
    }
}
 

import com.google.zxing.camera.CameraManager; //导入依赖的package包/类
@Override
public void handleMessage(Message message) {
    switch (message.what) {
        case R.id.auto_focus:
            // Log.d(TAG, "Got auto-focus message");
            // When one auto focus pass finishes, start another. This is the
            // closest thing to
            // continuous AF. It does seem to hunt a bit, but I'm not sure
            // what else to do.
            if (state == State.PREVIEW) {
                CameraManager.get().requestAutoFocus(this, R.id.auto_focus);
            }
            break;
        case R.id.restart_preview:
            Log.d(TAG, "Got restart preview message");
            restartPreviewAndDecode();
            break;
        case R.id.decode_succeeded:
            Log.d(TAG, "Got decode succeeded message");
            state = State.SUCCESS;
            Bundle bundle = message.getData();

            /***********************************************************************/
            Bitmap barcode = bundle == null ? null :
                    (Bitmap) bundle.getParcelable(DecodeThread.BARCODE_BITMAP);// ���ñ����߳�

            activity.handleDecode((Result) message.obj, barcode);// ���ؽ��
            /***********************************************************************/
            break;
        case R.id.decode_failed:
            // We're decoding as fast as possible, so when one decode fails,
            // start another.
            state = State.PREVIEW;
            CameraManager.get().requestPreviewFrame(decodeThread.getHandler(), R.id.decode);
            break;
        case R.id.return_scan_result:
            Log.d(TAG, "Got return scan result message");
            activity.setResult(Activity.RESULT_OK, (Intent) message.obj);
            activity.finish();
            break;
        case R.id.launch_product_query:
            Log.d(TAG, "Got product query message");
            String url = (String) message.obj;
            Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse(url));
            intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET);
            activity.startActivity(intent);
            break;
    }
}