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

Commit 71109da4 authored by Ytai Ben-Tsvi's avatar Ytai Ben-Tsvi
Browse files

Make IAudioRecord pure (stable) AIDL 

The MicrophoneInfo type has manual parceling. Converted to AIDL.
This required exposing a private method from the AidlConversion module
as well as making some changes in build files.

As part of the process, also modernized MicrophoneInfo to use standard
library types instead of Vector and String16.

Another thing that's happening here is that av-headers is now defined
as a standard Soong module, so that we can list its dependencies.

Test: Audio-related CTS tests from CtsMediaTestCases
Change-Id: I6d50d411c59987b7d3561f97ee94baa1b306e21d
parent bdc293ab

Android.bp

+26 −0
Original line number Diff line number Diff line
@@ -8,6 +8,7 @@ aidl_interface { 
    srcs: [

        "aidl/android/media/InterpolatorConfig.aidl",

        "aidl/android/media/InterpolatorType.aidl",

        "aidl/android/media/MicrophoneInfoData.aidl",

        "aidl/android/media/VolumeShaperConfiguration.aidl",

        "aidl/android/media/VolumeShaperConfigurationOptionFlag.aidl",

        "aidl/android/media/VolumeShaperConfigurationType.aidl",
@@ -20,8 +21,33 @@ aidl_interface { 
            min_sdk_version: "29",

            apex_available: [

                "//apex_available:platform",

                "com.android.bluetooth.updatable",

                "com.android.media",

                "com.android.media.swcodec",

            ],

        },

    },

}



cc_library_headers {

    name: "av-headers",

    export_include_dirs: ["include"],

    static_libs: [

        "av-types-aidl-unstable-cpp",

        "libaudioclient_aidl_conversion",

    ],

    export_static_lib_headers: [

        "av-types-aidl-unstable-cpp",

        "libaudioclient_aidl_conversion",

    ],

    host_supported: true,

    vendor_available: true,

    double_loadable: true,

    min_sdk_version: "29",

    apex_available: [

        "//apex_available:platform",

        "com.android.bluetooth.updatable",

        "com.android.media",

        "com.android.media.swcodec",

    ],

}

media/libaudioclient/aidl/android/media/MicrophoneInfo.aidl→aidl/android/media/MicrophoneInfoData.aidl

+22 −2
Original line number Diff line number Diff line 
/*

 * Copyright 2018 The Android Open Source Project

 * Copyright 2020 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.
@@ -16,4 +16,24 @@ 


package android.media;



parcelable MicrophoneInfo cpp_header "media/MicrophoneInfo.h";
 
/**

 * {@hide}

 */

parcelable MicrophoneInfoData {

    @utf8InCpp String deviceId;

    int portId;

    int type;

    @utf8InCpp String address;

    int deviceLocation;

    int deviceGroup;

    int indexInTheGroup;

    float[] geometricLocation;

    float[] orientation;

    float[] frequencies;

    float[] frequencyResponses;

    int[] channelMapping;

    float sensitivity;

    float maxSpl;

    float minSpl;

    int directionality;

}

include/media/MicrophoneInfo.h

+76 −102
Original line number Diff line number Diff line
@@ -17,33 +17,31 @@ 
#ifndef ANDROID_MICROPHONE_INFO_H

#define ANDROID_MICROPHONE_INFO_H



#include <android/media/MicrophoneInfoData.h>

#include <binder/Parcel.h>

#include <binder/Parcelable.h>

#include <media/AidlConversion.h>

#include <system/audio.h>

#include <utils/String16.h>

#include <utils/Vector.h>



namespace android {

namespace media {



#define RETURN_IF_FAILED(calledOnce)                                     \

    {                                                                    \

        status_t returnStatus = calledOnce;                              \

        if (returnStatus) {                                              \

            ALOGE("Failed at %s:%d (%s)", __FILE__, __LINE__, __func__); \

            return returnStatus;                                         \

         }                                                               \

    }

#define VALUE_OR_RETURN_STATUS(exp)          \

    ({                                       \

        auto _tmp = (exp);                   \

        if (!_tmp.ok()) return _tmp.error(); \

        std::move(_tmp.value());             \

    })



class MicrophoneInfo : public Parcelable {

public:

    MicrophoneInfo() = default;

    MicrophoneInfo(const MicrophoneInfo& microphoneInfo) = default;

    MicrophoneInfo(audio_microphone_characteristic_t& characteristic) {

        mDeviceId = String16(&characteristic.device_id[0]);

        mDeviceId = std::string(&characteristic.device_id[0]);

        mPortId = characteristic.id;

        mType = characteristic.device;

        mAddress = String16(&characteristic.address[0]);

        mAddress = std::string(&characteristic.address[0]);

        mDeviceLocation = characteristic.location;

        mDeviceGroup = characteristic.group;

        mIndexInTheGroup = characteristic.index_in_the_group;
@@ -53,8 +51,8 @@ public: 
        mOrientation.push_back(characteristic.orientation.x);

        mOrientation.push_back(characteristic.orientation.y);

        mOrientation.push_back(characteristic.orientation.z);

        Vector<float> frequencies;

        Vector<float> responses;

        std::vector<float> frequencies;

        std::vector<float> responses;

        for (size_t i = 0; i < characteristic.num_frequency_responses; i++) {

            frequencies.push_back(characteristic.frequency_responses[0][i]);

            responses.push_back(characteristic.frequency_responses[1][i]);
@@ -73,76 +71,73 @@ public: 
    virtual ~MicrophoneInfo() = default;



    virtual status_t writeToParcel(Parcel* parcel) const {

        RETURN_IF_FAILED(parcel->writeString16(mDeviceId));

        RETURN_IF_FAILED(parcel->writeInt32(mPortId));

        RETURN_IF_FAILED(parcel->writeUint32(mType));

        RETURN_IF_FAILED(parcel->writeString16(mAddress));

        RETURN_IF_FAILED(parcel->writeInt32(mDeviceLocation));

        RETURN_IF_FAILED(parcel->writeInt32(mDeviceGroup));

        RETURN_IF_FAILED(parcel->writeInt32(mIndexInTheGroup));

        RETURN_IF_FAILED(writeFloatVector(parcel, mGeometricLocation));

        RETURN_IF_FAILED(writeFloatVector(parcel, mOrientation));

        MicrophoneInfoData parcelable;

        return writeToParcelable(&parcelable)

               ?: parcelable.writeToParcel(parcel);

    }



    virtual status_t writeToParcelable(MicrophoneInfoData* parcelable) const {

        parcelable->deviceId = mDeviceId;

        parcelable->portId = mPortId;

        parcelable->type = VALUE_OR_RETURN_STATUS(convertReinterpret<int32_t>(mType));

        parcelable->address = mAddress;

        parcelable->deviceGroup = mDeviceGroup;

        parcelable->indexInTheGroup = mIndexInTheGroup;

        parcelable->geometricLocation = mGeometricLocation;

        parcelable->orientation = mOrientation;

        if (mFrequencyResponses.size() != 2) {

            return BAD_VALUE;

        }

        for (size_t i = 0; i < mFrequencyResponses.size(); i++) {

            RETURN_IF_FAILED(parcel->writeInt32(mFrequencyResponses[i].size()));

            RETURN_IF_FAILED(writeFloatVector(parcel, mFrequencyResponses[i]));

        }

        std::vector<int> channelMapping;

        for (size_t i = 0; i < mChannelMapping.size(); ++i) {

            channelMapping.push_back(mChannelMapping[i]);

        }

        RETURN_IF_FAILED(parcel->writeInt32Vector(channelMapping));

        RETURN_IF_FAILED(parcel->writeFloat(mSensitivity));

        RETURN_IF_FAILED(parcel->writeFloat(mMaxSpl));

        RETURN_IF_FAILED(parcel->writeFloat(mMinSpl));

        RETURN_IF_FAILED(parcel->writeInt32(mDirectionality));

        parcelable->frequencies = mFrequencyResponses[0];

        parcelable->frequencyResponses = mFrequencyResponses[1];

        parcelable->channelMapping = mChannelMapping;

        parcelable->sensitivity = mSensitivity;

        parcelable->maxSpl = mMaxSpl;

        parcelable->minSpl = mMinSpl;

        parcelable->directionality = mDirectionality;

        return OK;

    }



    virtual status_t readFromParcel(const Parcel* parcel) {

        RETURN_IF_FAILED(parcel->readString16(&mDeviceId));

        RETURN_IF_FAILED(parcel->readInt32(&mPortId));

        RETURN_IF_FAILED(parcel->readUint32(&mType));

        RETURN_IF_FAILED(parcel->readString16(&mAddress));

        RETURN_IF_FAILED(parcel->readInt32(&mDeviceLocation));

        RETURN_IF_FAILED(parcel->readInt32(&mDeviceGroup));

        RETURN_IF_FAILED(parcel->readInt32(&mIndexInTheGroup));

        RETURN_IF_FAILED(readFloatVector(parcel, &mGeometricLocation, 3));

        RETURN_IF_FAILED(readFloatVector(parcel, &mOrientation, 3));

        int32_t frequenciesNum;

        RETURN_IF_FAILED(parcel->readInt32(&frequenciesNum));

        Vector<float> frequencies;

        RETURN_IF_FAILED(readFloatVector(parcel, &frequencies, frequenciesNum));

        int32_t responsesNum;

        RETURN_IF_FAILED(parcel->readInt32(&responsesNum));

        Vector<float> responses;

        RETURN_IF_FAILED(readFloatVector(parcel, &responses, responsesNum));

        if (frequencies.size() != responses.size()) {

        MicrophoneInfoData data;

        return data.readFromParcel(parcel)

            ?: readFromParcelable(data);

    }



    virtual status_t readFromParcelable(const MicrophoneInfoData& parcelable) {

        mDeviceId = parcelable.deviceId;

        mPortId = parcelable.portId;

        mType = VALUE_OR_RETURN_STATUS(convertReinterpret<uint32_t>(parcelable.type));

        mAddress = parcelable.address;

        mDeviceLocation = parcelable.deviceLocation;

        mDeviceGroup = parcelable.deviceGroup;

        mIndexInTheGroup = parcelable.indexInTheGroup;

        if (parcelable.geometricLocation.size() != 3) {

            return BAD_VALUE;

        }

        mFrequencyResponses.push_back(frequencies);

        mFrequencyResponses.push_back(responses);

        std::vector<int> channelMapping;

        status_t result = parcel->readInt32Vector(&channelMapping);

        if (result != OK) {

            return result;

        mGeometricLocation = parcelable.geometricLocation;

        if (parcelable.orientation.size() != 3) {

            return BAD_VALUE;

        }

        if (channelMapping.size() != AUDIO_CHANNEL_COUNT_MAX) {

        mOrientation = parcelable.orientation;

        if (parcelable.frequencies.size() != parcelable.frequencyResponses.size()) {

            return BAD_VALUE;

        }

        for (size_t i = 0; i < channelMapping.size(); i++) {

            mChannelMapping.push_back(channelMapping[i]);



        mFrequencyResponses.push_back(parcelable.frequencies);

        mFrequencyResponses.push_back(parcelable.frequencyResponses);

        if (parcelable.channelMapping.size() != AUDIO_CHANNEL_COUNT_MAX) {

            return BAD_VALUE;

        }

        RETURN_IF_FAILED(parcel->readFloat(&mSensitivity));

        RETURN_IF_FAILED(parcel->readFloat(&mMaxSpl));

        RETURN_IF_FAILED(parcel->readFloat(&mMinSpl));

        RETURN_IF_FAILED(parcel->readInt32(&mDirectionality));

        mChannelMapping = parcelable.channelMapping;

        mSensitivity = parcelable.sensitivity;

        mMaxSpl = parcelable.maxSpl;

        mMinSpl = parcelable.minSpl;

        mDirectionality = parcelable.directionality;

        return OK;

    }



    String16 getDeviceId() const {

    std::string getDeviceId() const {

        return mDeviceId;

    }
@@ -154,7 +149,7 @@ public: 
        return mType;

    }



    String16 getAddress() const {

    std::string getAddress() const {

        return mAddress;

    }
@@ -170,19 +165,19 @@ public: 
        return mIndexInTheGroup;

    }



    const Vector<float>& getGeometricLocation() const {

    const std::vector<float>& getGeometricLocation() const {

        return mGeometricLocation;

    }



    const Vector<float>& getOrientation() const {

    const std::vector<float>& getOrientation() const {

        return mOrientation;

    }



    const Vector<Vector<float>>& getFrequencyResponses() const {

    const std::vector<std::vector<float>>& getFrequencyResponses() const {

        return mFrequencyResponses;

    }



    const Vector<int>& getChannelMapping() const {

    const std::vector<int>& getChannelMapping() const {

        return mChannelMapping;

    }
@@ -203,46 +198,25 @@ public: 
    }



private:

    status_t readFloatVector(

            const Parcel* parcel, Vector<float> *vectorPtr, size_t defaultLength) {

        std::optional<std::vector<float>> v;

        status_t result = parcel->readFloatVector(&v);

        if (result != OK) return result;

        vectorPtr->clear();

        if (v) {

            for (const auto& iter : *v) {

                vectorPtr->push_back(iter);

            }

        } else {

            vectorPtr->resize(defaultLength);

        }

        return OK;

    }

    status_t writeFloatVector(Parcel* parcel, const Vector<float>& vector) const {

        std::vector<float> v;

        for (size_t i = 0; i < vector.size(); i++) {

            v.push_back(vector[i]);

        }

        return parcel->writeFloatVector(v);

    }



    String16 mDeviceId;

    std::string mDeviceId;

    int32_t mPortId;

    uint32_t mType;

    String16 mAddress;

    std::string mAddress;

    int32_t mDeviceLocation;

    int32_t mDeviceGroup;

    int32_t mIndexInTheGroup;

    Vector<float> mGeometricLocation;

    Vector<float> mOrientation;

    Vector<Vector<float>> mFrequencyResponses;

    Vector<int> mChannelMapping;

    std::vector<float> mGeometricLocation;

    std::vector<float> mOrientation;

    std::vector<std::vector<float>> mFrequencyResponses;

    std::vector<int> mChannelMapping;

    float mSensitivity;

    float mMaxSpl;

    float mMinSpl;

    int32_t mDirectionality;

};



#undef VALUE_OR_RETURN_STATUS



} // namespace media

} // namespace android

media/libaudioclient/AidlConversion.cpp

+0 −6
Original line number Diff line number Diff line
@@ -135,12 +135,6 @@ ConversionResult<UnionFieldType<T, tag>> unionGetField(const T& u) { 


////////////////////////////////////////////////////////////////////////////////////////////////////



template<typename To, typename From>

ConversionResult<To> convertReinterpret(From from) {

    static_assert(sizeof(From) == sizeof(To));

    return static_cast<To>(from);

}



enum class Direction {

    INPUT, OUTPUT

};

media/libaudioclient/Android.bp

+14 −14
Original line number Diff line number Diff line
@@ -73,7 +73,6 @@ cc_library_shared { 
        // AIDL files for audioclient interfaces

        // The headers for these interfaces will be available to any modules that

        // include libaudioclient, at the path "aidl/package/path/BnFoo.h"

        ":libaudioclient_aidl_private",

        ":libaudioclient_aidl",



        "AudioEffect.cpp",
@@ -154,10 +153,14 @@ cc_library_shared { 
    },

}



cc_library_shared {

cc_library {

    name: "libaudioclient_aidl_conversion",

    srcs: ["AidlConversion.cpp"],

    local_include_dirs: ["include"],

    export_include_dirs: ["include"],

    host_supported: true,

    vendor_available: true,

    double_loadable: true,

    min_sdk_version: "29",

    shared_libs: [

        "audioclient-types-aidl-unstable-cpp",

        "libbase",
@@ -183,6 +186,12 @@ cc_library_shared { 
            "signed-integer-overflow",

        ],

    },

    apex_available: [

        "//apex_available:platform",

        "com.android.bluetooth.updatable",

        "com.android.media",

        "com.android.media.swcodec",

    ],

}



// AIDL interface between libaudioclient and framework.jar
@@ -194,16 +203,6 @@ filegroup { 
    path: "aidl",

}



// Used to strip the "aidl/" from the path, so the build system can predict the

// output filename.

filegroup {

    name: "libaudioclient_aidl_private",

    srcs: [

        "aidl/android/media/IAudioRecord.aidl",

    ],

    path: "aidl",

}



aidl_interface {

    name: "capture_state_listener-aidl",

    unstable: true,
@@ -291,6 +290,7 @@ aidl_interface { 
        "aidl/android/media/CreateTrackResponse.aidl",



        "aidl/android/media/IAudioFlingerClient.aidl",

        "aidl/android/media/IAudioRecord.aidl",

        "aidl/android/media/IAudioTrack.aidl",

        "aidl/android/media/IAudioTrackCallback.aidl",

    ],