/*
|
* Copyright (C) 2015 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.camera.device;
|
|
import android.annotation.TargetApi;
|
import android.hardware.Camera;
|
import android.os.Build.VERSION_CODES;
|
|
import com.android.camera.async.Lifetime;
|
import com.android.camera.debug.Log.Tag;
|
import com.android.camera.debug.Logger;
|
import com.android.camera.debug.Loggers;
|
import com.android.camera.device.CameraDeviceKey.ApiType;
|
import com.android.ex.camera2.portability.CameraAgent.CameraProxy;
|
import com.google.common.annotations.VisibleForTesting;
|
import com.google.common.util.concurrent.Futures;
|
import com.google.common.util.concurrent.ListenableFuture;
|
import com.google.common.util.concurrent.SettableFuture;
|
|
import java.util.concurrent.Future;
|
|
import javax.annotation.Nullable;
|
import javax.annotation.ParametersAreNonnullByDefault;
|
import javax.annotation.concurrent.GuardedBy;
|
|
/**
|
* This class's only job is to open and close camera devices safely, such that
|
* only one device of any type is open at any point in time. This provider
|
* operates on the principle that the most recent request wins.
|
*
|
* The logic for opening a camera device proceeds as follows:
|
*
|
* 1. If there is no open camera, create a new camera request, and open
|
* the device.
|
* 2. If there is an existing request, and the device id's match,
|
* then reuse the old request and cancel any outstanding "please
|
* open this device next" requests. However, if the previous future
|
* for that current device was not yet completed, cancel it, and
|
* create a new future that will then get returned.
|
* 3. If there is an existing request, but the device ids don't match,
|
* cancel any outstanding "please open this device next" requests.
|
* Then create a new request and return the future and begin the shutdown
|
* process on the current device holder. However, do NOT begin opening
|
* this device until the current device is closed.
|
*/
|
@ParametersAreNonnullByDefault
|
public class MultiCameraDeviceLifecycle {
|
private static final Tag TAG = new Tag("MltiDeviceLife");
|
|
private static class Singleton {
|
private static final MultiCameraDeviceLifecycle INSTANCE = new MultiCameraDeviceLifecycle(
|
CameraModuleHelper.provideLegacyCameraActionProvider(),
|
CameraModuleHelper.providePortabilityActionProvider(),
|
CameraModuleHelper.provideCamera2ActionProvider(),
|
ActiveCameraDeviceTracker.instance(),
|
Loggers.tagFactory());
|
}
|
|
public static MultiCameraDeviceLifecycle instance() {
|
return Singleton.INSTANCE;
|
}
|
|
private final LegacyCameraActionProvider mLegacyCameraActionProvider;
|
private final PortabilityCameraActionProvider mPortabilityCameraActionProvider;
|
private final Camera2ActionProvider mCamera2ActionProvider;
|
private final ActiveCameraDeviceTracker mActiveCameraDeviceTracker;
|
|
private final Object mDeviceLock = new Object();
|
private final Logger.Factory mLogFactory;
|
private final Logger mLogger;
|
|
@Nullable
|
@GuardedBy("mDeviceLock")
|
private SingleDeviceLifecycle mCurrentDevice;
|
|
@Nullable
|
@GuardedBy("mDeviceLock")
|
private SingleDeviceLifecycle mTargetDevice;
|
|
@Nullable
|
@GuardedBy("mDeviceLock")
|
private SettableFuture<Void> mShutdownFuture;
|
|
@VisibleForTesting
|
MultiCameraDeviceLifecycle(
|
LegacyCameraActionProvider legacyCameraActionProvider,
|
PortabilityCameraActionProvider portabilityCameraActionProvider,
|
Camera2ActionProvider camera2ActionProvider,
|
ActiveCameraDeviceTracker activeCameraDeviceTracker,
|
Logger.Factory logFactory) {
|
mLegacyCameraActionProvider = legacyCameraActionProvider;
|
mPortabilityCameraActionProvider = portabilityCameraActionProvider;
|
mCamera2ActionProvider = camera2ActionProvider;
|
mActiveCameraDeviceTracker = activeCameraDeviceTracker;
|
mLogFactory = logFactory;
|
mLogger = logFactory.create(TAG);
|
|
mLogger.d("Creating the CameraDeviceProvider.");
|
}
|
|
/**
|
* !!! Warning !!!
|
* Code using this class should close the camera device by closing the
|
* provided lifetime instead of calling close directly on the camera
|
* object. Failing to do so may leave the multi camera lifecycle in an
|
* inconsistent state.
|
*
|
* Returns a future to an API2 Camera device. The future will only
|
* complete if the camera is fully opened successfully. If the device cannot
|
* be opened, the future will be canceled or provided with an exception
|
* depending on the nature of the internal failure. This call will not block
|
* the calling thread.
|
*
|
* @param requestLifetime the lifetime for the duration of the request.
|
* Closing the lifetime will cancel any outstanding request and will
|
* cause the camera to close. Closing the lifetime instead of the device
|
* will ensure everything is shut down properly.
|
* @param cameraId the specific camera device to open.
|
*/
|
@TargetApi(VERSION_CODES.LOLLIPOP)
|
public ListenableFuture<android.hardware.camera2.CameraDevice> openCamera2Device(
|
Lifetime requestLifetime, CameraId cameraId) {
|
CameraDeviceKey key = new CameraDeviceKey(ApiType.CAMERA_API2, cameraId);
|
return openDevice(requestLifetime, key, mCamera2ActionProvider);
|
}
|
|
/**
|
* !!! Warning !!!
|
* Code using this class should close the camera device by closing the
|
* provided lifetime instead of calling close directly on the camera
|
* object. Failing to do so may leave the multi camera lifecycle in an
|
* inconsistent state.
|
*
|
* This returns a future to a CameraProxy device in auto mode and does not
|
* make any guarantees about the backing API version. The future will only
|
* return if the device is fully opened successfully. If the device cannot
|
* be opened, the future will be canceled or provided with an exception
|
* depending on the nature of the internal failure. This call will not block
|
* the calling thread.
|
*
|
* @param requestLifetime the lifetime for the duration of the request.
|
* Closing the lifetime will cancel any outstanding request and will
|
* cause the camera to close. Closing the lifetime instead of the device
|
* will ensure everything is shut down properly.
|
* @param cameraId the specific camera device to open.
|
*/
|
public ListenableFuture<CameraProxy> openPortabilityDevice(
|
Lifetime requestLifetime, CameraId cameraId) {
|
CameraDeviceKey key = new CameraDeviceKey(ApiType.CAMERA_API_PORTABILITY_AUTO,
|
cameraId);
|
return openDevice(requestLifetime, key, mPortabilityCameraActionProvider);
|
}
|
|
/**
|
* !!! Warning !!!
|
* Code using this class should close the camera device by closing the
|
* provided lifetime instead of calling close directly on the camera
|
* object. Failing to do so may leave the multi camera lifecycle in an
|
* inconsistent state.
|
*
|
* This returns a future to a CameraProxy device opened explicitly with an
|
* API2 backing device. The future will only return if the device is fully
|
* opened successfully. If the device cannot be opened, the future will be
|
* canceled or provided with an exception depending on the nature of the
|
* internal failure. This call will not block the calling thread.
|
*
|
* @param requestLifetime the lifetime for the duration of the request.
|
* Closing the lifetime will cancel any outstanding request and will
|
* cause the camera to close. Closing the lifetime instead of the device
|
* will ensure everything is shut down properly.
|
* @param cameraId the specific camera device to open.
|
*/
|
@TargetApi(VERSION_CODES.LOLLIPOP)
|
public ListenableFuture<CameraProxy> openCamera2PortabilityDevice(
|
Lifetime requestLifetime, CameraId cameraId) {
|
CameraDeviceKey key = new CameraDeviceKey(ApiType.CAMERA_API_PORTABILITY_API2,
|
cameraId);
|
return openDevice(requestLifetime, key, mPortabilityCameraActionProvider);
|
}
|
|
/**
|
* !!! Warning !!!
|
* Code using this class should close the camera device by closing the
|
* provided lifetime instead of calling close directly on the camera
|
* object. Failing to do so may leave the multi camera lifecycle in an
|
* inconsistent state.
|
*
|
* This returns a future to a CameraProxy device opened explicitly with an
|
* legacy backing API. The future will only return if the device is fully
|
* opened successfully. If the device cannot be opened, the future will be
|
* canceled or provided with an exception depending on the nature of the
|
* internal failure. This call will not block the calling thread.
|
*
|
* @param requestLifetime the lifetime for the duration of the request.
|
* Closing the lifetime will cancel any outstanding request and will
|
* cause the camera to close. Closing the lifetime instead of the device
|
* will ensure everything is shut down properly.
|
* @param cameraId the specific camera device to open.
|
*/
|
public ListenableFuture<CameraProxy> openLegacyPortabilityDevice(
|
Lifetime requestLifetime, CameraId cameraId) {
|
CameraDeviceKey key = new CameraDeviceKey(ApiType.CAMERA_API_PORTABILITY_API1, cameraId);
|
return openDevice(requestLifetime, key, mPortabilityCameraActionProvider);
|
}
|
/**
|
* !!! Warning !!!
|
* Code using this class should close the camera device by closing the
|
* provided lifetime instead of calling close directly on the camera
|
* object. Failing to do so may leave the multi camera lifecycle in an
|
* inconsistent state.
|
*
|
* This returns a future to a legacy Camera device The future will only return
|
* if the device is fully opened successfully. If the device cannot be opened,
|
* the future will be canceled or provided with an exception depending on the
|
* nature of the internal failure. This call will not block the calling thread.
|
*
|
* @param requestLifetime the lifetime for the duration of the request.
|
* Closing the lifetime will cancel any outstanding request and will
|
* cause the camera to close. Closing the lifetime instead of the device
|
* will ensure everything is shut down properly.
|
* @param cameraId the specific camera device to open.
|
*/
|
@Deprecated
|
public ListenableFuture<Camera> openLegacyCameraDevice(Lifetime requestLifetime,
|
CameraId cameraId) {
|
CameraDeviceKey key = new CameraDeviceKey(ApiType.CAMERA_API1, cameraId);
|
return openDevice(requestLifetime, key, mLegacyCameraActionProvider);
|
}
|
|
/**
|
* This will close any open or pending requests and will execute the future
|
* when all requests have been cleared out. This method executes immediately.
|
*/
|
public ListenableFuture<Void> shutdown() {
|
synchronized (mDeviceLock) {
|
mLogger.d("shutdownAsync()");
|
if (mCurrentDevice != null) {
|
// Ensure there are no queued requests. Cancel any existing requests.
|
clearTargetDevice();
|
|
// Create a future that we can complete when the device completes
|
// its shutdown cycle.
|
mShutdownFuture = SettableFuture.create();
|
|
// Execute close on the current device.
|
mCurrentDevice.close();
|
return mShutdownFuture;
|
} else if (mShutdownFuture != null) {
|
// This could occur if a previous shutdown call occurred, and
|
// the receiver called cancel on the future before it completed.
|
if (mShutdownFuture.isDone()) {
|
mShutdownFuture = null;
|
} else {
|
return mShutdownFuture;
|
}
|
}
|
// If there is no currently open device, this instance is already in a
|
// clean shutdown state.
|
return Futures.immediateFuture(null);
|
}
|
}
|
|
/**
|
* Given a request lifetime, a key and a provider, open a new device.
|
*/
|
private <TDevice> ListenableFuture<TDevice> openDevice(Lifetime requestLifetime,
|
CameraDeviceKey key, CameraDeviceActionProvider<TDevice> provider) {
|
|
final SingleDeviceLifecycle<TDevice, CameraDeviceKey> deviceLifecycle;
|
final ListenableFuture<TDevice> result;
|
|
synchronized (mDeviceLock) {
|
mLogger.d("[openDevice()] open(cameraId: '" + key + "')");
|
cancelShutdown();
|
|
if (mCurrentDevice == null) {
|
mLogger.d("[openDevice()] No existing request. Creating a new device.");
|
deviceLifecycle = createLifecycle(key, provider);
|
mCurrentDevice = deviceLifecycle;
|
result = deviceLifecycle.createRequest(requestLifetime);
|
deviceLifecycle.open();
|
mActiveCameraDeviceTracker.onCameraOpening(key.getCameraId());
|
} else if (mCurrentDevice.getId().equals(key)) {
|
mLogger.d("[openDevice()] Existing request with the same id.");
|
deviceLifecycle =
|
(SingleDeviceLifecycle<TDevice, CameraDeviceKey>) mCurrentDevice;
|
clearTargetDevice();
|
result = deviceLifecycle.createRequest(requestLifetime);
|
deviceLifecycle.open();
|
mActiveCameraDeviceTracker.onCameraOpening(key.getCameraId());
|
} else {
|
mLogger.d("[openDevice()] Existing request with a different id.");
|
mCurrentDevice.close();
|
deviceLifecycle = createLifecycle(key, provider);
|
clearTargetDevice();
|
mTargetDevice = deviceLifecycle;
|
result = deviceLifecycle.createRequest(requestLifetime);
|
}
|
|
mLogger.d("[openDevice()] Returning future.");
|
return result;
|
}
|
}
|
|
private <TDevice> SingleDeviceLifecycle<TDevice, CameraDeviceKey>
|
createLifecycle(CameraDeviceKey key,
|
CameraDeviceActionProvider<TDevice> provider) {
|
SingleDeviceShutdownListener<CameraDeviceKey> listener =
|
new SingleDeviceShutdownListener<CameraDeviceKey>() {
|
@Override
|
public void onShutdown(CameraDeviceKey key) {
|
onCameraDeviceShutdown(key);
|
}
|
};
|
|
SingleDeviceStateMachine<TDevice, CameraDeviceKey> deviceState =
|
new SingleDeviceStateMachine<>(provider.get(key), key, listener, mLogFactory);
|
|
return new CameraDeviceLifecycle<>(key, deviceState);
|
}
|
|
private void clearTargetDevice() {
|
if (mTargetDevice != null) {
|
mLogger.d("Target request exists. cancel() and clear.");
|
mTargetDevice.close();
|
mTargetDevice = null;
|
}
|
}
|
|
private void cancelShutdown() {
|
if (mShutdownFuture != null) {
|
mLogger.i("Canceling shutdown.");
|
Future<Void> shutdownFuture = mShutdownFuture;
|
mShutdownFuture = null;
|
shutdownFuture.cancel(true /* mayInterruptIfRunning */);
|
}
|
}
|
|
private void completeShutdown() {
|
if (mShutdownFuture != null) {
|
mLogger.i("Completing shutdown.");
|
SettableFuture<Void> shutdownFuture = mShutdownFuture;
|
mShutdownFuture = null;
|
shutdownFuture.set(null);
|
}
|
}
|
|
private void onCameraDeviceShutdown(CameraDeviceKey key) {
|
synchronized (mDeviceLock) {
|
mLogger.d("onCameraClosed(id: " + key + ").");
|
if (mShutdownFuture != null &&
|
(mCurrentDevice == null || (mCurrentDevice.getId().equals(key)))) {
|
// if the shutdown future is set but there is no current device,
|
// we should call shutdown, just in case so that it clears out the
|
// shutdown state. If
|
mCurrentDevice = null;
|
completeShutdown();
|
} if (mCurrentDevice != null && mCurrentDevice.getId().equals(key)) {
|
|
mLogger.d("Current device was closed.");
|
|
if (mTargetDevice != null) {
|
mLogger.d("Target request exists, calling open().");
|
mCurrentDevice = mTargetDevice;
|
mTargetDevice = null;
|
mCurrentDevice.open();
|
mActiveCameraDeviceTracker.onCameraOpening(((CameraDeviceKey)
|
mCurrentDevice.getId()).getCameraId());
|
} else {
|
mLogger.d("No target request exists. Clearing current device.");
|
mCurrentDevice = null;
|
mActiveCameraDeviceTracker.onCameraClosed(key.getCameraId());
|
}
|
}
|
}
|
}
|
}
|
