From a61a974d0ea5d1608f0d491f7209cf42898df929 Mon Sep 17 00:00:00 2001 From: roynatech2544 Date: Wed, 23 Feb 2022 19:10:22 +0900 Subject: [PATCH] universal7885: libshims: libcorrectcamera: overlay more func Change-Id: Ifd20fdff717b677b33bcd7865ec92962e3877da9 Signed-off-by: roynatech2544 --- .../libshims/camera/CamDevice_3_2.h | 159 ++++++++++++++++++ .../libshims/camera/CorrectCameraID.cpp | 9 +- 2 files changed, 166 insertions(+), 2 deletions(-) create mode 100644 universal7885-common/libshims/camera/CamDevice_3_2.h diff --git a/universal7885-common/libshims/camera/CamDevice_3_2.h b/universal7885-common/libshims/camera/CamDevice_3_2.h new file mode 100644 index 0000000..620e987 --- /dev/null +++ b/universal7885-common/libshims/camera/CamDevice_3_2.h @@ -0,0 +1,159 @@ +/* + * Copyright (C) 2016 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ANDROID_HARDWARE_CAM_DEVICE_V3_2_CAMERADEVICE_H +#define ANDROID_HARDWARE_CAM_DEVICE_V3_2_CAMERADEVICE_H + +#include "utils/Mutex.h" +#include "CameraModule.h" +#include "CameraMetadata.h" +#include "CameraDeviceSession.h" + +#include +#include +#include + +namespace android { +namespace hardware { +namespace camera { +namespace device { +namespace V3_2 { +namespace implementation { + +using ::android::hardware::camera::device::V3_2::RequestTemplate; +using ::android::hardware::camera::device::V3_2::ICameraDevice; +using ::android::hardware::camera::device::V3_2::ICameraDeviceCallback; +using ::android::hardware::camera::device::V3_2::ICameraDeviceSession; +using ::android::hardware::camera::common::V1_0::CameraResourceCost; +using ::android::hardware::camera::common::V1_0::Status; +using ::android::hardware::camera::common::V1_0::TorchMode; +using ::android::hardware::camera::common::V1_0::helper::CameraModule; +using ::android::hardware::Return; +using ::android::hardware::Void; +using ::android::hardware::hidl_vec; +using ::android::hardware::hidl_string; +using ::android::sp; +using ::android::Mutex; + +/* + * The camera device HAL implementation is opened lazily (via the open call) + */ +struct CameraDevice : public virtual RefBase { + // Called by provider HAL. Provider HAL must ensure the uniqueness of + // CameraDevice object per cameraId, or there could be multiple CameraDevice + // trying to access the same physical camera. + // Also, provider will have to keep track of all CameraDevice objects in + // order to notify CameraDevice when the underlying camera is detached + CameraDevice(sp module, + const std::string& cameraId, + const SortedVector>& cameraDeviceNames); + virtual ~CameraDevice(); + + // Retrieve the HIDL interface, split into its own class to avoid inheritance issues when + // dealing with minor version revs and simultaneous implementation and interface inheritance + virtual sp getInterface() { + return new TrampolineDeviceInterface_3_2(this); + } + + // Caller must use this method to check if CameraDevice ctor failed + bool isInitFailed() { return mInitFail; } + // Used by provider HAL to signal external camera disconnected + void setConnectionStatus(bool connected); + + /* Methods from ::android::hardware::camera::device::V3_2::ICameraDevice follow. */ + // The following method can be called without opening the actual camera device + Return getResourceCost(ICameraDevice::getResourceCost_cb _hidl_cb); + Return getCameraCharacteristics(ICameraDevice::getCameraCharacteristics_cb _hidl_cb); + Return getEurekaCharacteristics(ICameraDevice::getCameraCharacteristics_cb _hidl_cb); + Return setTorchMode(TorchMode mode); + + // Open the device HAL and also return a default capture session + Return open(const sp& callback, ICameraDevice::open_cb _hidl_cb); + + + // Forward the dump call to the opened session, or do nothing + Return dumpState(const ::android::hardware::hidl_handle& fd); + /* End of Methods from ::android::hardware::camera::device::V3_2::ICameraDevice */ + +protected: + + // Overridden by child implementations for returning different versions of CameraDeviceSession + virtual sp createSession(camera3_device_t*, + const camera_metadata_t* deviceInfo, + const sp&); + + const sp mModule; + const std::string mCameraId; + // const after ctor + int mCameraIdInt; + int mDeviceVersion; + bool mInitFail = false; + // Set by provider (when external camera is connected/disconnected) + bool mDisconnected; + wp mSession = nullptr; + + const SortedVector>& mCameraDeviceNames; + + // gating access to mSession and mDisconnected + mutable Mutex mLock; + + // convert conventional HAL status to HIDL Status + static Status getHidlStatus(int); + + Status initStatus() const; + +private: + struct TrampolineDeviceInterface_3_2 : public ICameraDevice { + TrampolineDeviceInterface_3_2(sp parent) : + mParent(parent) {} + + virtual Return getResourceCost(V3_2::ICameraDevice::getResourceCost_cb _hidl_cb) + override { + return mParent->getResourceCost(_hidl_cb); + } + + virtual Return getCameraCharacteristics( + V3_2::ICameraDevice::getCameraCharacteristics_cb _hidl_cb) override { + return mParent->getCameraCharacteristics(_hidl_cb); + } + + virtual Return setTorchMode(TorchMode mode) override { + return mParent->setTorchMode(mode); + } + + virtual Return open(const sp& callback, + V3_2::ICameraDevice::open_cb _hidl_cb) override { + return mParent->open(callback, _hidl_cb); + } + + virtual Return dumpState(const hidl_handle& fd) override { + return mParent->dumpState(fd); + } + + private: + sp mParent; + }; + +}; + +} // namespace implementation +} // namespace V3_2 +} // namespace device +} // namespace camera +} // namespace hardware +} // namespace android + +#endif // ANDROID_HARDWARE_CAM_DEVICE_V3_2_CAMERADEVICE_H diff --git a/universal7885-common/libshims/camera/CorrectCameraID.cpp b/universal7885-common/libshims/camera/CorrectCameraID.cpp index ac0f6f8..9162f70 100644 --- a/universal7885-common/libshims/camera/CorrectCameraID.cpp +++ b/universal7885-common/libshims/camera/CorrectCameraID.cpp @@ -8,7 +8,7 @@ * (at your option) any later version. */ -#include "CameraDevice_3_2.h" +#include "CamDevice_3_2.h" #include #include @@ -27,7 +27,7 @@ Return CameraDevice::getCameraCharacteristics(ICameraDevice::getCameraChar if (status == Status::OK) { //Module 2.1+ codepath. struct camera_info info; - if (mCameraIdInt == 2) mCameraIdInt = 1; + if (mCameraIdInt == 1) mCameraIdInt = 2; int ret = mModule->getCameraInfo(mCameraIdInt, &info); if (ret == OK) { convertToHidl(info.static_camera_characteristics, &cameraCharacteristics); @@ -40,9 +40,14 @@ Return CameraDevice::getCameraCharacteristics(ICameraDevice::getCameraChar return Void(); } +Return CameraDevice::getEurekaCharacteristics(ICameraDevice::getCameraCharacteristics_cb _hidl_cb) { + return CameraDevice::getCameraCharacteristics(_hidl_cb); +} + } // namespace implementation } // namespace V3_2 } // namespace device } // namespace camera } // namespace hardware } // namespace android +