Java 类android.media.CameraProfile 实例源码

public static int getQualityNumber(String jpegQuality) {
    Integer quality = mHashMap.get(jpegQuality);
    if (quality == null) {
        Log.w(TAG, "Unknown Jpeg quality: " + jpegQuality);
        return DEFAULT_QUALITY;
    }
    return CameraProfile.getJpegEncodingQualityParameter(quality.intValue());
}

public static void updateCameraParametersPreference(Context ctx, Camera cam) {


        // get Camera parameters
        Camera.Parameters params = cam.getParameters();

        List<String> focusModes = params.getSupportedFocusModes();
        if (focusModes.contains(Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE)) {
            // set the focus mode
            params.setFocusMode(Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE);
        }

        //set the camera picture size
        initialCameraPictureSize(ctx, params);

        // Set JPEG quality.
        int jpegQuality = CameraProfile.getJpegEncodingQualityParameter(0,
                CameraProfile.QUALITY_HIGH);
        params.setJpegQuality(jpegQuality);

        List<String> flashModes = params.getSupportedFlashModes();
        if (flashModes.contains(Camera.Parameters.FLASH_MODE_AUTO)) {
            // set the focus mode
            params.setFlashMode(Camera.Parameters.FLASH_MODE_AUTO);
        }

        List<String> whiteBalanceModes = params.getSupportedWhiteBalance();
        if (whiteBalanceModes.contains(Camera.Parameters.WHITE_BALANCE_AUTO)) {
            // set the focus mode
            params.setWhiteBalance(Camera.Parameters.WHITE_BALANCE_AUTO);
        }

        // set Camera parameters
        cam.setParameters(params);

    }

private void updateParametersPictureQuality() {
    int jpegQuality = CameraProfile.getJpegEncodingQualityParameter(mCameraId,
            CameraProfile.QUALITY_HIGH);
    mCameraSettings.setPhotoJpegCompressionQuality(jpegQuality);
}

@SuppressWarnings("deprecation")
private void setCameraParameters() {
    SettingsManager settingsManager = mActivity.getSettingsManager();

    // Update Desired Preview size in case video camera resolution has changed.
    updateDesiredPreviewSize();

    mCameraSettings.setPreviewSize(new Size(mDesiredPreviewWidth, mDesiredPreviewHeight));
    // This is required for Samsung SGH-I337 and probably other Samsung S4 versions
    if (Build.BRAND.toLowerCase().contains("samsung")) {
        mCameraSettings.setSetting("video-size",
                mProfile.videoFrameWidth + "x" + mProfile.videoFrameHeight);
    }
    int[] fpsRange =
            CameraUtil.getMaxPreviewFpsRange(mCameraCapabilities.getSupportedPreviewFpsRange());
    if (fpsRange.length > 0) {
        mCameraSettings.setPreviewFpsRange(fpsRange[0], fpsRange[1]);
    } else {
        mCameraSettings.setPreviewFrameRate(mProfile.videoFrameRate);
    }

    enableTorchMode(Keys.isCameraBackFacing(settingsManager, mAppController.getModuleScope()));

    // Set zoom.
    if (mCameraCapabilities.supports(CameraCapabilities.Feature.ZOOM)) {
        mCameraSettings.setZoomRatio(mZoomValue);
    }
    updateFocusParameters();

    mCameraSettings.setRecordingHintEnabled(true);

    if (mCameraCapabilities.supports(CameraCapabilities.Feature.VIDEO_STABILIZATION)) {
        mCameraSettings.setVideoStabilization(true);
    }

    // Set picture size.
    // The logic here is different from the logic in still-mode camera.
    // There we determine the preview size based on the picture size, but
    // here we determine the picture size based on the preview size.
    List<Size> supported = mCameraCapabilities.getSupportedPhotoSizes();
    Size optimalSize = CameraUtil.getOptimalVideoSnapshotPictureSize(supported,
            mDesiredPreviewWidth, mDesiredPreviewHeight);
    Size original = new Size(mCameraSettings.getCurrentPhotoSize());
    if (!original.equals(optimalSize)) {
        mCameraSettings.setPhotoSize(optimalSize);
    }
    Log.d(TAG, "Video snapshot size is " + optimalSize);

    // Set JPEG quality.
    int jpegQuality = CameraProfile.getJpegEncodingQualityParameter(mCameraId,
            CameraProfile.QUALITY_HIGH);
    mCameraSettings.setPhotoJpegCompressionQuality(jpegQuality);

    if (mCameraDevice != null) {
        mCameraDevice.applySettings(mCameraSettings);
        // Nexus 5 through KitKat 4.4.2 requires a second call to
        // .setParameters() for frame rate settings to take effect.
        mCameraDevice.applySettings(mCameraSettings);
    }

    // Update UI based on the new parameters.
    mUI.updateOnScreenIndicators(mCameraSettings);
}

@SuppressWarnings("deprecation")
private void initCamera(SurfaceHolder holder, int width, int height) {
    try {
        if (mCamera == null) {
            mCamera = Camera.open(0);
        }
        holder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
        Camera.Parameters parameters = mCamera.getParameters();
        if (flashModeString != null) {
            parameters.setFlashMode(flashModeString);
        }
        if (parameters.getSupportedFocusModes().contains(Camera.Parameters.FOCUS_MODE_AUTO)) {
            parameters.setFocusMode(Camera.Parameters.FOCUS_MODE_AUTO);
        }
        // flashModeString = Camera.Parameters.FLASH_MODE_OFF;
        parameters.setPictureFormat(ImageFormat.JPEG);
        int jpegQuality = CameraProfile.getJpegEncodingQualityParameter(0, CameraProfile.QUALITY_MEDIUM);
        parameters.setJpegQuality(jpegQuality);
        List<Camera.Size> previewSizes = parameters.getSupportedPreviewSizes();
        // Camera.Size preSize = getOptimalPicSize(previewSizes);
        Camera.Size preSize = getOptimalPicSize(previewSizes);
        if (preSize != null) {
            parameters.setPreviewSize(preSize.width, preSize.height);
        }
        List<Camera.Size> picSizes = parameters.getSupportedPictureSizes();
        Camera.Size picSize = getOptimalPicSize(picSizes);
        if (picSize != null) {
            parameters.setPictureSize(picSize.width, picSize.height);
        }
        mCamera.setParameters(parameters);
        mCamera.setDisplayOrientation(getPreviewDegree(getBackOpActivity()));
        mCamera.setPreviewDisplay(holder);
        mCamera.startPreview();         
        mCamera.autoFocus(new AutoFocusCallback() {
            @Override
            public void onAutoFocus(boolean success, Camera camera) {
                isFocusing = false;
            }
        });
        isFocusing = true;
    } catch (Exception e) {
        if (mCamera != null) {
            mCamera.release();
            mCamera = null;
        }
        e.printStackTrace();
    }
}

@SuppressWarnings("deprecation")
private void setCameraParameters() {
    mParameters.setPreviewSize(mDesiredPreviewWidth, mDesiredPreviewHeight);
    int[] fpsRange = CameraUtil.getMaxPreviewFpsRange(mParameters);
    if (fpsRange.length > 0) {
        mParameters.setPreviewFpsRange(
                fpsRange[Parameters.PREVIEW_FPS_MIN_INDEX],
                fpsRange[Parameters.PREVIEW_FPS_MAX_INDEX]);
    } else {
        mParameters.setPreviewFrameRate(mProfile.videoFrameRate);
    }

    forceFlashOffIfSupported(!mUI.isVisible());

    // Set white balance parameter.
    String whiteBalance = mPreferences.getString(
            CameraSettings.KEY_WHITE_BALANCE,
            mActivity.getString(R.string.pref_camera_whitebalance_default));
    if (isSupported(whiteBalance,
            mParameters.getSupportedWhiteBalance())) {
        mParameters.setWhiteBalance(whiteBalance);
    } else {
        whiteBalance = mParameters.getWhiteBalance();
        if (whiteBalance == null) {
            whiteBalance = Parameters.WHITE_BALANCE_AUTO;
        }
    }

    // Set zoom.
    if (mParameters.isZoomSupported()) {
        mParameters.setZoom(mZoomValue);
    }

    // Set continuous autofocus.
    List<String> supportedFocus = mParameters.getSupportedFocusModes();
    if (isSupported(Parameters.FOCUS_MODE_CONTINUOUS_VIDEO, supportedFocus)) {
        mParameters.setFocusMode(Parameters.FOCUS_MODE_CONTINUOUS_VIDEO);
    }

    mParameters.set(CameraUtil.RECORDING_HINT, CameraUtil.TRUE);

    // Enable video stabilization. Convenience methods not available in API
    // level <= 14
    String vstabSupported = mParameters.get("video-stabilization-supported");
    if ("true".equals(vstabSupported)) {
        mParameters.set("video-stabilization", "true");
    }

    // Set picture size.
    // The logic here is different from the logic in still-mode camera.
    // There we determine the preview size based on the picture size, but
    // here we determine the picture size based on the preview size.
    List<Size> supported = mParameters.getSupportedPictureSizes();
    Size optimalSize = CameraUtil.getOptimalVideoSnapshotPictureSize(supported,
            (double) mDesiredPreviewWidth / mDesiredPreviewHeight);
    Size original = mParameters.getPictureSize();
    if (!original.equals(optimalSize)) {
        mParameters.setPictureSize(optimalSize.width, optimalSize.height);
    }
    Log.v(TAG, "Video snapshot size is " + optimalSize.width + "x" +
            optimalSize.height);

    // Set JPEG quality.
    int jpegQuality = CameraProfile.getJpegEncodingQualityParameter(mCameraId,
            CameraProfile.QUALITY_HIGH);
    mParameters.setJpegQuality(jpegQuality);

    mCameraDevice.setParameters(mParameters);
    // Keep preview size up to date.
    mParameters = mCameraDevice.getParameters();

    // Update UI based on the new parameters.
    mUI.updateOnScreenIndicators(mParameters, mPreferences);
}