private static void mapAf(CameraMetadataNative m,
        Rect activeArray, ZoomData zoomData, Camera.Parameters p) {
    // control.afMode
    m.set(CaptureResult.CONTROL_AF_MODE, convertLegacyAfMode(p.getFocusMode()));

    // control.afRegions
    if (p.getMaxNumFocusAreas() > 0) {
        if (DEBUG) {
            String focusAreas = p.get("focus-areas");
            Log.v(TAG, "mapAe - parameter dump; focus-areas: " + focusAreas);
        }

        MeteringRectangle[] meteringRectArray = getMeteringRectangles(activeArray,
                zoomData, p.getFocusAreas(), "AF");

        m.set(CONTROL_AF_REGIONS, meteringRectArray);
    }
}
 

private static MeteringRectangle[] getMeteringRectangles(Rect activeArray, ZoomData zoomData,
        List<Camera.Area> meteringAreaList, String regionName) {
    List<MeteringRectangle> meteringRectList = new ArrayList<>();
    if (meteringAreaList != null) {
        for (Camera.Area area : meteringAreaList) {
            WeightedRectangle rect =
                    ParameterUtils.convertCameraAreaToActiveArrayRectangle(
                            activeArray, zoomData, area);

            meteringRectList.add(rect.toMetering());
        }
    }

    if (DEBUG) {
        Log.v(TAG,
                "Metering rectangles for " + regionName + ": "
                 + ListUtils.listToString(meteringRectList));
    }

    return meteringRectList.toArray(new MeteringRectangle[0]);
}
 

/**
 * Convert to a metering rectangle, clipping any of the values to stay within range.
 *
 * <p>If values are clipped, a warning is printed to logcat.</p>
 *
 * @return a new metering rectangle
 */
public MeteringRectangle toMetering() {
    int weight = clip(this.weight,
            MeteringRectangle.METERING_WEIGHT_MIN,
            MeteringRectangle.METERING_WEIGHT_MAX,
            rect,
            "weight");

    int x = clipLower(rect.left, /*lo*/0, rect, "left");
    int y = clipLower(rect.top, /*lo*/0, rect, "top");
    int w = clipLower(rect.width(), /*lo*/0, rect, "width");
    int h = clipLower(rect.height(), /*lo*/0, rect, "height");

    return new MeteringRectangle(x, y, w, h, weight);
}
 

@Override
public void marshal(MeteringRectangle value, ByteBuffer buffer) {
    int xMin = value.getX();
    int yMin = value.getY();
    int xMax = xMin + value.getWidth();
    int yMax = yMin + value.getHeight();
    int weight = value.getMeteringWeight();

    buffer.putInt(xMin);
    buffer.putInt(yMin);
    buffer.putInt(xMax);
    buffer.putInt(yMax);
    buffer.putInt(weight);
}
 

@Override
public MeteringRectangle unmarshal(ByteBuffer buffer) {
    int xMin = buffer.getInt();
    int yMin = buffer.getInt();
    int xMax = buffer.getInt();
    int yMax = buffer.getInt();
    int weight = buffer.getInt();

    int width = xMax - xMin;
    int height = yMax - yMin;

    return new MeteringRectangle(xMin, yMin, width, height, weight);
}
 

public void autoFocus(@Nullable AutoFocusCallback cb, MotionEvent pEvent, int screenW, int screenH) {
    if (cb != null) {
        mAutoFocusCallback = cb;
    }
    if (sensorArraySize != null) {
        final int y = (int) pEvent.getX() / screenW * sensorArraySize.height();
        final int x = (int) pEvent.getY() / screenH * sensorArraySize.width();
        final int halfTouchWidth = 150;
        final int halfTouchHeight = 150;
        MeteringRectangle focusAreaTouch = new MeteringRectangle(
                Math.max(x - halfTouchWidth, 0),
                Math.max(y - halfTouchHeight, 0),
                halfTouchWidth * 2,
                halfTouchHeight * 2,
                MeteringRectangle.METERING_WEIGHT_MAX - 1);

        try {
            mCaptureSession.stopRepeating();
            //Cancel any existing AF trigger (repeated touches, etc.)
            mPreviewRequestBuilder.set(CaptureRequest.CONTROL_AF_TRIGGER, CameraMetadata.CONTROL_AF_TRIGGER_CANCEL);
            mPreviewRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE, CaptureRequest.CONTROL_AF_MODE_OFF);
            mCaptureSession.capture(mPreviewRequestBuilder.build(), mCaptureCallback, mBackgroundHandler);

            //Now add a new AF trigger with focus region
            if (isMeteringAreaAFSupported) {
                mPreviewRequestBuilder.set(CaptureRequest.CONTROL_AF_REGIONS, new MeteringRectangle[]{focusAreaTouch});
            }
            mPreviewRequestBuilder.set(CaptureRequest.CONTROL_MODE, CameraMetadata.CONTROL_MODE_AUTO);
            mPreviewRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE, CaptureRequest.CONTROL_AF_MODE_AUTO);
            mPreviewRequestBuilder.set(CaptureRequest.CONTROL_AF_TRIGGER, CameraMetadata.CONTROL_AF_TRIGGER_START);
            mPreviewRequestBuilder.setTag("FOCUS_TAG"); //we'll capture this later for resuming the preview!
            //Then we ask for a single request (not repeating!)
            mCaptureSession.capture(mPreviewRequestBuilder.build(), mCaptureCallback, mBackgroundHandler);
        } catch (CameraAccessException ex) {
            Log.d("ASD", "AUTO FOCUS EXCEPTION: " + ex);
        }
    }
}
 

private ManualAutoFocusFactory(ManualAutoFocus manualAutoFocus,
                               Supplier<MeteringRectangle[]> aeMeteringRegion,
                               Supplier<MeteringRectangle[]> afMeteringRegion)
{
    mManualAutoFocus = manualAutoFocus;
    mAEMeteringRegion = aeMeteringRegion;
    mAFMeteringRegion = afMeteringRegion;
}
 

/**
 * @param cropRegion The current crop region, see
 *                   {@link CaptureRequest#SCALER_CROP_REGION}.
 */
@Override
public MeteringRectangle[] getAERegions(Rect cropRegion)
{
    return new MeteringRectangle[]{
            regionForNormalizedCoord(mAEPoint, cropRegion)
    };
}
 

/**
 * @param cropRegion The current crop region, see
 *                   {@link CaptureRequest#SCALER_CROP_REGION}.
 */
@Override
public MeteringRectangle[] getAFRegions(Rect cropRegion)
{
    return new MeteringRectangle[]{
            regionForNormalizedCoord(mAFPoint, cropRegion)
    };
}
 

private MeteringRectangle regionForNormalizedCoord(PointF point,
                                                   Rect cropRegion)
{
    // Compute half side length in pixels.
    int minCropEdge = Math.min(cropRegion.width(), cropRegion.height());
    int halfSideLength = (int) (0.5f * mSettings3A.getMeteringRegionFraction() * minCropEdge);

    // Compute the output MeteringRectangle in sensor space.
    // point is normalized to the screen.
    // Crop region itself is specified in sensor coordinates (see
    // CameraCharacteristics#SENSOR_INFO_ACTIVE_ARRAY_SIZE).

    // Normalized coordinates, now rotated into sensor space.
    PointF nsc = transformPortraitCoordinatesToSensorCoordinates(point);

    int xCenterSensor = (int) (cropRegion.left + nsc.x * cropRegion.width());
    int yCenterSensor = (int) (cropRegion.top + nsc.y * cropRegion.height());

    Rect meteringRegion = new Rect(xCenterSensor - halfSideLength,
            yCenterSensor - halfSideLength,
            xCenterSensor + halfSideLength,
            yCenterSensor + halfSideLength);

    // Clamp meteringRegion to cropRegion.
    meteringRegion.left = clamp(meteringRegion.left, cropRegion.left,
            cropRegion.right);
    meteringRegion.top = clamp(meteringRegion.top, cropRegion.top, cropRegion.bottom);
    meteringRegion.right = clamp(meteringRegion.right, cropRegion.left,
            cropRegion.right);
    meteringRegion.bottom = clamp(meteringRegion.bottom, cropRegion.top,
            cropRegion.bottom);

    return new MeteringRectangle(meteringRegion, mSettings3A.getMeteringWeight());
}
 

/**
 * Compute 3A regions for a sensor-referenced touch coordinate.
 * Returns a MeteringRectangle[] with length 1.
 *
 * @param nx                x coordinate of the touch point, in normalized portrait coordinates.
 * @param ny                y coordinate of the touch point, in normalized portrait coordinates.
 * @param fraction          Fraction in [0,1]. Multiplied by min(cropRegion.width(), cropRegion.height())
 *                          to determine the side length of the square MeteringRectangle.
 * @param cropRegion        Crop region of the image.
 * @param sensorOrientation sensor orientation as defined by
 *                          CameraCharacteristics.get(CameraCharacteristics.SENSOR_ORIENTATION).
 */
private static MeteringRectangle[] regionsForNormalizedCoord(float nx, float ny,
                                                             float fraction, final Rect cropRegion, int
                                                                     sensorOrientation)
{
    // Compute half side length in pixels.
    int minCropEdge = Math.min(cropRegion.width(), cropRegion.height());
    int halfSideLength = (int) (0.5f * fraction * minCropEdge);

    // Compute the output MeteringRectangle in sensor space.
    // nx, ny is normalized to the screen.
    // Crop region itself is specified in sensor coordinates.

    // Normalized coordinates, now rotated into sensor space.
    PointF nsc = CameraUtil.normalizedSensorCoordsForNormalizedDisplayCoords(
            nx, ny, sensorOrientation);

    int xCenterSensor = (int) (cropRegion.left + nsc.x * cropRegion.width());
    int yCenterSensor = (int) (cropRegion.top + nsc.y * cropRegion.height());

    Rect meteringRegion = new Rect(xCenterSensor - halfSideLength,
            yCenterSensor - halfSideLength,
            xCenterSensor + halfSideLength,
            yCenterSensor + halfSideLength);

    // Clamp meteringRegion to cropRegion.
    meteringRegion.left = CameraUtil.clamp(meteringRegion.left, cropRegion.left, cropRegion.right);
    meteringRegion.top = CameraUtil.clamp(meteringRegion.top, cropRegion.top, cropRegion.bottom);
    meteringRegion.right = CameraUtil.clamp(meteringRegion.right, cropRegion.left, cropRegion.right);
    meteringRegion.bottom = CameraUtil.clamp(meteringRegion.bottom, cropRegion.top, cropRegion.bottom);

    return new MeteringRectangle[]{new MeteringRectangle(meteringRegion, CAMERA2_REGION_WEIGHT)};
}
 

/**
 * @Return The weight to use for {@link MeteringRectangle}s for 3A.
 */
public int getMeteringWeight()
{
    // TODO Determine the optimal metering region for non-HDR photos.
    int weightMin = MeteringRectangle.METERING_WEIGHT_MIN;
    int weightRange = MeteringRectangle.METERING_WEIGHT_MAX
            - MeteringRectangle.METERING_WEIGHT_MIN;
    return (int) (weightMin + GCAM_METERING_REGION_FRACTION * weightRange);
}
 

public void autoFocus(@Nullable AutoFocusCallback cb, MotionEvent pEvent, int screenW, int screenH) {
    if(cb != null) {
        mAutoFocusCallback = cb;
    }
    if(sensorArraySize != null) {
        final int y = (int)pEvent.getX() / screenW * sensorArraySize.height();
        final int x = (int)pEvent.getY() / screenH * sensorArraySize.width();
        final int halfTouchWidth = 150;
        final int halfTouchHeight = 150;
        MeteringRectangle focusAreaTouch = new MeteringRectangle(
                Math.max(x-halfTouchWidth, 0),
                Math.max(y-halfTouchHeight, 0),
                halfTouchWidth*2,
                halfTouchHeight*2,
                MeteringRectangle.METERING_WEIGHT_MAX - 1);

        try {
            mCaptureSession.stopRepeating();
            //Cancel any existing AF trigger (repeated touches, etc.)
            mPreviewRequestBuilder.set(CaptureRequest.CONTROL_AF_TRIGGER, CameraMetadata.CONTROL_AF_TRIGGER_CANCEL);
            mPreviewRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE, CaptureRequest.CONTROL_AF_MODE_OFF);
            mCaptureSession.capture(mPreviewRequestBuilder.build(), mCaptureCallback, mBackgroundHandler);

            //Now add a new AF trigger with focus region
            if(isMeteringAreaAFSupported) {
                mPreviewRequestBuilder.set(CaptureRequest.CONTROL_AF_REGIONS, new MeteringRectangle[]{focusAreaTouch});
            }
            mPreviewRequestBuilder.set(CaptureRequest.CONTROL_MODE, CameraMetadata.CONTROL_MODE_AUTO);
            mPreviewRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE, CaptureRequest.CONTROL_AF_MODE_AUTO);
            mPreviewRequestBuilder.set(CaptureRequest.CONTROL_AF_TRIGGER, CameraMetadata.CONTROL_AF_TRIGGER_START);
            mPreviewRequestBuilder.setTag("FOCUS_TAG"); //we'll capture this later for resuming the preview!
            //Then we ask for a single request (not repeating!)
            mCaptureSession.capture(mPreviewRequestBuilder.build(), mCaptureCallback, mBackgroundHandler);
        } catch(CameraAccessException ex) {
            Log.d("ASD", "AUTO FOCUS EXCEPTION: "+ex);
        }
    }
}
 

public static MeteringRectangle[] regionsForNormalizedCoord(float nx, float ny,
                                                            float fraction, final Rect cropRegion, int sensorOrientation) {
    // Compute half side length in pixels.
    int minCropEdge = Math.min(cropRegion.width(), cropRegion.height());
    int halfSideLength = (int) (0.5f * fraction * minCropEdge);

    // Compute the output MeteringRectangle in sensor space.
    // nx, ny is normalized to the screen.
    // Crop region itself is specified in sensor coordinates.

    // Normalized coordinates, now rotated into sensor space.
    PointF nsc = CameraUtil.normalizedSensorCoordsForNormalizedDisplayCoords(
            nx, ny, sensorOrientation);

    int xCenterSensor = (int) (cropRegion.left + nsc.x * cropRegion.width());
    int yCenterSensor = (int) (cropRegion.top + nsc.y * cropRegion.height());

    Rect meteringRegion = new Rect(xCenterSensor - halfSideLength,
            yCenterSensor - halfSideLength,
            xCenterSensor + halfSideLength,
            yCenterSensor + halfSideLength);

    // Clamp meteringRegion to cropRegion.
    meteringRegion.left = CameraUtil.clamp(meteringRegion.left, cropRegion.left, cropRegion.right);
    meteringRegion.top = CameraUtil.clamp(meteringRegion.top, cropRegion.top, cropRegion.bottom);
    meteringRegion.right = CameraUtil.clamp(meteringRegion.right, cropRegion.left, cropRegion.right);
    meteringRegion.bottom = CameraUtil.clamp(meteringRegion.bottom, cropRegion.top, cropRegion.bottom);

    return new MeteringRectangle[]{new MeteringRectangle(meteringRegion, CAMERA2_REGION_WEIGHT)};
}
 

private static void mapAe(CameraMetadataNative m,
        CameraCharacteristics characteristics,
        CaptureRequest request, Rect activeArray, ZoomData zoomData, /*out*/Parameters p) {
    // control.aeAntiBandingMode
    {
        int antiBandingMode = LegacyMetadataMapper.convertAntiBandingModeOrDefault(
                p.getAntibanding());
        m.set(CONTROL_AE_ANTIBANDING_MODE, antiBandingMode);
    }

    // control.aeExposureCompensation
    {
        m.set(CONTROL_AE_EXPOSURE_COMPENSATION, p.getExposureCompensation());
    }

    // control.aeLock
    {
        boolean lock = p.isAutoExposureLockSupported() ? p.getAutoExposureLock() : false;
        m.set(CONTROL_AE_LOCK, lock);
        if (DEBUG) {
            Log.v(TAG,
                    "mapAe - android.control.aeLock = " + lock +
                    ", supported = " + p.isAutoExposureLockSupported());
        }

        Boolean requestLock = request.get(CaptureRequest.CONTROL_AE_LOCK);
        if (requestLock != null && requestLock != lock) {
            Log.w(TAG,
                    "mapAe - android.control.aeLock was requested to " + requestLock +
                    " but resulted in " + lock);
        }
    }

    // control.aeMode, flash.mode, flash.state
    mapAeAndFlashMode(m, characteristics, p);

    // control.aeState
    if (LegacyMetadataMapper.LIE_ABOUT_AE_STATE) {
        // Lie to pass CTS temporarily.
        // TODO: Implement precapture trigger, after which we can report CONVERGED ourselves
        m.set(CONTROL_AE_STATE, CONTROL_AE_STATE_CONVERGED);
    }

    // control.aeRegions
    if (p.getMaxNumMeteringAreas() > 0) {
        if (DEBUG) {
            String meteringAreas = p.get("metering-areas");
            Log.v(TAG, "mapAe - parameter dump; metering-areas: " + meteringAreas);
        }

        MeteringRectangle[] meteringRectArray = getMeteringRectangles(activeArray,
                zoomData, p.getMeteringAreas(), "AE");

        m.set(CONTROL_AE_REGIONS, meteringRectArray);
    }

}
 

/**
 * Calculate the actual/effective/reported normalized rectangle data from a metering
 * rectangle.
 *
 * <p>If any of the rectangles are out-of-range of their intended bounding box,
 * the {@link #RECTANGLE_EMPTY empty rectangle} is substituted instead
 * (with a weight of {@code 0}).</p>
 *
 * <p>The metering rectangle is bound by the crop region (effective/reported respectively).
 * The metering {@link Camera.Area area} is bound by {@code [-1000, 1000]}.</p>
 *
 * <p>No parameters are mutated; returns the new metering data.</p>
 *
 * @param activeArraySize active array size of the sensor (e.g. max jpeg size)
 * @param meteringRect the user-specified metering rectangle
 * @param zoomData the calculated zoom data corresponding to this request
 *
 * @return the metering area, the reported/effective metering rectangles
 */
public static MeteringData convertMeteringRectangleToLegacy(
        Rect activeArray, MeteringRectangle meteringRect, ZoomData zoomData) {
    Rect previewCrop = zoomData.previewCrop;

    float scaleW = (NORMALIZED_RECTANGLE_MAX - NORMALIZED_RECTANGLE_MIN) * 1.0f /
            previewCrop.width();
    float scaleH = (NORMALIZED_RECTANGLE_MAX - NORMALIZED_RECTANGLE_MIN) * 1.0f /
            previewCrop.height();

    Matrix transform = new Matrix();
    // Move the preview crop so that top,left is at (0,0), otherwise after scaling
    // the corner bounds will be outside of [-1000, 1000]
    transform.setTranslate(-previewCrop.left, -previewCrop.top);
    // Scale into [0, 2000] range about the center of the preview
    transform.postScale(scaleW, scaleH);
    // Move so that top left of a typical rect is at [-1000, -1000]
    transform.postTranslate(/*dx*/NORMALIZED_RECTANGLE_MIN, /*dy*/NORMALIZED_RECTANGLE_MIN);

    /*
     * Calculate the preview metering region (effective), and the camera1 api
     * normalized metering region.
     */
    Rect normalizedRegionUnbounded = ParamsUtils.mapRect(transform, meteringRect.getRect());

    /*
     * Try to intersect normalized area with [-1000, 1000] rectangle; otherwise
     * it's completely out of range
     */
    Rect normalizedIntersected = new Rect(normalizedRegionUnbounded);

    Camera.Area meteringArea;
    if (!normalizedIntersected.intersect(NORMALIZED_RECTANGLE_DEFAULT)) {
        Log.w(TAG,
                "convertMeteringRectangleToLegacy - metering rectangle too small, " +
                "no metering will be done");
        normalizedIntersected.set(RECTANGLE_EMPTY);
        meteringArea = new Camera.Area(RECTANGLE_EMPTY,
                MeteringRectangle.METERING_WEIGHT_DONT_CARE);
    } else {
        meteringArea = new Camera.Area(normalizedIntersected,
                meteringRect.getMeteringWeight());
    }

    /*
     * Calculate effective preview metering region
     */
    Rect previewMetering = meteringRect.getRect();
    if (!previewMetering.intersect(previewCrop)) {
        previewMetering.set(RECTANGLE_EMPTY);
    }

    /*
     * Calculate effective reported metering region
     * - Transform the calculated metering area back into active array space
     * - Clip it to be a subset of the reported crop region
     */
    Rect reportedMetering;
    {
        Camera.Area normalizedAreaUnbounded = new Camera.Area(
                normalizedRegionUnbounded, meteringRect.getMeteringWeight());
        WeightedRectangle reportedMeteringRect = convertCameraAreaToActiveArrayRectangle(
                activeArray, zoomData, normalizedAreaUnbounded, /*usePreviewCrop*/false);
        reportedMetering = reportedMeteringRect.rect;
    }

    if (DEBUG) {
        Log.v(TAG, String.format(
                "convertMeteringRectangleToLegacy - activeArray = %s, meteringRect = %s, " +
                "previewCrop = %s, meteringArea = %s, previewMetering = %s, " +
                "reportedMetering = %s, normalizedRegionUnbounded = %s",
                activeArray, meteringRect,
                previewCrop, stringFromArea(meteringArea), previewMetering,
                reportedMetering, normalizedRegionUnbounded));
    }

    return new MeteringData(meteringArea, previewMetering, reportedMetering);
}
 

private static WeightedRectangle convertCameraAreaToActiveArrayRectangle(
        Rect activeArray, ZoomData zoomData, Camera.Area area, boolean usePreviewCrop) {
    Rect previewCrop = zoomData.previewCrop;
    Rect reportedCrop = zoomData.reportedCrop;

    float scaleW = previewCrop.width() * 1.0f /
            (NORMALIZED_RECTANGLE_MAX - NORMALIZED_RECTANGLE_MIN);
    float scaleH = previewCrop.height() * 1.0f /
            (NORMALIZED_RECTANGLE_MAX - NORMALIZED_RECTANGLE_MIN);

    /*
     * Calculate the reported metering region from the non-intersected normalized region
     * by scaling and translating back into active array-relative coordinates.
     */
    Matrix transform = new Matrix();

    // Move top left from (-1000, -1000) to (0, 0)
    transform.setTranslate(/*dx*/NORMALIZED_RECTANGLE_MAX, /*dy*/NORMALIZED_RECTANGLE_MAX);

    // Scale from [0, 2000] back into the preview rectangle
    transform.postScale(scaleW, scaleH);

    // Move the rect so that the [-1000,-1000] point ends up at the preview [left, top]
    transform.postTranslate(previewCrop.left, previewCrop.top);

    Rect cropToIntersectAgainst = usePreviewCrop ? previewCrop : reportedCrop;

    // Now apply the transformation backwards to get the reported metering region
    Rect reportedMetering = ParamsUtils.mapRect(transform, area.rect);
    // Intersect it with the crop region, to avoid reporting out-of-bounds
    // metering regions
    if (!reportedMetering.intersect(cropToIntersectAgainst)) {
        reportedMetering.set(RECTANGLE_EMPTY);
    }

    int weight = area.weight;
    if (weight < MeteringRectangle.METERING_WEIGHT_MIN) {
        Log.w(TAG,
                "convertCameraAreaToMeteringRectangle - rectangle "
                        + stringFromArea(area) + " has too small weight, clip to 0");
        weight = 0;
    }

    return new WeightedRectangle(reportedMetering, area.weight);
}
 

protected MarshalerMeteringRectangle(TypeReference<MeteringRectangle> typeReference,
        int nativeType) {
    super(MarshalQueryableMeteringRectangle.this, typeReference, nativeType);
}
 

@Override
public Marshaler<MeteringRectangle> createMarshaler(
        TypeReference<MeteringRectangle> managedType, int nativeType) {
    return new MarshalerMeteringRectangle(managedType, nativeType);
}
 

@Override
public boolean isTypeMappingSupported(
        TypeReference<MeteringRectangle> managedType, int nativeType) {
    return nativeType == TYPE_INT32 && MeteringRectangle.class.equals(managedType.getType());
}
 

@Override
public MeteringRectangle[] getAFRegions(Rect cropRegion)
{
    return ZERO_WEIGHT_3A_REGION;
}
 

@Override
public MeteringRectangle[] getAERegions(Rect cropRegion)
{
    return ZERO_WEIGHT_3A_REGION;
}
 

public Supplier<MeteringRectangle[]> provideAEMeteringRegion()
{
    return mAEMeteringRegion;
}
 

public Supplier<MeteringRectangle[]> provideAFMeteringRegion()
{
    return mAFMeteringRegion;
}
 

@Override
public MeteringRectangle[] get()
{
    return mMeteringParameters.get().getAFRegions(mCropRegion.get());
}
 

@Override
public MeteringRectangle[] get()
{
    return mMeteringParameters.get().getAERegions(mCropRegion.get());
}
 

public static MeteringRectangle[] getZeroWeightRegion()
{
    return ZERO_WEIGHT_3A_REGION;
}
 

/**
 * @param lifetime              The lifetime of all created objects and their associated
 *                              resources.
 * @param cameraCharacteristics
 * @param rootTemplate          Provides preconfigured request builders to be used for
 *                              all requests to mFrameServer.
 * @param cameraCommandExecutor The
 * @param templateType          The template (e.g. CameraDevice.TEMPLATE_PREVIEW) to
 *                              use for repeating requests.
 */
public BasicCameraFactory(Lifetime lifetime,
                          OneCameraCharacteristics cameraCharacteristics,
                          FrameServer frameServer,
                          RequestBuilder.Factory rootTemplate,
                          CameraCommandExecutor cameraCommandExecutor,
                          PreviewCommandFactory previewCommandFactory,
                          Observable<OneCamera.PhotoCaptureParameters.Flash> flash,
                          Observable<Integer> exposure,
                          Observable<Float> zoom,
                          Observable<Boolean> hdrSceneSetting,
                          int templateType)
{
    RequestTemplate requestTemplate = new RequestTemplate(rootTemplate);
    requestTemplate.setParam(
            CaptureRequest.CONTROL_AF_MODE, CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE);
    requestTemplate.setParam(
            CaptureRequest.CONTROL_AE_MODE, new FlashBasedAEMode(flash, hdrSceneSetting));
    requestTemplate.setParam(
            CaptureRequest.CONTROL_AE_EXPOSURE_COMPENSATION, exposure);

    Supplier<FaceDetectMode> faceDetectMode = Suppliers.ofInstance(
            FaceDetect.getHighestFaceDetectMode(cameraCharacteristics));

    requestTemplate.setParam(CaptureRequest.CONTROL_MODE,
            new ControlModeSelector(hdrSceneSetting,
                    faceDetectMode,
                    cameraCharacteristics.getSupportedHardwareLevel()));
    requestTemplate.setParam(
            CaptureRequest.CONTROL_SCENE_MODE, new ControlSceneModeSelector(
                    hdrSceneSetting,
                    faceDetectMode,
                    cameraCharacteristics.getSupportedHardwareLevel()));
    requestTemplate.setParam(CaptureRequest.STATISTICS_FACE_DETECT_MODE,
            new StatisticsFaceDetectMode(faceDetectMode));

    Supplier<Rect> cropRegion = new ZoomedCropRegion(
            cameraCharacteristics.getSensorInfoActiveArraySize(), zoom);
    requestTemplate.setParam(CaptureRequest.SCALER_CROP_REGION, cropRegion);

    CameraCommand previewUpdaterCommand =
            previewCommandFactory.get(requestTemplate, templateType);

    // Use a resetting command to ensure that many rapid settings changes do
    // not result in many rapid (>30fps) requests to restart the preview.
    mPreviewUpdater = new ResettingRunnableCameraCommand(cameraCommandExecutor,
            previewUpdaterCommand);

    // Resend the repeating preview request when the zoom or flash state
    // changes to apply the new setting.
    // Also, de-register these callbacks when the camera is closed (to
    // not leak memory).
    SafeCloseable zoomCallback = zoom.addCallback(mPreviewUpdater, MoreExecutors
            .sameThreadExecutor());
    lifetime.add(zoomCallback);
    SafeCloseable flashCallback = flash.addCallback(mPreviewUpdater, MoreExecutors
            .sameThreadExecutor());
    lifetime.add(flashCallback);
    SafeCloseable exposureCallback = exposure.addCallback(mPreviewUpdater, MoreExecutors
            .sameThreadExecutor());
    lifetime.add(exposureCallback);
    SafeCloseable hdrCallback = hdrSceneSetting.addCallback(mPreviewUpdater, MoreExecutors
            .sameThreadExecutor());
    lifetime.add(hdrCallback);

    int sensorOrientation = cameraCharacteristics.getSensorOrientation();

    ManualAutoFocusFactory manualAutoFocusFactory = ManualAutoFocusFactory.create(new
                    Lifetime(lifetime), frameServer, cameraCommandExecutor, cropRegion,
            sensorOrientation, mPreviewUpdater, requestTemplate,
            templateType, new Settings3A(), Executors.newScheduledThreadPool(1),
            3 /* afHoldSeconds */);
    mManualAutoFocus = manualAutoFocusFactory.provideManualAutoFocus();
    Supplier<MeteringRectangle[]> aeRegions =
            manualAutoFocusFactory.provideAEMeteringRegion();
    Supplier<MeteringRectangle[]> afRegions =
            manualAutoFocusFactory.provideAFMeteringRegion();

    requestTemplate.setParam(CaptureRequest.CONTROL_AE_REGIONS, aeRegions);
    requestTemplate.setParam(CaptureRequest.CONTROL_AF_REGIONS, afRegions);

    mMeteredZoomedRequestBuilder = requestTemplate;
}
 

public void focusOnPoint(double x, double y, int width, int height) {
    if (mCameraDevice == null || mPreviewRequestBuilder == null) {
        return;
    }
    // 1. 先取相对于view上面的坐标
    int previewWidth = mPreviewSize.getWidth();
    int previewHeight = mPreviewSize.getHeight();
    if (mDisplayRotate == 90 || mDisplayRotate == 270) {
        previewWidth = mPreviewSize.getHeight();
        previewHeight = mPreviewSize.getWidth();
    }
    // 2. 计算摄像头取出的图像相对于view放大了多少，以及有多少偏移
    double tmp;
    double imgScale;
    double verticalOffset = 0;
    double horizontalOffset = 0;
    if (previewHeight * width > previewWidth * height) {
        imgScale = width * 1.0 / previewWidth;
        verticalOffset = (previewHeight - height / imgScale) / 2;
    } else {
        imgScale = height * 1.0 / previewHeight;
        horizontalOffset = (previewWidth - width / imgScale) / 2;
    }
    // 3. 将点击的坐标转换为图像上的坐标
    x = x / imgScale + horizontalOffset;
    y = y / imgScale + verticalOffset;
    if (90 == mDisplayRotate) {
        tmp = x;
        x = y;
        y = mPreviewSize.getHeight() - tmp;
    } else if (270 == mDisplayRotate) {
        tmp = x;
        x = mPreviewSize.getWidth() - y;
        y = tmp;
    }
    // 4. 计算取到的图像相对于裁剪区域的缩放系数，以及位移
    Rect cropRegion = mPreviewRequestBuilder.get(CaptureRequest.SCALER_CROP_REGION);
    if (cropRegion == null) {
        Log.w(TAG, "can't get crop region");
        cropRegion = mCameraCharacteristics.get(CameraCharacteristics.SENSOR_INFO_ACTIVE_ARRAY_SIZE);
    }
    int cropWidth = cropRegion.width();
    int cropHeight = cropRegion.height();
    if (mPreviewSize.getHeight() * cropWidth > mPreviewSize.getWidth() * cropHeight) {
        imgScale = cropHeight * 1.0 / mPreviewSize.getHeight();
        verticalOffset = 0;
        horizontalOffset = (cropWidth - imgScale * mPreviewSize.getWidth()) / 2;
    } else {
        imgScale = cropWidth * 1.0 / mPreviewSize.getWidth();
        horizontalOffset = 0;
        verticalOffset = (cropHeight - imgScale * mPreviewSize.getHeight()) / 2;
    }
    // 5. 将点击区域相对于图像的坐标，转化为相对于成像区域的坐标
    x = x * imgScale + horizontalOffset + cropRegion.left;
    y = y * imgScale + verticalOffset + cropRegion.top;
    double tapAreaRatio = 0.1;
    Rect rect = new Rect();
    rect.left = clamp((int) (x - tapAreaRatio / 2 * cropRegion.width()), 0, cropRegion.width());
    rect.right = clamp((int) (x + tapAreaRatio / 2 * cropRegion.width()), 0, cropRegion.width());
    rect.top = clamp((int) (y - tapAreaRatio / 2 * cropRegion.height()), 0, cropRegion.height());
    rect.bottom = clamp((int) (y + tapAreaRatio / 2 * cropRegion.height()), 0, cropRegion.height());
    // 6. 设置 AF、AE 的测光区域，即上述得到的 rect
    mPreviewRequestBuilder.set(CaptureRequest.CONTROL_AF_REGIONS, new MeteringRectangle[]{new MeteringRectangle
            (rect, 1000)});
    mPreviewRequestBuilder.set(CaptureRequest.CONTROL_AE_REGIONS, new MeteringRectangle[]{new MeteringRectangle
            (rect, 1000)});
    mPreviewRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE, CaptureRequest.CONTROL_AF_MODE_AUTO);
    mPreviewRequestBuilder.set(CaptureRequest.CONTROL_AF_TRIGGER, CameraMetadata.CONTROL_AF_TRIGGER_START);
    mPreviewRequestBuilder.set(CaptureRequest.CONTROL_AE_PRECAPTURE_TRIGGER, CameraMetadata
            .CONTROL_AE_PRECAPTURE_TRIGGER_START);
    try {
        // 7. 发送上述设置的对焦请求，并监听回调
        mCaptureSession.capture(mPreviewRequestBuilder.build(), mAfCaptureCallback, mBackgroundHandler);
    } catch (CameraAccessException e) {
        e.printStackTrace();
    }
}
 

public static MeteringRectangle[] getZeroWeightRegion() {
    return ZERO_WEIGHT_3A_REGION;
}