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

Commit 606115fd authored by Oscar Azucena's avatar Oscar Azucena Committed by Android (Google) Code Review
Browse files

Merge changes from topic "set_assistants_uid" 

* changes:
  Added audio service API to set active assistants.
  Added mechanism for setting multiple UIDs as assistants.
parents 97002460 c2cdda35

media/libaudioclient/AudioSystem.cpp

+8 −6
Original line number Diff line number Diff line
@@ -1911,20 +1911,22 @@ status_t AudioSystem::setSurroundFormatEnabled(audio_format_t audioFormat, bool 
            aps->setSurroundFormatEnabled(audioFormatAidl, enabled));

}



status_t AudioSystem::setAssistantUid(uid_t uid) {

status_t AudioSystem::setAssistantServicesUids(const std::vector<uid_t>& uids) {

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

    if (aps == 0) return PERMISSION_DENIED;



    int32_t uidAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_uid_t_int32_t(uid));

    return statusTFromBinderStatus(aps->setAssistantUid(uidAidl));

    std::vector<int32_t> uidsAidl = VALUE_OR_RETURN_STATUS(

                convertContainer<std::vector<int32_t>>(uids, legacy2aidl_uid_t_int32_t));

    return statusTFromBinderStatus(aps->setAssistantServicesUids(uidsAidl));

}



status_t AudioSystem::setHotwordDetectionServiceUid(uid_t uid) {

status_t AudioSystem::setActiveAssistantServicesUids(const std::vector<uid_t>& activeUids) {

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

    if (aps == 0) return PERMISSION_DENIED;



    int32_t uidAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_uid_t_int32_t(uid));

    return statusTFromBinderStatus(aps->setHotwordDetectionServiceUid(uidAidl));

    std::vector<int32_t> activeUidsAidl = VALUE_OR_RETURN_STATUS(

                convertContainer<std::vector<int32_t>>(activeUids, legacy2aidl_uid_t_int32_t));

    return statusTFromBinderStatus(aps->setActiveAssistantServicesUids(activeUidsAidl));

}



status_t AudioSystem::setA11yServicesUids(const std::vector<uid_t>& uids) {

media/libaudioclient/aidl/android/media/IAudioPolicyService.aidl

+2 −2
Original line number Diff line number Diff line
@@ -302,9 +302,9 @@ interface IAudioPolicyService { 


    void setSurroundFormatEnabled(in AudioFormatDescription audioFormat, boolean enabled);



    void setAssistantUid(int /* uid_t */ uid);

    void setAssistantServicesUids(in int[] /* uid_t[] */ uids);



    void setHotwordDetectionServiceUid(int /* uid_t */ uid);

    void setActiveAssistantServicesUids(in int[] /* uid_t[] */ activeUids);



    void setA11yServicesUids(in int[] /* uid_t[] */ uids);

media/libaudioclient/include/media/AidlConversionUtil.h

+20 −0
Original line number Diff line number Diff line
@@ -76,6 +76,26 @@ status_t convertRange(InputIterator start, 
    return OK;

}



/**

 * A generic template that helps convert containers of convertible types, using iterators.

 * Uses a limit as maximum conversion items.

 */

template<typename InputIterator, typename OutputIterator, typename Func>

status_t convertRangeWithLimit(InputIterator start,

                      InputIterator end,

                      OutputIterator out,

                      const Func& itemConversion,

                      const size_t limit) {

    InputIterator last = end;

    if (end - start > limit) {

        last = start + limit;

    }

    for (InputIterator iter = start; (iter != last); ++iter, ++out) {

        *out = VALUE_OR_RETURN_STATUS(itemConversion(*iter));

    }

    return OK;

}



/**

 * A generic template that helps convert containers of convertible types.

 */

media/libaudioclient/include/media/AudioSystem.h

+3 −2
Original line number Diff line number Diff line
@@ -438,8 +438,9 @@ public: 
                                               audio_format_t *surroundFormats);

    static status_t setSurroundFormatEnabled(audio_format_t audioFormat, bool enabled);



    static status_t setAssistantUid(uid_t uid);

    static status_t setHotwordDetectionServiceUid(uid_t uid);

    static status_t setAssistantServicesUids(const std::vector<uid_t>& uids);

    static status_t setActiveAssistantServicesUids(const std::vector<uid_t>& activeUids);



    static status_t setA11yServicesUids(const std::vector<uid_t>& uids);

    static status_t setCurrentImeUid(uid_t uid);

services/audiopolicy/service/AudioPolicyInterfaceImpl.cpp

+25 −16
Original line number Diff line number Diff line
@@ -2002,34 +2002,43 @@ Status AudioPolicyService::setSurroundFormatEnabled( 
            mAudioPolicyManager->setSurroundFormatEnabled(audioFormat, enabled));

}



Status AudioPolicyService::setAssistantUid(int32_t uidAidl)

Status convertInt32VectorToUidVectorWithLimit(

        const std::vector<int32_t>& uidsAidl, std::vector<uid_t>& uids) {

    RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(

        convertRangeWithLimit(uidsAidl.begin(),

            uidsAidl.end(),

            std::back_inserter(uids),

            aidl2legacy_int32_t_uid_t,

            MAX_ITEMS_PER_LIST)));



    return Status::ok();

}



Status AudioPolicyService::setAssistantServicesUids(const std::vector<int32_t>& uidsAidl)

{

    uid_t uid = VALUE_OR_RETURN_BINDER_STATUS(aidl2legacy_int32_t_uid_t(uidAidl));

    std::vector<uid_t> uids;

    RETURN_IF_BINDER_ERROR(convertInt32VectorToUidVectorWithLimit(uidsAidl, uids));



    Mutex::Autolock _l(mLock);

    mUidPolicy->setAssistantUid(uid);

    mUidPolicy->setAssistantUids(uids);

    return Status::ok();

}



Status AudioPolicyService::setHotwordDetectionServiceUid(int32_t uidAidl)

{

    uid_t uid = VALUE_OR_RETURN_BINDER_STATUS(aidl2legacy_int32_t_uid_t(uidAidl));

Status AudioPolicyService::setActiveAssistantServicesUids(

        const std::vector<int32_t>& activeUidsAidl) {

    std::vector<uid_t> activeUids;

    RETURN_IF_BINDER_ERROR(convertInt32VectorToUidVectorWithLimit(activeUidsAidl, activeUids));



    Mutex::Autolock _l(mLock);

    mUidPolicy->setHotwordDetectionServiceUid(uid);

    mUidPolicy->setActiveAssistantUids(activeUids);

    return Status::ok();

}



Status AudioPolicyService::setA11yServicesUids(const std::vector<int32_t>& uidsAidl)

{

    size_t size = uidsAidl.size();

    if (size > MAX_ITEMS_PER_LIST) {

        size = MAX_ITEMS_PER_LIST;

    }

    std::vector<uid_t> uids;

    RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(

            convertRange(uidsAidl.begin(),

                         uidsAidl.begin() + size,

                         std::back_inserter(uids),

                         aidl2legacy_int32_t_uid_t)));

    RETURN_IF_BINDER_ERROR(convertInt32VectorToUidVectorWithLimit(uidsAidl, uids));



    Mutex::Autolock _l(mLock);

    mUidPolicy->setA11yUids(uids);

    return Status::ok();