手动相机对焦Android Studio

我有一个SurfaceView显示一个CameraSource，我想让相机自动对焦。另外，当用户点击SurfaceView时，我希望相机聚焦在点击的区域。自动对焦已经启用，但手动对焦没有启用，我不知道如何添加，有什么提示吗

到目前为止，我的代码是：

public class MyActivity extends AppCompatActivity {

    SurfaceView cameraPreview;
    BarcodeDetector barcodeDetector;
    CameraSource cameraSource;
    final Integer requestCameraPermissionID = 1001;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.my_activity_layout);

        final int height = getSurfaceViewHeight();
        final int width = getSurfaceViewWidth();

        cameraPreview = findViewById(R.id.surfaceview_scanner);

        barcodeDetector = new BarcodeDetector.Builder(AddScanningActivity.this)
                .setBarcodeFormats(Barcode.ALL_FORMATS)
                .build();
        cameraSource = new CameraSource.Builder(AddScanningActivity.this, barcodeDetector)
                .setAutoFocusEnabled(false)
                .setRequestedPreviewSize(width, height)
                .build();
        barcodeDetector.setProcessor(new Detector.Processor<Barcode>() {
            @Override
            public void release() {

            }

            @Override
            public void receiveDetections(Detector.Detections<Barcode> detections) {
                    // handle detections
            }
        });

        cameraPreview.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                // handle manual focus here?
            }
        });

        cameraPreview.getHolder().addCallback(new SurfaceHolder.Callback() {
            @Override
            public void surfaceCreated(SurfaceHolder surfaceHolder) {
                final Handler handler = new Handler();
                handler.postDelayed(new Runnable() {
                    @Override
                    public void run() {
                        if (ActivityCompat.checkSelfPermission(getApplicationContext(), Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED) {
                            ActivityCompat.requestPermissions(AddScanningActivity.this,
                                    new String[]{Manifest.permission.CAMERA}, requestCameraPermissionID);
                        return;
                        }
                        try {
                                cameraSource.start(cameraPreview.getHolder());
                        } catch (IOException e) {
                                e.printStackTrace();
                        }
                    }
                }, 100);
            }

            @Override
            public void surfaceChanged(SurfaceHolder surfaceHolder, int i, int i1, int i2) {

            }

            @Override
            public void surfaceDestroyed(SurfaceHolder surfaceHolder) {
                cameraSource.stop();
            }
        });
    }
}

公共类MyActivity扩展了AppCompatActivity{
表面审查；
条码检测器条码检测器；
摄像源摄像源；
最终整数requestCameraPermissionID=1001；
@凌驾
创建时受保护的void（@Nullable Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
setContentView（R.layout.my_activity_layout）；
最终整数高度=GetSurfaceView（）；
最终整数宽度=getSurfaceViewWidth（）；
cameraPreview=findViewById（R.id.surfaceview\U扫描仪）；
barcodeDetector=new barcodeDetector.Builder（AddScanningActivity.this）
.setBarcodeFormats（条形码.所有_格式）
.build（）；
cameraSource=新建cameraSource.Builder（AddScanningActivity.this，barcodeDetector）
.setAutoFocusEnabled（错误）
.setRequestedPreviewSize（宽度、高度）
.build（）；
条形码检测器.setProcessor（新检测器.Processor（）{
@凌驾
公开无效释放（）{
}
@凌驾
公共空隙接收检测（检测器。检测）{
//处理检测
}
});
cameraPreview.setOnClickListener（新视图.OnClickListener（）{
@凌驾
公共void onClick（视图v）{
//在这里处理手动对焦？
}
});
cameraPreview.getHolder（）.addCallback（新的SurfaceHolder.Callback（））{
@凌驾
已创建的公共空隙表面（表面层表面层）{
最终处理程序=新处理程序（）；
handler.postDelayed（新的Runnable（）{
@凌驾
公开募捐{
if（ActivityCompat.checkSelfPermission（getApplicationContext（），Manifest.permission.CAMERA）！=PackageManager.permission\u已授予）{
ActivityCompat.requestPermissions（AddScanningActivity.this，
新字符串[]{Manifest.permission.CAMERA}，requestCameraPermissionID）；
返回；
}
试一试{
开始（cameraPreview.getHolder（））；
}捕获（IOE异常）{
e、 printStackTrace（）；
}
}
}, 100);
}
@凌驾
公共无效表面更改（表面更改表面更改表面更改，int i，int i1，int i2）{
}
@凌驾
公共空间表面已覆盖（表面层表面层）{
cameraSource.stop（）；
}
});
}
}

---

如果无法在同一表面视图中使用自动对焦和手动对焦，我宁愿使用手动对焦，也不愿使用自动对焦。

当您制作条形码应用程序时，我建议您使用“对焦”模式， 或

---

聚焦模式宏

谢谢您的回答！我会在有时间的时候尽快测试，到时候我会让你知道它是否有效。你能给我一些额外的提示如何实现吗？因为我无法理解，所以请在提供您的解释的同时code@NaingLinAung你能帮我做这些吗？

package com.example.yaumanualcamera;

import android.Manifest;
import android.content.Context;
import android.content.pm.PackageManager;
import android.graphics.Camera;
import android.graphics.SurfaceTexture;
import android.hardware.camera2.CameraAccessException;
import android.hardware.camera2.CameraCaptureSession;
import android.hardware.camera2.CameraCharacteristics;
import android.hardware.camera2.CameraDevice;
import android.hardware.camera2.CameraManager;
import android.hardware.camera2.CameraMetadata;
import android.hardware.camera2.CaptureRequest;
import android.hardware.camera2.params.StreamConfigurationMap;
import android.os.Handler;
import android.os.HandlerThread;
import android.support.annotation.NonNull;
import android.support.v4.app.ActivityCompat;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Size;
import android.view.Surface;
import android.view.TextureView;

import java.util.Arrays;

public class MainActivity extends AppCompatActivity {

    TextureView textureview;
    CameraDevice cameraDevice;
    String cameraId;
    Size imageDimensions;
    CaptureRequest.Builder captureRequestBuilder;
    CameraCaptureSession cameraSession;
    Handler backgroundHandler;
    HandlerThread handleThread;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        textureview = (TextureView) findViewById(R.id.texture);

        textureview.setSurfaceTextureListener(surfaceTextureListener);
    }

    TextureView.SurfaceTextureListener surfaceTextureListener = new TextureView.SurfaceTextureListener() {
        @Override
        public void onSurfaceTextureAvailable(SurfaceTexture surface, int width, int height) {
            try {
                openCamera();
            } catch (CameraAccessException e) {
                e.printStackTrace();
            }
        }

        @Override
        public void onSurfaceTextureSizeChanged(SurfaceTexture surface, int width, int height) {

        }

        @Override
        public boolean onSurfaceTextureDestroyed(SurfaceTexture surface) {
            return false;
        }

        @Override
        public void onSurfaceTextureUpdated(SurfaceTexture surface) {

        }
    };

    private void openCamera() throws CameraAccessException {
        CameraManager cameraManager = (CameraManager) getSystemService(Context.CAMERA_SERVICE);
        cameraId = cameraManager.getCameraIdList()[0];
        CameraCharacteristics cc = cameraManager.getCameraCharacteristics(cameraId);
        StreamConfigurationMap map = cc.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
        imageDimensions = map.getOutputSizes(SurfaceTexture.class)[0];
        if (ActivityCompat.checkSelfPermission(this, Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED) {
            return;
        }
        cameraManager.openCamera(cameraId, stateCallback, null);
    }

    CameraDevice.StateCallback stateCallback = new CameraDevice.StateCallback() {
        @Override
        public void onOpened(@NonNull CameraDevice camera) {
            cameraDevice = camera;
            try {
                startCameraPreview();
            } catch (CameraAccessException e) {
                e.printStackTrace();
            }
        }

        @Override
        public void onDisconnected(@NonNull CameraDevice camera) {
            cameraDevice.close();
        }

        @Override
        public void onError(@NonNull CameraDevice camera, int error) {
            cameraDevice.close();
            cameraDevice = null;
        }
    };

    private void startCameraPreview() throws CameraAccessException {
        SurfaceTexture texture = textureview.getSurfaceTexture();
        texture.setDefaultBufferSize(imageDimensions.getWidth(), imageDimensions.getHeight());

        Surface surface = new Surface(texture);
        captureRequestBuilder = cameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
        captureRequestBuilder.addTarget(surface);
        System.out.println("Focus 1 ====== "+captureRequestBuilder.get(CaptureRequest.LENS_FOCUS_DISTANCE));
        cameraDevice.createCaptureSession(Arrays.asList(surface), new CameraCaptureSession.StateCallback() {
            @Override
            public void onConfigured(@NonNull CameraCaptureSession session) {
                if (cameraDevice == null) {
                    return;
                }
                cameraSession = session;

                try {
                    updatePreview();
                } catch (CameraAccessException e) {

                }
            }

            @Override
            public void onConfigureFailed(@NonNull CameraCaptureSession session) {

            }
        }, null);
    }

    private void initPreview() {
        float valueAF;
        valueAF = 10.0f;
        captureRequestBuilder.set(CaptureRequest.CONTROL_MODE,CameraMetadata.CONTROL_MODE_AUTO);
        captureRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE, CameraMetadata.CONTROL_AF_MODE_OFF);
        captureRequestBuilder.set(CaptureRequest.LENS_FOCUS_DISTANCE, valueAF);
    }


    private void updatePreview() throws CameraAccessException {
        if (cameraDevice == null) {
            return;
        }
        initPreview();
        System.out.println("Focus 2 ====== "+captureRequestBuilder.get(CaptureRequest.LENS_FOCUS_DISTANCE));
        cameraSession.setRepeatingRequest(captureRequestBuilder.build(), null, backgroundHandler);
    }

    @Override
    protected void onResume() {
        super.onResume();
        startBackgroundThread();

        if (textureview.isAvailable()) {
            try {
                openCamera();
            } catch (CameraAccessException e) {
                e.printStackTrace();
            }
        } else {
            textureview.setSurfaceTextureListener(surfaceTextureListener);
        }
    }

    private void startBackgroundThread() {
        handleThread = new HandlerThread("CAMERA BACKGROUND");
        handleThread.start();
        backgroundHandler = new Handler(handleThread.getLooper());
    }

    @Override
    protected void onPause() {
        try {
            stopBackgroundThread();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        super.onPause();
    }

    private void stopBackgroundThread() throws InterruptedException {
        handleThread.quitSafely();
        handleThread.join();
        backgroundHandler = null;
        handleThread = null;
    }
}