| /* | |
| * 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. | |
| */ | |
| #define LOG_TAG "CameraFlashlight" | |
| #define ATRACE_TAG ATRACE_TAG_CAMERA | |
| // #define LOG_NDEBUG 0 | |
| #include <utils/Log.h> | |
| #include <utils/Trace.h> | |
| #include <cutils/properties.h> | |
| #include "camera/CameraMetadata.h" | |
| #include "CameraFlashlight.h" | |
| #include "gui/IGraphicBufferConsumer.h" | |
| #include "gui/BufferQueue.h" | |
| #include "camera/camera2/CaptureRequest.h" | |
| #include "device3/Camera3Device.h" | |
| namespace android { | |
| ///////////////////////////////////////////////////////////////////// | |
| // CameraFlashlight implementation begins | |
| // used by camera service to control flashflight. | |
| ///////////////////////////////////////////////////////////////////// | |
| CameraFlashlight::CameraFlashlight(CameraModule& cameraModule, | |
| const camera_module_callbacks_t& callbacks) : | |
| mCameraModule(&cameraModule), | |
| mCallbacks(&callbacks), | |
| mFlashlightMapInitialized(false) { | |
| } | |
| CameraFlashlight::~CameraFlashlight() { | |
| } | |
| status_t CameraFlashlight::createFlashlightControl(const String8& cameraId) { | |
| ALOGV("%s: creating a flash light control for camera %s", __FUNCTION__, | |
| cameraId.string()); | |
| if (mFlashControl != NULL) { | |
| return INVALID_OPERATION; | |
| } | |
| status_t res = OK; | |
| if (mCameraModule->getModuleApiVersion() >= CAMERA_MODULE_API_VERSION_2_4) { | |
| mFlashControl = new ModuleFlashControl(*mCameraModule, *mCallbacks); | |
| if (mFlashControl == NULL) { | |
| ALOGV("%s: cannot create flash control for module api v2.4+", | |
| __FUNCTION__); | |
| return NO_MEMORY; | |
| } | |
| } else { | |
| uint32_t deviceVersion = CAMERA_DEVICE_API_VERSION_1_0; | |
| if (mCameraModule->getModuleApiVersion() >= | |
| CAMERA_MODULE_API_VERSION_2_0) { | |
| camera_info info; | |
| res = mCameraModule->getCameraInfo( | |
| atoi(String8(cameraId).string()), &info); | |
| if (res) { | |
| ALOGE("%s: failed to get camera info for camera %s", | |
| __FUNCTION__, cameraId.string()); | |
| return res; | |
| } | |
| deviceVersion = info.device_version; | |
| } | |
| if (deviceVersion >= CAMERA_DEVICE_API_VERSION_3_0) { | |
| CameraDeviceClientFlashControl *flashControl = | |
| new CameraDeviceClientFlashControl(*mCameraModule, | |
| *mCallbacks); | |
| if (!flashControl) { | |
| return NO_MEMORY; | |
| } | |
| mFlashControl = flashControl; | |
| } else { | |
| mFlashControl = | |
| new CameraHardwareInterfaceFlashControl(*mCameraModule, | |
| *mCallbacks); | |
| } | |
| } | |
| return OK; | |
| } | |
| status_t CameraFlashlight::setTorchMode(const String8& cameraId, bool enabled) { | |
| if (!mFlashlightMapInitialized) { | |
| ALOGE("%s: findFlashUnits() must be called before this method.", | |
| __FUNCTION__); | |
| return NO_INIT; | |
| } | |
| ALOGV("%s: set torch mode of camera %s to %d", __FUNCTION__, | |
| cameraId.string(), enabled); | |
| status_t res = OK; | |
| Mutex::Autolock l(mLock); | |
| if (mOpenedCameraIds.indexOf(cameraId) != NAME_NOT_FOUND) { | |
| // This case is needed to avoid state corruption during the following call sequence: | |
| // CameraService::setTorchMode for camera ID 0 begins, does torch status checks | |
| // CameraService::connect for camera ID 0 begins, calls prepareDeviceOpen, ends | |
| // CameraService::setTorchMode for camera ID 0 continues, calls | |
| // CameraFlashlight::setTorchMode | |
| // TODO: Move torch status checks and state updates behind this CameraFlashlight lock | |
| // to avoid other similar race conditions. | |
| ALOGE("%s: Camera device %s is in use, cannot set torch mode.", | |
| __FUNCTION__, cameraId.string()); | |
| return -EBUSY; | |
| } | |
| if (mFlashControl == NULL) { | |
| if (enabled == false) { | |
| return OK; | |
| } | |
| res = createFlashlightControl(cameraId); | |
| if (res) { | |
| return res; | |
| } | |
| res = mFlashControl->setTorchMode(cameraId, enabled); | |
| return res; | |
| } | |
| // if flash control already exists, turning on torch mode may fail if it's | |
| // tied to another camera device for module v2.3 and below. | |
| res = mFlashControl->setTorchMode(cameraId, enabled); | |
| if (res == BAD_INDEX) { | |
| // flash control is tied to another camera device, need to close it and | |
| // try again. | |
| mFlashControl.clear(); | |
| res = createFlashlightControl(cameraId); | |
| if (res) { | |
| return res; | |
| } | |
| res = mFlashControl->setTorchMode(cameraId, enabled); | |
| } | |
| return res; | |
| } | |
| status_t CameraFlashlight::findFlashUnits() { | |
| Mutex::Autolock l(mLock); | |
| status_t res; | |
| int32_t numCameras = mCameraModule->getNumberOfCameras(); | |
| mHasFlashlightMap.clear(); | |
| mFlashlightMapInitialized = false; | |
| for (int32_t i = 0; i < numCameras; i++) { | |
| bool hasFlash = false; | |
| String8 id = String8::format("%d", i); | |
| res = createFlashlightControl(id); | |
| if (res) { | |
| ALOGE("%s: failed to create flash control for %s", __FUNCTION__, | |
| id.string()); | |
| } else { | |
| res = mFlashControl->hasFlashUnit(id, &hasFlash); | |
| if (res == -EUSERS || res == -EBUSY) { | |
| ALOGE("%s: failed to check if camera %s has a flash unit. Some " | |
| "camera devices may be opened", __FUNCTION__, | |
| id.string()); | |
| return res; | |
| } else if (res) { | |
| ALOGE("%s: failed to check if camera %s has a flash unit. %s" | |
| " (%d)", __FUNCTION__, id.string(), strerror(-res), | |
| res); | |
| } | |
| mFlashControl.clear(); | |
| } | |
| mHasFlashlightMap.add(id, hasFlash); | |
| } | |
| mFlashlightMapInitialized = true; | |
| return OK; | |
| } | |
| bool CameraFlashlight::hasFlashUnit(const String8& cameraId) { | |
| Mutex::Autolock l(mLock); | |
| return hasFlashUnitLocked(cameraId); | |
| } | |
| bool CameraFlashlight::hasFlashUnitLocked(const String8& cameraId) { | |
| if (!mFlashlightMapInitialized) { | |
| ALOGE("%s: findFlashUnits() must be called before this method.", | |
| __FUNCTION__); | |
| return false; | |
| } | |
| ssize_t index = mHasFlashlightMap.indexOfKey(cameraId); | |
| if (index == NAME_NOT_FOUND) { | |
| ALOGE("%s: camera %s not present when findFlashUnits() was called", | |
| __FUNCTION__, cameraId.string()); | |
| return false; | |
| } | |
| return mHasFlashlightMap.valueAt(index); | |
| } | |
| status_t CameraFlashlight::prepareDeviceOpen(const String8& cameraId) { | |
| ALOGV("%s: prepare for device open", __FUNCTION__); | |
| Mutex::Autolock l(mLock); | |
| if (!mFlashlightMapInitialized) { | |
| ALOGE("%s: findFlashUnits() must be called before this method.", | |
| __FUNCTION__); | |
| return NO_INIT; | |
| } | |
| if (mCameraModule->getModuleApiVersion() < CAMERA_MODULE_API_VERSION_2_4) { | |
| // framework is going to open a camera device, all flash light control | |
| // should be closed for backward compatible support. | |
| mFlashControl.clear(); | |
| if (mOpenedCameraIds.size() == 0) { | |
| // notify torch unavailable for all cameras with a flash | |
| int numCameras = mCameraModule->getNumberOfCameras(); | |
| for (int i = 0; i < numCameras; i++) { | |
| if (hasFlashUnitLocked(String8::format("%d", i))) { | |
| mCallbacks->torch_mode_status_change(mCallbacks, | |
| String8::format("%d", i).string(), | |
| TORCH_MODE_STATUS_NOT_AVAILABLE); | |
| } | |
| } | |
| } | |
| // close flash control that may be opened by calling hasFlashUnitLocked. | |
| mFlashControl.clear(); | |
| } | |
| if (mOpenedCameraIds.indexOf(cameraId) == NAME_NOT_FOUND) { | |
| mOpenedCameraIds.add(cameraId); | |
| } | |
| return OK; | |
| } | |
| status_t CameraFlashlight::deviceClosed(const String8& cameraId) { | |
| ALOGV("%s: device %s is closed", __FUNCTION__, cameraId.string()); | |
| Mutex::Autolock l(mLock); | |
| if (!mFlashlightMapInitialized) { | |
| ALOGE("%s: findFlashUnits() must be called before this method.", | |
| __FUNCTION__); | |
| return NO_INIT; | |
| } | |
| ssize_t index = mOpenedCameraIds.indexOf(cameraId); | |
| if (index == NAME_NOT_FOUND) { | |
| ALOGE("%s: couldn't find camera %s in the opened list", __FUNCTION__, | |
| cameraId.string()); | |
| } else { | |
| mOpenedCameraIds.removeAt(index); | |
| } | |
| // Cannot do anything until all cameras are closed. | |
| if (mOpenedCameraIds.size() != 0) | |
| return OK; | |
| if (mCameraModule->getModuleApiVersion() < CAMERA_MODULE_API_VERSION_2_4) { | |
| // notify torch available for all cameras with a flash | |
| int numCameras = mCameraModule->getNumberOfCameras(); | |
| for (int i = 0; i < numCameras; i++) { | |
| if (hasFlashUnitLocked(String8::format("%d", i))) { | |
| mCallbacks->torch_mode_status_change(mCallbacks, | |
| String8::format("%d", i).string(), | |
| TORCH_MODE_STATUS_AVAILABLE_OFF); | |
| } | |
| } | |
| } | |
| return OK; | |
| } | |
| // CameraFlashlight implementation ends | |
| FlashControlBase::~FlashControlBase() { | |
| } | |
| ///////////////////////////////////////////////////////////////////// | |
| // ModuleFlashControl implementation begins | |
| // Flash control for camera module v2.4 and above. | |
| ///////////////////////////////////////////////////////////////////// | |
| ModuleFlashControl::ModuleFlashControl(CameraModule& cameraModule, | |
| const camera_module_callbacks_t& callbacks) : | |
| mCameraModule(&cameraModule) { | |
| (void) callbacks; | |
| } | |
| ModuleFlashControl::~ModuleFlashControl() { | |
| } | |
| status_t ModuleFlashControl::hasFlashUnit(const String8& cameraId, bool *hasFlash) { | |
| if (!hasFlash) { | |
| return BAD_VALUE; | |
| } | |
| *hasFlash = false; | |
| Mutex::Autolock l(mLock); | |
| camera_info info; | |
| status_t res = mCameraModule->getCameraInfo(atoi(cameraId.string()), | |
| &info); | |
| if (res != 0) { | |
| return res; | |
| } | |
| CameraMetadata metadata; | |
| metadata = info.static_camera_characteristics; | |
| camera_metadata_entry flashAvailable = | |
| metadata.find(ANDROID_FLASH_INFO_AVAILABLE); | |
| if (flashAvailable.count == 1 && flashAvailable.data.u8[0] == 1) { | |
| *hasFlash = true; | |
| } | |
| return OK; | |
| } | |
| status_t ModuleFlashControl::setTorchMode(const String8& cameraId, bool enabled) { | |
| ALOGV("%s: set camera %s torch mode to %d", __FUNCTION__, | |
| cameraId.string(), enabled); | |
| Mutex::Autolock l(mLock); | |
| return mCameraModule->setTorchMode(cameraId.string(), enabled); | |
| } | |
| // ModuleFlashControl implementation ends | |
| ///////////////////////////////////////////////////////////////////// | |
| // CameraDeviceClientFlashControl implementation begins | |
| // Flash control for camera module <= v2.3 and camera HAL v2-v3 | |
| ///////////////////////////////////////////////////////////////////// | |
| CameraDeviceClientFlashControl::CameraDeviceClientFlashControl( | |
| CameraModule& cameraModule, | |
| const camera_module_callbacks_t& callbacks) : | |
| mCameraModule(&cameraModule), | |
| mCallbacks(&callbacks), | |
| mTorchEnabled(false), | |
| mMetadata(NULL), | |
| mStreaming(false) { | |
| } | |
| CameraDeviceClientFlashControl::~CameraDeviceClientFlashControl() { | |
| disconnectCameraDevice(); | |
| if (mMetadata) { | |
| delete mMetadata; | |
| } | |
| mSurface.clear(); | |
| mSurfaceTexture.clear(); | |
| mProducer.clear(); | |
| mConsumer.clear(); | |
| if (mTorchEnabled) { | |
| if (mCallbacks) { | |
| ALOGV("%s: notify the framework that torch was turned off", | |
| __FUNCTION__); | |
| mCallbacks->torch_mode_status_change(mCallbacks, | |
| mCameraId.string(), TORCH_MODE_STATUS_AVAILABLE_OFF); | |
| } | |
| } | |
| } | |
| status_t CameraDeviceClientFlashControl::initializeSurface( | |
| sp<CameraDeviceBase> &device, int32_t width, int32_t height) { | |
| status_t res; | |
| BufferQueue::createBufferQueue(&mProducer, &mConsumer); | |
| mSurfaceTexture = new GLConsumer(mConsumer, 0, GLConsumer::TEXTURE_EXTERNAL, | |
| true, true); | |
| if (mSurfaceTexture == NULL) { | |
| return NO_MEMORY; | |
| } | |
| int32_t format = HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED; | |
| res = mSurfaceTexture->setDefaultBufferSize(width, height); | |
| if (res) { | |
| return res; | |
| } | |
| res = mSurfaceTexture->setDefaultBufferFormat(format); | |
| if (res) { | |
| return res; | |
| } | |
| mSurface = new Surface(mProducer, /*useAsync*/ true); | |
| if (mSurface == NULL) { | |
| return NO_MEMORY; | |
| } | |
| res = device->createStream(mSurface, width, height, format, | |
| HAL_DATASPACE_UNKNOWN, CAMERA3_STREAM_ROTATION_0, &mStreamId); | |
| if (res) { | |
| return res; | |
| } | |
| res = device->configureStreams(); | |
| if (res) { | |
| return res; | |
| } | |
| return res; | |
| } | |
| status_t CameraDeviceClientFlashControl::getSmallestSurfaceSize( | |
| const camera_info& info, int32_t *width, int32_t *height) { | |
| if (!width || !height) { | |
| return BAD_VALUE; | |
| } | |
| int32_t w = INT32_MAX; | |
| int32_t h = 1; | |
| CameraMetadata metadata; | |
| metadata = info.static_camera_characteristics; | |
| camera_metadata_entry streamConfigs = | |
| metadata.find(ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS); | |
| for (size_t i = 0; i < streamConfigs.count; i += 4) { | |
| int32_t fmt = streamConfigs.data.i32[i]; | |
| if (fmt == ANDROID_SCALER_AVAILABLE_FORMATS_IMPLEMENTATION_DEFINED) { | |
| int32_t ww = streamConfigs.data.i32[i + 1]; | |
| int32_t hh = streamConfigs.data.i32[i + 2]; | |
| if (w * h > ww * hh) { | |
| w = ww; | |
| h = hh; | |
| } | |
| } | |
| } | |
| // if stream configuration is not found, try available processed sizes. | |
| if (streamConfigs.count == 0) { | |
| camera_metadata_entry availableProcessedSizes = | |
| metadata.find(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES); | |
| for (size_t i = 0; i < availableProcessedSizes.count; i += 2) { | |
| int32_t ww = availableProcessedSizes.data.i32[i]; | |
| int32_t hh = availableProcessedSizes.data.i32[i + 1]; | |
| if (w * h > ww * hh) { | |
| w = ww; | |
| h = hh; | |
| } | |
| } | |
| } | |
| if (w == INT32_MAX) { | |
| return NAME_NOT_FOUND; | |
| } | |
| *width = w; | |
| *height = h; | |
| return OK; | |
| } | |
| status_t CameraDeviceClientFlashControl::connectCameraDevice( | |
| const String8& cameraId) { | |
| camera_info info; | |
| status_t res = mCameraModule->getCameraInfo(atoi(cameraId.string()), &info); | |
| if (res != 0) { | |
| ALOGE("%s: failed to get camera info for camera %s", __FUNCTION__, | |
| cameraId.string()); | |
| return res; | |
| } | |
| sp<CameraDeviceBase> device = | |
| new Camera3Device(atoi(cameraId.string())); | |
| if (device == NULL) { | |
| return NO_MEMORY; | |
| } | |
| res = device->initialize(mCameraModule); | |
| if (res) { | |
| return res; | |
| } | |
| int32_t width, height; | |
| res = getSmallestSurfaceSize(info, &width, &height); | |
| if (res) { | |
| return res; | |
| } | |
| res = initializeSurface(device, width, height); | |
| if (res) { | |
| return res; | |
| } | |
| mCameraId = cameraId; | |
| mStreaming = (info.device_version <= CAMERA_DEVICE_API_VERSION_3_1); | |
| mDevice = device; | |
| return OK; | |
| } | |
| status_t CameraDeviceClientFlashControl::disconnectCameraDevice() { | |
| if (mDevice != NULL) { | |
| mDevice->disconnect(); | |
| mDevice.clear(); | |
| } | |
| return OK; | |
| } | |
| status_t CameraDeviceClientFlashControl::hasFlashUnit(const String8& cameraId, | |
| bool *hasFlash) { | |
| ALOGV("%s: checking if camera %s has a flash unit", __FUNCTION__, | |
| cameraId.string()); | |
| Mutex::Autolock l(mLock); | |
| return hasFlashUnitLocked(cameraId, hasFlash); | |
| } | |
| status_t CameraDeviceClientFlashControl::hasFlashUnitLocked( | |
| const String8& cameraId, bool *hasFlash) { | |
| if (!hasFlash) { | |
| return BAD_VALUE; | |
| } | |
| camera_info info; | |
| status_t res = mCameraModule->getCameraInfo( | |
| atoi(cameraId.string()), &info); | |
| if (res != 0) { | |
| ALOGE("%s: failed to get camera info for camera %s", __FUNCTION__, | |
| cameraId.string()); | |
| return res; | |
| } | |
| CameraMetadata metadata; | |
| metadata = info.static_camera_characteristics; | |
| camera_metadata_entry flashAvailable = | |
| metadata.find(ANDROID_FLASH_INFO_AVAILABLE); | |
| if (flashAvailable.count == 1 && flashAvailable.data.u8[0] == 1) { | |
| *hasFlash = true; | |
| } | |
| return OK; | |
| } | |
| status_t CameraDeviceClientFlashControl::submitTorchEnabledRequest() { | |
| status_t res; | |
| if (mMetadata == NULL) { | |
| mMetadata = new CameraMetadata(); | |
| if (mMetadata == NULL) { | |
| return NO_MEMORY; | |
| } | |
| res = mDevice->createDefaultRequest( | |
| CAMERA3_TEMPLATE_PREVIEW, mMetadata); | |
| if (res) { | |
| return res; | |
| } | |
| } | |
| uint8_t torchOn = ANDROID_FLASH_MODE_TORCH; | |
| mMetadata->update(ANDROID_FLASH_MODE, &torchOn, 1); | |
| mMetadata->update(ANDROID_REQUEST_OUTPUT_STREAMS, &mStreamId, 1); | |
| uint8_t aeMode = ANDROID_CONTROL_AE_MODE_ON; | |
| mMetadata->update(ANDROID_CONTROL_AE_MODE, &aeMode, 1); | |
| int32_t requestId = 0; | |
| mMetadata->update(ANDROID_REQUEST_ID, &requestId, 1); | |
| if (mStreaming) { | |
| res = mDevice->setStreamingRequest(*mMetadata); | |
| } else { | |
| res = mDevice->capture(*mMetadata); | |
| } | |
| return res; | |
| } | |
| status_t CameraDeviceClientFlashControl::setTorchMode( | |
| const String8& cameraId, bool enabled) { | |
| bool hasFlash = false; | |
| Mutex::Autolock l(mLock); | |
| status_t res = hasFlashUnitLocked(cameraId, &hasFlash); | |
| // pre-check | |
| if (enabled) { | |
| // invalid camera? | |
| if (res) { | |
| return -EINVAL; | |
| } | |
| // no flash unit? | |
| if (!hasFlash) { | |
| return -ENOSYS; | |
| } | |
| // already opened for a different device? | |
| if (mDevice != NULL && cameraId != mCameraId) { | |
| return BAD_INDEX; | |
| } | |
| } else if (mDevice == NULL || cameraId != mCameraId) { | |
| // disabling the torch mode of an un-opened or different device. | |
| return OK; | |
| } else { | |
| // disabling the torch mode of currently opened device | |
| disconnectCameraDevice(); | |
| mTorchEnabled = false; | |
| mCallbacks->torch_mode_status_change(mCallbacks, | |
| cameraId.string(), TORCH_MODE_STATUS_AVAILABLE_OFF); | |
| return OK; | |
| } | |
| if (mDevice == NULL) { | |
| res = connectCameraDevice(cameraId); | |
| if (res) { | |
| return res; | |
| } | |
| } | |
| res = submitTorchEnabledRequest(); | |
| if (res) { | |
| return res; | |
| } | |
| mTorchEnabled = true; | |
| mCallbacks->torch_mode_status_change(mCallbacks, | |
| cameraId.string(), TORCH_MODE_STATUS_AVAILABLE_ON); | |
| return OK; | |
| } | |
| // CameraDeviceClientFlashControl implementation ends | |
| ///////////////////////////////////////////////////////////////////// | |
| // CameraHardwareInterfaceFlashControl implementation begins | |
| // Flash control for camera module <= v2.3 and camera HAL v1 | |
| ///////////////////////////////////////////////////////////////////// | |
| CameraHardwareInterfaceFlashControl::CameraHardwareInterfaceFlashControl( | |
| CameraModule& cameraModule, | |
| const camera_module_callbacks_t& callbacks) : | |
| mCameraModule(&cameraModule), | |
| mCallbacks(&callbacks), | |
| mTorchEnabled(false) { | |
| } | |
| CameraHardwareInterfaceFlashControl::~CameraHardwareInterfaceFlashControl() { | |
| disconnectCameraDevice(); | |
| mSurface.clear(); | |
| mSurfaceTexture.clear(); | |
| mProducer.clear(); | |
| mConsumer.clear(); | |
| if (mTorchEnabled) { | |
| if (mCallbacks) { | |
| ALOGV("%s: notify the framework that torch was turned off", | |
| __FUNCTION__); | |
| mCallbacks->torch_mode_status_change(mCallbacks, | |
| mCameraId.string(), TORCH_MODE_STATUS_AVAILABLE_OFF); | |
| } | |
| } | |
| } | |
| status_t CameraHardwareInterfaceFlashControl::setTorchMode( | |
| const String8& cameraId, bool enabled) { | |
| Mutex::Autolock l(mLock); | |
| // pre-check | |
| status_t res; | |
| if (enabled) { | |
| bool hasFlash = false; | |
| // Check if it has a flash unit and leave camera device open. | |
| res = hasFlashUnitLocked(cameraId, &hasFlash, /*keepDeviceOpen*/true); | |
| // invalid camera? | |
| if (res) { | |
| // hasFlashUnitLocked() returns BAD_INDEX if mDevice is connected to | |
| // another camera device. | |
| return res == BAD_INDEX ? BAD_INDEX : -EINVAL; | |
| } | |
| // no flash unit? | |
| if (!hasFlash) { | |
| // Disconnect camera device if it has no flash. | |
| disconnectCameraDevice(); | |
| return -ENOSYS; | |
| } | |
| } else if (mDevice == NULL || cameraId != mCameraId) { | |
| // disabling the torch mode of an un-opened or different device. | |
| return OK; | |
| } else { | |
| // disabling the torch mode of currently opened device | |
| disconnectCameraDevice(); | |
| mTorchEnabled = false; | |
| mCallbacks->torch_mode_status_change(mCallbacks, | |
| cameraId.string(), TORCH_MODE_STATUS_AVAILABLE_OFF); | |
| return OK; | |
| } | |
| res = startPreviewAndTorch(); | |
| if (res) { | |
| return res; | |
| } | |
| mTorchEnabled = true; | |
| mCallbacks->torch_mode_status_change(mCallbacks, | |
| cameraId.string(), TORCH_MODE_STATUS_AVAILABLE_ON); | |
| return OK; | |
| } | |
| status_t CameraHardwareInterfaceFlashControl::hasFlashUnit( | |
| const String8& cameraId, bool *hasFlash) { | |
| Mutex::Autolock l(mLock); | |
| // Close device after checking if it has a flash unit. | |
| return hasFlashUnitLocked(cameraId, hasFlash, /*keepDeviceOpen*/false); | |
| } | |
| status_t CameraHardwareInterfaceFlashControl::hasFlashUnitLocked( | |
| const String8& cameraId, bool *hasFlash, bool keepDeviceOpen) { | |
| bool closeCameraDevice = false; | |
| if (!hasFlash) { | |
| return BAD_VALUE; | |
| } | |
| status_t res; | |
| if (mDevice == NULL) { | |
| // Connect to camera device to query if it has a flash unit. | |
| res = connectCameraDevice(cameraId); | |
| if (res) { | |
| return res; | |
| } | |
| // Close camera device only when it is just opened and the caller doesn't want to keep | |
| // the camera device open. | |
| closeCameraDevice = !keepDeviceOpen; | |
| } | |
| if (cameraId != mCameraId) { | |
| return BAD_INDEX; | |
| } | |
| const char *flashMode = | |
| mParameters.get(CameraParameters::KEY_SUPPORTED_FLASH_MODES); | |
| if (flashMode && strstr(flashMode, CameraParameters::FLASH_MODE_TORCH)) { | |
| *hasFlash = true; | |
| } else { | |
| *hasFlash = false; | |
| } | |
| if (closeCameraDevice) { | |
| res = disconnectCameraDevice(); | |
| if (res != OK) { | |
| ALOGE("%s: Failed to disconnect camera device. %s (%d)", __FUNCTION__, | |
| strerror(-res), res); | |
| return res; | |
| } | |
| } | |
| return OK; | |
| } | |
| status_t CameraHardwareInterfaceFlashControl::startPreviewAndTorch() { | |
| status_t res = OK; | |
| res = mDevice->startPreview(); | |
| if (res) { | |
| ALOGE("%s: start preview failed. %s (%d)", __FUNCTION__, | |
| strerror(-res), res); | |
| return res; | |
| } | |
| mParameters.set(CameraParameters::KEY_FLASH_MODE, | |
| CameraParameters::FLASH_MODE_TORCH); | |
| return mDevice->setParameters(mParameters); | |
| } | |
| status_t CameraHardwareInterfaceFlashControl::getSmallestSurfaceSize( | |
| int32_t *width, int32_t *height) { | |
| if (!width || !height) { | |
| return BAD_VALUE; | |
| } | |
| int32_t w = INT32_MAX; | |
| int32_t h = 1; | |
| Vector<Size> sizes; | |
| mParameters.getSupportedPreviewSizes(sizes); | |
| for (size_t i = 0; i < sizes.size(); i++) { | |
| Size s = sizes[i]; | |
| if (w * h > s.width * s.height) { | |
| w = s.width; | |
| h = s.height; | |
| } | |
| } | |
| if (w == INT32_MAX) { | |
| return NAME_NOT_FOUND; | |
| } | |
| *width = w; | |
| *height = h; | |
| return OK; | |
| } | |
| status_t CameraHardwareInterfaceFlashControl::initializePreviewWindow( | |
| sp<CameraHardwareInterface> device, int32_t width, int32_t height) { | |
| status_t res; | |
| BufferQueue::createBufferQueue(&mProducer, &mConsumer); | |
| mSurfaceTexture = new GLConsumer(mConsumer, 0, GLConsumer::TEXTURE_EXTERNAL, | |
| true, true); | |
| if (mSurfaceTexture == NULL) { | |
| return NO_MEMORY; | |
| } | |
| int32_t format = HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED; | |
| res = mSurfaceTexture->setDefaultBufferSize(width, height); | |
| if (res) { | |
| return res; | |
| } | |
| res = mSurfaceTexture->setDefaultBufferFormat(format); | |
| if (res) { | |
| return res; | |
| } | |
| mSurface = new Surface(mProducer, /*useAsync*/ true); | |
| if (mSurface == NULL) { | |
| return NO_MEMORY; | |
| } | |
| res = native_window_api_connect(mSurface.get(), NATIVE_WINDOW_API_CAMERA); | |
| if (res) { | |
| ALOGE("%s: Unable to connect to native window", __FUNCTION__); | |
| return res; | |
| } | |
| return device->setPreviewWindow(mSurface); | |
| } | |
| status_t CameraHardwareInterfaceFlashControl::connectCameraDevice( | |
| const String8& cameraId) { | |
| sp<CameraHardwareInterface> device = | |
| new CameraHardwareInterface(cameraId.string()); | |
| status_t res = device->initialize(mCameraModule); | |
| if (res) { | |
| ALOGE("%s: initializing camera %s failed", __FUNCTION__, | |
| cameraId.string()); | |
| return res; | |
| } | |
| // need to set __get_memory in set_callbacks(). | |
| device->setCallbacks(NULL, NULL, NULL, NULL); | |
| mParameters = device->getParameters(); | |
| int32_t width, height; | |
| res = getSmallestSurfaceSize(&width, &height); | |
| if (res) { | |
| ALOGE("%s: failed to get smallest surface size for camera %s", | |
| __FUNCTION__, cameraId.string()); | |
| return res; | |
| } | |
| res = initializePreviewWindow(device, width, height); | |
| if (res) { | |
| ALOGE("%s: failed to initialize preview window for camera %s", | |
| __FUNCTION__, cameraId.string()); | |
| return res; | |
| } | |
| mCameraId = cameraId; | |
| mDevice = device; | |
| return OK; | |
| } | |
| status_t CameraHardwareInterfaceFlashControl::disconnectCameraDevice() { | |
| if (mDevice == NULL) { | |
| return OK; | |
| } | |
| if (mParameters.get(CameraParameters::KEY_FLASH_MODE)) { | |
| // There is a flash, turn if off. | |
| // (If there isn't one, leave the parameter null) | |
| mParameters.set(CameraParameters::KEY_FLASH_MODE, | |
| CameraParameters::FLASH_MODE_OFF); | |
| mDevice->setParameters(mParameters); | |
| } | |
| mDevice->stopPreview(); | |
| status_t res = native_window_api_disconnect(mSurface.get(), | |
| NATIVE_WINDOW_API_CAMERA); | |
| if (res) { | |
| ALOGW("%s: native_window_api_disconnect failed: %s (%d)", | |
| __FUNCTION__, strerror(-res), res); | |
| } | |
| mDevice->setPreviewWindow(NULL); | |
| mDevice->release(); | |
| mDevice = NULL; | |
| return OK; | |
| } | |
| // CameraHardwareInterfaceFlashControl implementation ends | |
| } |