Merge "audio policy: receive assistant and a11y service UIDs"

media/libaudioclient/AudioSystem.cpp

@@ -1298,6 +1298,24 @@ status_t AudioSystem::setSurroundFormatEnabled(audio_format_t audioFormat, bool
     return aps->setSurroundFormatEnabled(audioFormat, enabled);
 }
 
+
+status_t AudioSystem::setAssistantUid(uid_t uid)
+{
+    const sp <IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
+    if (aps == 0) return PERMISSION_DENIED;
+
+    return aps->setAssistantUid(uid);
+}
+
+status_t AudioSystem::setA11yServicesUids(const std::vector<uid_t>& uids)
+{
+    const sp <IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
+    if (aps == 0) return PERMISSION_DENIED;
+
+    return aps->setA11yServicesUids(uids);
+}
+
+
 // ---------------------------------------------------------------------------
 
 int AudioSystem::AudioPolicyServiceClient::addAudioPortCallback(

media/libaudioclient/IAudioPolicyService.cpp

@@ -85,7 +85,9 @@ enum {
     ADD_STREAM_DEFAULT_EFFECT,
     REMOVE_STREAM_DEFAULT_EFFECT,
     ADD_SOURCE_DEFAULT_EFFECT,
-    REMOVE_SOURCE_DEFAULT_EFFECT
+    REMOVE_SOURCE_DEFAULT_EFFECT,
+    SET_ASSISTANT_UID,
+    SET_A11Y_SERVICES_UIDS,
 };
 
 #define MAX_ITEMS_PER_LIST 1024
@@ -941,6 +943,33 @@ public:
         return static_cast <status_t> (reply.readInt32());
     }
 
+    virtual status_t setAssistantUid(uid_t uid)
+    {
+        Parcel data, reply;
+        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
+        data.writeInt32(uid);
+        status_t status = remote()->transact(SET_ASSISTANT_UID, data, &reply);
+        if (status != NO_ERROR) {
+            return status;
+        }
+        return static_cast <status_t> (reply.readInt32());
+    }
+
+    virtual status_t setA11yServicesUids(const std::vector<uid_t>& uids)
+    {
+        Parcel data, reply;
+        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
+        data.writeInt32(uids.size());
+        for (auto uid : uids) {
+            data.writeInt32(uid);
+        }
+        status_t status = remote()->transact(SET_A11Y_SERVICES_UIDS, data, &reply);
+        if (status != NO_ERROR) {
+            return status;
+        }
+        return static_cast <status_t> (reply.readInt32());
+    }
+
 };
 
 IMPLEMENT_META_INTERFACE(AudioPolicyService, "android.media.IAudioPolicyService");
@@ -997,7 +1026,9 @@ status_t BnAudioPolicyService::onTransact(
         case START_AUDIO_SOURCE:
         case STOP_AUDIO_SOURCE:
         case GET_SURROUND_FORMATS:
-        case SET_SURROUND_FORMAT_ENABLED: {
+        case SET_SURROUND_FORMAT_ENABLED:
+        case SET_ASSISTANT_UID:
+        case SET_A11Y_SERVICES_UIDS: {
             if (!isServiceUid(IPCThreadState::self()->getCallingUid())) {
                 ALOGW("%s: transaction %d received from PID %d unauthorized UID %d",
                       __func__, code, IPCThreadState::self()->getCallingPid(),
@@ -1710,6 +1741,42 @@ status_t BnAudioPolicyService::onTransact(
             return NO_ERROR;
         }
 
+        case SET_ASSISTANT_UID: {
+            CHECK_INTERFACE(IAudioPolicyService, data, reply);
+            int32_t uid;
+            status_t status = data.readInt32(&uid);
+            if (status != NO_ERROR) {
+                return status;
+            }
+            status = setAssistantUid(uid);
+            reply->writeInt32(static_cast <int32_t>(status));
+            return NO_ERROR;
+        }
+
+        case SET_A11Y_SERVICES_UIDS: {
+            CHECK_INTERFACE(IAudioPolicyService, data, reply);
+            std::vector<uid_t> uids;
+            int32_t size;
+            status_t status = data.readInt32(&size);
+            if (status != NO_ERROR) {
+                return status;
+            }
+            if (size > MAX_ITEMS_PER_LIST) {
+                size = MAX_ITEMS_PER_LIST;
+            }
+            for (int32_t i = 0; i < size; i++) {
+                int32_t uid;
+                status =  data.readInt32(&uid);
+                if (status != NO_ERROR) {
+                    return status;
+                }
+                uids.push_back(uid);
+            }
+            status = setA11yServicesUids(uids);
+            reply->writeInt32(static_cast <int32_t>(status));
+            return NO_ERROR;
+        }
+
         default:
             return BBinder::onTransact(code, data, reply, flags);
     }

media/libaudioclient/include/media/AudioSystem.h

@@ -343,6 +343,9 @@ public:
                                        bool reported);
     static status_t setSurroundFormatEnabled(audio_format_t audioFormat, bool enabled);
 
+    static status_t setAssistantUid(uid_t uid);
+    static status_t setA11yServicesUids(const std::vector<uid_t>& uids);
+
     // ----------------------------------------------------------------------------
 
     class AudioPortCallback : public RefBase

media/libaudioclient/include/media/IAudioPolicyService.h

@@ -20,15 +20,14 @@
 #include <stdint.h>
 #include <sys/types.h>
 #include <unistd.h>
-
 #include <utils/RefBase.h>
 #include <utils/Errors.h>
 #include <binder/IInterface.h>
 #include <media/AudioSystem.h>
 #include <media/AudioPolicy.h>
 #include <media/IAudioPolicyServiceClient.h>
-
 #include <system/audio_policy.h>
+#include <vector>
 
 namespace android {
 
@@ -180,6 +179,9 @@ public:
                                         bool *surroundFormatsEnabled,
                                         bool reported) = 0;
     virtual status_t setSurroundFormatEnabled(audio_format_t audioFormat, bool enabled) = 0;
+
+    virtual status_t setAssistantUid(uid_t uid) = 0;
+    virtual status_t setA11yServicesUids(const std::vector<uid_t>& uids) = 0;
 };
 
 

services/audiopolicy/service/AudioPolicyInterfaceImpl.cpp

@@ -1135,4 +1135,18 @@ status_t AudioPolicyService::setSurroundFormatEnabled(audio_format_t audioFormat
     return mAudioPolicyManager->setSurroundFormatEnabled(audioFormat, enabled);
 }
 
+status_t AudioPolicyService::setAssistantUid(uid_t uid)
+{
+    Mutex::Autolock _l(mLock);
+    mUidPolicy->setAssistantUid(uid);
+    return NO_ERROR;
+}
+
+status_t AudioPolicyService::setA11yServicesUids(const std::vector<uid_t>& uids)
+{
+    Mutex::Autolock _l(mLock);
+    mUidPolicy->setA11yUids(uids);
+    return NO_ERROR;
+}
+
 } // namespace android

services/audiopolicy/service/AudioPolicyService.cpp

@@ -637,6 +637,12 @@ void AudioPolicyService::UidPolicy::updateUidLocked(std::unordered_map<uid_t, bo
     }
 }
 
+bool AudioPolicyService::UidPolicy::isA11yUid(uid_t uid)
+{
+    std::vector<uid_t>::iterator it = find(mA11yUids.begin(), mA11yUids.end(), uid);
+    return it != mA11yUids.end();
+}
+
 // -----------  AudioPolicyService::AudioCommandThread implementation ----------
 
 AudioPolicyService::AudioCommandThread::AudioCommandThread(String8 name,

services/audiopolicy/service/AudioPolicyService.h

@@ -214,6 +214,9 @@ public:
                                         bool reported);
     virtual status_t setSurroundFormatEnabled(audio_format_t audioFormat, bool enabled);
 
+    virtual status_t setAssistantUid(uid_t uid);
+    virtual status_t setA11yServicesUids(const std::vector<uid_t>& uids);
+
             status_t doStopOutput(audio_port_handle_t portId);
             void doReleaseOutput(audio_port_handle_t portId);
 
@@ -277,7 +280,7 @@ private:
     class UidPolicy : public BnUidObserver, public virtual IBinder::DeathRecipient {
     public:
         explicit UidPolicy(wp<AudioPolicyService> service)
-                : mService(service), mObserverRegistered(false) {}
+                : mService(service), mObserverRegistered(false), mAssistantUid(0) {}
 
         void registerSelf();
         void unregisterSelf();
@@ -286,6 +289,10 @@ private:
         void binderDied(const wp<IBinder> &who) override;
 
         bool isUidActive(uid_t uid);
+        void setAssistantUid(uid_t uid) { mAssistantUid = uid; }
+        bool isAssistantUid(uid_t uid) { return uid == mAssistantUid; }
+        void setA11yUids(const std::vector<uid_t>& uids) { mA11yUids.clear(); mA11yUids = uids; }
+        bool isA11yUid(uid_t uid);
 
         // BnUidObserver implementation
         void onUidActive(uid_t uid) override;
@@ -307,6 +314,8 @@ private:
         bool mObserverRegistered;
         std::unordered_map<uid_t, bool> mOverrideUids;
         std::unordered_map<uid_t, bool> mCachedUids;
+        uid_t mAssistantUid;
+        std::vector<uid_t> mA11yUids;
     };
 
     // Thread used to send audio config commands to audio flinger