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
Loading
Loading
Loading
Loading
+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) {
+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);

+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.
 */
+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);

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