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

Commit 6a68ac51 authored by android-build-team Robot's avatar android-build-team Robot
Browse files

Snap for 5657398 from 48eb9b80 to qt-c2f2-release 

Change-Id: I3cad61b3a4ec4b17e163131a7318d38a5a89f54e
parents 7cd15220 48eb9b80

camera/ndk/ndk_vendor/tests/AImageReaderVendorTest.cpp

+55 −28
Original line number Diff line number Diff line
@@ -24,6 +24,7 @@ 
#include <algorithm>

#include <mutex>

#include <string>

#include <variant>

#include <vector>

#include <stdio.h>

#include <stdio.h>
@@ -49,6 +50,7 @@ static constexpr int kTestImageHeight = 480; 
static constexpr int kTestImageFormat = AIMAGE_FORMAT_YUV_420_888;



using android::hardware::camera::common::V1_0::helper::VendorTagDescriptorCache;

using ConfiguredWindows = std::set<native_handle_t *>;



class CameraHelper {

   public:
@@ -60,9 +62,12 @@ class CameraHelper { 
        const char* physicalCameraId;

        native_handle_t* anw;

    };

    int initCamera(native_handle_t* imgReaderAnw,



    // Retaining the error code in case the caller needs to analyze it.

    std::variant<int, ConfiguredWindows> initCamera(native_handle_t* imgReaderAnw,

            const std::vector<PhysicalImgReaderInfo>& physicalImgReaders,

            bool usePhysicalSettings) {

        ConfiguredWindows configuredWindows;

        if (imgReaderAnw == nullptr) {

            ALOGE("Cannot initialize camera before image reader get initialized.");

            return -1;
@@ -78,7 +83,7 @@ class CameraHelper { 
        ret = ACameraManager_openCamera(mCameraManager, mCameraId, &mDeviceCb, &mDevice);

        if (ret != AMEDIA_OK || mDevice == nullptr) {

            ALOGE("Failed to open camera, ret=%d, mDevice=%p.", ret, mDevice);

            return -1;

            return ret;

        }



        // Create capture session
@@ -97,8 +102,9 @@ class CameraHelper { 
            ALOGE("ACaptureSessionOutputContainer_add failed, ret=%d", ret);

            return ret;

        }



        configuredWindows.insert(mImgReaderAnw);

        std::vector<const char*> idPointerList;

        std::set<const native_handle_t*> physicalStreamMap;

        for (auto& physicalStream : physicalImgReaders) {

            ACaptureSessionOutput* sessionOutput = nullptr;

            ret = ACaptureSessionPhysicalOutput_create(physicalStream.anw,
@@ -112,21 +118,25 @@ class CameraHelper { 
                ALOGE("ACaptureSessionOutputContainer_add failed, ret=%d", ret);

                return ret;

            }

            mExtraOutputs.push_back(sessionOutput);

            ret = ACameraDevice_isSessionConfigurationSupported(mDevice, mOutputs);

            if (ret != ACAMERA_OK && ret != ACAMERA_ERROR_UNSUPPORTED_OPERATION) {

                ALOGW("ACameraDevice_isSessionConfigurationSupported failed, ret=%d camera id %s",

                      ret, mCameraId);

                ACaptureSessionOutputContainer_remove(mOutputs, sessionOutput);

                ACaptureSessionOutput_free(sessionOutput);

                continue;

            }

            configuredWindows.insert(physicalStream.anw);

            // Assume that at most one physical stream per physical camera.

            mPhysicalCameraIds.push_back(physicalStream.physicalCameraId);

            idPointerList.push_back(physicalStream.physicalCameraId);

            physicalStreamMap.insert(physicalStream.anw);

            mSessionPhysicalOutputs.push_back(sessionOutput);

        }

        ACameraIdList cameraIdList;

        cameraIdList.numCameras = idPointerList.size();

        cameraIdList.cameraIds = idPointerList.data();



        ret = ACameraDevice_isSessionConfigurationSupported(mDevice, mOutputs);

        if (ret != ACAMERA_OK && ret != ACAMERA_ERROR_UNSUPPORTED_OPERATION) {

            ALOGE("ACameraDevice_isSessionConfigurationSupported failed, ret=%d", ret);

            return ret;

        }



        ret = ACameraDevice_createCaptureSession(mDevice, mOutputs, &mSessionCb, &mSession);

        if (ret != AMEDIA_OK) {

            ALOGE("ACameraDevice_createCaptureSession failed, ret=%d", ret);
@@ -157,6 +167,10 @@ class CameraHelper { 
        }



        for (auto& physicalStream : physicalImgReaders) {

            if (physicalStreamMap.find(physicalStream.anw) == physicalStreamMap.end()) {

                ALOGI("Skipping physicalStream anw=%p", physicalStream.anw);

                continue;

            }

            ACameraOutputTarget* outputTarget = nullptr;

            ret = ACameraOutputTarget_create(physicalStream.anw, &outputTarget);

            if (ret != AMEDIA_OK) {
@@ -168,11 +182,11 @@ class CameraHelper { 
                ALOGE("ACaptureRequest_addTarget failed, ret=%d", ret);

                return ret;

            }

            mReqExtraOutputs.push_back(outputTarget);

            mReqPhysicalOutputs.push_back(outputTarget);

        }



        mIsCameraReady = true;

        return 0;

        return configuredWindows;

    }
@@ -184,10 +198,10 @@ class CameraHelper { 
            ACameraOutputTarget_free(mReqImgReaderOutput);

            mReqImgReaderOutput = nullptr;

        }

        for (auto& outputTarget : mReqExtraOutputs) {

        for (auto& outputTarget : mReqPhysicalOutputs) {

            ACameraOutputTarget_free(outputTarget);

        }

        mReqExtraOutputs.clear();

        mReqPhysicalOutputs.clear();

        if (mStillRequest) {

            ACaptureRequest_free(mStillRequest);

            mStillRequest = nullptr;
@@ -201,10 +215,10 @@ class CameraHelper { 
            ACaptureSessionOutput_free(mImgReaderOutput);

            mImgReaderOutput = nullptr;

        }

        for (auto& extraOutput : mExtraOutputs) {

        for (auto& extraOutput : mSessionPhysicalOutputs) {

            ACaptureSessionOutput_free(extraOutput);

        }

        mExtraOutputs.clear();

        mSessionPhysicalOutputs.clear();

        if (mOutputs) {

            ACaptureSessionOutputContainer_free(mOutputs);

            mOutputs = nullptr;
@@ -262,13 +276,13 @@ class CameraHelper { 
    // Capture session

    ACaptureSessionOutputContainer* mOutputs = nullptr;

    ACaptureSessionOutput* mImgReaderOutput = nullptr;

    std::vector<ACaptureSessionOutput*> mExtraOutputs;

    std::vector<ACaptureSessionOutput*> mSessionPhysicalOutputs;



    ACameraCaptureSession* mSession = nullptr;

    // Capture request

    ACaptureRequest* mStillRequest = nullptr;

    ACameraOutputTarget* mReqImgReaderOutput = nullptr;

    std::vector<ACameraOutputTarget*> mReqExtraOutputs;

    std::vector<ACameraOutputTarget*> mReqPhysicalOutputs;



    bool mIsCameraReady = false;

    const char* mCameraId;
@@ -581,9 +595,11 @@ class AImageReaderVendorTest : public ::testing::Test { 
        }



        CameraHelper cameraHelper(id, mCameraManager);

        ret = cameraHelper.initCamera(testCase.getNativeWindow(),

                {}/*physicalImageReaders*/, false/*usePhysicalSettings*/);

        if (ret < 0) {

        std::variant<int, ConfiguredWindows> retInit =

                cameraHelper.initCamera(testCase.getNativeWindow(), {}/*physicalImageReaders*/,

                                        false/*usePhysicalSettings*/);

        int *retp = std::get_if<int>(&retInit);

        if (retp) {

            ALOGE("Unable to initialize camera helper");

            return false;

        }
@@ -751,10 +767,15 @@ class AImageReaderVendorTest : public ::testing::Test { 
        physicalImgReaderInfo.push_back({physicalCameraIds[0], testCases[1]->getNativeWindow()});

        physicalImgReaderInfo.push_back({physicalCameraIds[1], testCases[2]->getNativeWindow()});



        int ret = cameraHelper.initCamera(testCases[0]->getNativeWindow(),

                physicalImgReaderInfo, usePhysicalSettings);

        ASSERT_EQ(ret, 0);



        std::variant<int, ConfiguredWindows> retInit =

                cameraHelper.initCamera(testCases[0]->getNativeWindow(), physicalImgReaderInfo,

                                        usePhysicalSettings);

        int *retp = std::get_if<int>(&retInit);

        ASSERT_EQ(retp, nullptr);

        ConfiguredWindows *configuredWindowsp = std::get_if<ConfiguredWindows>(&retInit);

        ASSERT_NE(configuredWindowsp, nullptr);

        ASSERT_LE(configuredWindowsp->size(), testCases.size());

        int ret = 0;

        if (!cameraHelper.isCameraReady()) {

            ALOGW("Camera is not ready after successful initialization. It's either due to camera "

                  "on board lacks BACKWARDS_COMPATIBLE capability or the device does not have "
@@ -776,9 +797,15 @@ class AImageReaderVendorTest : public ::testing::Test { 
                break;

            }

        }

        ASSERT_EQ(testCases[0]->getAcquiredImageCount(), pictureCount);

        ASSERT_EQ(testCases[1]->getAcquiredImageCount(), pictureCount);

        ASSERT_EQ(testCases[2]->getAcquiredImageCount(), pictureCount);

        for(auto &testCase : testCases) {

            auto it = configuredWindowsp->find(testCase->getNativeWindow());

            if (it == configuredWindowsp->end()) {

                continue;

            }

            ALOGI("Testing window %p", testCase->getNativeWindow());

            ASSERT_EQ(testCase->getAcquiredImageCount(), pictureCount);

        }



        ASSERT_TRUE(cameraHelper.checkCallbacks(pictureCount));



        ACameraMetadata_free(staticMetadata);

media/libaudioclient/AudioSystem.cpp

+7 −0
Original line number Diff line number Diff line
@@ -1512,6 +1512,13 @@ status_t AudioSystem::getVolumeGroupFromAudioAttributes(const AudioAttributes &a 
    return aps->getVolumeGroupFromAudioAttributes(aa, volumeGroup);

}



status_t AudioSystem::setRttEnabled(bool enabled)

{

    const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();

    if (aps == 0) return PERMISSION_DENIED;

    return aps->setRttEnabled(enabled);

}



// ---------------------------------------------------------------------------



int AudioSystem::AudioPolicyServiceClient::addAudioPortCallback(

media/libaudioclient/IAudioPolicyService.cpp

+23 −1
Original line number Diff line number Diff line
@@ -104,6 +104,7 @@ enum { 
    GET_VOLUME_GROUP_FOR_ATTRIBUTES,

    SET_ALLOWED_CAPTURE_POLICY,

    MOVE_EFFECTS_TO_IO,

    SET_RTT_ENABLED

};



#define MAX_ITEMS_PER_LIST 1024
@@ -1271,6 +1272,18 @@ public: 
        volumeGroup = static_cast<volume_group_t>(reply.readInt32());

        return NO_ERROR;

    }



    virtual status_t setRttEnabled(bool enabled)

    {

        Parcel data, reply;

        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());

        data.writeInt32(static_cast<int32_t>(enabled));

        status_t status = remote()->transact(SET_RTT_ENABLED, data, &reply);

        if (status != NO_ERROR) {

           return status;

        }

        return static_cast<status_t>(reply.readInt32());

    }

};



IMPLEMENT_META_INTERFACE(AudioPolicyService, "android.media.IAudioPolicyService");
@@ -1332,7 +1345,8 @@ status_t BnAudioPolicyService::onTransact( 
        case REMOVE_UID_DEVICE_AFFINITY:

        case GET_OFFLOAD_FORMATS_A2DP:

        case LIST_AUDIO_VOLUME_GROUPS:

        case GET_VOLUME_GROUP_FOR_ATTRIBUTES: {

        case GET_VOLUME_GROUP_FOR_ATTRIBUTES:

        case SET_RTT_ENABLED: {

            if (!isServiceUid(IPCThreadState::self()->getCallingUid())) {

                ALOGW("%s: transaction %d received from PID %d unauthorized UID %d",

                      __func__, code, IPCThreadState::self()->getCallingPid(),
@@ -2347,6 +2361,14 @@ status_t BnAudioPolicyService::onTransact( 
            return NO_ERROR;

        }



        case SET_RTT_ENABLED: {

            CHECK_INTERFACE(IAudioPolicyService, data, reply);

            bool enabled = static_cast<bool>(data.readInt32());

            status_t status = setRttEnabled(enabled);

            reply->writeInt32(status);

            return NO_ERROR;

        }



        default:

            return BBinder::onTransact(code, data, reply, flags);

    }

media/libaudioclient/include/media/AudioSystem.h

+2 −0
Original line number Diff line number Diff line
@@ -394,6 +394,8 @@ public: 
    static status_t getVolumeGroupFromAudioAttributes(const AudioAttributes &aa,

                                                      volume_group_t &volumeGroup);



    static status_t setRttEnabled(bool enabled);



    // ----------------------------------------------------------------------------



    class AudioVolumeGroupCallback : public RefBase

media/libaudioclient/include/media/IAudioPolicyService.h

+2 −0
Original line number Diff line number Diff line
@@ -220,6 +220,8 @@ public: 
    virtual status_t listAudioVolumeGroups(AudioVolumeGroupVector &groups) = 0;

    virtual status_t getVolumeGroupFromAudioAttributes(const AudioAttributes &aa,

                                                       volume_group_t &volumeGroup) = 0;



    virtual status_t setRttEnabled(bool enabled) = 0;

};