public void zoom(int step) {
   Camera.Parameters parameters = mCamera.getParameters();
   if (!parameters.isZoomSupported()) return;
   int zoom = parameters.getZoom() + step;
   if (zoom > parameters.getMaxZoom()) zoom = parameters.getMaxZoom();
   else if (zoom < 0) zoom = 0;
   parameters.setZoom(zoom);
   String str = parameters.getZoomRatios().get(zoom) + "%";
   zoomText.setText(str);
   mCamera.setParameters(parameters);
 }
  public int doZoom(float scale) {
    synchronized (mCameraLock) {
      if (mCamera == null) {
        return 0;
      }
      int currentZoom = 0;
      int maxZoom;
      Camera.Parameters parameters = mCamera.getParameters();
      if (!parameters.isZoomSupported()) {
        Log.w(TAG, mContext.getString(R.string.zoom_not_supported));
        return currentZoom;
      }
      maxZoom = parameters.getMaxZoom();

      currentZoom = parameters.getZoom() + 1;
      float newZoom;
      if (scale > 1) {
        newZoom = currentZoom + scale * (maxZoom / 10);
      } else {
        newZoom = currentZoom * scale;
      }
      currentZoom = Math.round(newZoom) - 1;
      if (currentZoom < 0) {
        currentZoom = 0;
      } else if (currentZoom > maxZoom) {
        currentZoom = maxZoom;
      }
      parameters.setZoom(currentZoom);
      mCamera.setParameters(parameters);
      return currentZoom;
    }
  }
  protected void enableZoomControls(Camera.Parameters params) {
    final SharedPreferences settings = getContext().getSharedPreferences("ZoomCtl", 0);

    // set zoom level to previously set level if available, otherwise maxZoom
    final int maxZoom = params.getMaxZoom();
    int currentZoom = settings.getInt("ZoomLvl", maxZoom);
    params.setZoom(currentZoom);

    if (_zoomControl == null) return;

    _zoomControl.setMax(maxZoom);
    _zoomControl.setProgress(currentZoom);
    _zoomControl.setOnSeekBarChangeListener(
        new SeekBar.OnSeekBarChangeListener() {
          @Override
          public void onProgressChanged(SeekBar seekBar, int progress, boolean fromUser) {
            Camera.Parameters params = mCamera.getParameters();
            params.setZoom(progress);
            mCamera.setParameters(params);

            if (settings != null) {
              SharedPreferences.Editor editor = settings.edit();
              editor.putInt("ZoomLvl", progress);
              editor.apply();
            }
          }

          @Override
          public void onStartTrackingTouch(SeekBar seekBar) {}

          @Override
          public void onStopTrackingTouch(SeekBar seekBar) {}
        });
  }
Exemple #4
0
  /** 焦点放大 */
  public void zoomIn() {
    if (camera != null && camera.getParameters().isZoomSupported()) {

      Camera.Parameters parameters = camera.getParameters();
      if (parameters.getZoom() >= parameters.getMaxZoom()) {
        return;
      }

      parameters.setZoom(parameters.getZoom() + 1);
      camera.setParameters(parameters);
    }
  }
Exemple #5
0
  public ZoomTransaction zoomTo(int level) {
    if (camera == null) {
      throw new IllegalStateException("Yes, we have no camera, we have no camera today");
    } else {
      Camera.Parameters params = camera.getParameters();

      if (level >= 0 && level <= params.getMaxZoom()) {
        return (new ZoomTransaction(camera, level));
      } else {
        throw new IllegalArgumentException(String.format("Invalid zoom level: %d", level));
      }
    }
  }
 @Override
 public void onCreate(Bundle savedInstanceState) {
   super.onCreate(savedInstanceState);
   boolean useFrontCamera = getArguments().getBoolean(FRONT_CAMERA, false);
   camera = getCameraInstance(useFrontCamera);
   if (camera == null) {
     return;
   }
   initScreenParams();
   parameters = camera.getParameters();
   zoomRatios = parameters.getZoomRatios();
   zoomIndex = minZoomIndex = 0;
   maxZoomIndex = parameters.getMaxZoom();
   previewSizes = buildPreviewSizesRatioMap(parameters.getSupportedPreviewSizes());
   pictureSizes = buildPictureSizesRatioMap(parameters.getSupportedPictureSizes());
   List<String> sceneModes = parameters.getSupportedSceneModes();
   if (sceneModes != null) {
     for (String mode : sceneModes) {
       if (mode.equals(Camera.Parameters.SCENE_MODE_HDR)) {
         supportedHDR = true;
         break;
       }
     }
   }
   // it returns false positive
   /*getActivity().getApplicationContext().getPackageManager()
   .hasSystemFeature(PackageManager.FEATURE_CAMERA_FLASH);*/
   List<String> flashModes = parameters.getSupportedFlashModes();
   if (flashModes == null || flashModes.size() <= 1) {
     /* Device has no flash */
     supportedFlash = false;
   } else {
     supportedFlash = true;
   }
   if (CameraConst.DEBUG) {
     Timber.d("PictureSizesRatioMap:");
     for (Ratio r : pictureSizes.keySet()) {
       Timber.d(r.toString() + ":");
       for (Quality q : pictureSizes.get(r).keySet()) {
         Camera.Size size = pictureSizes.get(r).get(q);
         if (size != null) {
           Timber.d(q.toString() + ": " + size.width + "x" + size.height);
         }
       }
     }
   }
   expandParams(getArguments());
   initParams();
 }
Exemple #7
0
  public void zoomin(float m) {
    if (params.isZoomSupported()) {
      maxZoomLevel = params.getMaxZoom();

      float zoom = (float) currentZoomLevel;

      zoom += (m / 100f);

      currentZoomLevel = (int) zoom;

      if (currentZoomLevel > maxZoomLevel) currentZoomLevel = maxZoomLevel;
      if (currentZoomLevel < 1) currentZoomLevel = 1;

      params.setZoom(currentZoomLevel);
      mCamera.setParameters(params);
    }
  }
 private static Integer indexOfClosestZoom(Camera.Parameters parameters, double targetZoomRatio) {
   List<Integer> ratios = parameters.getZoomRatios();
   Log.i(TAG, "Zoom ratios: " + ratios);
   int maxZoom = parameters.getMaxZoom();
   if (ratios == null || ratios.isEmpty() || ratios.size() != maxZoom + 1) {
     Log.w(TAG, "Invalid zoom ratios!");
     return null;
   }
   double target100 = 100.0 * targetZoomRatio;
   double smallestDiff = Double.POSITIVE_INFINITY;
   int closestIndex = 0;
   for (int i = 0; i < ratios.size(); i++) {
     double diff = Math.abs(ratios.get(i) - target100);
     if (diff < smallestDiff) {
       smallestDiff = diff;
       closestIndex = i;
     }
   }
   Log.i(TAG, "Chose zoom ratio of " + (ratios.get(closestIndex) / 100.0));
   return closestIndex;
 }
  /**
   * Get the available 'crop' (zoom) rectangles for this camera.
   *
   * <p>When zoom is supported, this will return a list of {@code 1 + #getMaxZoom} size, where each
   * crop rectangle corresponds to a zoom ratio (and is centered at the middle).
   *
   * <p>Each crop rectangle is changed to have the same aspect ratio as {@code streamSize}, by
   * shrinking the rectangle if necessary.
   *
   * <p>To get the reported crop region when applying a zoom to the sensor, use {@code streamSize} =
   * {@code activeArray size}.
   *
   * @param params non-{@code null} camera api1 parameters
   * @param activeArray active array dimensions, in sensor space
   * @param streamSize stream size dimensions, in pixels
   * @return a list of available zoom rectangles, sorted from least zoomed to most zoomed
   */
  private static List<Rect> getAvailableCropRectangles(
      Camera.Parameters params, Rect activeArray, Size streamSize) {
    checkNotNull(params, "params must not be null");
    checkNotNull(activeArray, "activeArray must not be null");
    checkNotNull(streamSize, "streamSize must not be null");

    // TODO: change all uses of Rect activeArray to Size activeArray,
    // since we want the crop to be active-array relative, not pixel-array relative

    Rect unzoomedStreamCrop = getPreviewCropRectangleUnzoomed(activeArray, streamSize);

    if (!params.isZoomSupported()) {
      // Trivial case: No zoom -> only support the full size as the crop region
      return new ArrayList<>(Arrays.asList(unzoomedStreamCrop));
    }

    List<Rect> zoomCropRectangles = new ArrayList<>(params.getMaxZoom() + 1);
    Matrix scaleMatrix = new Matrix();
    RectF scaledRect = new RectF();

    for (int zoom : params.getZoomRatios()) {
      float shrinkRatio = ZOOM_RATIO_MULTIPLIER * 1.0f / zoom; // normalize to 1.0 and smaller

      // set scaledRect to unzoomedStreamCrop
      ParamsUtils.convertRectF(unzoomedStreamCrop, /*out*/ scaledRect);

      scaleMatrix.setScale(
          shrinkRatio, shrinkRatio, activeArray.exactCenterX(), activeArray.exactCenterY());

      scaleMatrix.mapRect(scaledRect);

      Rect intRect = ParamsUtils.createRect(scaledRect);

      // Round the rect corners towards the nearest integer values
      zoomCropRectangles.add(intRect);
    }

    return zoomCropRectangles;
  }
 public int getMaxZoom() {
   Camera.Parameters parameters = mCamera.getParameters();
   if (!parameters.isZoomSupported()) return 0;
   return parameters.getMaxZoom();
 }