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

Commit 829d90db authored by Oscar Azucena's avatar Oscar Azucena
Browse files

Added mechanism for setting multiple UIDs as assistants. 

Added mechanism for setting multiple services UIDS as assistants. The
current assistant behaviour for recording still remains the same.

Bug: 189312611
Test: m -j, and run assistant via hotword trigger and key press
Change-Id: Iccd01c8a8ceaacc16418e0857bda805452b26152
parent 3eeeda39

media/libaudioclient/AudioSystem.cpp

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

            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();

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

    if (aps == 0) return PERMISSION_DENIED;

    if (aps == 0) return PERMISSION_DENIED;





    int32_t uidAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_uid_t_int32_t(uid));

    std::vector<int32_t> uidsAidl = VALUE_OR_RETURN_STATUS(

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

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

}

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



status_t AudioSystem::setHotwordDetectionServiceUid(uid_t uid) {

    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));

}

}





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

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

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

+1 −3
Original line number Original line Diff line number Diff line
@@ -302,9 +302,7 @@ interface IAudioPolicyService { 




    void setSurroundFormatEnabled(in AudioFormatDescription audioFormat, boolean enabled);

    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 setA11yServicesUids(in int[] /* uid_t[] */ uids);

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

media/libaudioclient/include/media/AidlConversionUtil.h

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

    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.

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

 */

 */

media/libaudioclient/include/media/AudioSystem.h

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

                                               audio_format_t *surroundFormats);

    static status_t setSurroundFormatEnabled(audio_format_t audioFormat, bool enabled);

    static status_t setSurroundFormatEnabled(audio_format_t audioFormat, bool enabled);





    static status_t setAssistantUid(uid_t uid);

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

    static status_t setHotwordDetectionServiceUid(uid_t uid);

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

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

    static status_t setCurrentImeUid(uid_t uid);

    static status_t setCurrentImeUid(uid_t uid);

services/audiopolicy/service/AudioPolicyInterfaceImpl.cpp

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

            mAudioPolicyManager->setSurroundFormatEnabled(audioFormat, enabled));

}

}





Status AudioPolicyService::setAssistantUid(int32_t uidAidl)

Status convertInt32VectorToUidVectorWithLimit(

{

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

    uid_t uid = VALUE_OR_RETURN_BINDER_STATUS(aidl2legacy_int32_t_uid_t(uidAidl));

    RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(

    Mutex::Autolock _l(mLock);

        convertRangeWithLimit(uidsAidl.begin(),

    mUidPolicy->setAssistantUid(uid);

            uidsAidl.end(),

            std::back_inserter(uids),

            aidl2legacy_int32_t_uid_t,

            MAX_ITEMS_PER_LIST)));



    return Status::ok();

    return Status::ok();

}

}





Status AudioPolicyService::setHotwordDetectionServiceUid(int32_t uidAidl)

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);

    Mutex::Autolock _l(mLock);

    mUidPolicy->setHotwordDetectionServiceUid(uid);

    mUidPolicy->setAssistantUids(uids);

    return Status::ok();

    return Status::ok();

}

}





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

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;

    std::vector<uid_t> uids;

    RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(

    RETURN_IF_BINDER_ERROR(convertInt32VectorToUidVectorWithLimit(uidsAidl, uids));

            convertRange(uidsAidl.begin(),



                         uidsAidl.begin() + size,

                         std::back_inserter(uids),

                         aidl2legacy_int32_t_uid_t)));

    Mutex::Autolock _l(mLock);

    Mutex::Autolock _l(mLock);

    mUidPolicy->setA11yUids(uids);

    mUidPolicy->setA11yUids(uids);

    return Status::ok();

    return Status::ok();