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

Commit 462c24b3 authored by Jayant Chowdhary's avatar Jayant Chowdhary Committed by Android (Google) Code Review
Browse files

Merge "camera: Delete supportsCameraApi binder call" into main

parents f79297de 87856e26

camera/aidl/android/hardware/ICameraService.aidl

+0 −8
Original line number Diff line number Diff line
@@ -261,14 +261,6 @@ interface ICameraService 
     */

    @utf8InCpp String getLegacyParameters(int cameraId);



    /**

     * apiVersion constants for supportsCameraApi

     */

    const int API_VERSION_1 = 1;

    const int API_VERSION_2 = 2;



    // Determines if a particular API version is supported directly for a cameraId.

    boolean supportsCameraApi(@utf8InCpp String cameraId, int apiVersion);

    // Determines if a cameraId is a hidden physical camera of a logical multi-camera.

    boolean isHiddenPhysicalCamera(@utf8InCpp String cameraId);

    // Inject the external camera to replace the internal camera session.

camera/ndk/impl/ACameraManager.cpp

+24 −53
Original line number Diff line number Diff line
@@ -376,17 +376,12 @@ void CameraManagerGlobal::registerAvailCallback(const DeviceContext& deviceConte 
    const auto& [_, newlyRegistered] = mCallbacks.insert(cb);

    // Send initial callbacks if callback is newly registered

    if (newlyRegistered) {

        for (auto& [key, statusAndHAL3Support] : mDeviceStatusMap) {

        for (auto& [key, logicalAndPhysicalStatus] : mDeviceStatusMap) {

            if (!isCameraAccessible(deviceContext, key.deviceId)) {

                continue;

            }

            const std::string& cameraId = key.cameraId;

            int32_t status = statusAndHAL3Support.getStatus();

            // Don't send initial callbacks for camera ids which don't support

            // camera2

            if (!statusAndHAL3Support.supportsHAL3) {

                continue;

            }

            int32_t status = logicalAndPhysicalStatus.getStatus();



            // Camera available/unavailable callback

            sp<AMessage> msg = new AMessage(kWhatSendSingleCallback, mHandler);
@@ -400,7 +395,7 @@ void CameraManagerGlobal::registerAvailCallback(const DeviceContext& deviceConte 


            // Physical camera unavailable callback

            std::set<std::string> unavailablePhysicalCameras =

                    statusAndHAL3Support.getUnavailablePhysicalIds();

                    logicalAndPhysicalStatus.getUnavailablePhysicalIds();

            for (const auto& physicalCameraId : unavailablePhysicalCameras) {

                sp<AMessage> msg = new AMessage(kWhatSendSinglePhysicalCameraCallback, mHandler);

                ACameraManager_PhysicalCameraAvailabilityCallback cbFunc =
@@ -416,42 +411,23 @@ void CameraManagerGlobal::registerAvailCallback(const DeviceContext& deviceConte 
    }

}



bool CameraManagerGlobal::supportsCamera2ApiLocked(const std::string &cameraId) {

    bool camera2Support = false;

    auto cs = getCameraServiceLocked();

    if (cs == nullptr) {

        return false;

    }

    binder::Status serviceRet =

        cs->supportsCameraApi(cameraId,

                hardware::ICameraService::API_VERSION_2, &camera2Support);

    if (!serviceRet.isOk()) {

        ALOGE("%s: supportsCameraApi2Locked() call failed for cameraId  %s",

                __FUNCTION__, cameraId.c_str());

        return false;

    }

    return camera2Support;

}



void CameraManagerGlobal::getCameraIdList(const DeviceContext& context,

        std::vector<std::string>* cameraIds) {

    // Ensure that we have initialized/refreshed the list of available devices

    Mutex::Autolock _l(mLock);

    // Needed to make sure we're connected to cameraservice

    getCameraServiceLocked();

    for (auto& [key, statusAndHAL3Support] : mDeviceStatusMap) {

    for (auto& [key, logicalAndPhysicalStatus] : mDeviceStatusMap) {

        if (!isCameraAccessible(context, key.deviceId)) {

            continue;

        }



        int32_t status = statusAndHAL3Support.getStatus();

        int32_t status = logicalAndPhysicalStatus.getStatus();

        if (status == hardware::ICameraServiceListener::STATUS_NOT_PRESENT ||

                status == hardware::ICameraServiceListener::STATUS_ENUMERATING) {

            continue;

        }

        if (!statusAndHAL3Support.supportsHAL3) {

            continue;

        }



        cameraIds->push_back(key.cameraId);

    }

}
@@ -649,15 +625,13 @@ void CameraManagerGlobal::onStatusChangedLocked(int32_t status, const int device 
        return;

    }



    bool supportsHAL3 = supportsCamera2ApiLocked(cameraId);

    if (firstStatus) {

        mDeviceStatusMap.emplace(std::piecewise_construct, std::forward_as_tuple(key),

                                 std::forward_as_tuple(status, supportsHAL3));

                std::forward_as_tuple(status));

    } else {

        mDeviceStatusMap[key].updateStatus(status);

    }

    // Iterate through all registered callbacks

    if (supportsHAL3) {

    for (auto cb : mCallbacks) {

        if (!isCameraAccessible(cb.mDeviceContext, deviceId)) {

            continue;
@@ -671,7 +645,6 @@ void CameraManagerGlobal::onStatusChangedLocked(int32_t status, const int device 
        mPendingCallbackCnt++;

        msg->post();

    }

    }

    if (status == hardware::ICameraServiceListener::STATUS_NOT_PRESENT) {

        mDeviceStatusMap.erase(key);

    }
@@ -705,8 +678,6 @@ void CameraManagerGlobal::onStatusChangedLocked(int32_t status, const int device 
        return;

    }



    bool supportsHAL3 = supportsCamera2ApiLocked(cameraId);



    bool updated = false;

    if (status == hardware::ICameraServiceListener::STATUS_PRESENT) {

        updated = mDeviceStatusMap[key].removeUnavailablePhysicalId(physicalCameraId);
@@ -715,7 +686,7 @@ void CameraManagerGlobal::onStatusChangedLocked(int32_t status, const int device 
    }



    // Iterate through all registered callbacks

    if (supportsHAL3 && updated) {

    if (updated) {

        for (auto cb : mCallbacks) {

            if (!isCameraAccessible(cb.mDeviceContext, deviceId)) {

                continue;
@@ -733,31 +704,31 @@ void CameraManagerGlobal::onStatusChangedLocked(int32_t status, const int device 
    }

}



int32_t CameraManagerGlobal::StatusAndHAL3Support::getStatus() {

int32_t CameraManagerGlobal::Status::getStatus() {

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

    return status;

}



void CameraManagerGlobal::StatusAndHAL3Support::updateStatus(int32_t newStatus) {

void CameraManagerGlobal::Status::updateStatus(int32_t newStatus) {

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

    status = newStatus;

}



bool CameraManagerGlobal::StatusAndHAL3Support::addUnavailablePhysicalId(

bool CameraManagerGlobal::Status::addUnavailablePhysicalId(

        const std::string& physicalCameraId) {

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

    auto result = unavailablePhysicalIds.insert(physicalCameraId);

    return result.second;

}



bool CameraManagerGlobal::StatusAndHAL3Support::removeUnavailablePhysicalId(

bool CameraManagerGlobal::Status::removeUnavailablePhysicalId(

        const std::string& physicalCameraId) {

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

    auto count = unavailablePhysicalIds.erase(physicalCameraId);

    return count > 0;

}



std::set<std::string> CameraManagerGlobal::StatusAndHAL3Support::getUnavailablePhysicalIds() {

std::set<std::string> CameraManagerGlobal::Status::getUnavailablePhysicalIds() {

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

    return unavailablePhysicalIds;

}

camera/ndk/impl/ACameraManager.h

+5 −7
Original line number Diff line number Diff line
@@ -260,18 +260,16 @@ class CameraManagerGlobal final : public RefBase { 
    // Utils for status

    static bool validStatus(int32_t status);

    static bool isStatusAvailable(int32_t status);

    bool supportsCamera2ApiLocked(const std::string &cameraId);



    struct StatusAndHAL3Support {

    struct Status {

      private:

        int32_t status = hardware::ICameraServiceListener::STATUS_NOT_PRESENT;

        mutable std::mutex mLock;

        std::set<std::string> unavailablePhysicalIds;

      public:

        const bool supportsHAL3 = false;

        StatusAndHAL3Support(int32_t st, bool HAL3support):

                status(st), supportsHAL3(HAL3support) { };

        StatusAndHAL3Support() = default;

        Status(int32_t st):

                status(st) { };

        Status() = default;



        bool addUnavailablePhysicalId(const std::string& physicalCameraId);

        bool removeUnavailablePhysicalId(const std::string& physicalCameraId);
@@ -308,7 +306,7 @@ class CameraManagerGlobal final : public RefBase { 
        }

    };



    std::map<DeviceStatusMapKey, StatusAndHAL3Support> mDeviceStatusMap;

    std::map<DeviceStatusMapKey, Status> mDeviceStatusMap;



    // For the singleton instance

    static Mutex sLock;

camera/tests/CameraBinderTests.cpp

+0 −9
Original line number Diff line number Diff line
@@ -389,15 +389,6 @@ TEST(CameraServiceBinderTest, CheckBinderCameraService) { 


    for (int32_t i = 0; i < numCameras; i++) {

        std::string cameraId = std::to_string(i);

        bool isSupported = false;

        res = service->supportsCameraApi(cameraId,

                hardware::ICameraService::API_VERSION_2, &isSupported);

        EXPECT_TRUE(res.isOk()) << res;



        // We only care about binder calls for the Camera2 API.  Camera1 is deprecated.

        if (!isSupported) {

            continue;

        }



        // Check metadata binder call

        CameraMetadata metadata;

camera/tests/CameraCharacteristicsPermission.cpp

+1 −8
Original line number Diff line number Diff line
@@ -66,19 +66,12 @@ void CameraCharacteristicsPermission::TearDown() { 
TEST_F(CameraCharacteristicsPermission, TestCameraPermission) {

    for (int32_t cameraId = 0; cameraId < numCameras; cameraId++) {

        std::string cameraIdStr = std::to_string(cameraId);

        bool isSupported = false;

        auto rc = mCameraService->supportsCameraApi(cameraIdStr,

                hardware::ICameraService::API_VERSION_2, &isSupported);

        EXPECT_TRUE(rc.isOk());

        if (!isSupported) {

            continue;

        }



        CameraMetadata metadata;

        std::vector<int32_t> tagsNeedingPermission;

        AttributionSourceState clientAttribution;

        clientAttribution.deviceId = kDefaultDeviceId;

        rc = mCameraService->getCameraCharacteristics(cameraIdStr,

        auto rc = mCameraService->getCameraCharacteristics(cameraIdStr,

                /*targetSdkVersion*/__ANDROID_API_FUTURE__,

                /*overrideToPortrait*/false, clientAttribution, /*devicePolicy*/0, &metadata);

        ASSERT_TRUE(rc.isOk());