/*
|
* Copyright (C) 2012 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.ex.camera2.portability;
|
|
import android.annotation.TargetApi;
|
import android.graphics.SurfaceTexture;
|
import android.hardware.Camera;
|
import android.hardware.Camera.OnZoomChangeListener;
|
import android.os.Build;
|
import android.os.Handler;
|
import android.os.Looper;
|
import android.os.Message;
|
import android.view.SurfaceHolder;
|
|
import com.android.ex.camera2.portability.debug.Log;
|
|
/**
|
* An interface which provides possible camera device operations.
|
*
|
* The client should call {@code CameraAgent.openCamera} to get an instance
|
* of {@link CameraAgent.CameraProxy} to control the camera. Classes
|
* implementing this interface should have its own one unique {@code Thread}
|
* other than the main thread for camera operations. Camera device callbacks
|
* are wrapped since the client should not deal with
|
* {@code android.hardware.Camera} directly.
|
*
|
* TODO: provide callback interfaces for:
|
* {@code android.hardware.Camera.ErrorCallback},
|
* {@code android.hardware.Camera.OnZoomChangeListener}, and
|
*/
|
public abstract class CameraAgent {
|
public static final long CAMERA_OPERATION_TIMEOUT_MS = 3500;
|
|
private static final Log.Tag TAG = new Log.Tag("CamAgnt");
|
|
public static class CameraStartPreviewCallbackForward
|
implements CameraStartPreviewCallback {
|
private final Handler mHandler;
|
private final CameraStartPreviewCallback mCallback;
|
|
public static CameraStartPreviewCallbackForward getNewInstance(
|
Handler handler, CameraStartPreviewCallback cb) {
|
if (handler == null || cb == null) {
|
return null;
|
}
|
return new CameraStartPreviewCallbackForward(handler, cb);
|
}
|
|
private CameraStartPreviewCallbackForward(Handler h,
|
CameraStartPreviewCallback cb) {
|
mHandler = h;
|
mCallback = cb;
|
}
|
|
@Override
|
public void onPreviewStarted() {
|
mHandler.post(new Runnable() {
|
@Override
|
public void run() {
|
mCallback.onPreviewStarted();
|
}});
|
}
|
}
|
|
/**
|
* A callback helps to invoke the original callback on another
|
* {@link android.os.Handler}.
|
*/
|
public static class CameraOpenCallbackForward implements CameraOpenCallback {
|
private final Handler mHandler;
|
private final CameraOpenCallback mCallback;
|
|
/**
|
* Returns a new instance of {@link FaceDetectionCallbackForward}.
|
*
|
* @param handler The handler in which the callback will be invoked in.
|
* @param cb The callback to be invoked.
|
* @return The instance of the {@link FaceDetectionCallbackForward}, or
|
* null if any parameter is null.
|
*/
|
public static CameraOpenCallbackForward getNewInstance(
|
Handler handler, CameraOpenCallback cb) {
|
if (handler == null || cb == null) {
|
return null;
|
}
|
return new CameraOpenCallbackForward(handler, cb);
|
}
|
|
private CameraOpenCallbackForward(Handler h, CameraOpenCallback cb) {
|
// Given that we are using the main thread handler, we can create it
|
// here instead of holding onto the PhotoModule objects. In this
|
// way, we can avoid memory leak.
|
mHandler = new Handler(Looper.getMainLooper());
|
mCallback = cb;
|
}
|
|
@Override
|
public void onCameraOpened(final CameraProxy camera) {
|
mHandler.post(new Runnable() {
|
@Override
|
public void run() {
|
mCallback.onCameraOpened(camera);
|
}});
|
}
|
|
@Override
|
public void onCameraDisabled(final int cameraId) {
|
mHandler.post(new Runnable() {
|
@Override
|
public void run() {
|
mCallback.onCameraDisabled(cameraId);
|
}});
|
}
|
|
@Override
|
public void onDeviceOpenFailure(final int cameraId, final String info) {
|
mHandler.post(new Runnable() {
|
@Override
|
public void run() {
|
mCallback.onDeviceOpenFailure(cameraId, info);
|
}});
|
}
|
|
@Override
|
public void onDeviceOpenedAlready(final int cameraId, final String info) {
|
mHandler.post(new Runnable() {
|
@Override
|
public void run() {
|
mCallback.onDeviceOpenedAlready(cameraId, info);
|
}});
|
}
|
|
@Override
|
public void onReconnectionFailure(final CameraAgent mgr, final String info) {
|
mHandler.post(new Runnable() {
|
@Override
|
public void run() {
|
mCallback.onReconnectionFailure(mgr, info);
|
}});
|
}
|
}
|
|
/**
|
* An interface which wraps
|
* {@link android.hardware.Camera.ErrorCallback}
|
*/
|
public static interface CameraErrorCallback {
|
public void onError(int error, CameraProxy camera);
|
}
|
|
/**
|
* An interface which wraps
|
* {@link android.hardware.Camera.AutoFocusCallback}.
|
*/
|
public static interface CameraAFCallback {
|
public void onAutoFocus(boolean focused, CameraProxy camera);
|
}
|
|
/**
|
* An interface which wraps
|
* {@link android.hardware.Camera.AutoFocusMoveCallback}.
|
*/
|
public static interface CameraAFMoveCallback {
|
public void onAutoFocusMoving(boolean moving, CameraProxy camera);
|
}
|
|
/**
|
* An interface which wraps
|
* {@link android.hardware.Camera.ShutterCallback}.
|
*/
|
public static interface CameraShutterCallback {
|
public void onShutter(CameraProxy camera);
|
}
|
|
/**
|
* An interface which wraps
|
* {@link android.hardware.Camera.PictureCallback}.
|
*/
|
public static interface CameraPictureCallback {
|
public void onPictureTaken(byte[] data, CameraProxy camera);
|
}
|
|
/**
|
* An interface which wraps
|
* {@link android.hardware.Camera.PreviewCallback}.
|
*/
|
public static interface CameraPreviewDataCallback {
|
public void onPreviewFrame(byte[] data, CameraProxy camera);
|
}
|
|
/**
|
* An interface which wraps
|
* {@link android.hardware.Camera.FaceDetectionListener}.
|
*/
|
public static interface CameraFaceDetectionCallback {
|
/**
|
* Callback for face detection.
|
*
|
* @param faces Recognized face in the preview.
|
* @param camera The camera which the preview image comes from.
|
*/
|
public void onFaceDetection(Camera.Face[] faces, CameraProxy camera);
|
}
|
|
/**
|
* An interface to be called when the camera preview has started.
|
*/
|
public static interface CameraStartPreviewCallback {
|
/**
|
* Callback when the preview starts.
|
*/
|
public void onPreviewStarted();
|
}
|
|
/**
|
* An interface to be called for any events when opening or closing the
|
* camera device. This error callback is different from the one defined
|
* in the framework, {@link android.hardware.Camera.ErrorCallback}, which
|
* is used after the camera is opened.
|
*/
|
public static interface CameraOpenCallback {
|
/**
|
* Callback when camera open succeeds.
|
*/
|
public void onCameraOpened(CameraProxy camera);
|
|
/**
|
* Callback when {@link com.android.camera.CameraDisabledException} is
|
* caught.
|
*
|
* @param cameraId The disabled camera.
|
*/
|
public void onCameraDisabled(int cameraId);
|
|
/**
|
* Callback when {@link com.android.camera.CameraHardwareException} is
|
* caught.
|
*
|
* @param cameraId The camera with the hardware failure.
|
* @param info The extra info regarding this failure.
|
*/
|
public void onDeviceOpenFailure(int cameraId, String info);
|
|
/**
|
* Callback when trying to open the camera which is already opened.
|
*
|
* @param cameraId The camera which is causing the open error.
|
*/
|
public void onDeviceOpenedAlready(int cameraId, String info);
|
|
/**
|
* Callback when {@link java.io.IOException} is caught during
|
* {@link android.hardware.Camera#reconnect()}.
|
*
|
* @param mgr The {@link CameraAgent}
|
* with the reconnect failure.
|
*/
|
public void onReconnectionFailure(CameraAgent mgr, String info);
|
}
|
|
/**
|
* Opens the camera of the specified ID asynchronously. The camera device
|
* will be opened in the camera handler thread and will be returned through
|
* the {@link CameraAgent.CameraOpenCallback#
|
* onCameraOpened(com.android.camera.cameradevice.CameraAgent.CameraProxy)}.
|
*
|
* @param handler The {@link android.os.Handler} in which the callback
|
* was handled.
|
* @param callback The callback for the result.
|
* @param cameraId The camera ID to open.
|
*/
|
public void openCamera(final Handler handler, final int cameraId,
|
final CameraOpenCallback callback) {
|
try {
|
getDispatchThread().runJob(new Runnable() {
|
@Override
|
public void run() {
|
getCameraHandler().obtainMessage(CameraActions.OPEN_CAMERA, cameraId, 0,
|
CameraOpenCallbackForward.getNewInstance(handler, callback)).sendToTarget();
|
}
|
});
|
} catch (final RuntimeException ex) {
|
getCameraExceptionHandler().onDispatchThreadException(ex);
|
}
|
}
|
|
/**
|
* Closes the camera device.
|
*
|
* @param camera The camera to close. {@code null} means all.
|
* @param synced Whether this call should be synchronous.
|
*/
|
public void closeCamera(CameraProxy camera, boolean synced) {
|
try {
|
if (synced) {
|
// Don't bother to wait since camera is in bad state.
|
if (getCameraState().isInvalid()) {
|
return;
|
}
|
final WaitDoneBundle bundle = new WaitDoneBundle();
|
|
getDispatchThread().runJobSync(new Runnable() {
|
@Override
|
public void run() {
|
getCameraHandler().obtainMessage(CameraActions.RELEASE).sendToTarget();
|
getCameraHandler().post(bundle.mUnlockRunnable);
|
}}, bundle.mWaitLock, CAMERA_OPERATION_TIMEOUT_MS, "camera release");
|
} else {
|
getDispatchThread().runJob(new Runnable() {
|
@Override
|
public void run() {
|
getCameraHandler().removeCallbacksAndMessages(null);
|
getCameraHandler().obtainMessage(CameraActions.RELEASE).sendToTarget();
|
}});
|
}
|
} catch (final RuntimeException ex) {
|
getCameraExceptionHandler().onDispatchThreadException(ex);
|
}
|
}
|
|
/**
|
* Sets a callback for handling camera api runtime exceptions on
|
* a handler.
|
*/
|
public abstract void setCameraExceptionHandler(CameraExceptionHandler exceptionHandler);
|
|
/**
|
* Recycles the resources used by this instance. CameraAgent will be in
|
* an unusable state after calling this.
|
*/
|
public abstract void recycle();
|
|
/**
|
* @return The camera devices info.
|
*/
|
public abstract CameraDeviceInfo getCameraDeviceInfo();
|
|
/**
|
* @return The handler to which camera tasks should be posted.
|
*/
|
protected abstract Handler getCameraHandler();
|
|
/**
|
* @return The thread used on which client callbacks are served.
|
*/
|
protected abstract DispatchThread getDispatchThread();
|
|
/**
|
* @return The state machine tracking the camera API's current status.
|
*/
|
protected abstract CameraStateHolder getCameraState();
|
|
/**
|
* @return The exception handler.
|
*/
|
protected abstract CameraExceptionHandler getCameraExceptionHandler();
|
|
/**
|
* An interface that takes camera operation requests and post messages to the
|
* camera handler thread. All camera operations made through this interface is
|
* asynchronous by default except those mentioned specifically.
|
*/
|
public abstract static class CameraProxy {
|
|
/**
|
* Returns the underlying {@link android.hardware.Camera} object used
|
* by this proxy. This method should only be used when handing the
|
* camera device over to {@link android.media.MediaRecorder} for
|
* recording.
|
*/
|
@Deprecated
|
public abstract android.hardware.Camera getCamera();
|
|
/**
|
* @return The camera ID associated to by this
|
* {@link CameraAgent.CameraProxy}.
|
*/
|
public abstract int getCameraId();
|
|
/**
|
* @return The camera characteristics.
|
*/
|
public abstract CameraDeviceInfo.Characteristics getCharacteristics();
|
|
/**
|
* @return The camera capabilities.
|
*/
|
public abstract CameraCapabilities getCapabilities();
|
|
/**
|
* @return The camera agent which creates this proxy.
|
*/
|
public abstract CameraAgent getAgent();
|
|
/**
|
* Reconnects to the camera device. On success, the camera device will
|
* be returned through {@link CameraAgent
|
* .CameraOpenCallback#onCameraOpened(com.android.camera.cameradevice.CameraAgent
|
* .CameraProxy)}.
|
* @see android.hardware.Camera#reconnect()
|
*
|
* @param handler The {@link android.os.Handler} in which the callback
|
* was handled.
|
* @param cb The callback when any error happens.
|
*/
|
public void reconnect(final Handler handler, final CameraOpenCallback cb) {
|
try {
|
getDispatchThread().runJob(new Runnable() {
|
@Override
|
public void run() {
|
getCameraHandler().obtainMessage(CameraActions.RECONNECT, getCameraId(), 0,
|
CameraOpenCallbackForward.getNewInstance(handler, cb)).sendToTarget();
|
}});
|
} catch (final RuntimeException ex) {
|
getAgent().getCameraExceptionHandler().onDispatchThreadException(ex);
|
}
|
}
|
|
/**
|
* Unlocks the camera device.
|
*
|
* @see android.hardware.Camera#unlock()
|
*/
|
public void unlock() {
|
// Don't bother to wait since camera is in bad state.
|
if (getCameraState().isInvalid()) {
|
return;
|
}
|
final WaitDoneBundle bundle = new WaitDoneBundle();
|
try {
|
getDispatchThread().runJobSync(new Runnable() {
|
@Override
|
public void run() {
|
getCameraHandler().sendEmptyMessage(CameraActions.UNLOCK);
|
getCameraHandler().post(bundle.mUnlockRunnable);
|
}
|
}, bundle.mWaitLock, CAMERA_OPERATION_TIMEOUT_MS, "camera unlock");
|
} catch (final RuntimeException ex) {
|
getAgent().getCameraExceptionHandler().onDispatchThreadException(ex);
|
}
|
}
|
|
/**
|
* Locks the camera device.
|
* @see android.hardware.Camera#lock()
|
*/
|
public void lock() {
|
try {
|
getDispatchThread().runJob(new Runnable() {
|
@Override
|
public void run() {
|
getCameraHandler().sendEmptyMessage(CameraActions.LOCK);
|
}});
|
} catch (final RuntimeException ex) {
|
getAgent().getCameraExceptionHandler().onDispatchThreadException(ex);
|
}
|
}
|
|
/**
|
* Sets the {@link android.graphics.SurfaceTexture} for preview.
|
*
|
* <p>Note that, once this operation has been performed, it is no longer
|
* possible to change the preview or photo sizes in the
|
* {@link CameraSettings} instance for this camera, and the mutators for
|
* these fields are allowed to ignore all further invocations until the
|
* preview is stopped with {@link #stopPreview}.</p>
|
*
|
* @param surfaceTexture The {@link SurfaceTexture} for preview.
|
*
|
* @see CameraSettings#setPhotoSize
|
* @see CameraSettings#setPreviewSize
|
*/
|
// XXX: Despite the above documentation about locking the sizes, the API
|
// 1 implementation doesn't currently enforce this at all, although the
|
// Camera class warns that preview sizes shouldn't be changed while a
|
// preview is running. Furthermore, the API 2 implementation doesn't yet
|
// unlock the sizes when stopPreview() is invoked (see related FIXME on
|
// the STOP_PREVIEW case in its handler; in the meantime, changing API 2
|
// sizes would require closing and reopening the camera.
|
public void setPreviewTexture(final SurfaceTexture surfaceTexture) {
|
try {
|
getDispatchThread().runJob(new Runnable() {
|
@Override
|
public void run() {
|
getCameraHandler()
|
.obtainMessage(CameraActions.SET_PREVIEW_TEXTURE_ASYNC, surfaceTexture)
|
.sendToTarget();
|
}});
|
} catch (final RuntimeException ex) {
|
getAgent().getCameraExceptionHandler().onDispatchThreadException(ex);
|
}
|
}
|
|
/**
|
* Blocks until a {@link android.graphics.SurfaceTexture} has been set
|
* for preview.
|
*
|
* <p>Note that, once this operation has been performed, it is no longer
|
* possible to change the preview or photo sizes in the
|
* {@link CameraSettings} instance for this camera, and the mutators for
|
* these fields are allowed to ignore all further invocations.</p>
|
*
|
* @param surfaceTexture The {@link SurfaceTexture} for preview.
|
*
|
* @see CameraSettings#setPhotoSize
|
* @see CameraSettings#setPreviewSize
|
*/
|
public void setPreviewTextureSync(final SurfaceTexture surfaceTexture) {
|
// Don't bother to wait since camera is in bad state.
|
if (getCameraState().isInvalid()) {
|
return;
|
}
|
final WaitDoneBundle bundle = new WaitDoneBundle();
|
try {
|
getDispatchThread().runJobSync(new Runnable() {
|
@Override
|
public void run() {
|
getCameraHandler()
|
.obtainMessage(CameraActions.SET_PREVIEW_TEXTURE_ASYNC, surfaceTexture)
|
.sendToTarget();
|
getCameraHandler().post(bundle.mUnlockRunnable);
|
}}, bundle.mWaitLock, CAMERA_OPERATION_TIMEOUT_MS, "set preview texture");
|
} catch (final RuntimeException ex) {
|
getAgent().getCameraExceptionHandler().onDispatchThreadException(ex);
|
}
|
}
|
|
/**
|
* Sets the {@link android.view.SurfaceHolder} for preview.
|
*
|
* @param surfaceHolder The {@link SurfaceHolder} for preview.
|
*/
|
public void setPreviewDisplay(final SurfaceHolder surfaceHolder) {
|
try {
|
getDispatchThread().runJob(new Runnable() {
|
@Override
|
public void run() {
|
getCameraHandler()
|
.obtainMessage(CameraActions.SET_PREVIEW_DISPLAY_ASYNC, surfaceHolder)
|
.sendToTarget();
|
}});
|
} catch (final RuntimeException ex) {
|
getAgent().getCameraExceptionHandler().onDispatchThreadException(ex);
|
}
|
}
|
|
/**
|
* Starts the camera preview.
|
*/
|
public void startPreview() {
|
try {
|
getDispatchThread().runJob(new Runnable() {
|
@Override
|
public void run() {
|
getCameraHandler()
|
.obtainMessage(CameraActions.START_PREVIEW_ASYNC, null).sendToTarget();
|
}});
|
} catch (final RuntimeException ex) {
|
getAgent().getCameraExceptionHandler().onDispatchThreadException(ex);
|
}
|
}
|
|
/**
|
* Starts the camera preview and executes a callback on a handler once
|
* the preview starts.
|
*/
|
public void startPreviewWithCallback(final Handler h, final CameraStartPreviewCallback cb) {
|
try {
|
getDispatchThread().runJob(new Runnable() {
|
@Override
|
public void run() {
|
getCameraHandler().obtainMessage(CameraActions.START_PREVIEW_ASYNC,
|
CameraStartPreviewCallbackForward.getNewInstance(h, cb))
|
.sendToTarget();
|
}});
|
} catch (final RuntimeException ex) {
|
getAgent().getCameraExceptionHandler().onDispatchThreadException(ex);
|
}
|
}
|
|
/**
|
* Stops the camera preview synchronously.
|
* {@code stopPreview()} must be synchronous to ensure that the caller can
|
* continues to release resources related to camera preview.
|
*/
|
public void stopPreview() {
|
// Don't bother to wait since camera is in bad state.
|
if (getCameraState().isInvalid()) {
|
return;
|
}
|
final WaitDoneBundle bundle = new WaitDoneBundle();
|
try {
|
getDispatchThread().runJobSync(new Runnable() {
|
@Override
|
public void run() {
|
getCameraHandler().obtainMessage(CameraActions.STOP_PREVIEW, bundle)
|
.sendToTarget();
|
}}, bundle.mWaitLock, CAMERA_OPERATION_TIMEOUT_MS, "stop preview");
|
} catch (final RuntimeException ex) {
|
getAgent().getCameraExceptionHandler().onDispatchThreadException(ex);
|
}
|
}
|
|
/**
|
* Sets the callback for preview data.
|
*
|
* @param handler The {@link android.os.Handler} in which the callback was handled.
|
* @param cb The callback to be invoked when the preview data is available.
|
* @see android.hardware.Camera#setPreviewCallback(android.hardware.Camera.PreviewCallback)
|
*/
|
public abstract void setPreviewDataCallback(Handler handler, CameraPreviewDataCallback cb);
|
|
/**
|
* Sets the one-time callback for preview data.
|
*
|
* @param handler The {@link android.os.Handler} in which the callback was handled.
|
* @param cb The callback to be invoked when the preview data for
|
* next frame is available.
|
* @see android.hardware.Camera#setPreviewCallback(android.hardware.Camera.PreviewCallback)
|
*/
|
public abstract void setOneShotPreviewCallback(Handler handler,
|
CameraPreviewDataCallback cb);
|
|
/**
|
* Sets the callback for preview data.
|
*
|
* @param handler The handler in which the callback will be invoked.
|
* @param cb The callback to be invoked when the preview data is available.
|
* @see android.hardware.Camera#setPreviewCallbackWithBuffer(android.hardware.Camera.PreviewCallback)
|
*/
|
public abstract void setPreviewDataCallbackWithBuffer(Handler handler,
|
CameraPreviewDataCallback cb);
|
|
/**
|
* Adds buffer for the preview callback.
|
*
|
* @param callbackBuffer The buffer allocated for the preview data.
|
*/
|
public void addCallbackBuffer(final byte[] callbackBuffer) {
|
try {
|
getDispatchThread().runJob(new Runnable() {
|
@Override
|
public void run() {
|
getCameraHandler()
|
.obtainMessage(CameraActions.ADD_CALLBACK_BUFFER, callbackBuffer)
|
.sendToTarget();
|
}
|
});
|
} catch (final RuntimeException ex) {
|
getAgent().getCameraExceptionHandler().onDispatchThreadException(ex);
|
}
|
}
|
|
/**
|
* Starts the auto-focus process. The result will be returned through the callback.
|
*
|
* @param handler The handler in which the callback will be invoked.
|
* @param cb The auto-focus callback.
|
*/
|
public abstract void autoFocus(Handler handler, CameraAFCallback cb);
|
|
/**
|
* Cancels the auto-focus process.
|
*
|
* <p>This action has the highest priority and will get processed before anything
|
* else that is pending. Moreover, any pending auto-focuses that haven't yet
|
* began will also be ignored.</p>
|
*/
|
public void cancelAutoFocus() {
|
// Do not use the dispatch thread since we want to avoid a wait-cycle
|
// between applySettingsHelper which waits until the state is not FOCUSING.
|
// cancelAutoFocus should get executed asap, set the state back to idle.
|
getCameraHandler().sendMessageAtFrontOfQueue(
|
getCameraHandler().obtainMessage(CameraActions.CANCEL_AUTO_FOCUS));
|
getCameraHandler().sendEmptyMessage(CameraActions.CANCEL_AUTO_FOCUS_FINISH);
|
}
|
|
/**
|
* Sets the auto-focus callback
|
*
|
* @param handler The handler in which the callback will be invoked.
|
* @param cb The callback to be invoked when the preview data is available.
|
*/
|
@TargetApi(Build.VERSION_CODES.JELLY_BEAN)
|
public abstract void setAutoFocusMoveCallback(Handler handler, CameraAFMoveCallback cb);
|
|
/**
|
* Instrument the camera to take a picture.
|
*
|
* @param handler The handler in which the callback will be invoked.
|
* @param shutter The callback for shutter action, may be null.
|
* @param raw The callback for uncompressed data, may be null.
|
* @param postview The callback for postview image data, may be null.
|
* @param jpeg The callback for jpeg image data, may be null.
|
* @see android.hardware.Camera#takePicture(
|
* android.hardware.Camera.ShutterCallback,
|
* android.hardware.Camera.PictureCallback,
|
* android.hardware.Camera.PictureCallback)
|
*/
|
public abstract void takePicture(
|
Handler handler,
|
CameraShutterCallback shutter,
|
CameraPictureCallback raw,
|
CameraPictureCallback postview,
|
CameraPictureCallback jpeg);
|
|
/**
|
* Sets the display orientation for camera to adjust the preview and JPEG orientation.
|
*
|
* @param degrees The counterclockwise rotation in degrees, relative to the device's natural
|
* orientation. Should be 0, 90, 180 or 270.
|
*/
|
public void setDisplayOrientation(final int degrees) {
|
setDisplayOrientation(degrees, true);
|
}
|
|
/**
|
* Sets the display orientation for camera to adjust the preview—and, optionally,
|
* JPEG—orientations.
|
* <p>If capture rotation is not requested, future captures will be returned in the sensor's
|
* physical rotation, which does not necessarily match the device's natural orientation.</p>
|
*
|
* @param degrees The counterclockwise rotation in degrees, relative to the device's natural
|
* orientation. Should be 0, 90, 180 or 270.
|
* @param capture Whether to adjust the JPEG capture orientation as well as the preview one.
|
*/
|
public void setDisplayOrientation(final int degrees, final boolean capture) {
|
try {
|
getDispatchThread().runJob(new Runnable() {
|
@Override
|
public void run() {
|
getCameraHandler()
|
.obtainMessage(CameraActions.SET_DISPLAY_ORIENTATION, degrees,
|
capture ? 1 : 0)
|
.sendToTarget();
|
}});
|
} catch (final RuntimeException ex) {
|
getAgent().getCameraExceptionHandler().onDispatchThreadException(ex);
|
}
|
}
|
|
public void setJpegOrientation(final int degrees) {
|
try {
|
getDispatchThread().runJob(new Runnable() {
|
@Override
|
public void run() {
|
getCameraHandler()
|
.obtainMessage(CameraActions.SET_JPEG_ORIENTATION, degrees, 0)
|
.sendToTarget();
|
}});
|
} catch (final RuntimeException ex) {
|
getAgent().getCameraExceptionHandler().onDispatchThreadException(ex);
|
}
|
}
|
|
/**
|
* Sets the listener for zoom change.
|
*
|
* @param listener The listener.
|
*/
|
public abstract void setZoomChangeListener(OnZoomChangeListener listener);
|
|
/**
|
* Sets the face detection listener.
|
*
|
* @param handler The handler in which the callback will be invoked.
|
* @param callback The callback for face detection results.
|
*/
|
public abstract void setFaceDetectionCallback(Handler handler,
|
CameraFaceDetectionCallback callback);
|
|
/**
|
* Starts the face detection.
|
*/
|
public void startFaceDetection() {
|
try {
|
getDispatchThread().runJob(new Runnable() {
|
@Override
|
public void run() {
|
getCameraHandler().sendEmptyMessage(CameraActions.START_FACE_DETECTION);
|
}});
|
} catch (final RuntimeException ex) {
|
getAgent().getCameraExceptionHandler().onDispatchThreadException(ex);
|
}
|
}
|
|
/**
|
* Stops the face detection.
|
*/
|
public void stopFaceDetection() {
|
try {
|
getDispatchThread().runJob(new Runnable() {
|
@Override
|
public void run() {
|
getCameraHandler().sendEmptyMessage(CameraActions.STOP_FACE_DETECTION);
|
}});
|
} catch (final RuntimeException ex) {
|
getAgent().getCameraExceptionHandler().onDispatchThreadException(ex);
|
}
|
}
|
|
/**
|
* Sets the camera parameters.
|
*
|
* @param params The camera parameters to use.
|
*/
|
@Deprecated
|
public abstract void setParameters(Camera.Parameters params);
|
|
/**
|
* Gets the current camera parameters synchronously. This method is
|
* synchronous since the caller has to wait for the camera to return
|
* the parameters. If the parameters are already cached, it returns
|
* immediately.
|
*/
|
@Deprecated
|
public abstract Camera.Parameters getParameters();
|
|
/**
|
* Gets the current camera settings synchronously.
|
* <p>This method is synchronous since the caller has to wait for the
|
* camera to return the parameters. If the parameters are already
|
* cached, it returns immediately.</p>
|
*/
|
public abstract CameraSettings getSettings();
|
|
/**
|
* Default implementation of {@link #applySettings(CameraSettings)}
|
* that is only missing the set of states it needs to wait for
|
* before applying the settings.
|
*
|
* @param settings The settings to use on the device.
|
* @param statesToAwait Bitwise OR of the required camera states.
|
* @return Whether the settings can be applied.
|
*/
|
protected boolean applySettingsHelper(CameraSettings settings,
|
final int statesToAwait) {
|
if (settings == null) {
|
Log.v(TAG, "null argument in applySettings()");
|
return false;
|
}
|
if (!getCapabilities().supports(settings)) {
|
Log.w(TAG, "Unsupported settings in applySettings()");
|
return false;
|
}
|
|
final CameraSettings copyOfSettings = settings.copy();
|
try {
|
getDispatchThread().runJob(new Runnable() {
|
@Override
|
public void run() {
|
CameraStateHolder cameraState = getCameraState();
|
// Don't bother to wait since camera is in bad state.
|
if (cameraState.isInvalid()) {
|
return;
|
}
|
cameraState.waitForStates(statesToAwait);
|
getCameraHandler().obtainMessage(CameraActions.APPLY_SETTINGS, copyOfSettings)
|
.sendToTarget();
|
}});
|
} catch (final RuntimeException ex) {
|
getAgent().getCameraExceptionHandler().onDispatchThreadException(ex);
|
}
|
return true;
|
}
|
|
/**
|
* Applies the settings to the camera device.
|
*
|
* <p>If the camera is either focusing or capturing; settings applications
|
* will be (asynchronously) deferred until those operations complete.</p>
|
*
|
* @param settings The settings to use on the device.
|
* @return Whether the settings can be applied.
|
*/
|
public abstract boolean applySettings(CameraSettings settings);
|
|
/**
|
* Forces {@code CameraProxy} to update the cached version of the camera
|
* settings regardless of the dirty bit.
|
*/
|
public void refreshSettings() {
|
try {
|
getDispatchThread().runJob(new Runnable() {
|
@Override
|
public void run() {
|
getCameraHandler().sendEmptyMessage(CameraActions.REFRESH_PARAMETERS);
|
}});
|
} catch (final RuntimeException ex) {
|
getAgent().getCameraExceptionHandler().onDispatchThreadException(ex);
|
}
|
}
|
|
/**
|
* Enables/Disables the camera shutter sound.
|
*
|
* @param enable {@code true} to enable the shutter sound,
|
* {@code false} to disable it.
|
*/
|
public void enableShutterSound(final boolean enable) {
|
try {
|
getDispatchThread().runJob(new Runnable() {
|
@Override
|
public void run() {
|
getCameraHandler()
|
.obtainMessage(CameraActions.ENABLE_SHUTTER_SOUND, (enable ? 1 : 0), 0)
|
.sendToTarget();
|
}});
|
} catch (final RuntimeException ex) {
|
getAgent().getCameraExceptionHandler().onDispatchThreadException(ex);
|
}
|
}
|
|
/**
|
* Dumps the current settings of the camera device.
|
*
|
* <p>The content varies based on the underlying camera API settings
|
* implementation.</p>
|
*
|
* @return The content of the device settings represented by a string.
|
*/
|
public abstract String dumpDeviceSettings();
|
|
/**
|
* @return The handler to which camera tasks should be posted.
|
*/
|
public abstract Handler getCameraHandler();
|
|
/**
|
* @return The thread used on which client callbacks are served.
|
*/
|
public abstract DispatchThread getDispatchThread();
|
|
/**
|
* @return The state machine tracking the camera API's current mode.
|
*/
|
public abstract CameraStateHolder getCameraState();
|
}
|
|
public static class WaitDoneBundle {
|
public final Runnable mUnlockRunnable;
|
public final Object mWaitLock;
|
|
WaitDoneBundle() {
|
mWaitLock = new Object();
|
mUnlockRunnable = new Runnable() {
|
@Override
|
public void run() {
|
synchronized (mWaitLock) {
|
mWaitLock.notifyAll();
|
}
|
}};
|
}
|
|
/**
|
* Notify all synchronous waiters waiting on message completion with {@link #mWaitLock}.
|
*
|
* <p>This assumes that the message was sent with {@code this} as the {@code Message#obj}.
|
* Otherwise the message is ignored.</p>
|
*/
|
/*package*/ static void unblockSyncWaiters(Message msg) {
|
if (msg == null) return;
|
|
if (msg.obj instanceof WaitDoneBundle) {
|
WaitDoneBundle bundle = (WaitDoneBundle)msg.obj;
|
bundle.mUnlockRunnable.run();
|
}
|
}
|
}
|
}
|
