/*
* 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();
}
}
}
}
|
