devbox
天景科技苑
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

安卓使用uvc协议调用usb外接摄像头_安卓uvc 摄像头

作者：天景科技苑 | 2024-08-22 16:29:11

赞

踩

安卓uvc 摄像头

Java 自带的camera api只能获取简单的拍摄，无法实现类似手机的调倍数和调焦距。自己使用github上项目为大家试试能不能成功。

目前比较简单直接拉取就可以使用的是UVCAndroid这个项目源码。其他的只要你们能搜索到，我都尝试了，要不是libusb这个编译不出来，要不就是缺少ndk。

我接下来试试用ndk看可以运行成功不。

我的需求是，用代码页面滚动条控制摄像头的参数。有些usb摄像头还真的不好搞。有大佬成功过没。

下面代码是camera。可以运行成功，对一些没那么高要求的摄像头还是没问题的。

  1. package com.hs.smart.cabinet.ui;
  2.  
  3. import android.Manifest;
  4. import android.content.Intent;
  5. import android.content.pm.PackageManager;
  6. import android.graphics.ImageFormat;
  7. import android.hardware.Camera;
  8. import android.os.AsyncTask;
  9. import android.os.Bundle;
  10. import android.os.Handler;
  11. import android.os.Message;
  12. import android.view.Surface;
  13. import android.view.SurfaceView;
  14. import android.view.View;
  15. import android.widget.Button;
  16. import android.widget.Toast;
  17.  
  18. import androidx.appcompat.app.AppCompatActivity;
  19. import androidx.core.app.ActivityCompat;
  20. import androidx.core.content.ContextCompat;
  21.  
  22. import com.donkingliang.imageselector.ImageSelectorActivity;
  23. import com.hs.smart.cabinet.R;
  24. import com.hs.smart.cabinet.helper.CameraControlsDialogFragment;
  25. import com.hs.smart.cabinet.helper.ProcessPhotoAsyncTask;
  26. import com.hs.smart.cabinet.utils.MyField;
  27.  
  28. import java.io.IOException;
  29. import java.util.List;
  30. import android.widget.SeekBar;
  31.  
  32. /************************************
  33.  *@desc：这是拍照页面，使用第三个摄像头拍照
  34.  * 即涉案涉财柜中的第三个摄像头
  35.  *@Author: admin
  36.  *@DateTime:2024/4/2 11:59
  37.  *@Copyright: hskj
  38.  *************************************/
  39. public class TakePhotoActivity extends AppCompatActivity
  40.         implements View.OnClickListener, Camera.PreviewCallback {
  41.     private SurfaceView surfaceView;
  42.     private Button photograph;
  43.     private Button switchs;
  44.     private CameraControlsDialogFragment mControlsDialog;
  45.  
  46.     private Button camerasettings;
  47.     private int rotation;
  48.     private int shortSize;
  49.     private int longSize;
  50.     private Camera camera;
  51.     private Camera.CameraInfo cameraInfo;
  52.     private Camera.Parameters parameters;
  53.  
  54.     @Override
  55.     protected void onCreate(Bundle savedInstanceState) {
  56.         super.onCreate(savedInstanceState);
  57.         setContentView(R.layout.activity_take_photo);
  58.         initView();
  59.     }
  60.  
  61.     private void initView() {
  62.         surfaceView = (SurfaceView) findViewById(R.id.camera_view);
  63.         photograph = (Button) findViewById(R.id.photograph);
  64.         switchs = (Button) findViewById(R.id.switchs);
  65.         camerasettings = (Button) findViewById(R.id.camerasettings);
  66.         photograph.setOnClickListener(this);
  67.         switchs.setOnClickListener(this);
  68.         camerasettings.setOnClickListener(this);
  69.     }
  70.  
  71.     @Override
  72.     public void onClick(View v) {
  73.         switch (v.getId()) {
  74.             case R.id.photograph:    //拍照
  75.                 if (camera == null) {
  76.                     Toast.makeText(this, "请打开相机", Toast.LENGTH_SHORT).show();
  77.                     return;
  78.                 }
  79.                 parameters = camera.getParameters();
  80.                 parameters.setPictureFormat(ImageFormat.JPEG);
  81.                 camera.setParameters(parameters);
  82.                 camera.startPreview();
  83.                 camera.takePicture(null, null, new Camera.PictureCallback() {
  84.                     @Override
  85.                     public void onPictureTaken(byte[] data, Camera camera) {
  86.                         ProcessPhotoAsyncTask myTask = new ProcessPhotoAsyncTask(TakePhotoActivity.this,
  87.                                 cameraInfo.facing,
  88.                                 data,
  89.                                 camera,
  90.                                 processImageHandler
  91.                         );
  92.                         myTask.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
  93.                     }
  94.                 });
  95.  
  96.                 break;
  97.  
  98.             case R.id.switchs:
  99.                 gotoTakePhoto();
  100.                 break;
  101.             case R.id.camerasettings:
  102.                 showCameraControlsDialog();
  103.                 break;
  104.         }
  105.     }
  106.     private void showCameraControlsDialog() {
  107.         if (mControlsDialog == null) {
  108.             mControlsDialog = new CameraControlsDialogFragment();
  109.         }
  110.  
  111.         // When DialogFragment is not showing
  112.         if (!mControlsDialog.isAdded()) {
  113.             mControlsDialog.show(getSupportFragmentManager(), "controls_dialog");
  114.         }
  115.     }
  116.  
  117.     @Override
  118.     public void onWindowFocusChanged(boolean hasFocus) {
  119.         super.onWindowFocusChanged(hasFocus);
  120.         if (hasFocus) {
  121.             int[] a = new int[2];
  122.             surfaceView.getLocationOnScreen(a);
  123.             shortSize = surfaceView.getHeight();     //横屏为宽度，竖屏为高度
  124.             longSize = surfaceView.getWidth();
  125.             rotation = getWindowManager().getDefaultDisplay().getRotation();
  126.             cameraInfo = new Camera.CameraInfo();
  127.             checkCameraPermission();
  128.         }
  129.     }
  130.  
  131.     private Handler processImageHandler = new Handler() {
  132.         @Override
  133.         public void handleMessage(Message msg) {
  134.             switch (msg.what) {
  135.                 case 1:
  136.                     String filePath = (String) msg.obj;
  137.                     Intent data = new Intent();
  138.                     data.putExtra(MyField.KEY_CARGO_PHOTO_PATH, filePath);
  139.                     setResult(RESULT_OK, data);
  140.                     finish();
  141.                     break;
  142.                 default:
  143.                     break;
  144.             }
  145.         }
  146.     };
  147.  
  148.  
  149.     // 1.申请相机权限---------------------------------------------------------------------------
  150.     private void checkCameraPermission() {
  151.         //检查是否有相机权限
  152.         if (ContextCompat.checkSelfPermission(this, Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED &&
  153.                 ContextCompat.checkSelfPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) {
  154.             //没权限，请求权限
  155.             ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.CAMERA, Manifest.permission.WRITE_EXTERNAL_STORAGE},
  156.                     1);
  157.         } else {
  158.             //有权限
  159.             //Log.d("MainActivity", "有权限");
  160.             getCameras(0);  //0为后摄，1为前摄
  161.         }
  162.     }
  163.  
  164.     //权限请求回调
  165.     @Override
  166.     public void onRequestPermissionsResult(int requestCode, String permissions[], int[] grantResults) {
  167.         super.onRequestPermissionsResult(requestCode, permissions, grantResults);
  168.         switch (requestCode) {
  169.             case 1:
  170.                 if (grantResults != null && grantResults.length > 0
  171.                         && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
  172.                     //用户同意权限
  173.                     getCameras(0);  //0为后摄，1为前摄
  174.                 } else {
  175.                     // 权限被用户拒绝了，可以提示用户,关闭界面等等。
  176.                     Toast.makeText(this, "拒绝权限，请去设置里面手动开启权限", Toast.LENGTH_SHORT).show();
  177.                 }
  178.                 break;
  179.         }
  180.     }
  181.  
  182.     //预览数据监听
  183.     @Override
  184.     public void onPreviewFrame(byte[] data, Camera camera) {
  185.         camera.addCallbackBuffer(data);
  186.     }
  187.  
  188.     /*
  189.    3.查找指定摄像头ID，根据摄像头ID打开指定的相机----------------------------------------------------------------------------------------------
  190.        根据摄像头的朝向查找指定摄像头id
  191.        0代表后摄的朝向，但是它不一定是后摄的id
  192.        1代表前摄的朝向
  193.    */
  194.     public void getCameras(int lens_facing) {
  195.         //先释放相机资源
  196.         releaseCamera();
  197.         //获取相机信息
  198.         if (cameraInfo == null) {
  199.             cameraInfo = new Camera.CameraInfo();
  200.         }
  201.         //获取相机个数
  202.         int cameraCount = Camera.getNumberOfCameras();
  203.         if (lens_facing >= cameraCount-1) {
  204.             //获取id最大的一个相机
  205.             lens_facing = cameraCount-1;
  206.         }
  207.  
  208.  
  209.         //由于不知道第几个是前置摄像头，遍历获取前置摄像头
  210.         for (int camIdx = 0; camIdx < cameraCount; camIdx++) {
  211.             Camera.getCameraInfo(camIdx, cameraInfo);
  212.  
  213.             if (camIdx == lens_facing) {
  214.                 //根据id打开相机
  215.                 //Log.d("MainActivity", "相机id为" + camIdx);
  216.                 camera = Camera.open(camIdx);
  217.                 setPreview();
  218.                 break;
  219.             }
  220.         }
  221.     }
  222.  
  223.     /*
  224.     4.设置预览参数和相机参数后开启预览-----------------------------------------------------------
  225.      */
  226.     public void setPreview() {
  227.         try {
  228.             //设置摄像头参数
  229.             parameters = camera.getParameters();
  230.             //设置预览大小
  231.             parameters.setPreviewSize(1920, 1080);
  232.             //设置图片大小，拍照
  233.             parameters.setPictureSize(1920, 1080);
  234.             //设置预览格式,所有的相机都支持 NV21格式
  235.             parameters.setPreviewFormat(ImageFormat.NV21);
  236.             //设置聚焦
  237.             parameters.setFocusMode(Camera.Parameters.FOCUS_MODE_AUTO);
  238.             // 获取焦距范围
  239. //            List<Integer> zoomRatios = parameters.getZoomRatios();
  240. //
  241. //            // 设置焦距
  242. //            int desiredZoom = 50; // 设置为焦距范围内的一个值
  243. //            int zoomIndex = zoomRatios.indexOf(desiredZoom);
  244. //            parameters.setZoom(zoomIndex);
  245.             //修改相机摄像头参数
  246.             camera.setParameters(parameters);
  247.             //修改相机预览方向
  248.             camera.setDisplayOrientation(adjustCameraOrientation());
  249.             //绑定预览视图
  250.             camera.setPreviewDisplay(surfaceView.getHolder());
  251.             //设置预览数据监听
  252.             camera.setPreviewCallbackWithBuffer(this);
  253.             //开始预览
  254.             camera.startPreview();
  255.         } catch (IOException e) {
  256.         }
  257.     }
  258.  
  259.     //获取预览最佳尺寸
  260.     private Camera.Size getBestSize() {
  261.         List<Camera.Size> sizes = parameters.getSupportedPreviewSizes();
  262.         Camera.Size bestSize = null;
  263.         float uiRatio = (float) longSize / shortSize;
  264.         float minRatio = uiRatio;
  265.         for (Camera.Size previewSize : sizes) {
  266.             float cameraRatio = (float) previewSize.width / previewSize.height;
  267.  
  268.             //如果找不到比例相同的，找一个最近的,防止预览变形
  269.             float offset = Math.abs(cameraRatio - minRatio);
  270.             if (offset < minRatio) {
  271.                 minRatio = offset;
  272.                 bestSize = previewSize;
  273.             }
  274.             //比例相同
  275.             if (uiRatio == cameraRatio) {
  276.                 bestSize = previewSize;
  277.                 break;
  278.             }
  279.         }
  280.         return bestSize;
  281.     }
  282.  
  283.     /**
  284.      * 调整预览方向
  285.      * 由于手机的图片数据都来自摄像头硬件传感器，这个传感器默认的方向横向的，所以要根据前后摄像头调整方向
  286.      */
  287.     private int adjustCameraOrientation() {
  288.         //判断当前的横竖屏
  289.  
  290.         int degress = 0;
  291.         //获取手机的方向
  292.         switch (rotation) {
  293.             case Surface.ROTATION_0:
  294.                 degress = 0;
  295.                 break;
  296.             case Surface.ROTATION_90:
  297.                 degress = 90;
  298.                 break;
  299.             case Surface.ROTATION_180:
  300.                 degress = 180;
  301.                 break;
  302.             case Surface.ROTATION_270:
  303.                 degress = 270;
  304.                 break;
  305.         }
  306.         int result = 0;
  307.         if (cameraInfo.facing == Camera.CameraInfo.CAMERA_FACING_BACK) {
  308.             //后置摄像头
  309.             result = (cameraInfo.orientation - degress + 360) % 360;
  310.         } else if (cameraInfo.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) {
  311.             //前置摄像头，多一步镜像
  312.             result = (cameraInfo.orientation + degress) % 360;
  313.             result = (360 - result) % 360;
  314.         }
  315.         return result;
  316.     }
  317.  
  318.     //释放相机资源
  319.     private void releaseCamera() {
  320.         if (camera != null) {
  321.             camera.stopPreview();
  322.             camera.stopFaceDetection();
  323.             camera.setPreviewCallback(null);
  324.             camera.release();
  325.             camera = null;
  326.         }
  327.     }
  328.     private int currentCameraId = 2;
  329.     private void gotoTakePhoto() {
  330.         getCameras(currentCameraId);
  331.         //切换摄像头
  332.         int cameraCount = Camera.getNumberOfCameras();
  333.         if (currentCameraId < cameraCount - 1) {
  334.             currentCameraId += 1;
  335.         } else {
  336.             currentCameraId = 0;
  337.         }
  338.         if (currentCameraId < 0 || currentCameraId >= cameraCount) {
  339.             currentCameraId = 0;
  340.         }
  341.     }
  342. }

下面代码是camera2。可以运行成功，对一些没那么高要求的摄像头还是没问题的。

  1. package com.hs.smart.cabinet.ui;
  2.  
  3. import android.Manifest;
  4. import android.content.Context;
  5. import android.content.DialogInterface;
  6. import android.content.Intent;
  7. import android.content.pm.PackageManager;
  8. import android.graphics.ImageFormat;
  9. import android.graphics.Rect;
  10. import android.hardware.camera2.CameraAccessException;
  11. import android.hardware.camera2.CameraCaptureSession;
  12. import android.hardware.camera2.CameraCharacteristics;
  13. import android.hardware.camera2.CameraDevice;
  14. import android.hardware.camera2.CameraManager;
  15. import android.hardware.camera2.CaptureRequest;
  16. import android.hardware.camera2.TotalCaptureResult;
  17. import android.hardware.camera2.params.StreamConfigurationMap;
  18. import android.media.Image;
  19. import android.media.ImageReader;
  20. import android.os.Bundle;
  21. import android.os.Handler;
  22. import android.os.HandlerThread;
  23. import android.os.Message;
  24. import android.util.Log;
  25. import android.util.Size;
  26. import android.util.SparseIntArray;
  27. import android.view.Surface;
  28. import android.view.SurfaceHolder;
  29. import android.view.SurfaceView;
  30. import android.view.View;
  31. import android.widget.Button;
  32. import android.widget.Toast;
  33.  
  34. import androidx.annotation.NonNull;
  35. import androidx.appcompat.app.AppCompatActivity;
  36. import androidx.core.app.ActivityCompat;
  37. import androidx.core.content.ContextCompat;
  38.  
  39. import com.hs.smart.cabinet.R;
  40. import com.hs.smart.cabinet.helper.CameraControlsDialogFragment;
  41. import com.hs.smart.cabinet.helper.CameraControlsDialogFragmentTest;
  42. import com.hs.smart.cabinet.helper.ProcessPhotoAsyncTask;
  43. import com.hs.smart.cabinet.utils.MyField;
  44.  
  45. import java.nio.ByteBuffer;
  46. import java.util.ArrayList;
  47. import java.util.Arrays;
  48. import java.util.List;
  49.  
  50. public class TakePhotoZoomActivity extends AppCompatActivity implements View.OnClickListener {
  51.     private SurfaceView surfaceView;
  52.     private Button photograph;
  53.     private Button switchs;
  54.     private CameraControlsDialogFragmentTest mControlsDialog;
  55.     private Button camerasettings;
  56.     private int rotation;
  57.     private int shortSize;
  58.     private int longSize;
  59.     private CameraDevice cameraDevice;
  60.     private CameraCaptureSession captureSession;
  61.     private CaptureRequest.Builder captureRequestBuilder;
  62.     private ImageReader imageReader;
  63.     private CameraManager cameraManager;
  64.     private Handler backgroundHandler;
  65.     private String currentCameraId;
  66.     private SurfaceHolder surfaceHolder;
  67.     private static final int CAMERA_PERMISSION_REQUEST_CODE = 200;
  68.     private static final SparseIntArray ORIENTATIONS = new SparseIntArray();
  69.  
  70.     static {
  71.         ORIENTATIONS.append(Surface.ROTATION_0, 90);
  72.         ORIENTATIONS.append(Surface.ROTATION_90, 0);
  73.         ORIENTATIONS.append(Surface.ROTATION_180, 270);
  74.         ORIENTATIONS.append(Surface.ROTATION_270, 180);
  75.     }
  76.  
  77.     private float currentZoomLevel = 1.0f;
  78.     private float currentFocusDistance = 0.0f;
  79.     private boolean supportsAutoFocus;
  80.     private boolean supportsZoom;
  81.     private float maxZoom;
  82.     private boolean cameraCapabilitiesInitialized = false;
  83.     private boolean isDialogVisible = false;
  84.     // 添加变量用于记录当前焦距值
  85.  
  86.  
  87.     @Override
  88.     protected void onCreate(Bundle savedInstanceState) {
  89.         super.onCreate(savedInstanceState);
  90.         setContentView(R.layout.activity_take_photo);
  91.  
  92.         initView();
  93.         HandlerThread handlerThread = new HandlerThread("CameraBackground");
  94.         handlerThread.start();
  95.         backgroundHandler = new Handler(handlerThread.getLooper());
  96.     }
  97.  
  98.     private void initView() {
  99.         surfaceView = findViewById(R.id.camera_view);
  100.         photograph = findViewById(R.id.photograph);
  101.         switchs = findViewById(R.id.switchs);
  102.         camerasettings = findViewById(R.id.camerasettings);
  103.         photograph.setOnClickListener(this);
  104.         switchs.setOnClickListener(this);
  105.         camerasettings.setOnClickListener(this);
  106.  
  107.         surfaceHolder = surfaceView.getHolder();
  108.         surfaceHolder.addCallback(new SurfaceHolder.Callback() {
  109.             @Override
  110.             public void surfaceCreated(@NonNull SurfaceHolder holder) {
  111.                 // Setup camera when the surface is created
  112.                 setupAndOpenCamera();
  113.             }
  114.  
  115.             @Override
  116.             public void surfaceChanged(@NonNull SurfaceHolder holder, int format, int width, int height) {
  117.             }
  118.  
  119.             @Override
  120.             public void surfaceDestroyed(@NonNull SurfaceHolder holder) {
  121.                 closeCamera();
  122.             }
  123.         });
  124.     }
  125.  
  126.     private void setupAndOpenCamera() {
  127.         cameraManager = (CameraManager) getSystemService(Context.CAMERA_SERVICE);
  128.         try {
  129.             currentCameraId = cameraManager.getCameraIdList()[0];
  130.             CameraCharacteristics characteristics = cameraManager.getCameraCharacteristics(currentCameraId);
  131.  
  132.             StreamConfigurationMap map = characteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
  133.             // Continue with your camera setup...
  134.             imageReader = ImageReader.newInstance(640, 480, ImageFormat.JPEG, 1);
  135.             cameraManager.openCamera(currentCameraId, new CameraDevice.StateCallback() {
  136.                 @Override
  137.                 public void onOpened(@NonNull CameraDevice camera) {
  138.                     cameraDevice = camera;
  139.                     createCameraPreviewSession();
  140.                 }
  141.  
  142.                 @Override
  143.                 public void onDisconnected(@NonNull CameraDevice camera) {
  144.                     camera.close();
  145.                     cameraDevice = null;
  146.                 }
  147.  
  148.                 @Override
  149.                 public void onError(@NonNull CameraDevice camera, int error) {
  150.                     camera.close();
  151.                     cameraDevice = null;
  152.                 }
  153.             }, backgroundHandler);
  154.         } catch (CameraAccessException e) {
  155.             e.printStackTrace();
  156.         } catch (SecurityException e) {
  157.             e.printStackTrace();
  158.         }
  159.     }
  160.  
  161.     @Override
  162.     public void onClick(View v) {
  163.         switch (v.getId()) {
  164.             case R.id.photograph:
  165.                 takePictureWithCurrentFocusDistance();
  166.                 break;
  167.             case R.id.switchs:
  168.                 switchCamera();
  169.                 break;
  170.             case R.id.camerasettings:
  171.                 showCameraControlsDialog();
  172.                 break;
  173.             default:
  174.                 break;
  175.         }
  176.     }
  177.  
  178.     private void createCameraPreviewSession() {
  179.         try {
  180.             surfaceHolder.setFixedSize(640, 480);
  181.             captureRequestBuilder = cameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
  182.             captureRequestBuilder.addTarget(surfaceHolder.getSurface());
  183.  
  184.             cameraDevice.createCaptureSession(
  185.                     Arrays.asList(surfaceHolder.getSurface(), imageReader.getSurface()),
  186.                     new CameraCaptureSession.StateCallback() {
  187.                         @Override
  188.                         public void onConfigured(@NonNull CameraCaptureSession session) {
  189.                             if (cameraDevice == null) return;
  190.                             captureSession = session;
  191.                             try {
  192.                                 captureRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE, CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE);
  193.                                 captureSession.setRepeatingRequest(captureRequestBuilder.build(), null, backgroundHandler);
  194.                             } catch (CameraAccessException e) {
  195.                                 e.printStackTrace();
  196.                             }
  197.                         }
  198.  
  199.                         @Override
  200.                         public void onConfigureFailed(@NonNull CameraCaptureSession session) {
  201.                         }
  202.                     }, null);
  203.         } catch (CameraAccessException e) {
  204.             e.printStackTrace();
  205.         }
  206.     }
  207.  
  208.     private void takePicture() {
  209.         if (cameraDevice == null) return;
  210.         try {
  211.             CaptureRequest.Builder captureBuilder = cameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_STILL_CAPTURE);
  212.             captureBuilder.addTarget(imageReader.getSurface());
  213.             captureBuilder.set(CaptureRequest.CONTROL_AF_MODE, captureRequestBuilder.get(CaptureRequest.CONTROL_AF_MODE));
  214.  
  215.             captureSession.stopRepeating();
  216.             captureSession.capture(captureBuilder.build(), new CameraCaptureSession.CaptureCallback() {
  217.                 @Override
  218.                 public void onCaptureCompleted(@NonNull CameraCaptureSession session, @NonNull CaptureRequest request, @NonNull TotalCaptureResult result) {
  219.                     super.onCaptureCompleted(session, request, result);
  220.                     try {
  221.                         captureSession.setRepeatingRequest(captureRequestBuilder.build(), null, backgroundHandler);
  222.                     } catch (CameraAccessException e) {
  223.                         e.printStackTrace();
  224.                     }
  225.                 }
  226.             }, backgroundHandler);
  227.         } catch (CameraAccessException e) {
  228.             e.printStackTrace();
  229.         }
  230.     }
  231.     private void takePictureWithCurrentFocusDistance() {
  232.         if (cameraDevice == null) return;
  233.         try {
  234.             // 创建新的 CaptureRequest.Builder 对象
  235.             CaptureRequest.Builder captureBuilder = cameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_STILL_CAPTURE);
  236.             captureBuilder.addTarget(imageReader.getSurface());
  237.  
  238.             // 设置最新的焦距值参数
  239.             captureBuilder.set(CaptureRequest.CONTROL_AF_MODE, CaptureRequest.CONTROL_AF_MODE_OFF); // 确保对焦模式为手动
  240.             captureBuilder.set(CaptureRequest.LENS_FOCUS_DISTANCE, currentFocusDistance); // 使用最新的焦距值
  241.  
  242.             // 暂停重复请求，以便进行单次拍照
  243.             captureSession.stopRepeating();
  244.  
  245.             // 拍照并在拍照完成后恢复重复请求
  246.             captureSession.capture(captureBuilder.build(), new CameraCaptureSession.CaptureCallback() {
  247.                 @Override
  248.                 public void onCaptureCompleted(@NonNull CameraCaptureSession session, @NonNull CaptureRequest request, @NonNull TotalCaptureResult result) {
  249.                     super.onCaptureCompleted(session, request, result);
  250.                     try {
  251.                         // 拍照完成后，恢复重复请求以保持预览
  252.                         captureSession.setRepeatingRequest(captureRequestBuilder.build(), null, backgroundHandler);
  253.                     } catch (CameraAccessException e) {
  254.                         e.printStackTrace();
  255.                     }
  256.                 }
  257.             }, backgroundHandler);
  258.  
  259.         } catch (CameraAccessException e) {
  260.             e.printStackTrace();
  261.         }
  262.     }
  263.     @Override
  264.     public void onWindowFocusChanged(boolean hasFocus) {
  265.         super.onWindowFocusChanged(hasFocus);
  266.         if (hasFocus) {
  267.             int[] a = new int[2];
  268.             surfaceView.getLocationOnScreen(a);
  269.             shortSize = surfaceView.getHeight();     //横屏为宽度，竖屏为高度
  270.             longSize = surfaceView.getWidth();
  271.             rotation = getWindowManager().getDefaultDisplay().getRotation();
  272.             checkCameraPermission();
  273.         }
  274.     }
  275.  
  276.     private final Handler processImageHandler = new Handler() {
  277.         @Override
  278.         public void handleMessage(Message msg) {
  279.             switch (msg.what) {
  280.                 case 1:
  281.                     String filePath = (String) msg.obj;
  282.                     Intent data = new Intent();
  283.                     data.putExtra(MyField.KEY_CARGO_PHOTO_PATH, filePath);
  284.                     setResult(RESULT_OK, data);
  285.                     finish();
  286.                     break;
  287.                 default:
  288.                     break;
  289.             }
  290.         }
  291.     };
  292.  
  293.     private void checkCameraPermission() {
  294.         if (ContextCompat.checkSelfPermission(this, Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED ||
  295.                 ContextCompat.checkSelfPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) {
  296.             ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.CAMERA, Manifest.permission.WRITE_EXTERNAL_STORAGE}, CAMERA_PERMISSION_REQUEST_CODE);
  297.         } else {
  298.             List<String> usbCameraIds = getUsbCameraIds(getBaseContext());
  299.             setupCamera(usbCameraIds.get(0));
  300.             openCamera();
  301.         }
  302.     }
  303.  
  304.     @Override
  305.     public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
  306.         super.onRequestPermissionsResult(requestCode, permissions, grantResults);
  307.         if (requestCode == CAMERA_PERMISSION_REQUEST_CODE) {
  308.             if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
  309.                 setupCamera(Integer.toString(CameraCharacteristics.LENS_FACING_BACK));
  310.                 openCamera();
  311.             } else {
  312.                 Toast.makeText(this, "拒绝权限，请去设置里面手动开启权限", Toast.LENGTH_SHORT).show();
  313.             }
  314.         }
  315.     }
  316.  
  317.     private void setupCamera(String cameraId) {
  318.         // 初始化 CameraManager
  319.         cameraManager = (CameraManager) getSystemService(Context.CAMERA_SERVICE);
  320.         try {
  321.             Log.d("SetupCamera", "Setting up camera with ID: " + cameraId);
  322.             CameraCharacteristics characteristics = cameraManager.getCameraCharacteristics(cameraId);
  323.             StreamConfigurationMap map = characteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
  324.  
  325.             // 预览尺寸设置、ImageReader初始化和回调设置
  326.             Size[] sizes = map.getOutputSizes(SurfaceHolder.class);
  327.             Size bestSize = getBestSize(sizes);
  328.  
  329.             // 配置 ImageReader 用于接收图像数据
  330.             imageReader = ImageReader.newInstance(bestSize.getWidth(), bestSize.getHeight(), ImageFormat.JPEG, 1);
  331.             imageReader.setOnImageAvailableListener(imageAvailableListener, backgroundHandler);
  332.  
  333.             // 设置当前摄像头 ID
  334.             currentCameraId = cameraId;
  335.         } catch (CameraAccessException e) {
  336.             Log.e("SetupCamera", "CameraAccessException: " + e.getMessage());
  337.             e.printStackTrace();
  338.         }
  339.     }
  340.  
  341.     private Size getBestSize(Size[] sizes) {
  342.         float uiRatio = (float) longSize / shortSize;
  343.         float minRatio = uiRatio;
  344.         Size bestSize = sizes[0];
  345.         for (Size size : sizes) {
  346.             float cameraRatio = (float) size.getWidth() / size.getHeight();
  347.             float offset = Math.abs(cameraRatio - minRatio);
  348.             if (offset < minRatio) {
  349.                 minRatio = offset;
  350.                 bestSize = size;
  351.             }
  352.             if (uiRatio == cameraRatio) {
  353.                 bestSize = size;
  354.                 break;
  355.             }
  356.         }
  357.         return bestSize;
  358.     }
  359.  
  360.     private void openCamera() {
  361.         try {
  362.             if (ContextCompat.checkSelfPermission(this, Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED) {
  363.                 return;
  364.             }
  365.             Log.d("OpenCamera", "Opening camera with ID: " + currentCameraId);
  366.             cameraManager.openCamera(currentCameraId, cameraStateCallback, backgroundHandler);
  367.         } catch (CameraAccessException e) {
  368.             Log.e("OpenCamera", "CameraAccessException: " + e.getMessage());
  369.             e.printStackTrace();
  370.         }
  371.     }
  372.  
  373.     private final CameraDevice.StateCallback cameraStateCallback = new CameraDevice.StateCallback() {
  374.         @Override
  375.         public void onOpened(@NonNull CameraDevice camera) {
  376.             cameraDevice = camera;
  377.             createCameraPreviewSession();
  378.         }
  379.  
  380.         @Override
  381.         public void onDisconnected(@NonNull CameraDevice camera) {
  382.             camera.close();
  383.             cameraDevice = null;
  384.         }
  385.  
  386.         @Override
  387.         public void onError(@NonNull CameraDevice camera, int error) {
  388.             camera.close();
  389.             cameraDevice = null;
  390.         }
  391.     };
  392.  
  393.  
  394.     private final CameraCaptureSession.StateCallback captureStateCallback = new CameraCaptureSession.StateCallback() {
  395.         @Override
  396.         public void onConfigured(@NonNull CameraCaptureSession session) {
  397.             captureSession = session;
  398.             try {
  399.                 // 自动对焦
  400.                 captureRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE, CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE);
  401.                 // 开始预览
  402.                 captureSession.setRepeatingRequest(captureRequestBuilder.build(), null, backgroundHandler);
  403.             } catch (CameraAccessException e) {
  404.                 e.printStackTrace();
  405.             }
  406.         }
  407.  
  408.         @Override
  409.         public void onConfigureFailed(@NonNull CameraCaptureSession session) {
  410.             Toast.makeText(TakePhotoZoomActivity.this, "配置失败", Toast.LENGTH_SHORT).show();
  411.         }
  412.     };
  413.     // 镜头图像可用时调用
  414.     private final ImageReader.OnImageAvailableListener imageAvailableListener = new ImageReader.OnImageAvailableListener() {
  415.         @Override
  416.         public void onImageAvailable(ImageReader reader) {
  417.             Image image = null;
  418.             try {
  419.                 image = reader.acquireLatestImage();
  420.                 if (image != null) {
  421.                     // 处理图片数据
  422.                     ByteBuffer buffer = image.getPlanes()[0].getBuffer();
  423.                     byte[] data = new byte[buffer.remaining()];
  424.                     buffer.get(data);
  425.                     new ProcessPhotoAsyncTask(TakePhotoZoomActivity.this, Integer.valueOf(currentCameraId), data, null, processImageHandler).execute();
  426.                 }
  427.             } finally {
  428.                 if (image != null) {
  429.                     image.close();
  430.                 }
  431.             }
  432.         }
  433.     };
  434.  
  435.     private void switchCamera() {
  436.         closeCamera();
  437.         if (currentCameraId.equals(Integer.toString(CameraCharacteristics.LENS_FACING_BACK))) {
  438.             setupCamera(Integer.toString(CameraCharacteristics.LENS_FACING_FRONT));
  439.         } else {
  440.             setupCamera(Integer.toString(CameraCharacteristics.LENS_FACING_BACK));
  441.         }
  442.         openCamera();
  443.     }
  444.  
  445.     @Override
  446.     protected void onPause() {
  447.         closeCamera();
  448.         super.onPause();
  449.     }
  450.  
  451.     public static List<String> getUsbCameraIds(Context context) {
  452.         List<String> usbCameraIds = new ArrayList<>();
  453.         try {
  454.             CameraManager cameraManager = (CameraManager) context.getSystemService(Context.CAMERA_SERVICE);
  455.             for (String cameraId : cameraManager.getCameraIdList()) {
  456.                 CameraCharacteristics characteristics = cameraManager.getCameraCharacteristics(cameraId);
  457.                 Integer hardwareLevel = characteristics.get(CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL);
  458.                 if (hardwareLevel != null && hardwareLevel == CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_EXTERNAL) {
  459.                     usbCameraIds.add(cameraId);
  460.                 }
  461.             }
  462.         } catch (CameraAccessException e) {
  463.             e.printStackTrace();
  464.         }
  465.         return usbCameraIds;
  466.     }
  467.  
  468.  
  469.     // 更新缩放
  470.     public void setZoom(float zoomLevel) {
  471.         try {
  472.             Rect zoomRect = calculateZoomRect(zoomLevel);
  473.             CaptureRequest.Builder captureBuilder = cameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
  474.             captureBuilder.addTarget(imageReader.getSurface());
  475.             captureBuilder.set(CaptureRequest.SCALER_CROP_REGION, zoomRect);
  476.             captureSession.setRepeatingRequest(captureBuilder.build(), null, backgroundHandler);
  477.             currentZoomLevel = zoomLevel;
  478.         } catch (CameraAccessException e) {
  479.             e.printStackTrace();
  480.         }
  481.     }
  482.  
  483.     private Rect calculateZoomRect(float zoomLevel) {
  484.         CameraCharacteristics characteristics = null;
  485.         try {
  486.             characteristics = cameraManager.getCameraCharacteristics(currentCameraId);
  487.         } catch (CameraAccessException e) {
  488.             throw new RuntimeException(e);
  489.         }
  490.         Rect activeArraySize = characteristics.get(CameraCharacteristics.SENSOR_INFO_ACTIVE_ARRAY_SIZE);
  491.         int cropWidth = (int) (activeArraySize.width() / zoomLevel);
  492.         int cropHeight = (int) (activeArraySize.height() / zoomLevel);
  493.         int cropLeft = (activeArraySize.width() - cropWidth) / 2;
  494.         int cropTop = (activeArraySize.height() - cropHeight) / 2;
  495.         return new Rect(cropLeft, cropTop, cropLeft + cropWidth, cropTop + cropHeight);
  496.     }
  497.  
  498.     private void showCameraControlsDialog() {
  499.         if (!cameraCapabilitiesInitialized) {
  500.             initializeCameraCapabilities();
  501.         }
  502.         if (isDialogVisible) return;
  503.  
  504.         CameraControlsDialogFragment dialog = CameraControlsDialogFragment.newInstance(supportsAutoFocus, supportsZoom, maxZoom);
  505.         dialog.show(getSupportFragmentManager(), "CameraControlsDialogFragment");
  506.         isDialogVisible = true;
  507.  
  508.         // 监听对话框消失事件，重置标记
  509.         getSupportFragmentManager().executePendingTransactions();
  510.         dialog.getDialog().setOnDismissListener(dialogInterface -> isDialogVisible = false);
  511.     }
  512.  
  513.     private void initializeCameraCapabilities() {
  514.         cameraManager = (CameraManager) getSystemService(Context.CAMERA_SERVICE);
  515.         try {
  516.             CameraCharacteristics characteristics = cameraManager.getCameraCharacteristics(currentCameraId);
  517.             checkCameraCapabilities(characteristics);
  518.             cameraCapabilitiesInitialized = true;
  519.         } catch (CameraAccessException e) {
  520.             e.printStackTrace();
  521.         }
  522.     }
  523.  
  524.     private void checkCameraCapabilities(CameraCharacteristics characteristics) {
  525.         int[] afModes = characteristics.get(CameraCharacteristics.CONTROL_AF_AVAILABLE_MODES);
  526.         supportsAutoFocus = afModes != null && afModes.length > 0;
  527.         for (int mode : afModes) {
  528.             if (mode == CameraCharacteristics.CONTROL_AF_MODE_OFF) {
  529.                 supportsAutoFocus = true;
  530.                 break;
  531.             }
  532.         }
  533.         Float maxZoom = characteristics.get(CameraCharacteristics.SCALER_AVAILABLE_MAX_DIGITAL_ZOOM);
  534.         supportsZoom = maxZoom != null && maxZoom > 1.0;
  535.         this.maxZoom = supportsZoom ? maxZoom : 1.0f;
  536.     }
  537.  
  538.     public void setFocusDistance(float distance) {
  539.         if (cameraDevice == null || captureSession == null) return;
  540.         try {
  541.             // 在原有的 captureRequestBuilder 上直接进行修改
  542.             captureRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE, CaptureRequest.CONTROL_AF_MODE_OFF);
  543.             captureRequestBuilder.set(CaptureRequest.LENS_FOCUS_DISTANCE, distance);
  544.  
  545.             // 重新设置重复请求以应用新的对焦距离
  546.             captureSession.setRepeatingRequest(captureRequestBuilder.build(), null, backgroundHandler);
  547.             currentFocusDistance = distance;
  548.         } catch (CameraAccessException e) {
  549.             e.printStackTrace();
  550.         }
  551.     }
  552.  
  553.  
  554.     private void closeCamera() {
  555.         if (captureSession != null) {
  556.             captureSession.close();
  557.             captureSession = null;
  558.         }
  559.         if (cameraDevice != null) {
  560.             cameraDevice.close();
  561.             cameraDevice = null;
  562.         }
  563.         if (imageReader != null) {
  564.             imageReader.close();
  565.             imageReader = null;
  566.         }
  567.     }
  568.  
  569.     @Override
  570.     protected void onDestroy() {
  571.         super.onDestroy();
  572.         closeCamera();
  573.     }
  574. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/天景科技苑/article/detail/1017149
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号