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

Commit f9cddbfe authored by TreeHugger Robot's avatar TreeHugger Robot Committed by Android (Google) Code Review
Browse files

Merge changes from topics "devicesRoleForStrategy", "useAudioDevicesTypeAddrVector" 

* changes:
  Introduce device(s) role for strategy.
  Use AudioDeviceTypeAddrVector instead of Vector<AudioDeviceTypeAddr>
parents 242cf337 0a488938

media/libaudioclient/AudioSystem.cpp

+12 −10
Original line number Diff line number Diff line
@@ -1362,7 +1362,7 @@ status_t AudioSystem::registerPolicyMixes(const Vector<AudioMix>& mixes, bool re 
    return aps->registerPolicyMixes(mixes, registration);

}



status_t AudioSystem::setUidDeviceAffinities(uid_t uid, const Vector<AudioDeviceTypeAddr>& devices)

status_t AudioSystem::setUidDeviceAffinities(uid_t uid, const AudioDeviceTypeAddrVector& devices)

{

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

    if (aps == 0) return PERMISSION_DENIED;
@@ -1376,7 +1376,7 @@ status_t AudioSystem::removeUidDeviceAffinities(uid_t uid) { 
}



status_t AudioSystem::setUserIdDeviceAffinities(int userId,

                                                const Vector<AudioDeviceTypeAddr>& devices)

                                                const AudioDeviceTypeAddrVector& devices)

{

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

    if (aps == 0) return PERMISSION_DENIED;
@@ -1603,33 +1603,35 @@ bool AudioSystem::isCallScreenModeSupported() 
    return aps->isCallScreenModeSupported();

}



status_t AudioSystem::setPreferredDeviceForStrategy(product_strategy_t strategy,

                                                    const AudioDeviceTypeAddr &device)

status_t AudioSystem::setDevicesRoleForStrategy(product_strategy_t strategy,

                                                device_role_t role,

                                                const AudioDeviceTypeAddrVector &devices)

{

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

    if (aps == 0) {

        return PERMISSION_DENIED;

    }

    return aps->setPreferredDeviceForStrategy(strategy, device);

    return aps->setDevicesRoleForStrategy(strategy, role, devices);

}



status_t AudioSystem::removePreferredDeviceForStrategy(product_strategy_t strategy)

status_t AudioSystem::removeDevicesRoleForStrategy(product_strategy_t strategy, device_role_t role)

{

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

    if (aps == 0) {

        return PERMISSION_DENIED;

    }

    return aps->removePreferredDeviceForStrategy(strategy);

    return aps->removeDevicesRoleForStrategy(strategy, role);

}



status_t AudioSystem::getPreferredDeviceForStrategy(product_strategy_t strategy,

        AudioDeviceTypeAddr &device)

status_t AudioSystem::getDevicesForRoleAndStrategy(product_strategy_t strategy,

                                                   device_role_t role,

                                                   AudioDeviceTypeAddrVector &devices)

{

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

    if (aps == 0) {

        return PERMISSION_DENIED;

    }

    return aps->getPreferredDeviceForStrategy(strategy, device);

    return aps->getDevicesForRoleAndStrategy(strategy, role, devices);

}



class CaptureStateListenerImpl : public media::BnCaptureStateListener,

media/libaudioclient/IAudioPolicyService.cpp

+71 −99
Original line number Diff line number Diff line
@@ -112,9 +112,9 @@ enum { 
    MOVE_EFFECTS_TO_IO,

    SET_RTT_ENABLED,

    IS_CALL_SCREEN_MODE_SUPPORTED,

    SET_PREFERRED_DEVICE_FOR_PRODUCT_STRATEGY,

    REMOVE_PREFERRED_DEVICE_FOR_PRODUCT_STRATEGY,

    GET_PREFERRED_DEVICE_FOR_PRODUCT_STRATEGY,

    SET_DEVICES_ROLE_FOR_PRODUCT_STRATEGY,

    REMOVE_DEVICES_ROLE_FOR_PRODUCT_STRATEGY,

    GET_DEVICES_FOR_ROLE_AND_PRODUCT_STRATEGY,

    GET_DEVICES_FOR_ATTRIBUTES,

    AUDIO_MODULES_UPDATED,  // oneway

    SET_CURRENT_IME_UID,
@@ -1173,31 +1173,18 @@ public: 
        return reply.readBool();

    }



    virtual status_t setUidDeviceAffinities(uid_t uid, const Vector<AudioDeviceTypeAddr>& devices)

    virtual status_t setUidDeviceAffinities(uid_t uid, const AudioDeviceTypeAddrVector& devices)

    {

        Parcel data, reply;

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



        data.writeInt32((int32_t) uid);

        size_t size = devices.size();

        size_t sizePosition = data.dataPosition();

        data.writeInt32((int32_t) size);

        size_t finalSize = size;

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

            size_t position = data.dataPosition();

            if (devices[i].writeToParcel(&data) != NO_ERROR) {

                data.setDataPosition(position);

                finalSize--;

            }

        }

        if (size != finalSize) {

            size_t position = data.dataPosition();

            data.setDataPosition(sizePosition);

            data.writeInt32(finalSize);

            data.setDataPosition(position);

        status_t status = data.writeParcelableVector(devices);

        if (status != NO_ERROR) {

            return status;

        }



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

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

        if (status == NO_ERROR) {

            status = (status_t)reply.readInt32();

        }
@@ -1218,32 +1205,18 @@ public: 
        return status;

    }



        virtual status_t setUserIdDeviceAffinities(int userId,

                const Vector<AudioDeviceTypeAddr>& devices)

    virtual status_t setUserIdDeviceAffinities(int userId, const AudioDeviceTypeAddrVector& devices)

    {

        Parcel data, reply;

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



        data.writeInt32((int32_t) userId);

            size_t size = devices.size();

            size_t sizePosition = data.dataPosition();

            data.writeInt32((int32_t) size);

            size_t finalSize = size;

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

                size_t position = data.dataPosition();

                if (devices[i].writeToParcel(&data) != NO_ERROR) {

                    data.setDataPosition(position);

                    finalSize--;

                }

            }

            if (size != finalSize) {

                size_t position = data.dataPosition();

                data.setDataPosition(sizePosition);

                data.writeInt32(finalSize);

                data.setDataPosition(position);

        status_t status = data.writeParcelableVector(devices);

        if (status != NO_ERROR) {

            return status;

        }



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

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

        if (status == NO_ERROR) {

            status = (status_t)reply.readInt32();

        }
@@ -1384,30 +1357,31 @@ public: 
        return reply.readBool();

    }



    virtual status_t setPreferredDeviceForStrategy(product_strategy_t strategy,

            const AudioDeviceTypeAddr &device)

    virtual status_t setDevicesRoleForStrategy(product_strategy_t strategy,

            device_role_t role, const AudioDeviceTypeAddrVector &devices)

    {

        Parcel data, reply;

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

        data.writeUint32(static_cast<uint32_t>(strategy));

        status_t status = device.writeToParcel(&data);

        data.writeUint32(static_cast<uint32_t>(role));

        status_t status = data.writeParcelableVector(devices);

        if (status != NO_ERROR) {

            return BAD_VALUE;

        }

        status = remote()->transact(SET_PREFERRED_DEVICE_FOR_PRODUCT_STRATEGY,

                data, &reply);

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

        if (status != NO_ERROR) {

           return status;

        }

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

    }



    virtual status_t removePreferredDeviceForStrategy(product_strategy_t strategy)

    virtual status_t removeDevicesRoleForStrategy(product_strategy_t strategy, device_role_t role)

    {

        Parcel data, reply;

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

        data.writeUint32(static_cast<uint32_t>(strategy));

        status_t status = remote()->transact(REMOVE_PREFERRED_DEVICE_FOR_PRODUCT_STRATEGY,

        data.writeUint32(static_cast<uint32_t>(role));

        status_t status = remote()->transact(REMOVE_DEVICES_ROLE_FOR_PRODUCT_STRATEGY,

                data, &reply);

        if (status != NO_ERROR) {

           return status;
@@ -1415,18 +1389,19 @@ public: 
        return static_cast<status_t>(reply.readInt32());

    }



    virtual status_t getPreferredDeviceForStrategy(product_strategy_t strategy,

            AudioDeviceTypeAddr &device)

    virtual status_t getDevicesForRoleAndStrategy(product_strategy_t strategy,

            device_role_t role, AudioDeviceTypeAddrVector &devices)

    {

        Parcel data, reply;

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

        data.writeUint32(static_cast<uint32_t>(strategy));

        status_t status = remote()->transact(GET_PREFERRED_DEVICE_FOR_PRODUCT_STRATEGY,

        data.writeUint32(static_cast<uint32_t>(role));

        status_t status = remote()->transact(GET_DEVICES_FOR_ROLE_AND_PRODUCT_STRATEGY,

                data, &reply);

        if (status != NO_ERROR) {

            return status;

        }

        status = device.readFromParcel(&reply);

        status = reply.readParcelableVector(&devices);

        if (status != NO_ERROR) {

            return status;

        }
@@ -1561,10 +1536,10 @@ status_t BnAudioPolicyService::onTransact( 
        case RELEASE_SOUNDTRIGGER_SESSION:

        case SET_RTT_ENABLED:

        case IS_CALL_SCREEN_MODE_SUPPORTED:

        case SET_PREFERRED_DEVICE_FOR_PRODUCT_STRATEGY:

        case SET_DEVICES_ROLE_FOR_PRODUCT_STRATEGY:

        case SET_SUPPORTED_SYSTEM_USAGES:

        case REMOVE_PREFERRED_DEVICE_FOR_PRODUCT_STRATEGY:

        case GET_PREFERRED_DEVICE_FOR_PRODUCT_STRATEGY:

        case REMOVE_DEVICES_ROLE_FOR_PRODUCT_STRATEGY:

        case GET_DEVICES_FOR_ROLE_AND_PRODUCT_STRATEGY:

        case GET_DEVICES_FOR_ATTRIBUTES:

        case SET_ALLOWED_CAPTURE_POLICY:

        case AUDIO_MODULES_UPDATED:
@@ -2460,15 +2435,12 @@ status_t BnAudioPolicyService::onTransact( 
        case SET_UID_DEVICE_AFFINITY: {

            CHECK_INTERFACE(IAudioPolicyService, data, reply);

            const uid_t uid = (uid_t) data.readInt32();

            Vector<AudioDeviceTypeAddr> devices;

            size_t size = (size_t)data.readInt32();

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

                AudioDeviceTypeAddr device;

                if (device.readFromParcel((Parcel*)&data) == NO_ERROR) {

                    devices.add(device);

                }

            AudioDeviceTypeAddrVector devices;

            status_t status = data.readParcelableVector(&devices);

            if (status != NO_ERROR) {

                return status;

            }

            status_t status = setUidDeviceAffinities(uid, devices);

            status = setUidDeviceAffinities(uid, devices);

            reply->writeInt32(status);

            return NO_ERROR;

        }
@@ -2484,15 +2456,12 @@ status_t BnAudioPolicyService::onTransact( 
        case SET_USERID_DEVICE_AFFINITY: {

            CHECK_INTERFACE(IAudioPolicyService, data, reply);

            const int userId = (int) data.readInt32();

            Vector<AudioDeviceTypeAddr> devices;

            size_t size = (size_t)data.readInt32();

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

                AudioDeviceTypeAddr device;

                if (device.readFromParcel((Parcel*)&data) == NO_ERROR) {

                    devices.add(device);

                }

            AudioDeviceTypeAddrVector devices;

            status_t status = data.readParcelableVector(&devices);

            if (status != NO_ERROR) {

                return status;

            }

            status_t status = setUserIdDeviceAffinities(userId, devices);

            status = setUserIdDeviceAffinities(userId, devices);

            reply->writeInt32(status);

            return NO_ERROR;

        }
@@ -2649,33 +2618,36 @@ status_t BnAudioPolicyService::onTransact( 
            return NO_ERROR;

        }



        case SET_PREFERRED_DEVICE_FOR_PRODUCT_STRATEGY: {

        case SET_DEVICES_ROLE_FOR_PRODUCT_STRATEGY: {

            CHECK_INTERFACE(IAudioPolicyService, data, reply);

            product_strategy_t strategy = (product_strategy_t) data.readUint32();

            AudioDeviceTypeAddr device;

            status_t status = device.readFromParcel((Parcel*)&data);

            device_role_t role = (device_role_t) data.readUint32();

            AudioDeviceTypeAddrVector devices;

            status_t status = data.readParcelableVector(&devices);

            if (status != NO_ERROR) {

                return status;

            }

            status = setPreferredDeviceForStrategy(strategy, device);

            status = setDevicesRoleForStrategy(strategy, role, devices);

            reply->writeInt32(status);

            return NO_ERROR;

        }



        case REMOVE_PREFERRED_DEVICE_FOR_PRODUCT_STRATEGY: {

        case REMOVE_DEVICES_ROLE_FOR_PRODUCT_STRATEGY: {

            CHECK_INTERFACE(IAudioPolicyService, data, reply);

            product_strategy_t strategy = (product_strategy_t) data.readUint32();

            status_t status = removePreferredDeviceForStrategy(strategy);

            device_role_t role = (device_role_t) data.readUint32();

            status_t status = removeDevicesRoleForStrategy(strategy, role);

            reply->writeInt32(status);

            return NO_ERROR;

        }



        case GET_PREFERRED_DEVICE_FOR_PRODUCT_STRATEGY: {

        case GET_DEVICES_FOR_ROLE_AND_PRODUCT_STRATEGY: {

            CHECK_INTERFACE(IAudioPolicyService, data, reply);

            product_strategy_t strategy = (product_strategy_t) data.readUint32();

            AudioDeviceTypeAddr device;

            status_t status = getPreferredDeviceForStrategy(strategy, device);

            status_t marshall_status = device.writeToParcel(reply);

            device_role_t role = (device_role_t) data.readUint32();

            AudioDeviceTypeAddrVector devices;

            status_t status = getDevicesForRoleAndStrategy(strategy, role, devices);

            status_t marshall_status = reply->writeParcelableVector(devices);

            if (marshall_status != NO_ERROR) {

                return marshall_status;

            }

media/libaudioclient/include/media/AudioSystem.h

+7 −7
Original line number Diff line number Diff line
@@ -361,11 +361,11 @@ public: 


    static status_t registerPolicyMixes(const Vector<AudioMix>& mixes, bool registration);



    static status_t setUidDeviceAffinities(uid_t uid, const Vector<AudioDeviceTypeAddr>& devices);

    static status_t setUidDeviceAffinities(uid_t uid, const AudioDeviceTypeAddrVector& devices);



    static status_t removeUidDeviceAffinities(uid_t uid);



    static status_t setUserIdDeviceAffinities(int userId, const Vector<AudioDeviceTypeAddr>& devices);

    static status_t setUserIdDeviceAffinities(int userId, const AudioDeviceTypeAddrVector& devices);



    static status_t removeUserIdDeviceAffinities(int userId);
@@ -425,13 +425,13 @@ public: 
     */

    static status_t setAudioHalPids(const std::vector<pid_t>& pids);



    static status_t setPreferredDeviceForStrategy(product_strategy_t strategy,

            const AudioDeviceTypeAddr &device);

    static status_t setDevicesRoleForStrategy(product_strategy_t strategy,

            device_role_t role, const AudioDeviceTypeAddrVector &devices);



    static status_t removePreferredDeviceForStrategy(product_strategy_t strategy);

    static status_t removeDevicesRoleForStrategy(product_strategy_t strategy, device_role_t role);



    static status_t getPreferredDeviceForStrategy(product_strategy_t strategy,

            AudioDeviceTypeAddr &device);

    static status_t getDevicesForRoleAndStrategy(product_strategy_t strategy,

            device_role_t role, AudioDeviceTypeAddrVector &devices);



    static status_t getDeviceForStrategy(product_strategy_t strategy,

            AudioDeviceTypeAddr &device);

media/libaudioclient/include/media/IAudioPolicyService.h

+10 −7
Original line number Diff line number Diff line
@@ -196,13 +196,13 @@ public: 


    virtual status_t registerPolicyMixes(const Vector<AudioMix>& mixes, bool registration) = 0;



    virtual status_t setUidDeviceAffinities(uid_t uid, const Vector<AudioDeviceTypeAddr>& devices)

    virtual status_t setUidDeviceAffinities(uid_t uid, const AudioDeviceTypeAddrVector& devices)

            = 0;



    virtual status_t removeUidDeviceAffinities(uid_t uid) = 0;



    virtual status_t setUserIdDeviceAffinities(int userId,

            const Vector<AudioDeviceTypeAddr>& devices) = 0;

            const AudioDeviceTypeAddrVector& devices) = 0;



    virtual status_t removeUserIdDeviceAffinities(int userId) = 0;
@@ -241,13 +241,16 @@ public: 


    virtual bool     isCallScreenModeSupported() = 0;



    virtual status_t setPreferredDeviceForStrategy(product_strategy_t strategy,

                                                   const AudioDeviceTypeAddr &device) = 0;

    virtual status_t setDevicesRoleForStrategy(product_strategy_t strategy,

                                               device_role_t role,

                                               const AudioDeviceTypeAddrVector &devices) = 0;



    virtual status_t removePreferredDeviceForStrategy(product_strategy_t strategy) = 0;

    virtual status_t removeDevicesRoleForStrategy(product_strategy_t strategy,

                                                  device_role_t role) = 0;



    virtual status_t getPreferredDeviceForStrategy(product_strategy_t strategy,

                                                   AudioDeviceTypeAddr &device) = 0;

    virtual status_t getDevicesForRoleAndStrategy(product_strategy_t strategy,

                                                  device_role_t role,

                                                  AudioDeviceTypeAddrVector &devices) = 0;



    // The return code here is only intended to represent transport errors. The

    // actual server implementation should always return NO_ERROR.

media/libaudiofoundation/AudioDeviceTypeAddr.cpp

+68 −2
Original line number Diff line number Diff line
@@ -16,12 +16,56 @@ 


#include <media/AudioDeviceTypeAddr.h>



#include <arpa/inet.h>

#include <iostream>

#include <regex>

#include <sstream>



namespace android {



namespace {



static const std::string SUPPRESSED = "SUPPRESSED";

static const std::regex MAC_ADDRESS_REGEX("([0-9a-fA-F]{2}:){5}[0-9a-fA-F]{2}");



bool isSenstiveAddress(const std::string &address) {

    if (std::regex_match(address, MAC_ADDRESS_REGEX)) {

        return true;

    }



    sockaddr_storage ss4;

    if (inet_pton(AF_INET, address.c_str(), &ss4) > 0) {

        return true;

    }



    sockaddr_storage ss6;

    if (inet_pton(AF_INET6, address.c_str(), &ss6) > 0) {

        return true;

    }



    return false;

}



} // namespace



AudioDeviceTypeAddr::AudioDeviceTypeAddr(audio_devices_t type, const std::string &address) :

        mType(type), mAddress(address) {

    mIsAddressSensitive = isSenstiveAddress(mAddress);

}



const char* AudioDeviceTypeAddr::getAddress() const {

    return mAddress.c_str();

}



const std::string& AudioDeviceTypeAddr::address() const {

    return mAddress;

}



void AudioDeviceTypeAddr::setAddress(const std::string& address) {

    mAddress = address;

    mIsAddressSensitive = isSenstiveAddress(mAddress);

}



bool AudioDeviceTypeAddr::equals(const AudioDeviceTypeAddr& other) const {

    return mType == other.mType && mAddress == other.mAddress;

}
@@ -38,7 +82,17 @@ bool AudioDeviceTypeAddr::operator<(const AudioDeviceTypeAddr& other) const { 


void AudioDeviceTypeAddr::reset() {

    mType = AUDIO_DEVICE_NONE;

    mAddress = "";

    setAddress("");

}



std::string AudioDeviceTypeAddr::toString(bool includeSensitiveInfo) const {

    std::stringstream sstream;

    sstream << "type:0x" << std::hex << mType;

    // IP and MAC address are sensitive information. The sensitive information will be suppressed

    // is `includeSensitiveInfo` is false.

    sstream << ",@:"

            << (!includeSensitiveInfo && mIsAddressSensitive ? SUPPRESSED : mAddress);

    return sstream.str();

}



status_t AudioDeviceTypeAddr::readFromParcel(const Parcel *parcel) {
@@ -64,4 +118,16 @@ DeviceTypeSet getAudioDeviceTypes(const AudioDeviceTypeAddrVector& deviceTypeAdd 
    return deviceTypes;

}



std::string dumpAudioDeviceTypeAddrVector(const AudioDeviceTypeAddrVector& deviceTypeAddrs,

                                          bool includeSensitiveInfo) {

    std::stringstream stream;

    for (auto it = deviceTypeAddrs.begin(); it != deviceTypeAddrs.end(); ++it) {

        if (it != deviceTypeAddrs.begin()) {

            stream << " ";

        }

        stream << it->toString(includeSensitiveInfo);

    }

    return stream.str();

}



} // namespace android
 
 No newline at end of file