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

Commit 4e826218 authored by jiabin's avatar jiabin Committed by Eric Laurent
Browse files

Introduce device(s) role for strategy. 

Adding interface to get/set/removeDevicesRoleForStrategy. The interfaces
allows to modify the devices' role, such as preferred, for strategy.
Get/set/removePreferredDeviceForStrategy is reimplemented by the new
interfaces.

Test: atest AudioHostTest
Test: atest AudioServiceHostTest
Test: atest AudioServiceTest
Test: atest audiopolicy_tests
Bug: 160352965
Change-Id: I0af737542a8599938cae4e142b733159f21ed5a8
Merged-In: I0af737542a8599938cae4e142b733159f21ed5a8
parent c1afe3ba

media/libaudioclient/AudioSystem.cpp

+10 −8
Original line number Diff line number Diff line
@@ -1604,33 +1604,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

+32 −27
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,
@@ -1357,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;
@@ -1388,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;

        }
@@ -1534,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:
@@ -2616,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

+5 −5
Original line number Diff line number Diff line
@@ -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

+8 −5
Original line number Diff line number Diff line
@@ -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

+67 −1
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) {
@@ -66,4 +120,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