在android中实现tuch对焦摄像头

我想实现触摸来聚焦我的定制相机这里是我的定制相机代码。我知道android api 14级支持的重点和它的硬件依赖性，所以任何人都知道如何实现它

private SurfaceView previewSv；
私人影像按钮、照相/摄像机、galleryIb；
私人文本视图取消电视；
私有处理程序=新处理程序（）；
私人摄像机；
私有int-cameraId=0；
私有布尔cameraFlash=true；
@凌驾
创建时受保护的void（Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
setContentView（R.layout.activity_main）；
布尔值hasCameraFlash=getPackageManager（）.hasSystemFeature(
包装管理器功能（摄像头和闪光灯）；
布尔值hasFrontCam=getPackageManager（）.hasSystemFeature(
包装管理器功能（摄像头前）；
previewSv=（SurfaceView）findViewById（R.id.preview_sv）；
stillImgCamIb=（ImageButton）findViewById（R.id.still\u img\u camera\u ib）；
videoCamIb=（ImageButton）findViewById（R.id.video\u camera\u ib）；
galleryIb=（图像按钮）findViewById（R.id.gallery_ib）；
cancelTv=（TextView）findViewById（R.id.cancel\u tv）；
stillImgCamIb.setOnClickListener（this）；
videoCamIb.setOnClickListener（本）；
galleryIb.setOnClickListener（此）；
cancelTv.setOnClickListener（此）；
startCameraPreview（）；
}
@凌驾
受保护的void onStop（）{
super.onStop（）；
stopCameraPreview（）；
停止录制（）；
}
@凌驾
公共void onClick（视图v）{
开关（v.getId（））{
案例R.id.静止\图像\摄像机\ ib：
if（mode==mode.STILL\u摄像头）{
如果（预览）{
handleStillCamClick（）；
}
}else if（mode==mode.VIDEO\u-CAMERA）{
stopCameraPreview（）；
startRecording（）；
激活模式（记录模式）；
}else if（mode==mode.RECORDING）{
停止录制（）；
激活模式（视频摄像机模式）；
}否则{
激活模式（模式。静止摄像头）；
}
打破
案例R.id.视频\摄像机\ ib：
if（mode==mode.VIDEO\u摄像头）{
激活模式（模式。静止摄像头）；
}否则{
激活模式（视频摄像机模式）；
}
打破
案例R.id.gallery_ib：
//openGallery（）；
打破
案例R.id.cancel\u tv：
激活模式（视频摄像机模式）；
停止录制（）；
打破
违约：
打破
}
}
私有Uri capturedImageUri；
私有布尔预览=false；
私有void startCameraPreview（）{
如果（！预览）{
预览=正确；
摄像机=摄像机。打开（摄像机阵列）；
camera.getParameters（）.setFlashMode(
cameraFlash？参数。闪光灯模式打开
：参数。闪烁（模式关闭）；
摄像头。设置显示方向（90）；
如果（照相机！=null）{
试一试{
System.out.println（“启动相机预览！”）；
setPreviewDisplay（previewSv.getHolder（））；
camera.startPreview（）；
}捕获（IOE异常）{
e、 printStackTrace（）；
}
}
}
previewSv.getHolder（）.addCallback（新的回调（）{
@凌驾
公共空间表面覆盖（表面覆盖物持有人）{
stopCameraPreview（）；
}
@凌驾
已创建的公共空白表面（表面持有人）{
}
@凌驾
公共无效表面更改（表面文件夹持有者，整数格式，
整数宽度，整数高度）{
如果（预览）{
stopCameraPreview（）；
}
startCameraPreview（）；
}
});
}
私有void stopCameraPreview（）{
如果（相机！=空和预览（&F）{
camera.stopPreview（）；
相机。释放（）；
摄像机=零；
预览=假；
}
}
私有无效handleStillCamClick（）{
如果（照相机！=null）{
Parameters params=camera.getParameters（）；
Size defaultSize=params.getPictureSize（）；
System.out.println（“默认大小X:+defaultSize.width+”，Y:”
+（尺寸、高度）；
//在支持的大小上循环并选择一个大于640px的大小
//宽&高，仅当默认大小太小时
如果（defaultSize.width<640 | defaultSize.height<640）{
列表大小=params.getSupportedPictureSizes（）；
//int biggestH=0；
//int-biggestW=0；
int maxH=整数的最大值；
int maxW=整数的最大值；
对于（int i=0；i=1000；
布尔betterHeight=thisH=1000；
布尔值为fourthreeaspect=thisW==（4*thisH/3）；
如果（是四个方面）{
System.out.println（“支架尺寸：W”+此尺寸.width
+，H:“+此尺寸。高度）；
}否则{
System.out.println（“不是4/3，但支持大小：W”
+thisSize.width+”，H:“+thisSize.height）；
}
if（更宽和更高和更宽和更宽）{
最大值=此值；
maxW=thisW；
}
}
如果（最大值<99999&&maxW<99999）{
System.out.println（“找到最佳尺寸，W:+maxW+，H:”
+最大值）；
Toast.makeText(
这
“以分辨率拍摄：”+maxW+“x”+maxH，
Toast.LENGTH_LONG）.show（）；
参数setPictureSize（maxW，maxH）；
}埃尔斯
    private SurfaceView previewSv;
    private ImageButton stillImgCamIb, videoCamIb, galleryIb;
    private TextView cancelTv;

    private Handler handler = new Handler();

    private Camera camera;
    private int cameraId = 0;
    private boolean cameraFlash = true;

    @Override

protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    boolean hasCameraFlash = getPackageManager().hasSystemFeature(
            PackageManager.FEATURE_CAMERA_FLASH);
    boolean hasFrontCam = getPackageManager().hasSystemFeature(
            PackageManager.FEATURE_CAMERA_FRONT);

    previewSv = (SurfaceView) findViewById(R.id.preview_sv);

    stillImgCamIb = (ImageButton) findViewById(R.id.still_img_camera_ib);
    videoCamIb = (ImageButton) findViewById(R.id.video_camera_ib);
    galleryIb = (ImageButton) findViewById(R.id.gallery_ib);

    cancelTv = (TextView) findViewById(R.id.cancel_tv);

    stillImgCamIb.setOnClickListener(this);
    videoCamIb.setOnClickListener(this);
    galleryIb.setOnClickListener(this);
    cancelTv.setOnClickListener(this);

    startCameraPreview();
}

@Override
protected void onStop() {
    super.onStop();
    stopCameraPreview();
    stopRecording();
}

@Override
public void onClick(View v) {
    switch (v.getId()) {
    case R.id.still_img_camera_ib:
        if (mode == Mode.STILL_CAMERA) {
            if (previewing) {
                handleStillCamClick();
            }
        } else if (mode == Mode.VIDEO_CAMERA) {
            stopCameraPreview();
            startRecording();
            activateMode(Mode.RECORDING);
        } else if (mode == Mode.RECORDING) {
            stopRecording();
            activateMode(Mode.VIDEO_CAMERA);
        } else {
            activateMode(Mode.STILL_CAMERA);
        }
        break;
    case R.id.video_camera_ib:
        if (mode == Mode.VIDEO_CAMERA) {
            activateMode(Mode.STILL_CAMERA);
        } else {
            activateMode(Mode.VIDEO_CAMERA);
        }
        break;
    case R.id.gallery_ib:
        // openGallery();
        break;
    case R.id.cancel_tv:
        activateMode(Mode.VIDEO_CAMERA);
        stopRecording();
        break;

    default:
        break;
    }
}

private Uri capturedImageUri;
private boolean previewing = false;

private void startCameraPreview() {
    if (!previewing) {
        previewing = true;
        camera = Camera.open(cameraId);
        camera.getParameters().setFlashMode(
                cameraFlash ? Parameters.FLASH_MODE_ON
                        : Parameters.FLASH_MODE_OFF);
        camera.setDisplayOrientation(90);
        if (camera != null) {
            try {
                System.out.println("Started camera preview!");
                camera.setPreviewDisplay(previewSv.getHolder());
                camera.startPreview();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    previewSv.getHolder().addCallback(new Callback() {

        @Override
        public void surfaceDestroyed(SurfaceHolder holder) {
            stopCameraPreview();
        }

        @Override
        public void surfaceCreated(SurfaceHolder holder) {

        }

        @Override
        public void surfaceChanged(SurfaceHolder holder, int format,
                int width, int height) {
            if (previewing) {
                stopCameraPreview();
            }
            startCameraPreview();
        }
    });
}

private void stopCameraPreview() {
    if (camera != null && previewing) {
        camera.stopPreview();
        camera.release();
        camera = null;
        previewing = false;
    }
}

private void handleStillCamClick() {
    if (camera != null) {

        Parameters params = camera.getParameters();

        Size defaultSize = params.getPictureSize();
        System.out.println("Default size X:" + defaultSize.width + ", Y:"
                + defaultSize.height);

        // Loop over supported sizes and pick one that is larger than 640px
        // wide & tall, only if the default size is too small
        if (defaultSize.width < 640 || defaultSize.height < 640) {
            List<Size> sizes = params.getSupportedPictureSizes();

            // int biggestH = 0;
            // int biggestW = 0;
            int maxH = Integer.MAX_VALUE;
            int maxW = Integer.MAX_VALUE;
            for (int i = 0; i < sizes.size(); i++) {
                Size thisSize = sizes.get(i);

                int thisW = thisSize.width;
                int thisH = thisSize.height;

                boolean betterWidth = thisW < maxW && thisW >= 1000;
                boolean betterHeight = thisH < maxH && thisH >= 1000;
                boolean isFourThreeAspect = thisW == (4 * thisH / 3);

                if (isFourThreeAspect) {
                    System.out.println("Supports size: W" + thisSize.width
                            + ", H:" + thisSize.height);
                } else {
                    System.out.println("not 4/3, but Supports size: W"
                            + thisSize.width + ", H:" + thisSize.height);
                }

                if (betterWidth && betterHeight && isFourThreeAspect) {
                    maxH = thisH;
                    maxW = thisW;
                }

            }

            if (maxH < 99999 && maxW < 99999) {
                System.out.println("Found best size, W:" + maxW + ", H:"
                        + maxH);
                Toast.makeText(
                        this,
                        "Taking picture at resolution:" + maxW + "x" + maxH,
                        Toast.LENGTH_LONG).show();
                params.setPictureSize(maxW, maxH);
            } else {
                System.out
                        .println("Couldn't find best size! Going with default");
            }

            camera.setParameters(params);
        } else {

        }

        camera.takePicture(new ShutterCallback() {
            @Override
            public void onShutter() {
            }
        }, null, new PictureCallback() {
            public void onPictureTaken(byte[] bytes, Camera camera) {
                System.out
                        .println("got jpeg bytes, length:" + bytes.length);
                stopCameraPreview();
            }
        });
    }
}

public MediaRecorder mediaRecorder = new MediaRecorder();
private boolean recording = false;

protected void startRecording() {
    String path = Environment.getExternalStorageDirectory()
            .getAbsolutePath().toString();
    String filename = "/xyz.mp4";

    mediaRecorder = new MediaRecorder();

    camera = Camera.open(cameraId);
    camera.getParameters().setFlashMode(
            cameraFlash ? Parameters.FLASH_MODE_AUTO
                    : Parameters.FLASH_MODE_OFF);
    camera.setDisplayOrientation(90);
    Log.d("TabCustomCameraFragment", "startRecording - Camera.open");
    camera.lock();
    camera.unlock();

    mediaRecorder.setCamera(camera);
    mediaRecorder.setVideoSource(MediaRecorder.VideoSource.DEFAULT);
    mediaRecorder.setAudioSource(MediaRecorder.AudioSource.DEFAULT);
    mediaRecorder.setProfile(CamcorderProfile
            .get(CamcorderProfile.QUALITY_HIGH));
    mediaRecorder.setVideoSize(640, 640);

    mediaRecorder.setPreviewDisplay(previewSv.getHolder().getSurface());
    mediaRecorder.setOutputFile(path + filename);
    if (isVertical()) {
        mediaRecorder.setOrientationHint(cameraId == 0 ? 90 : 270);
    } else {
        mediaRecorder.setOrientationHint(cameraId == 0 ? 90 : 180);
    }
    mediaRecorder.setMaxDuration(10000);

    try {
        camera.stopPreview();

        mediaRecorder.prepare();
        mediaRecorder.start();
        recording = true;
        remainingCaptureTime = MAX_VIDEO_DURATION;
        updateRemainingTime();
    } catch (IllegalStateException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }

}

protected void stopRecording() {
    if (mediaRecorder != null && recording) {
        mediaRecorder.stop();
        mediaRecorder.reset();
        mediaRecorder.release();
        camera.release();
        recording = false;
        handler.removeCallbacksAndMessages(null);
    }
}

private int remainingCaptureTime;

private void updateRemainingTime() {
    Log.d("TabCustomCameraFragment",
            "updateRemainingTime - remainingCaptureTime="
                    + remainingCaptureTime);
    if (remainingCaptureTime <= 500) {
        stopCameraPreview();
        stopRecording();
        return;
    }

    handler.postDelayed(new Runnable() {
        @Override
        public void run() {
            remainingCaptureTime -= 500;
            updateRemainingTime();
        }
    }, 500);
}

private boolean isVertical() {
    Display getOrient = getWindowManager().getDefaultDisplay();
    if (getOrient.getWidth() <= getOrient.getHeight()) {
        return true;
    }
    return false;
}

private enum Mode {
    STILL_CAMERA, VIDEO_CAMERA, RECORDING;
}

private Mode mode = Mode.STILL_CAMERA;

private void activateMode(Mode mode) {
    switch (mode) {
    case STILL_CAMERA:
        this.mode = Mode.STILL_CAMERA;
        cancelTv.setVisibility(View.GONE);
        galleryIb.setVisibility(View.VISIBLE);
        videoCamIb.setVisibility(View.VISIBLE);
        break;
    case VIDEO_CAMERA:
        this.mode = Mode.VIDEO_CAMERA;
        stillImgCamIb.setImageResource(R.drawable.ic_launcher);
        videoCamIb.setImageResource(R.drawable.ic_launcher);
        cancelTv.setVisibility(View.GONE);
        galleryIb.setVisibility(View.VISIBLE);
        videoCamIb.setVisibility(View.VISIBLE);
        break;
    case RECORDING:
        this.mode = Mode.RECORDING;
        stillImgCamIb.setImageResource(R.drawable.ic_launcher);
        cancelTv.setVisibility(View.VISIBLE);
        galleryIb.setVisibility(View.GONE);
        videoCamIb.setVisibility(View.GONE);
        break;

    default:
        break;
    }
}

@Override
public void onBackPressed() {
    super.onBackPressed();
    stopCameraPreview();
    stopRecording();
}