Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 0b1cb14c authored by Eino-Ville Talvala's avatar Eino-Ville Talvala Committed by Yin-Chia Yeh
Browse files

Camera: Update camera service to use new HIDL HALs, part 2 

- Use string for device ID in Camera3Device
- Remove camera3_device_t parameter from Camera3Stream::finishConfiguration
  - Disables ability for the stream to register buffers
  - This means device HALv3.0 and v3.1 are no longer supported
- Add HIDL support to Camera3Device:
  - Add HalInterface class to abstract whether legacy or HIDL HAL is in use
- TODO
  - CameraHardwareInterface
  - Switch to using HIDL definitions instead of camera3.h definitions in
    main body of code

Test: Compiles
Bug: 30985004
Bug: 32991422
Change-Id: I9c3c0f7b7ea5d1d74e14b1d882779e3b9445da69
parent 2f09bac6

services/camera/libcameraservice/common/CameraDeviceBase.h

+1 −1
Original line number Diff line number Diff line
@@ -48,7 +48,7 @@ class CameraDeviceBase : public virtual RefBase { 
    /**

     * The device's camera ID

     */

    virtual int      getId() const = 0;

    virtual const String8& getId() const = 0;



    virtual status_t initialize(CameraModule *module) = 0;

    virtual status_t initialize(sp<CameraProviderManager> manager) = 0;

services/camera/libcameraservice/common/CameraProviderManager.cpp

+50 −4
Original line number Diff line number Diff line
@@ -151,7 +151,7 @@ status_t CameraProviderManager::getCameraCharacteristics(const std::string &id, 
        CameraMetadata* characteristics) const {

    std::lock_guard<std::mutex> lock(mInterfaceMutex);



    auto deviceInfo = findDeviceInfoLocked(id, /*minVersion*/ hardware::hidl_version{3,0});

    auto deviceInfo = findDeviceInfoLocked(id, /*minVersion*/ {3,0}, /*maxVersion*/ {4,0});

    if (deviceInfo == nullptr) return NAME_NOT_FOUND;



    return deviceInfo->getCameraCharacteristics(characteristics);
@@ -180,7 +180,6 @@ status_t CameraProviderManager::getHighestSupportedVersion(const std::string &id 
    return OK;

}





status_t CameraProviderManager::setTorchMode(const std::string &id, bool enabled) {

    std::lock_guard<std::mutex> lock(mInterfaceMutex);
@@ -190,6 +189,51 @@ status_t CameraProviderManager::setTorchMode(const std::string &id, bool enabled 
    return deviceInfo->setTorchMode(enabled);

}



status_t CameraProviderManager::openSession(const std::string &id,

        const sp<hardware::camera::device::V3_2::ICameraDeviceCallback>& callback,

        /*out*/

        sp<hardware::camera::device::V3_2::ICameraDeviceSession> *session) {



    std::lock_guard<std::mutex> lock(mInterfaceMutex);



    auto deviceInfo = findDeviceInfoLocked(id,

            /*minVersion*/ {3,0}, /*maxVersion*/ {4,0});

    if (deviceInfo == nullptr) return NAME_NOT_FOUND;



    auto *deviceInfo3 = static_cast<ProviderInfo::DeviceInfo3*>(deviceInfo);



    Status status;

    deviceInfo3->mInterface->open(callback, [&status, &session]

            (Status s, const sp<device::V3_2::ICameraDeviceSession>& cameraSession) {

                status = s;

                if (status == Status::OK) {

                    *session = cameraSession;

                }

            });

    return mapToStatusT(status);

}



status_t CameraProviderManager::openSession(const std::string &id,

        const sp<hardware::camera::device::V1_0::ICameraDeviceCallback>& callback,

        /*out*/

        sp<hardware::camera::device::V1_0::ICameraDevice> *session) {



    std::lock_guard<std::mutex> lock(mInterfaceMutex);



    auto deviceInfo = findDeviceInfoLocked(id,

            /*minVersion*/ {1,0}, /*maxVersion*/ {2,0});

    if (deviceInfo == nullptr) return NAME_NOT_FOUND;



    auto *deviceInfo1 = static_cast<ProviderInfo::DeviceInfo1*>(deviceInfo);



    Status status = deviceInfo1->mInterface->open(callback);

    if (status == Status::OK) {

        *session = deviceInfo1->mInterface;

    }

    return mapToStatusT(status);

}





hardware::Return<void> CameraProviderManager::onRegistration(

        const hardware::hidl_string& /*fqName*/,

        const hardware::hidl_string& name,
@@ -211,10 +255,12 @@ status_t CameraProviderManager::dump(int fd, const Vector<String16>& args) { 
}



CameraProviderManager::ProviderInfo::DeviceInfo* CameraProviderManager::findDeviceInfoLocked(

        const std::string& id, hardware::hidl_version minVersion) const {

        const std::string& id,

        hardware::hidl_version minVersion, hardware::hidl_version maxVersion) const {

    for (auto& provider : mProviders) {

        for (auto& deviceInfo : provider->mDevices) {

            if (deviceInfo->mId == id && minVersion <= deviceInfo->mVersion) {

            if (deviceInfo->mId == id &&

                    minVersion <= deviceInfo->mVersion && maxVersion >= deviceInfo->mVersion) {

                return deviceInfo.get();

            }

        }

services/camera/libcameraservice/common/CameraProviderManager.h

+33 −9
Original line number Diff line number Diff line
@@ -155,6 +155,22 @@ public: 
     */

    status_t setTorchMode(const std::string &id, bool enabled);



    /**

     * Open an active session to a camera device.

     *

     * This fully powers on the camera device hardware, and returns a handle to a

     * session to be used for hardware configuration and operation.

     */

    status_t openSession(const std::string &id,

            const sp<hardware::camera::device::V3_2::ICameraDeviceCallback>& callback,

            /*out*/

            sp<hardware::camera::device::V3_2::ICameraDeviceSession> *session);



    status_t openSession(const std::string &id,

            const sp<hardware::camera::device::V1_0::ICameraDeviceCallback>& callback,

            /*out*/

            sp<hardware::camera::device::V1_0::ICameraDevice> *session);



    /**

     * IServiceNotification::onRegistration

     * Invoked by the hardware service manager when a new camera provider is registered
@@ -168,6 +184,12 @@ public: 
     */

    status_t dump(int fd, const Vector<String16>& args);



    /**

     * Conversion methods between HAL Status and status_t and strings

     */

    static status_t mapToStatusT(const hardware::camera::common::V1_0::Status& s);

    static const char* statusToString(const hardware::camera::common::V1_0::Status& s);



private:

    // All private members, unless otherwise noted, expect mInterfaceMutex to be locked before use

    mutable std::mutex mInterfaceMutex;
@@ -238,12 +260,6 @@ private: 
        };

        std::vector<std::unique_ptr<DeviceInfo>> mDevices;



    private:

        std::string mType;

        uint32_t mId;



        CameraProviderManager *mManager;



        // HALv1-specific camera fields, including the actual device interface

        struct DeviceInfo1 : public DeviceInfo {

            typedef hardware::camera::device::V1_0::ICameraDevice InterfaceT;
@@ -280,6 +296,12 @@ private: 
            CameraMetadata mCameraCharacteristics;

        };



    private:

        std::string mType;

        uint32_t mId;



        CameraProviderManager *mManager;



        // Templated method to instantiate the right kind of DeviceInfo and call the

        // right CameraProvider getCameraDeviceInterface_* method.

        template<class DeviceInfoT>
@@ -301,8 +323,12 @@ private: 


    // Utility to find a DeviceInfo by ID; pointer is only valid while mInterfaceMutex is held

    // and the calling code doesn't mutate the list of providers or their lists of devices.

    // Finds the first device of the given ID that falls within the requested version range

    //   minVersion <= deviceVersion < maxVersion

    // No guarantees on the order of traversal

    ProviderInfo::DeviceInfo* findDeviceInfoLocked(const std::string& id,

            hardware::hidl_version minVersion = hardware::hidl_version{0,0}) const;

            hardware::hidl_version minVersion = hardware::hidl_version{0,0},

            hardware::hidl_version maxVersion = hardware::hidl_version{1000,0}) const;



    status_t addProvider(const std::string& newProvider, bool expected = true);

    status_t removeProvider(const std::string& provider);
@@ -311,8 +337,6 @@ private: 


    std::vector<sp<ProviderInfo>> mProviders;



    static status_t mapToStatusT(const hardware::camera::common::V1_0::Status& s);

    static const char* statusToString(const hardware::camera::common::V1_0::Status&);

    static const char* deviceStatusToString(

        const hardware::camera::common::V1_0::CameraDeviceStatus&);

    static const char* torchStatusToString(

services/camera/libcameraservice/common/FrameProcessorBase.cpp

+12 −12
Original line number Diff line number Diff line
@@ -123,7 +123,7 @@ void FrameProcessorBase::processNewFrames(const sp<CameraDeviceBase> &device) { 
    ATRACE_CALL();

    CaptureResult result;



    ALOGV("%s: Camera %d: Process new frames", __FUNCTION__, device->getId());

    ALOGV("%s: Camera %s: Process new frames", __FUNCTION__, device->getId().string());



    while ( (res = device->getNextResult(&result)) == OK) {
@@ -133,8 +133,8 @@ void FrameProcessorBase::processNewFrames(const sp<CameraDeviceBase> &device) { 


        entry = result.mMetadata.find(ANDROID_REQUEST_FRAME_COUNT);

        if (entry.count == 0) {

            ALOGE("%s: Camera %d: Error reading frame number",

                    __FUNCTION__, device->getId());

            ALOGE("%s: Camera %s: Error reading frame number",

                    __FUNCTION__, device->getId().string());

            break;

        }

        ATRACE_INT("cam2_frame", entry.data.i32[0]);
@@ -149,8 +149,8 @@ void FrameProcessorBase::processNewFrames(const sp<CameraDeviceBase> &device) { 
        }

    }

    if (res != NOT_ENOUGH_DATA) {

        ALOGE("%s: Camera %d: Error getting next frame: %s (%d)",

                __FUNCTION__, device->getId(), strerror(-res), res);

        ALOGE("%s: Camera %s: Error getting next frame: %s (%d)",

                __FUNCTION__, device->getId().string(), strerror(-res), res);

        return;

    }
@@ -159,8 +159,8 @@ void FrameProcessorBase::processNewFrames(const sp<CameraDeviceBase> &device) { 


bool FrameProcessorBase::processSingleFrame(CaptureResult &result,

                                            const sp<CameraDeviceBase> &device) {

    ALOGV("%s: Camera %d: Process single frame (is empty? %d)",

          __FUNCTION__, device->getId(), result.mMetadata.isEmpty());

    ALOGV("%s: Camera %s: Process single frame (is empty? %d)",

            __FUNCTION__, device->getId().string(), result.mMetadata.isEmpty());

    return processListeners(result, device) == OK;

}
@@ -178,8 +178,8 @@ status_t FrameProcessorBase::processListeners(const CaptureResult &result, 
        entry = result.mMetadata.find(ANDROID_QUIRKS_PARTIAL_RESULT);

        if (entry.count != 0 &&

                entry.data.u8[0] == ANDROID_QUIRKS_PARTIAL_RESULT_PARTIAL) {

            ALOGV("%s: Camera %d: This is a partial result",

                    __FUNCTION__, device->getId());

            ALOGV("%s: Camera %s: This is a partial result",

                    __FUNCTION__, device->getId().string());

            isPartialResult = true;

        }

    }
@@ -190,7 +190,7 @@ status_t FrameProcessorBase::processListeners(const CaptureResult &result, 
    // include CaptureResultExtras.

    entry = result.mMetadata.find(ANDROID_REQUEST_ID);

    if (entry.count == 0) {

        ALOGE("%s: Camera %d: Error reading frame id", __FUNCTION__, device->getId());

        ALOGE("%s: Camera %s: Error reading frame id", __FUNCTION__, device->getId().string());

        return BAD_VALUE;

    }

    int32_t requestId = entry.data.i32[0];
@@ -215,8 +215,8 @@ status_t FrameProcessorBase::processListeners(const CaptureResult &result, 
            item++;

        }

    }

    ALOGV("%s: Camera %d: Got %zu range listeners out of %zu", __FUNCTION__,

          device->getId(), listeners.size(), mRangeListeners.size());

    ALOGV("%s: Camera %s: Got %zu range listeners out of %zu", __FUNCTION__,

          device->getId().string(), listeners.size(), mRangeListeners.size());



    List<sp<FilteredListener> >::iterator item = listeners.begin();

    for (; item != listeners.end(); item++) {

services/camera/libcameraservice/device3/Camera3Device.cpp

+705 −131

File changed.

Preview size limit exceeded, changes collapsed.