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

Camera基本属性了解及设置_setpreviewsize

作者：羊村懒王 | 2024-02-18 00:30:13

赞

踩

setpreviewsize

  将camera肯定是要有预览界面来配合着才有激情，不然无图无真相。那就讲的没有太大的激情。

  我们对camera的使用一般是在app里面有用到设置获取图片的时候提供一个拍照功能，一般是跳转到系统的拍照界面使用camera来获取图片；有的app有需求就跳转到自己的拍照界面。我们知道系统的应用其实也是个app，无论是跳转到系统拍照界面还是自己的拍照界面其实都是一个preview，然后再“截屏”生成一个图片。我下面讲一些关于camera的基础和preview的结合使用。

  首先要获取camera的属性：Camera.Parameters parameters = camera.getParameters();

 camera的基本属性设置：

  （1）设置预览大小 :  

    parameters.setPreviewSize(“宽”, “高”);

   一般设置的预览大小就是手机屏幕的宽高，那么就要获取屏幕的宽高，然后再经过稍微的处理：

  1.   WindowManager manager = (WindowManager) mContext.getSystemService(Context.WINDOW_SERVICE);
  2.         Display display = manager.getDefaultDisplay();
  3. 	宽：display.getWidth()  高：display.getHeight()
 由于下面的介绍都会用到一个系统的实体Point,所以我这里把宽高设置到这个实体里面，然后方便使用，然后就得到下面的代码： 

  1.  WindowManager manager = (WindowManager) mContext.getSystemService(Context.WINDOW_SERVICE);
  2.         Display display = manager.getDefaultDisplay();
  3.  
  4.         //获取屏幕的宽高（像素值）设置到一个实体(point)里面
  5.        Point screenResolution = new Point(display.getWidth(), display.getHeight());
然后再根据屏幕的宽高做优化处理： 

  1.  /*根据相机的参数和手机屏幕参数来重新设置相机的*/
  2.     public Point getCameraResolution(Camera.Parameters parameters, Point screenResolution) {
  3.         String previewSizeValueString = parameters.get("preview-size-values");
  4.         if (previewSizeValueString == null) {
  5.             previewSizeValueString = parameters.get("preview-size-value");
  6.         }
  7.  
  8.         Point cameraResolution = null;
  9.  
  10.         if (previewSizeValueString != null) {
  11.             cameraResolution = findBestPreviewSizeValue(previewSizeValueString, screenResolution);
  12.         }
  13.  
  14.         if (cameraResolution == null) {
  15.             //没有找到最优的预览效果,那么至少也要确保相机分辨率是8的倍数(我也不知道为什么)，下面的操作就是防备屏幕不是8的倍数，如果
  16.             //是8的倍数，就会在上面的寻找最优size的时候会找到的
  17.             cameraResolution = new Point(
  18.                     (screenResolution.x >> 3) << 3,
  19.                     (screenResolution.y >> 3) << 3);
  20.         }
  21.         return cameraResolution;
  22.     }
  23.  
  24.     /*根据预览大小和手机屏幕大小来设一个比较完美的预览效果*/
  25.     public Point findBestPreviewSizeValue(CharSequence previewSizeValueString, Point screenResolution) {
  26.         int bestX = 0;
  27.         int bestY = 0;
  28.         int diff = Integer.MAX_VALUE;//差值
  29.         for (String previewSize : COMMA_PATTERN.split(previewSizeValueString)) {
  30.  
  31.             previewSize = previewSize.trim();
  32.             int dimPosition = previewSize.indexOf('x');
  33.             if (dimPosition < 0) {
  34.                 //这是一个很差的预览大小
  35.                 continue;
  36.             }
  37.  
  38.             int newX;
  39.             int newY;
  40.             try {
  41.                 newX = Integer.parseInt(previewSize.substring(0, dimPosition));
  42.                 newY = Integer.parseInt(previewSize.substring(dimPosition + 1));
  43.             } catch (NumberFormatException nfe) {
  44.                 //字符串转换异常，这是自己写的tryCatch，是为了安全起见
  45.                 continue;
  46.             }
  47.  
  48.             int newDiff = Math.abs(newX - screenResolution.x) + Math.abs(newY - screenResolution.y);
  49.  
  50.             if (newDiff == 0) {
  51.                 bestX = newX;
  52.                 bestY = newY;
  53.                 break;
  54.             } else if (newDiff < diff) {
  55.                 bestX = newX;
  56.                 bestY = newY;
  57.                 diff = newDiff;
  58.             }
  59.         }
  60.  
  61.         if (bestY > 0 && bestX > 0) {
  62.             return new Point(bestX, bestY);
  63.         }
  64.  
  65.         return null;
  66.     }

最后把优化处理之后的point的数据设置个camera的parameters： 

  1.  Camera.Parameters parameters = camera.getParameters();
  2.         parameters.setPreviewSize(cameraResolution.x, cameraResolution.y);//设置相机的预览size


（2）设置闪光灯：

  

  1.  /*设置闪光灯，本来是不用设置的，应该是直接获取，但是根据三星建议说防止黑客攻击，最好设置一下*/
  2.     private void setFlash(Camera.Parameters parameters) {
  3.         if (Build.MODEL.contains("Behold II") && Integer.parseInt(Build.VERSION.SDK) == 3) {
  4.             parameters.set("flash-value", 1);
  5.         } else {
  6.             parameters.set("flash-value", 2);
  7.         }
  8.         parameters.set("flash-mode", "off");
  9.     }

（3）设置缩放：

   一般使用camera进行拍照和录制视频的时候都要支持手势识别进行缩放，原理就是把手势缩放的xy值然后进行算法转换然后动态的设置到camera的parameter上。

  1.  /*设置缩放*/
  2.     private void setZoom(Camera.Parameters parameters) {
  3.         String zoomSupportString = parameters.get("zoom-supported");
  4.         if (zoomSupportString != null && !Boolean.parseBoolean(zoomSupportString)) {
  5.             return;
  6.         }
  7.  
  8.         int tenDesiredZoom = TEN_DESIRED_ZOOM;//TEN_DESIRED_ZOOM = 27
  9.  
  10.         String maxZoomString = parameters.get("max-zoom");
  11.         if (maxZoomString != null) {
  12.             try {
  13.                 int tenMaxZoom = (int) (10.0 * Double.parseDouble(maxZoomString));
  14.                 if (tenDesiredZoom > tenMaxZoom) {
  15.                     tenDesiredZoom = tenMaxZoom;
  16.                 }
  17.             } catch (NumberFormatException e) {
  18.                 Log.i(TAG, "获取原本的缩放最大级别转换失败");
  19.             }
  20.  
  21.             String takingPictureZoomMaxString = parameters.get("taking-picture-zoom-max");
  22.             if (takingPictureZoomMaxString != null) {
  23.                 try {
  24.                     int takePicMax = Integer.parseInt(takingPictureZoomMaxString);
  25.                     if (tenDesiredZoom > takePicMax) {
  26.                         tenDesiredZoom = takePicMax;
  27.                     }
  28.                     Log.i(TAG, "拍照缩放级别被最原始级别小");
  29.                 } catch (NumberFormatException nfe) {
  30.                     Log.i(TAG, "拍照缩放级别转换失败");
  31.                 }
  32.             }
  33.  
  34.             String motZoomMaxString = parameters.get("mot-zoom-values");
  35.             if (motZoomMaxString != null) {
  36.                 tenDesiredZoom = findBestMotZoomValue(motZoomMaxString, tenDesiredZoom);
  37.             }
  38.  
  39.             String motZoomStepString = parameters.get("mot-zoom-step");
  40.             if (motZoomStepString != null) {
  41.                 try {
  42.                     double motZoomStep = Double.parseDouble(motZoomStepString.trim());
  43.                     int tenZoomStep = (int) (10.0 * motZoomStep);
  44.                     if (tenZoomStep > 1) {
  45.                         tenDesiredZoom -= tenDesiredZoom % tenZoomStep;
  46.                     }
  47.                 } catch (NumberFormatException nfe) {
  48.  
  49.                 }
  50.             }
  51.  
  52.             if (maxZoomString != null || motZoomMaxString != null) {
  53.                 parameters.set("zoom", String.valueOf(tenDesiredZoom / 10.0));
  54.             }
  55.  
  56.             if (takingPictureZoomMaxString != null) {
  57.                 parameters.set("taking-picture-zoom", tenDesiredZoom);
  58.             }
  59.         }
  60.     }
  61.  
  62.     private static int findBestMotZoomValue(CharSequence stringValues, int tenDesireZoom) {
  63.  
  64.         int tenBestValue = 0;
  65.         for (String stringValue : COMMA_PATTERN.split(stringValues)) {
  66.             stringValue = stringValue.trim();
  67.             double value;
  68.             try {
  69.                 value = Double.parseDouble(stringValue);
  70.             } catch (NumberFormatException nfe) {
  71.                 return tenDesireZoom;
  72.             }
  73.  
  74.             int tenValue = (int) (10.0 * value);
  75.             if (Math.abs(tenDesireZoom - value) < Math.abs(tenDesireZoom - tenBestValue)) {
  76.                 tenBestValue = tenValue;
  77.             }
  78.         }
  79.         return tenBestValue;
  80.     }
使用的时候你可以直接进行设置,parameter.set("zoom","10");来设置缩放。

 最后贴一个完整测camera的配置类：

 

  1. import android.content.Context;
  2. import android.graphics.Point;
  3. import android.hardware.Camera;
  4. import android.os.Build;
  5. import android.util.Log;
  6. import android.view.Display;
  7. import android.view.WindowManager;
  8.  
  9. import java.lang.reflect.Method;
  10. import java.util.regex.Pattern;
  11.  
  12.  
  13. public class CameraConfigurationManager {
  14.     private static final String TAG = "Cy==CameraConfigManager";
  15.     private Context mContext;
  16.     private Point screenResolution;
  17.     private static final Pattern COMMA_PATTERN = Pattern.compile(",");
  18.     private Point cameraResolution;
  19.     private static final int TEN_DESIRED_ZOOM = 27;//设置十级缩放级别
  20.     private int previewFormat;
  21.     private String previewFormatString;
  22.  
  23.     private CameraConfigurationManager() {
  24.     }
  25.  
  26.     public Point getCameraResolution() {
  27.         return cameraResolution;
  28.     }
  29.  
  30.     public Point getScreenResolution() {
  31.         return screenResolution;
  32.     }
  33.  
  34.     public int getPreviewFormat() {
  35.         return previewFormat;
  36.     }
  37.  
  38.     public String getPreviewFormatString() {
  39.         return previewFormatString;
  40.     }
  41.  
  42.     private static final class Holder {
  43.         private static final CameraConfigurationManager CAMERA_CONFIGURATION_MANAGER = new CameraConfigurationManager();
  44.     }
  45.  
  46.     public static CameraConfigurationManager getInstance() {
  47.         return Holder.CAMERA_CONFIGURATION_MANAGER;
  48.     }
  49.  
  50.     public CameraConfigurationManager setContext(Context mContext) {
  51.         this.mContext = mContext;
  52.         return this;
  53.     }
  54.  
  55.     /*获取手机的相机和手机屏幕的一些基本参数*/
  56.     public void getCameraParams(Camera camera) {
  57.         Camera.Parameters parameters = camera.getParameters();
  58.         //获取相机预览界面格式
  59.         previewFormat = parameters.getPreviewFormat();
  60.         previewFormatString = parameters.get("preview-format");
  61.  
  62.         WindowManager manager = (WindowManager) mContext.getSystemService(Context.WINDOW_SERVICE);
  63.         Display display = manager.getDefaultDisplay();
  64.  
  65.         //获取屏幕的宽高（像素值）设置到一个实体(point)里面
  66.         screenResolution = new Point(display.getWidth(), display.getHeight());
  67.         //尽量获取相机最好的point
  68.         cameraResolution = getCameraResolution(parameters, screenResolution);
  69.     }
  70.  
  71.     /*设置相机的预览参数（渴望设置成什么样就设置成什么样）*/
  72.     public void setDseiredCameraParameters(Camera camera) {
  73.         Camera.Parameters parameters = camera.getParameters();
  74.         parameters.setPreviewSize(cameraResolution.x, cameraResolution.y);//设置相机的预览size
  75.         setFlash(parameters);
  76.         setZoom(parameters);
  77.         setDisplayOrientation(camera, 90);
  78.         camera.setParameters(parameters);
  79.     }
  80.  
  81.     /*设置展示角度*/
  82.     private void setDisplayOrientation(Camera camera, int orientation) {
  83.         Class<? extends Camera> clazz = camera.getClass();
  84.         try {
  85.             Method displayOrientation = clazz.getMethod("setDisplayOrientation", new Class[]{int.class});
  86.             if (displayOrientation != null) {
  87.                 displayOrientation.invoke(camera, new Object[]{orientation});
  88.             }
  89.         } catch (Exception e) {
  90.             e.printStackTrace();
  91.         }
  92.  
  93.     }
  94.  
  95.     /*设置缩放*/
  96.     private void setZoom(Camera.Parameters parameters) {
  97.         String zoomSupportString = parameters.get("zoom-supported");
  98.         if (zoomSupportString != null && !Boolean.parseBoolean(zoomSupportString)) {
  99.             return;
  100.         }
  101.  
  102.         int tenDesiredZoom = TEN_DESIRED_ZOOM;//TEN_DESIRED_ZOOM = 27
  103.  
  104.         String maxZoomString = parameters.get("max-zoom");
  105.         if (maxZoomString != null) {
  106.             try {
  107.                 int tenMaxZoom = (int) (10.0 * Double.parseDouble(maxZoomString));
  108.                 if (tenDesiredZoom > tenMaxZoom) {
  109.                     tenDesiredZoom = tenMaxZoom;
  110.                 }
  111.             } catch (NumberFormatException e) {
  112.                 Log.i(TAG, "获取原本的缩放最大级别转换失败");
  113.             }
  114.  
  115.             String takingPictureZoomMaxString = parameters.get("taking-picture-zoom-max");
  116.             if (takingPictureZoomMaxString != null) {
  117.                 try {
  118.                     int takePicMax = Integer.parseInt(takingPictureZoomMaxString);
  119.                     if (tenDesiredZoom > takePicMax) {
  120.                         tenDesiredZoom = takePicMax;
  121.                     }
  122.                     Log.i(TAG, "拍照缩放级别被最原始级别小");
  123.                 } catch (NumberFormatException nfe) {
  124.                     Log.i(TAG, "拍照缩放级别转换失败");
  125.                 }
  126.             }
  127.  
  128.             String motZoomMaxString = parameters.get("mot-zoom-values");
  129.             if (motZoomMaxString != null) {
  130.                 tenDesiredZoom = findBestMotZoomValue(motZoomMaxString, tenDesiredZoom);
  131.             }
  132.  
  133.             String motZoomStepString = parameters.get("mot-zoom-step");
  134.             if (motZoomStepString != null) {
  135.                 try {
  136.                     double motZoomStep = Double.parseDouble(motZoomStepString.trim());
  137.                     int tenZoomStep = (int) (10.0 * motZoomStep);
  138.                     if (tenZoomStep > 1) {
  139.                         tenDesiredZoom -= tenDesiredZoom % tenZoomStep;
  140.                     }
  141.                 } catch (NumberFormatException nfe) {
  142.  
  143.                 }
  144.             }
  145.  
  146.             if (maxZoomString != null || motZoomMaxString != null) {
  147.                 parameters.set("zoom", String.valueOf(tenDesiredZoom / 10.0));
  148.             }
  149.  
  150.             if (takingPictureZoomMaxString != null) {
  151.                 parameters.set("taking-picture-zoom", tenDesiredZoom);
  152.             }
  153.         }
  154.     }
  155.  
  156.     private static int findBestMotZoomValue(CharSequence stringValues, int tenDesireZoom) {
  157.  
  158.         int tenBestValue = 0;
  159.         for (String stringValue : COMMA_PATTERN.split(stringValues)) {
  160.             stringValue = stringValue.trim();
  161.             double value;
  162.             try {
  163.                 value = Double.parseDouble(stringValue);
  164.             } catch (NumberFormatException nfe) {
  165.                 return tenDesireZoom;
  166.             }
  167.  
  168.             int tenValue = (int) (10.0 * value);
  169.             if (Math.abs(tenDesireZoom - value) < Math.abs(tenDesireZoom - tenBestValue)) {
  170.                 tenBestValue = tenValue;
  171.             }
  172.         }
  173.         return tenBestValue;
  174.     }
  175.  
  176.     /*设置闪光灯，本来是不用设置的，应该是直接获取，但是根据三星建议说防止黑客攻击，最好设置一下*/
  177.     private void setFlash(Camera.Parameters parameters) {
  178.         if (Build.MODEL.contains("Behold II") && CameraManager.SDK_INT == 3) {
  179.             parameters.set("flash-value", 1);
  180.         } else {
  181.             parameters.set("flash-value", 2);
  182.         }
  183.         parameters.set("flash-mode", "off");
  184.     }
  185.  
  186.     /*根据相机的参数和手机屏幕参数来重新设置相机的*/
  187.     public Point getCameraResolution(Camera.Parameters parameters, Point screenResolution) {
  188.         String previewSizeValueString = parameters.get("preview-size-values");
  189.         if (previewSizeValueString == null) {
  190.             previewSizeValueString = parameters.get("preview-size-value");
  191.         }
  192.  
  193.         Point cameraResolution = null;
  194.  
  195.         if (previewSizeValueString != null) {
  196.             cameraResolution = findBestPreviewSizeValue(previewSizeValueString, screenResolution);
  197.         }
  198.  
  199.         if (cameraResolution == null) {
  200.             //没有找到最优的预览效果,那么至少也要确保相机分辨率是8的倍数(我也不知道为什么)，下面的操作就是防备屏幕不是8的倍数，如果
  201.             //是8的倍数，就会在上面的寻找最优size的时候会找到的
  202.             cameraResolution = new Point(
  203.                     (screenResolution.x >> 3) << 3,
  204.                     (screenResolution.y >> 3) << 3);
  205.         }
  206.         return cameraResolution;
  207.     }
  208.  
  209.     /*根据预览大小和手机屏幕大小来设一个比较完美的预览效果*/
  210.     public Point findBestPreviewSizeValue(CharSequence previewSizeValueString, Point screenResolution) {
  211.         int bestX = 0;
  212.         int bestY = 0;
  213.         int diff = Integer.MAX_VALUE;//差值
  214.         for (String previewSize : COMMA_PATTERN.split(previewSizeValueString)) {
  215.  
  216.             previewSize = previewSize.trim();
  217.             int dimPosition = previewSize.indexOf('x');
  218.             if (dimPosition < 0) {
  219.                 //这是一个很差的预览大小
  220.                 continue;
  221.             }
  222.  
  223.             int newX;
  224.             int newY;
  225.             try {
  226.                 newX = Integer.parseInt(previewSize.substring(0, dimPosition));
  227.                 newY = Integer.parseInt(previewSize.substring(dimPosition + 1));
  228.             } catch (NumberFormatException nfe) {
  229.                 //字符串转换异常，这是自己写的tryCatch，是为了安全起见
  230.                 continue;
  231.             }
  232.  
  233.             int newDiff = Math.abs(newX - screenResolution.x) + Math.abs(newY - screenResolution.y);
  234.  
  235.             if (newDiff == 0) {
  236.                 bestX = newX;
  237.                 bestY = newY;
  238.                 break;
  239.             } else if (newDiff < diff) {
  240.                 bestX = newX;
  241.                 bestY = newY;
  242.                 diff = newDiff;
  243.             }
  244.         }
  245.  
  246.         if (bestY > 0 && bestX > 0) {
  247.             return new Point(bestX, bestY);
  248.         }
  249.  
  250.         return null;
  251.     }
  252. }



 

    

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

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

  

闽ICP备14008679号