| /* |
| * Copyright (C) 2016 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package com.android.dialer.callcomposer.camera; |
| |
| import android.content.Context; |
| import android.hardware.Camera; |
| import android.hardware.Camera.CameraInfo; |
| import android.net.Uri; |
| import android.os.AsyncTask; |
| import android.os.Looper; |
| import android.support.annotation.NonNull; |
| import android.support.annotation.Nullable; |
| import android.support.annotation.VisibleForTesting; |
| import android.text.TextUtils; |
| import android.view.MotionEvent; |
| import android.view.OrientationEventListener; |
| import android.view.Surface; |
| import android.view.View; |
| import android.view.WindowManager; |
| import com.android.dialer.callcomposer.camera.camerafocus.FocusOverlayManager; |
| import com.android.dialer.callcomposer.camera.camerafocus.RenderOverlay; |
| import com.android.dialer.common.Assert; |
| import com.android.dialer.common.LogUtil; |
| import com.android.dialer.common.concurrent.DialerExecutorComponent; |
| import java.io.IOException; |
| import java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.Comparator; |
| import java.util.List; |
| |
| /** |
| * Class which manages interactions with the camera, but does not do any UI. This class is designed |
| * to be a singleton to ensure there is one component managing the camera and releasing the native |
| * resources. In order to acquire a camera, a caller must: |
| * |
| * <ul> |
| * <li>Call selectCamera to select front or back camera |
| * <li>Call setSurface to control where the preview is shown |
| * <li>Call openCamera to request the camera start preview |
| * </ul> |
| * |
| * Callers should call onPause and onResume to ensure that the camera is release while the activity |
| * is not active. This class is not thread safe. It should only be called from one thread (the UI |
| * thread or test thread) |
| */ |
| public class CameraManager implements FocusOverlayManager.Listener { |
| /** Callbacks for the camera manager listener */ |
| public interface CameraManagerListener { |
| void onCameraError(int errorCode, Exception e); |
| |
| void onCameraChanged(); |
| } |
| |
| /** Callback when taking image or video */ |
| public interface MediaCallback { |
| int MEDIA_CAMERA_CHANGED = 1; |
| int MEDIA_NO_DATA = 2; |
| |
| void onMediaReady(Uri uriToMedia, String contentType, int width, int height); |
| |
| void onMediaFailed(Exception exception); |
| |
| void onMediaInfo(int what); |
| } |
| |
| // Error codes |
| private static final int ERROR_OPENING_CAMERA = 1; |
| private static final int ERROR_SHOWING_PREVIEW = 2; |
| private static final int ERROR_HARDWARE_ACCELERATION_DISABLED = 3; |
| private static final int ERROR_TAKING_PICTURE = 4; |
| |
| private static final int NO_CAMERA_SELECTED = -1; |
| |
| private static final Camera.ShutterCallback NOOP_SHUTTER_CALLBACK = |
| new Camera.ShutterCallback() { |
| @Override |
| public void onShutter() { |
| // Do nothing |
| } |
| }; |
| |
| private static CameraManager instance; |
| |
| /** The CameraInfo for the currently selected camera */ |
| private final CameraInfo cameraInfo; |
| |
| /** The index of the selected camera or NO_CAMERA_SELECTED if a camera hasn't been selected yet */ |
| private int cameraIndex; |
| |
| /** True if the device has front and back cameras */ |
| private final boolean hasFrontAndBackCamera; |
| |
| /** True if the camera should be open (may not yet be actually open) */ |
| private boolean openRequested; |
| |
| /** The preview view to show the preview on */ |
| private CameraPreview cameraPreview; |
| |
| /** The helper classs to handle orientation changes */ |
| private OrientationHandler orientationHandler; |
| |
| /** Tracks whether the preview has hardware acceleration */ |
| private boolean isHardwareAccelerationSupported; |
| |
| /** |
| * The task for opening the camera, so it doesn't block the UI thread Using AsyncTask rather than |
| * SafeAsyncTask because the tasks need to be serialized, but don't need to be on the UI thread |
| * TODO(blemmon): If we have other AyncTasks (not SafeAsyncTasks) this may contend and we may need |
| * to create a dedicated thread, or synchronize the threads in the thread pool |
| */ |
| private AsyncTask<Integer, Void, Camera> openCameraTask; |
| |
| /** |
| * The camera index that is queued to be opened, but not completed yet, or NO_CAMERA_SELECTED if |
| * no open task is pending |
| */ |
| private int pendingOpenCameraIndex = NO_CAMERA_SELECTED; |
| |
| /** The instance of the currently opened camera */ |
| private Camera camera; |
| |
| /** The rotation of the screen relative to the camera's natural orientation */ |
| private int rotation; |
| |
| /** The callback to notify when errors or other events occur */ |
| private CameraManagerListener listener; |
| |
| /** True if the camera is currently in the process of taking an image */ |
| private boolean takingPicture; |
| |
| /** Manages auto focus visual and behavior */ |
| private final FocusOverlayManager focusOverlayManager; |
| |
| private CameraManager() { |
| this.cameraInfo = new CameraInfo(); |
| cameraIndex = NO_CAMERA_SELECTED; |
| |
| // Check to see if a front and back camera exist |
| boolean hasFrontCamera = false; |
| boolean hasBackCamera = false; |
| final CameraInfo cameraInfo = new CameraInfo(); |
| final int cameraCount = Camera.getNumberOfCameras(); |
| try { |
| for (int i = 0; i < cameraCount; i++) { |
| Camera.getCameraInfo(i, cameraInfo); |
| if (cameraInfo.facing == CameraInfo.CAMERA_FACING_FRONT) { |
| hasFrontCamera = true; |
| } else if (cameraInfo.facing == CameraInfo.CAMERA_FACING_BACK) { |
| hasBackCamera = true; |
| } |
| if (hasFrontCamera && hasBackCamera) { |
| break; |
| } |
| } |
| } catch (final RuntimeException e) { |
| LogUtil.e("CameraManager.CameraManager", "Unable to load camera info", e); |
| } |
| hasFrontAndBackCamera = hasFrontCamera && hasBackCamera; |
| focusOverlayManager = new FocusOverlayManager(this, Looper.getMainLooper()); |
| |
| // Assume the best until we are proven otherwise |
| isHardwareAccelerationSupported = true; |
| } |
| |
| /** Gets the singleton instance */ |
| public static CameraManager get() { |
| if (instance == null) { |
| instance = new CameraManager(); |
| } |
| return instance; |
| } |
| |
| /** |
| * Sets the surface to use to display the preview This must only be called AFTER the CameraPreview |
| * has a texture ready |
| * |
| * @param preview The preview surface view |
| */ |
| void setSurface(final CameraPreview preview) { |
| if (preview == cameraPreview) { |
| return; |
| } |
| |
| if (preview != null) { |
| Assert.checkArgument(preview.isValid()); |
| preview.setOnTouchListener( |
| new View.OnTouchListener() { |
| @Override |
| public boolean onTouch(final View view, final MotionEvent motionEvent) { |
| if ((motionEvent.getActionMasked() & MotionEvent.ACTION_UP) |
| == MotionEvent.ACTION_UP) { |
| focusOverlayManager.setPreviewSize(view.getWidth(), view.getHeight()); |
| focusOverlayManager.onSingleTapUp( |
| (int) motionEvent.getX() + view.getLeft(), |
| (int) motionEvent.getY() + view.getTop()); |
| } |
| view.performClick(); |
| return true; |
| } |
| }); |
| } |
| cameraPreview = preview; |
| tryShowPreview(); |
| } |
| |
| public void setRenderOverlay(final RenderOverlay renderOverlay) { |
| focusOverlayManager.setFocusRenderer( |
| renderOverlay != null ? renderOverlay.getPieRenderer() : null); |
| } |
| |
| /** Convenience function to swap between front and back facing cameras */ |
| public void swapCamera() { |
| Assert.checkState(cameraIndex >= 0); |
| selectCamera( |
| cameraInfo.facing == CameraInfo.CAMERA_FACING_FRONT |
| ? CameraInfo.CAMERA_FACING_BACK |
| : CameraInfo.CAMERA_FACING_FRONT); |
| } |
| |
| /** |
| * Selects the first camera facing the desired direction, or the first camera if there is no |
| * camera in the desired direction |
| * |
| * @param desiredFacing One of the CameraInfo.CAMERA_FACING_* constants |
| * @return True if a camera was selected, or false if selecting a camera failed |
| */ |
| public boolean selectCamera(final int desiredFacing) { |
| try { |
| // We already selected a camera facing that direction |
| if (cameraIndex >= 0 && this.cameraInfo.facing == desiredFacing) { |
| return true; |
| } |
| |
| final int cameraCount = Camera.getNumberOfCameras(); |
| Assert.checkState(cameraCount > 0); |
| |
| cameraIndex = NO_CAMERA_SELECTED; |
| setCamera(null); |
| final CameraInfo cameraInfo = new CameraInfo(); |
| for (int i = 0; i < cameraCount; i++) { |
| Camera.getCameraInfo(i, cameraInfo); |
| if (cameraInfo.facing == desiredFacing) { |
| cameraIndex = i; |
| Camera.getCameraInfo(i, this.cameraInfo); |
| break; |
| } |
| } |
| |
| // There's no camera in the desired facing direction, just select the first camera |
| // regardless of direction |
| if (cameraIndex < 0) { |
| cameraIndex = 0; |
| Camera.getCameraInfo(0, this.cameraInfo); |
| } |
| |
| if (openRequested) { |
| // The camera is open, so reopen with the newly selected camera |
| openCamera(); |
| } |
| return true; |
| } catch (final RuntimeException e) { |
| LogUtil.e("CameraManager.selectCamera", "RuntimeException in CameraManager.selectCamera", e); |
| if (listener != null) { |
| listener.onCameraError(ERROR_OPENING_CAMERA, e); |
| } |
| return false; |
| } |
| } |
| |
| public int getCameraIndex() { |
| return cameraIndex; |
| } |
| |
| public void selectCameraByIndex(final int cameraIndex) { |
| if (this.cameraIndex == cameraIndex) { |
| return; |
| } |
| |
| try { |
| this.cameraIndex = cameraIndex; |
| Camera.getCameraInfo(this.cameraIndex, cameraInfo); |
| if (openRequested) { |
| openCamera(); |
| } |
| } catch (final RuntimeException e) { |
| LogUtil.e( |
| "CameraManager.selectCameraByIndex", |
| "RuntimeException in CameraManager.selectCameraByIndex", |
| e); |
| if (listener != null) { |
| listener.onCameraError(ERROR_OPENING_CAMERA, e); |
| } |
| } |
| } |
| |
| @Nullable |
| @VisibleForTesting |
| public CameraInfo getCameraInfo() { |
| if (cameraIndex == NO_CAMERA_SELECTED) { |
| return null; |
| } |
| return cameraInfo; |
| } |
| |
| /** @return True if the device has both a front and back camera */ |
| public boolean hasFrontAndBackCamera() { |
| return hasFrontAndBackCamera; |
| } |
| |
| /** Opens the camera on a separate thread and initiates the preview if one is available */ |
| void openCamera() { |
| if (this.cameraIndex == NO_CAMERA_SELECTED) { |
| // Ensure a selected camera if none is currently selected. This may happen if the |
| // camera chooser is not the default media chooser. |
| selectCamera(CameraInfo.CAMERA_FACING_BACK); |
| } |
| openRequested = true; |
| // We're already opening the camera or already have the camera handle, nothing more to do |
| if (pendingOpenCameraIndex == this.cameraIndex || this.camera != null) { |
| return; |
| } |
| |
| // True if the task to open the camera has to be delayed until the current one completes |
| boolean delayTask = false; |
| |
| // Cancel any previous open camera tasks |
| if (openCameraTask != null) { |
| pendingOpenCameraIndex = NO_CAMERA_SELECTED; |
| delayTask = true; |
| } |
| |
| pendingOpenCameraIndex = this.cameraIndex; |
| openCameraTask = |
| new AsyncTask<Integer, Void, Camera>() { |
| private Exception exception; |
| |
| @Override |
| protected Camera doInBackground(final Integer... params) { |
| try { |
| final int cameraIndex = params[0]; |
| LogUtil.v( |
| "CameraManager.doInBackground", |
| "Opening camera " + CameraManager.this.cameraIndex); |
| return Camera.open(cameraIndex); |
| } catch (final Exception e) { |
| LogUtil.e("CameraManager.doInBackground", "Exception while opening camera", e); |
| exception = e; |
| return null; |
| } |
| } |
| |
| @Override |
| protected void onPostExecute(final Camera camera) { |
| // If we completed, but no longer want this camera, then release the camera |
| if (openCameraTask != this || !openRequested) { |
| releaseCamera(camera); |
| cleanup(); |
| return; |
| } |
| |
| cleanup(); |
| |
| LogUtil.v( |
| "CameraManager.onPostExecute", |
| "Opened camera " + CameraManager.this.cameraIndex + " " + (camera != null)); |
| setCamera(camera); |
| if (camera == null) { |
| if (listener != null) { |
| listener.onCameraError(ERROR_OPENING_CAMERA, exception); |
| } |
| LogUtil.e("CameraManager.onPostExecute", "Error opening camera"); |
| } |
| } |
| |
| @Override |
| protected void onCancelled() { |
| super.onCancelled(); |
| cleanup(); |
| } |
| |
| private void cleanup() { |
| pendingOpenCameraIndex = NO_CAMERA_SELECTED; |
| if (openCameraTask != null && openCameraTask.getStatus() == Status.PENDING) { |
| // If there's another task waiting on this one to complete, start it now |
| openCameraTask.execute(CameraManager.this.cameraIndex); |
| } else { |
| openCameraTask = null; |
| } |
| } |
| }; |
| LogUtil.v("CameraManager.openCamera", "Start opening camera " + this.cameraIndex); |
| if (!delayTask) { |
| openCameraTask.execute(this.cameraIndex); |
| } |
| } |
| |
| /** Closes the camera releasing the resources it uses */ |
| void closeCamera() { |
| openRequested = false; |
| setCamera(null); |
| } |
| |
| /** |
| * Sets the listener which will be notified of errors or other events in the camera |
| * |
| * @param listener The listener to notify |
| */ |
| public void setListener(final CameraManagerListener listener) { |
| Assert.isMainThread(); |
| this.listener = listener; |
| if (!isHardwareAccelerationSupported && this.listener != null) { |
| this.listener.onCameraError(ERROR_HARDWARE_ACCELERATION_DISABLED, null); |
| } |
| } |
| |
| public void takePicture(final float heightPercent, @NonNull final MediaCallback callback) { |
| Assert.checkState(!takingPicture); |
| Assert.isNotNull(callback); |
| cameraPreview.setFocusable(false); |
| focusOverlayManager.cancelAutoFocus(); |
| if (this.camera == null) { |
| // The caller should have checked isCameraAvailable first, but just in case, protect |
| // against a null camera by notifying the callback that taking the picture didn't work |
| callback.onMediaFailed(null); |
| return; |
| } |
| final Camera.PictureCallback jpegCallback = |
| new Camera.PictureCallback() { |
| @Override |
| public void onPictureTaken(final byte[] bytes, final Camera camera) { |
| takingPicture = false; |
| if (CameraManager.this.camera != camera) { |
| // This may happen if the camera was changed between front/back while the |
| // picture is being taken. |
| callback.onMediaInfo(MediaCallback.MEDIA_CAMERA_CHANGED); |
| return; |
| } |
| |
| if (bytes == null) { |
| callback.onMediaInfo(MediaCallback.MEDIA_NO_DATA); |
| return; |
| } |
| |
| final Camera.Size size = camera.getParameters().getPictureSize(); |
| int width; |
| int height; |
| if (rotation == 90 || rotation == 270) { |
| // Is rotated, so swapping dimensions is desired |
| // noinspection SuspiciousNameCombination |
| width = size.height; |
| // noinspection SuspiciousNameCombination |
| height = size.width; |
| } else { |
| width = size.width; |
| height = size.height; |
| } |
| LogUtil.i( |
| "CameraManager.onPictureTaken", "taken picture size: " + bytes.length + " bytes"); |
| DialerExecutorComponent.get(cameraPreview.getContext()) |
| .dialerExecutorFactory() |
| .createNonUiTaskBuilder( |
| new ImagePersistWorker( |
| width, height, heightPercent, bytes, cameraPreview.getContext())) |
| .onSuccess( |
| (result) -> { |
| callback.onMediaReady( |
| result.getUri(), "image/jpeg", result.getWidth(), result.getHeight()); |
| }) |
| .onFailure( |
| (throwable) -> { |
| callback.onMediaFailed(new Exception("Persisting image failed", throwable)); |
| }) |
| .build() |
| .executeSerial(null); |
| } |
| }; |
| |
| takingPicture = true; |
| try { |
| this.camera.takePicture( |
| // A shutter callback is required to enable shutter sound |
| NOOP_SHUTTER_CALLBACK, null /* raw */, null /* postView */, jpegCallback); |
| } catch (final RuntimeException e) { |
| LogUtil.e("CameraManager.takePicture", "RuntimeException in CameraManager.takePicture", e); |
| takingPicture = false; |
| if (listener != null) { |
| listener.onCameraError(ERROR_TAKING_PICTURE, e); |
| } |
| } |
| } |
| |
| /** |
| * Asynchronously releases a camera |
| * |
| * @param camera The camera to release |
| */ |
| private void releaseCamera(final Camera camera) { |
| if (camera == null) { |
| return; |
| } |
| |
| focusOverlayManager.onCameraReleased(); |
| |
| new AsyncTask<Void, Void, Void>() { |
| @Override |
| protected Void doInBackground(final Void... params) { |
| LogUtil.v("CameraManager.doInBackground", "Releasing camera " + cameraIndex); |
| camera.release(); |
| return null; |
| } |
| }.execute(); |
| } |
| |
| /** |
| * Updates the orientation of the {@link Camera} w.r.t. the orientation of the device and the |
| * orientation that the physical camera is mounted on the device. |
| * |
| * @param camera that needs to be reorientated |
| * @param screenRotation rotation of the physical device |
| * @param cameraOrientation {@link CameraInfo#orientation} |
| * @param cameraIsFrontFacing {@link CameraInfo#CAMERA_FACING_FRONT} |
| * @return rotation that images returned from {@link |
| * android.hardware.Camera.PictureCallback#onPictureTaken(byte[], Camera)} will be rotated. |
| */ |
| @VisibleForTesting |
| static int updateCameraRotation( |
| @NonNull Camera camera, |
| int screenRotation, |
| int cameraOrientation, |
| boolean cameraIsFrontFacing) { |
| Assert.isNotNull(camera); |
| Assert.checkArgument(cameraOrientation % 90 == 0); |
| |
| int rotation = screenRotationToDegress(screenRotation); |
| boolean portrait = rotation == 0 || rotation == 180; |
| |
| if (!portrait && !cameraIsFrontFacing) { |
| rotation += 180; |
| } |
| rotation += cameraOrientation; |
| rotation %= 360; |
| |
| // Rotate the camera |
| if (portrait && cameraIsFrontFacing) { |
| camera.setDisplayOrientation((rotation + 180) % 360); |
| } else { |
| camera.setDisplayOrientation(rotation); |
| } |
| |
| // Rotate the images returned when a picture is taken |
| Camera.Parameters params = camera.getParameters(); |
| params.setRotation(rotation); |
| camera.setParameters(params); |
| return rotation; |
| } |
| |
| private static int screenRotationToDegress(int screenRotation) { |
| switch (screenRotation) { |
| case Surface.ROTATION_0: |
| return 0; |
| case Surface.ROTATION_90: |
| return 90; |
| case Surface.ROTATION_180: |
| return 180; |
| case Surface.ROTATION_270: |
| return 270; |
| default: |
| throw Assert.createIllegalStateFailException("Invalid surface rotation."); |
| } |
| } |
| |
| /** Sets the current camera, releasing any previously opened camera */ |
| private void setCamera(final Camera camera) { |
| if (this.camera == camera) { |
| return; |
| } |
| |
| releaseCamera(this.camera); |
| this.camera = camera; |
| tryShowPreview(); |
| if (listener != null) { |
| listener.onCameraChanged(); |
| } |
| } |
| |
| /** Shows the preview if the camera is open and the preview is loaded */ |
| private void tryShowPreview() { |
| if (cameraPreview == null || this.camera == null) { |
| if (orientationHandler != null) { |
| orientationHandler.disable(); |
| orientationHandler = null; |
| } |
| focusOverlayManager.onPreviewStopped(); |
| return; |
| } |
| try { |
| this.camera.stopPreview(); |
| if (!takingPicture) { |
| rotation = |
| updateCameraRotation( |
| this.camera, |
| getScreenRotation(), |
| cameraInfo.orientation, |
| cameraInfo.facing == CameraInfo.CAMERA_FACING_FRONT); |
| } |
| |
| final Camera.Parameters params = this.camera.getParameters(); |
| final Camera.Size pictureSize = chooseBestPictureSize(); |
| final Camera.Size previewSize = chooseBestPreviewSize(pictureSize); |
| params.setPreviewSize(previewSize.width, previewSize.height); |
| params.setPictureSize(pictureSize.width, pictureSize.height); |
| logCameraSize("Setting preview size: ", previewSize); |
| logCameraSize("Setting picture size: ", pictureSize); |
| cameraPreview.setSize(previewSize, cameraInfo.orientation); |
| for (final String focusMode : params.getSupportedFocusModes()) { |
| if (TextUtils.equals(focusMode, Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE)) { |
| // Use continuous focus if available |
| params.setFocusMode(focusMode); |
| break; |
| } |
| } |
| |
| this.camera.setParameters(params); |
| cameraPreview.startPreview(this.camera); |
| this.camera.startPreview(); |
| this.camera.setAutoFocusMoveCallback( |
| new Camera.AutoFocusMoveCallback() { |
| @Override |
| public void onAutoFocusMoving(final boolean start, final Camera camera) { |
| focusOverlayManager.onAutoFocusMoving(start); |
| } |
| }); |
| focusOverlayManager.setParameters(this.camera.getParameters()); |
| focusOverlayManager.setMirror(cameraInfo.facing == CameraInfo.CAMERA_FACING_BACK); |
| focusOverlayManager.onPreviewStarted(); |
| if (orientationHandler == null) { |
| orientationHandler = new OrientationHandler(cameraPreview.getContext()); |
| orientationHandler.enable(); |
| } |
| } catch (final IOException e) { |
| LogUtil.e("CameraManager.tryShowPreview", "IOException in CameraManager.tryShowPreview", e); |
| if (listener != null) { |
| listener.onCameraError(ERROR_SHOWING_PREVIEW, e); |
| } |
| } catch (final RuntimeException e) { |
| LogUtil.e( |
| "CameraManager.tryShowPreview", "RuntimeException in CameraManager.tryShowPreview", e); |
| if (listener != null) { |
| listener.onCameraError(ERROR_SHOWING_PREVIEW, e); |
| } |
| } |
| } |
| |
| private int getScreenRotation() { |
| return cameraPreview |
| .getContext() |
| .getSystemService(WindowManager.class) |
| .getDefaultDisplay() |
| .getRotation(); |
| } |
| |
| public boolean isCameraAvailable() { |
| return camera != null && !takingPicture && isHardwareAccelerationSupported; |
| } |
| |
| /** |
| * Choose the best picture size by trying to find a size close to the MmsConfig's max size, which |
| * is closest to the screen aspect ratio. In case of RCS conversation returns default size. |
| */ |
| private Camera.Size chooseBestPictureSize() { |
| return camera.getParameters().getPictureSize(); |
| } |
| |
| /** |
| * Chose the best preview size based on the picture size. Try to find a size with the same aspect |
| * ratio and size as the picture if possible |
| */ |
| private Camera.Size chooseBestPreviewSize(final Camera.Size pictureSize) { |
| final List<Camera.Size> sizes = |
| new ArrayList<Camera.Size>(camera.getParameters().getSupportedPreviewSizes()); |
| final float aspectRatio = pictureSize.width / (float) pictureSize.height; |
| final int capturePixels = pictureSize.width * pictureSize.height; |
| |
| // Sort the sizes so the best size is first |
| Collections.sort( |
| sizes, |
| new SizeComparator(Integer.MAX_VALUE, Integer.MAX_VALUE, aspectRatio, capturePixels)); |
| |
| return sizes.get(0); |
| } |
| |
| private class OrientationHandler extends OrientationEventListener { |
| OrientationHandler(final Context context) { |
| super(context); |
| } |
| |
| @Override |
| public void onOrientationChanged(final int orientation) { |
| if (!takingPicture) { |
| rotation = |
| updateCameraRotation( |
| camera, |
| getScreenRotation(), |
| cameraInfo.orientation, |
| cameraInfo.facing == CameraInfo.CAMERA_FACING_FRONT); |
| } |
| } |
| } |
| |
| private static class SizeComparator implements Comparator<Camera.Size> { |
| private static final int PREFER_LEFT = -1; |
| private static final int PREFER_RIGHT = 1; |
| |
| // The max width/height for the preferred size. Integer.MAX_VALUE if no size limit |
| private final int maxWidth; |
| private final int maxHeight; |
| |
| // The desired aspect ratio |
| private final float targetAspectRatio; |
| |
| // The desired size (width x height) to try to match |
| private final int targetPixels; |
| |
| public SizeComparator( |
| final int maxWidth, |
| final int maxHeight, |
| final float targetAspectRatio, |
| final int targetPixels) { |
| this.maxWidth = maxWidth; |
| this.maxHeight = maxHeight; |
| this.targetAspectRatio = targetAspectRatio; |
| this.targetPixels = targetPixels; |
| } |
| |
| /** |
| * Returns a negative value if left is a better choice than right, or a positive value if right |
| * is a better choice is better than left. 0 if they are equal |
| */ |
| @Override |
| public int compare(final Camera.Size left, final Camera.Size right) { |
| // If one size is less than the max size prefer it over the other |
| if ((left.width <= maxWidth && left.height <= maxHeight) |
| != (right.width <= maxWidth && right.height <= maxHeight)) { |
| return left.width <= maxWidth ? PREFER_LEFT : PREFER_RIGHT; |
| } |
| |
| // If one is closer to the target aspect ratio, prefer it. |
| final float leftAspectRatio = left.width / (float) left.height; |
| final float rightAspectRatio = right.width / (float) right.height; |
| final float leftAspectRatioDiff = Math.abs(leftAspectRatio - targetAspectRatio); |
| final float rightAspectRatioDiff = Math.abs(rightAspectRatio - targetAspectRatio); |
| if (leftAspectRatioDiff != rightAspectRatioDiff) { |
| return (leftAspectRatioDiff - rightAspectRatioDiff) < 0 ? PREFER_LEFT : PREFER_RIGHT; |
| } |
| |
| // At this point they have the same aspect ratio diff and are either both bigger |
| // than the max size or both smaller than the max size, so prefer the one closest |
| // to target size |
| final int leftDiff = Math.abs((left.width * left.height) - targetPixels); |
| final int rightDiff = Math.abs((right.width * right.height) - targetPixels); |
| return leftDiff - rightDiff; |
| } |
| } |
| |
| @Override // From FocusOverlayManager.Listener |
| public void autoFocus() { |
| if (this.camera == null) { |
| return; |
| } |
| |
| try { |
| this.camera.autoFocus( |
| new Camera.AutoFocusCallback() { |
| @Override |
| public void onAutoFocus(final boolean success, final Camera camera) { |
| focusOverlayManager.onAutoFocus(success, false /* shutterDown */); |
| } |
| }); |
| } catch (final RuntimeException e) { |
| LogUtil.e("CameraManager.autoFocus", "RuntimeException in CameraManager.autoFocus", e); |
| // If autofocus fails, the camera should have called the callback with success=false, |
| // but some throw an exception here |
| focusOverlayManager.onAutoFocus(false /*success*/, false /*shutterDown*/); |
| } |
| } |
| |
| @Override // From FocusOverlayManager.Listener |
| public void cancelAutoFocus() { |
| if (camera == null) { |
| return; |
| } |
| try { |
| camera.cancelAutoFocus(); |
| } catch (final RuntimeException e) { |
| // Ignore |
| LogUtil.e( |
| "CameraManager.cancelAutoFocus", "RuntimeException in CameraManager.cancelAutoFocus", e); |
| } |
| } |
| |
| @Override // From FocusOverlayManager.Listener |
| public boolean capture() { |
| return false; |
| } |
| |
| @Override // From FocusOverlayManager.Listener |
| public void setFocusParameters() { |
| if (camera == null) { |
| return; |
| } |
| try { |
| final Camera.Parameters parameters = camera.getParameters(); |
| parameters.setFocusMode(focusOverlayManager.getFocusMode()); |
| if (parameters.getMaxNumFocusAreas() > 0) { |
| // Don't set focus areas (even to null) if focus areas aren't supported, camera may |
| // crash |
| parameters.setFocusAreas(focusOverlayManager.getFocusAreas()); |
| } |
| parameters.setMeteringAreas(focusOverlayManager.getMeteringAreas()); |
| camera.setParameters(parameters); |
| } catch (final RuntimeException e) { |
| // This occurs when the device is out of space or when the camera is locked |
| LogUtil.e( |
| "CameraManager.setFocusParameters", |
| "RuntimeException in CameraManager setFocusParameters"); |
| } |
| } |
| |
| public void resetPreview() { |
| camera.startPreview(); |
| if (cameraPreview != null) { |
| cameraPreview.setFocusable(true); |
| } |
| } |
| |
| private void logCameraSize(final String prefix, final Camera.Size size) { |
| // Log the camera size and aspect ratio for help when examining bug reports for camera |
| // failures |
| LogUtil.i( |
| "CameraManager.logCameraSize", |
| prefix + size.width + "x" + size.height + " (" + (size.width / (float) size.height) + ")"); |
| } |
| |
| @VisibleForTesting |
| public void resetCameraManager() { |
| instance = null; |
| } |
| } |
