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

Commit 3c522e2b authored by Avichal Rakesh's avatar Avichal Rakesh
Browse files

cameraservice: Make getSessionCharacteristics accessible earlier 

The current implementation of getSessionCharacteristics forced Camera2
to open a corresponding CameraDevice. However, there is no technical
limitation that prevents getSessionCharacteristics from being
accessible before an openCamera call.

This CL moves the getSessionCharacteristics to be a function in
ICameraService instead of ICameraDeviceUser which allows camera2
to call getSessionCharacteristics before calling openCamera
for a given device.

Bug: 320741775
Test: atest CtsCameraTestCases:CameraDeviceTest passes.
Test: atest CtsCameraTestCases:FeatureCombinationTest passes.
Test: atest CtsCameraTestCases:CameraDeviceSetupTest passes.
Test: atest cameraservice_test passes.
Change-Id: Ia21f882fac5ece59dcd6a70e04b2f81ef6dee4c3
parent 6eb16d47

camera/aidl/android/hardware/ICameraService.aidl

+22 −8
Original line number Diff line number Diff line
@@ -281,11 +281,25 @@ interface ICameraService 
     * Check whether a particular session configuration with optional session parameters

     * has camera device support.

     *

      * @param cameraId The camera id to query session configuration on

     * @param cameraId The camera id to query session configuration for

     * @param sessionConfiguration Specific session configuration to be verified.

     * @return true  - in case the stream combination is supported.

     *         false - in case there is no device support.

     */

    boolean isSessionConfigurationWithParametersSupported(@utf8InCpp String cameraId,

            in SessionConfiguration sessionConfiguration);



    /**

     * Get the camera characteristics for a particular session configuration for

     * the given camera device.

     *

     * @param cameraId ID of the device for which the session characteristics must be fetched.

     * @param sessionConfiguration session configuration for which the characteristics

     * must be fetched.

     * @return - characteristics associated with the given session.

     */

    CameraMetadataNative getSessionCharacteristics(@utf8InCpp String cameraId,

                int targetSdkVersion,

                boolean overrideToPortrait,

                in SessionConfiguration sessionConfiguration);

}

camera/aidl/android/hardware/camera2/ICameraDeviceUser.aidl

+0 −9
Original line number Diff line number Diff line
@@ -99,15 +99,6 @@ interface ICameraDeviceUser 
      */

    boolean isSessionConfigurationSupported(in SessionConfiguration sessionConfiguration);



    /**

     * Get the camera characteristics for a particular session configuration

     *

     * @param sessionConfiguration Specific session configuration for which the characteristics

     * are fetched.

     * @return - characteristics associated with the given session.

     */

    CameraMetadataNative getSessionCharacteristics(in SessionConfiguration sessionConfiguration);



    void deleteStream(int streamId);



    /**

services/camera/libcameraservice/CameraService.cpp

+55 −0
Original line number Diff line number Diff line
@@ -984,6 +984,61 @@ Status CameraService::isSessionConfigurationWithParametersSupported( 
    return res;

}



Status CameraService::getSessionCharacteristics(const std::string& unresolvedCameraId,

                                                int targetSdkVersion, bool overrideToPortrait,

                                                const SessionConfiguration& sessionConfiguration,

                                                /*out*/ CameraMetadata* outMetadata) {

    ATRACE_CALL();



    if (!mInitialized) {

        ALOGE("%s: Camera HAL couldn't be initialized", __FUNCTION__);

        logServiceError("Camera subsystem is not available", ERROR_DISCONNECTED);

        return STATUS_ERROR(ERROR_DISCONNECTED, "Camera subsystem is not available");

    }



    const std::string cameraId =

            resolveCameraId(unresolvedCameraId, CameraThreadState::getCallingUid());



    if (outMetadata == nullptr) {

        std::string msg =

                fmt::sprintf("Camera %s: Invalid 'outMetadata' input!", unresolvedCameraId.c_str());

        ALOGE("%s: %s", __FUNCTION__, msg.c_str());

        return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, msg.c_str());

    }



    bool overrideForPerfClass = SessionConfigurationUtils::targetPerfClassPrimaryCamera(

            mPerfClassPrimaryCameraIds, cameraId, targetSdkVersion);



    status_t ret = mCameraProviderManager->getSessionCharacteristics(

            cameraId, sessionConfiguration, overrideForPerfClass, overrideToPortrait, outMetadata);



    // TODO(b/303645857): Remove fingerprintable metadata if the caller process does not have

    //                    camera access permission.



    Status res = Status::ok();

    switch (ret) {

        case OK:

            // Expected, no handling needed.

            break;

        case INVALID_OPERATION: {

                std::string msg = fmt::sprintf(

                        "Camera %s: Session characteristics query not supported!",

                        cameraId.c_str());

                ALOGD("%s: %s", __FUNCTION__, msg.c_str());

                res = STATUS_ERROR(CameraService::ERROR_INVALID_OPERATION, msg.c_str());

            }

            break;

        default: {

                std::string msg = fmt::sprintf("Camera %s: Error: %s (%d)", cameraId.c_str(),

                                               strerror(-ret), ret);

                ALOGE("%s: %s", __FUNCTION__, msg.c_str());

                res = STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, msg.c_str());

            }

    }



    return res;

}



Status CameraService::parseCameraIdRemapping(

        const hardware::CameraIdRemapping& cameraIdRemapping,

        /* out */ TCameraIdRemapping* cameraIdRemappingMap) {

services/camera/libcameraservice/CameraService.h

+5 −0
Original line number Diff line number Diff line
@@ -248,6 +248,11 @@ public: 
            /*out*/

            bool* supported);



    virtual binder::Status getSessionCharacteristics(

            const std::string& cameraId, int targetSdkVersion, bool overrideToPortrait,

            const SessionConfiguration& sessionConfiguration,

            /*out*/ CameraMetadata* outMetadata);



    // Extra permissions checks

    virtual status_t    onTransact(uint32_t code, const Parcel& data,

                                   Parcel* reply, uint32_t flags);

services/camera/libcameraservice/api2/CameraDeviceClient.cpp

+0 −54
Original line number Diff line number Diff line
@@ -777,60 +777,6 @@ binder::Status CameraDeviceClient::isSessionConfigurationSupported( 
    return res;

}



binder::Status CameraDeviceClient::getSessionCharacteristics(

        const SessionConfiguration& sessionConfiguration,

        /*out*/

        hardware::camera2::impl::CameraMetadataNative* sessionCharacteristics) {

    ATRACE_CALL();

    binder::Status res;

    status_t ret = OK;

    if (!(res = checkPidStatus(__FUNCTION__)).isOk()) return res;



    Mutex::Autolock icl(mBinderSerializationLock);



    if (!mDevice.get()) {

        return STATUS_ERROR(CameraService::ERROR_DISCONNECTED, "Camera device no longer alive");

    }



    auto operatingMode = sessionConfiguration.getOperatingMode();

    res = SessionConfigurationUtils::checkOperatingMode(operatingMode, mDevice->info(),

            mCameraIdStr);

    if (!res.isOk()) {

        return res;

    }



    camera3::metadataGetter getMetadata = [this](const std::string &id,

            bool /*overrideForPerfClass*/) {

          return mDevice->infoPhysical(id);};

    ret = mProviderManager->getSessionCharacteristics(mCameraIdStr.c_str(),

            sessionConfiguration, mOverrideForPerfClass, getMetadata,

            sessionCharacteristics);



    switch (ret) {

        case OK:

            // Expected, do nothing.

            break;

        case INVALID_OPERATION: {

                std::string msg = fmt::sprintf(

                        "Camera %s: Session characteristics query not supported!",

                        mCameraIdStr.c_str());

                ALOGD("%s: %s", __FUNCTION__, msg.c_str());

                res = STATUS_ERROR(CameraService::ERROR_INVALID_OPERATION, msg.c_str());

            }



            break;

        default: {

                std::string msg = fmt::sprintf( "Camera %s: Error: %s (%d)", mCameraIdStr.c_str(),

                        strerror(-ret), ret);

                ALOGE("%s: %s", __FUNCTION__, msg.c_str());

                res = STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT,

                        msg.c_str());

            }

    }



    return res;

}



binder::Status CameraDeviceClient::deleteStream(int streamId) {

    ATRACE_CALL();

    ALOGV("%s (streamId = 0x%x)", __FUNCTION__, streamId);