Add attributionTag to audio-recordings
... by replacing packageName/uid/pid by the Identity class.
This allows us to track which parts of the app trigger audio-recordings.
90% of the code is just sending around the additional parameters.
This adds it for the Java and native API.
Test: atest CtsAppOpsTestCases
CtsNativeMediaAAudioTestCases
Fixes: 160150145
Change-Id: Ibd7b884f7fcd4668a4e27f997e59cfc3217a9e89
diff --git a/services/audioflinger/Android.bp b/services/audioflinger/Android.bp
index 518ef9a..2294c49 100644
--- a/services/audioflinger/Android.bp
+++ b/services/audioflinger/Android.bp
@@ -80,6 +80,7 @@
"libmedia_helper",
"libshmemcompat",
"libvibrator",
+ "media_permission-aidl-cpp",
],
static_libs: [
@@ -93,6 +94,10 @@
"libmedia_headers",
],
+ export_shared_lib_headers: [
+ "media_permission-aidl-cpp",
+ ],
+
cflags: [
"-DSTATE_QUEUE_INSTANTIATIONS=\"StateQueueInstantiations.cpp\"",
"-fvisibility=hidden",
diff --git a/services/audioflinger/AudioFlinger.cpp b/services/audioflinger/AudioFlinger.cpp
index dacb758..6678287 100644
--- a/services/audioflinger/AudioFlinger.cpp
+++ b/services/audioflinger/AudioFlinger.cpp
@@ -103,6 +103,7 @@
namespace android {
using media::IEffectClient;
+using media::permission::Identity;
static const char kDeadlockedString[] = "AudioFlinger may be deadlocked\n";
static const char kHardwareLockedString[] = "Hardware lock is taken\n";
@@ -355,7 +356,7 @@
ret = AudioSystem::getOutputForAttr(&localAttr, &io,
actualSessionId,
- &streamType, client.clientPid, client.clientUid,
+ &streamType, client.identity,
&fullConfig,
(audio_output_flags_t)(AUDIO_OUTPUT_FLAG_MMAP_NOIRQ |
AUDIO_OUTPUT_FLAG_DIRECT),
@@ -366,9 +367,7 @@
ret = AudioSystem::getInputForAttr(&localAttr, &io,
RECORD_RIID_INVALID,
actualSessionId,
- client.clientPid,
- client.clientUid,
- client.packageName,
+ client.identity,
config,
AUDIO_INPUT_FLAG_MMAP_NOIRQ, deviceId, &portId);
}
@@ -772,27 +771,33 @@
audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE;
std::vector<audio_io_handle_t> secondaryOutputs;
- bool updatePid = (input.clientInfo.clientPid == -1);
+ // TODO b/182392553: refactor or make clearer
+ pid_t clientPid =
+ VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_pid_t(input.clientInfo.identity.pid));
+ bool updatePid = (clientPid == (pid_t)-1);
const uid_t callingUid = IPCThreadState::self()->getCallingUid();
- uid_t clientUid = input.clientInfo.clientUid;
+ uid_t clientUid =
+ VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_uid_t(input.clientInfo.identity.uid));
audio_io_handle_t effectThreadId = AUDIO_IO_HANDLE_NONE;
std::vector<int> effectIds;
audio_attributes_t localAttr = input.attr;
+ Identity adjIdentity = input.clientInfo.identity;
if (!isAudioServerOrMediaServerUid(callingUid)) {
ALOGW_IF(clientUid != callingUid,
"%s uid %d tried to pass itself off as %d",
__FUNCTION__, callingUid, clientUid);
+ adjIdentity.uid = VALUE_OR_RETURN_STATUS(legacy2aidl_uid_t_int32_t(callingUid));
clientUid = callingUid;
updatePid = true;
}
- pid_t clientPid = input.clientInfo.clientPid;
const pid_t callingPid = IPCThreadState::self()->getCallingPid();
if (updatePid) {
- ALOGW_IF(clientPid != -1 && clientPid != callingPid,
+ ALOGW_IF(clientPid != (pid_t)-1 && clientPid != callingPid,
"%s uid %d pid %d tried to pass itself off as pid %d",
__func__, callingUid, callingPid, clientPid);
clientPid = callingPid;
+ adjIdentity.pid = VALUE_OR_RETURN_STATUS(legacy2aidl_pid_t_int32_t(callingPid));
}
audio_session_t sessionId = input.sessionId;
@@ -807,7 +812,7 @@
output.outputId = AUDIO_IO_HANDLE_NONE;
output.selectedDeviceId = input.selectedDeviceId;
lStatus = AudioSystem::getOutputForAttr(&localAttr, &output.outputId, sessionId, &streamType,
- clientPid, clientUid, &input.config, input.flags,
+ adjIdentity, &input.config, input.flags,
&output.selectedDeviceId, &portId, &secondaryOutputs);
if (lStatus != NO_ERROR || output.outputId == AUDIO_IO_HANDLE_NONE) {
@@ -872,9 +877,8 @@
&output.frameCount, &output.notificationFrameCount,
input.notificationsPerBuffer, input.speed,
input.sharedBuffer, sessionId, &output.flags,
- callingPid, input.clientInfo.clientTid, clientUid,
- &lStatus, portId, input.audioTrackCallback,
- input.opPackageName);
+ callingPid, adjIdentity, input.clientInfo.clientTid,
+ &lStatus, portId, input.audioTrackCallback);
LOG_ALWAYS_FATAL_IF((lStatus == NO_ERROR) && (track == 0));
// we don't abort yet if lStatus != NO_ERROR; there is still work to be done regardless
@@ -2032,23 +2036,25 @@
output.buffers.clear();
output.inputId = AUDIO_IO_HANDLE_NONE;
- bool updatePid = (input.clientInfo.clientPid == -1);
+ // TODO b/182392553: refactor or clean up
+ Identity adjIdentity = input.clientInfo.identity;
+ bool updatePid = (adjIdentity.pid == -1);
const uid_t callingUid = IPCThreadState::self()->getCallingUid();
- uid_t clientUid = input.clientInfo.clientUid;
+ const uid_t currentUid = VALUE_OR_RETURN_STATUS(legacy2aidl_uid_t_int32_t(adjIdentity.uid));
if (!isAudioServerOrMediaServerUid(callingUid)) {
- ALOGW_IF(clientUid != callingUid,
+ ALOGW_IF(currentUid != callingUid,
"%s uid %d tried to pass itself off as %d",
- __FUNCTION__, callingUid, clientUid);
- clientUid = callingUid;
+ __FUNCTION__, callingUid, currentUid);
+ adjIdentity.uid = VALUE_OR_RETURN_STATUS(legacy2aidl_uid_t_int32_t(callingUid));
updatePid = true;
}
- pid_t clientPid = input.clientInfo.clientPid;
const pid_t callingPid = IPCThreadState::self()->getCallingPid();
+ const pid_t currentPid = VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_pid_t(adjIdentity.pid));
if (updatePid) {
- ALOGW_IF(clientPid != -1 && clientPid != callingPid,
+ ALOGW_IF(currentPid != (pid_t)-1 && currentPid != callingPid,
"%s uid %d pid %d tried to pass itself off as pid %d",
- __func__, callingUid, callingPid, clientPid);
- clientPid = callingPid;
+ __func__, callingUid, callingPid, currentPid);
+ adjIdentity.pid = VALUE_OR_RETURN_STATUS(legacy2aidl_pid_t_int32_t(callingPid));
}
// we don't yet support anything other than linear PCM
@@ -2076,7 +2082,7 @@
output.selectedDeviceId = input.selectedDeviceId;
output.flags = input.flags;
- client = registerPid(clientPid);
+ client = registerPid(VALUE_OR_FATAL(aidl2legacy_int32_t_pid_t(adjIdentity.pid)));
// Not a conventional loop, but a retry loop for at most two iterations total.
// Try first maybe with FAST flag then try again without FAST flag if that fails.
@@ -2096,9 +2102,7 @@
input.riid,
sessionId,
// FIXME compare to AudioTrack
- clientPid,
- clientUid,
- input.opPackageName,
+ adjIdentity,
&input.config,
output.flags, &output.selectedDeviceId, &portId);
if (lStatus != NO_ERROR) {
@@ -2125,10 +2129,9 @@
input.config.format, input.config.channel_mask,
&output.frameCount, sessionId,
&output.notificationFrameCount,
- callingPid, clientUid, &output.flags,
+ callingPid, adjIdentity, &output.flags,
input.clientInfo.clientTid,
- &lStatus, portId,
- input.opPackageName);
+ &lStatus, portId);
LOG_ALWAYS_FATAL_IF((lStatus == NO_ERROR) && (recordTrack == 0));
// lStatus == BAD_TYPE means FAST flag was rejected: request a new input from
@@ -3521,9 +3524,7 @@
const int32_t priority = request.priority;
const AudioDeviceTypeAddr device = VALUE_OR_RETURN_STATUS(
aidl2legacy_AudioDeviceTypeAddress(request.device));
- const String16 opPackageName = VALUE_OR_RETURN_STATUS(
- aidl2legacy_string_view_String16(request.opPackageName));
- pid_t pid = VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_pid_t(request.pid));
+ Identity adjIdentity = request.identity;
const audio_session_t sessionId = VALUE_OR_RETURN_STATUS(
aidl2legacy_int32_t_audio_session_t(request.sessionId));
audio_io_handle_t io = VALUE_OR_RETURN_STATUS(
@@ -3539,17 +3540,21 @@
status_t lStatus = NO_ERROR;
+ // TODO b/182392553: refactor or make clearer
const uid_t callingUid = IPCThreadState::self()->getCallingUid();
- if (pid == -1 || !isAudioServerOrMediaServerUid(callingUid)) {
+ adjIdentity.uid = VALUE_OR_RETURN_STATUS(legacy2aidl_uid_t_int32_t(callingUid));
+ pid_t currentPid = VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_pid_t(adjIdentity.pid));
+ if (currentPid == -1 || !isAudioServerOrMediaServerUid(callingUid)) {
const pid_t callingPid = IPCThreadState::self()->getCallingPid();
- ALOGW_IF(pid != -1 && pid != callingPid,
+ ALOGW_IF(currentPid != -1 && currentPid != callingPid,
"%s uid %d pid %d tried to pass itself off as pid %d",
- __func__, callingUid, callingPid, pid);
- pid = callingPid;
+ __func__, callingUid, callingPid, currentPid);
+ adjIdentity.pid = VALUE_OR_RETURN_STATUS(legacy2aidl_pid_t_int32_t(callingPid));
+ currentPid = callingPid;
}
ALOGV("createEffect pid %d, effectClient %p, priority %d, sessionId %d, io %d, factory %p",
- pid, effectClient.get(), priority, sessionId, io, mEffectsFactoryHal.get());
+ adjIdentity.pid, effectClient.get(), priority, sessionId, io, mEffectsFactoryHal.get());
if (mEffectsFactoryHal == 0) {
ALOGE("%s: no effects factory hal", __func__);
@@ -3577,7 +3582,7 @@
goto Exit;
}
} else if (sessionId == AUDIO_SESSION_DEVICE) {
- if (!modifyDefaultAudioEffectsAllowed(pid, callingUid)) {
+ if (!modifyDefaultAudioEffectsAllowed(adjIdentity)) {
ALOGE("%s: device effect permission denied for uid %d", __func__, callingUid);
lStatus = PERMISSION_DENIED;
goto Exit;
@@ -3622,7 +3627,7 @@
// check recording permission for visualizer
if ((memcmp(&descOut.type, SL_IID_VISUALIZATION, sizeof(effect_uuid_t)) == 0) &&
// TODO: Do we need to start/stop op - i.e. is there recording being performed?
- !recordingAllowed(opPackageName, pid, callingUid)) {
+ !recordingAllowed(adjIdentity)) {
lStatus = PERMISSION_DENIED;
goto Exit;
}
@@ -3648,7 +3653,7 @@
Mutex::Autolock _l(mLock);
if (sessionId == AUDIO_SESSION_DEVICE) {
- sp<Client> client = registerPid(pid);
+ sp<Client> client = registerPid(currentPid);
ALOGV("%s device type %#x address %s", __func__, device.mType, device.getAddress());
handle = mDeviceEffectManager.createEffect_l(
&descOut, device, client, effectClient, mPatchPanel.patches_l(),
@@ -3752,7 +3757,7 @@
}
}
- sp<Client> client = registerPid(pid);
+ sp<Client> client = registerPid(currentPid);
// create effect on selected output thread
bool pinned = !audio_is_global_session(sessionId) && isSessionAcquired_l(sessionId);
diff --git a/services/audioflinger/MmapTracks.h b/services/audioflinger/MmapTracks.h
index b83f6b5..ba868d7 100644
--- a/services/audioflinger/MmapTracks.h
+++ b/services/audioflinger/MmapTracks.h
@@ -29,8 +29,7 @@
audio_channel_mask_t channelMask,
audio_session_t sessionId,
bool isOut,
- uid_t uid,
- pid_t pid,
+ const media::permission::Identity& identity,
pid_t creatorPid,
audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE);
virtual ~MmapTrack();
diff --git a/services/audioflinger/PlaybackTracks.h b/services/audioflinger/PlaybackTracks.h
index c70d6f9..a5b3077 100644
--- a/services/audioflinger/PlaybackTracks.h
+++ b/services/audioflinger/PlaybackTracks.h
@@ -15,6 +15,8 @@
** limitations under the License.
*/
+#include <android/media/permission/Identity.h>
+
#ifndef INCLUDING_FROM_AUDIOFLINGER_H
#error This header file should only be included from AudioFlinger.h
#endif
@@ -26,11 +28,13 @@
bool hasOpPlayAudio() const;
static sp<OpPlayAudioMonitor> createIfNeeded(
- uid_t uid, const audio_attributes_t& attr, int id, audio_stream_type_t streamType,
- const std::string& opPackageName);
+ const android::media::permission::Identity& identity,
+ const audio_attributes_t& attr, int id,
+ audio_stream_type_t streamType);
private:
- OpPlayAudioMonitor(uid_t uid, audio_usage_t usage, int id, const String16& opPackageName);
+ OpPlayAudioMonitor(const android::media::permission::Identity& identity,
+ audio_usage_t usage, int id);
void onFirstRef() override;
static void getPackagesForUid(uid_t uid, Vector<String16>& packages);
@@ -50,10 +54,9 @@
void checkPlayAudioForUsage();
std::atomic_bool mHasOpPlayAudio;
- const uid_t mUid;
+ const android::media::permission::Identity mIdentity;
const int32_t mUsage; // on purpose not audio_usage_t because always checked in appOps as int32_t
const int mId; // for logging purposes only
- const String16 mOpPackageName;
};
// playback track
@@ -72,14 +75,13 @@
const sp<IMemory>& sharedBuffer,
audio_session_t sessionId,
pid_t creatorPid,
- uid_t uid,
+ const media::permission::Identity& identity,
audio_output_flags_t flags,
track_type type,
audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE,
/** default behaviour is to start when there are as many frames
* ready as possible (aka. Buffer is full). */
- size_t frameCountToBeReady = SIZE_MAX,
- const std::string opPackageName = "");
+ size_t frameCountToBeReady = SIZE_MAX);
virtual ~Track();
virtual status_t initCheck() const;
@@ -336,7 +338,7 @@
audio_format_t format,
audio_channel_mask_t channelMask,
size_t frameCount,
- uid_t uid);
+ android::media::permission::Identity& identity);
virtual ~OutputTrack();
virtual status_t start(AudioSystem::sync_event_t event =
diff --git a/services/audioflinger/RecordTracks.h b/services/audioflinger/RecordTracks.h
index d87239d..4d03441 100644
--- a/services/audioflinger/RecordTracks.h
+++ b/services/audioflinger/RecordTracks.h
@@ -26,10 +26,10 @@
bool hasOpRecordAudio() const;
static sp<OpRecordAudioMonitor> createIfNeeded
- (uid_t uid, const audio_attributes_t& attr, const String16& opPackageName);
+ (const media::permission::Identity& identity, const audio_attributes_t& attr);
private:
- OpRecordAudioMonitor(uid_t uid, const String16& opPackageName);
+ explicit OpRecordAudioMonitor(const media::permission::Identity& identity);
void onFirstRef() override;
AppOpsManager mAppOpsManager;
@@ -49,8 +49,7 @@
void checkRecordAudio();
std::atomic_bool mHasOpRecordAudio;
- const uid_t mUid;
- const String16 mPackage;
+ const media::permission::Identity mIdentity;
};
// record track
@@ -67,10 +66,9 @@
size_t bufferSize,
audio_session_t sessionId,
pid_t creatorPid,
- uid_t uid,
+ const media::permission::Identity& identity,
audio_input_flags_t flags,
track_type type,
- const String16& opPackageName,
audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE);
virtual ~RecordTrack();
virtual status_t initCheck() const;
@@ -149,7 +147,7 @@
// used to enforce OP_RECORD_AUDIO
uid_t mUid;
- String16 mOpPackageName;
+ media::permission::Identity mIdentity;
sp<OpRecordAudioMonitor> mOpRecordAudioMonitor;
};
diff --git a/services/audioflinger/Threads.cpp b/services/audioflinger/Threads.cpp
index eaf0d10..90f7a61 100644
--- a/services/audioflinger/Threads.cpp
+++ b/services/audioflinger/Threads.cpp
@@ -108,6 +108,7 @@
// TODO: Move these macro/inlines to a header file.
#define max(a, b) ((a) > (b) ? (a) : (b))
+
template <typename T>
static inline T min(const T& a, const T& b)
{
@@ -117,6 +118,7 @@
namespace android {
using media::IEffectClient;
+using media::permission::Identity;
// retry counts for buffer fill timeout
// 50 * ~20msecs = 1 second
@@ -2076,12 +2078,11 @@
audio_session_t sessionId,
audio_output_flags_t *flags,
pid_t creatorPid,
+ const Identity& identity,
pid_t tid,
- uid_t uid,
status_t *status,
audio_port_handle_t portId,
- const sp<media::IAudioTrackCallback>& callback,
- const std::string& opPackageName)
+ const sp<media::IAudioTrackCallback>& callback)
{
size_t frameCount = *pFrameCount;
size_t notificationFrameCount = *pNotificationFrameCount;
@@ -2172,8 +2173,8 @@
"sampleRate=%u mSampleRate=%u "
"hasFastMixer=%d tid=%d fastTrackAvailMask=%#x",
sharedBuffer.get(), frameCount, mFrameCount, format, mFormat,
- audio_is_linear_pcm(format),
- channelMask, sampleRate, mSampleRate, hasFastMixer(), tid, mFastTrackAvailMask);
+ audio_is_linear_pcm(format), channelMask, sampleRate,
+ mSampleRate, hasFastMixer(), tid, mFastTrackAvailMask);
*flags = (audio_output_flags_t)(*flags & ~AUDIO_OUTPUT_FLAG_FAST);
}
}
@@ -2372,8 +2373,8 @@
track = new Track(this, client, streamType, attr, sampleRate, format,
channelMask, frameCount,
nullptr /* buffer */, (size_t)0 /* bufferSize */, sharedBuffer,
- sessionId, creatorPid, uid, trackFlags, TrackBase::TYPE_DEFAULT, portId,
- SIZE_MAX /*frameCountToBeReady*/, opPackageName);
+ sessionId, creatorPid, identity, trackFlags, TrackBase::TYPE_DEFAULT,
+ portId, SIZE_MAX /*frameCountToBeReady*/);
lStatus = track != 0 ? track->initCheck() : (status_t) NO_MEMORY;
if (lStatus != NO_ERROR) {
@@ -6812,13 +6813,19 @@
// from different OutputTracks and their associated MixerThreads (e.g. one may
// nearly empty and the other may be dropping data).
+ // TODO b/182392769: use identity util, move to server edge
+ Identity identity = Identity();
+ identity.uid = VALUE_OR_FATAL(legacy2aidl_uid_t_int32_t(
+ IPCThreadState::self()->getCallingUid()));
+ identity.pid = VALUE_OR_FATAL(legacy2aidl_pid_t_int32_t(
+ IPCThreadState::self()->getCallingPid()));
sp<OutputTrack> outputTrack = new OutputTrack(thread,
this,
mSampleRate,
mFormat,
mChannelMask,
frameCount,
- IPCThreadState::self()->getCallingUid());
+ identity);
status_t status = outputTrack != 0 ? outputTrack->initCheck() : (status_t) NO_MEMORY;
if (status != NO_ERROR) {
ALOGE("addOutputTrack() initCheck failed %d", status);
@@ -7730,12 +7737,11 @@
audio_session_t sessionId,
size_t *pNotificationFrameCount,
pid_t creatorPid,
- uid_t uid,
+ const Identity& identity,
audio_input_flags_t *flags,
pid_t tid,
status_t *status,
- audio_port_handle_t portId,
- const String16& opPackageName)
+ audio_port_handle_t portId)
{
size_t frameCount = *pFrameCount;
size_t notificationFrameCount = *pNotificationFrameCount;
@@ -7868,8 +7874,8 @@
track = new RecordTrack(this, client, attr, sampleRate,
format, channelMask, frameCount,
- nullptr /* buffer */, (size_t)0 /* bufferSize */, sessionId, creatorPid, uid,
- *flags, TrackBase::TYPE_DEFAULT, opPackageName, portId);
+ nullptr /* buffer */, (size_t)0 /* bufferSize */, sessionId, creatorPid,
+ identity, *flags, TrackBase::TYPE_DEFAULT, portId);
lStatus = track->initCheck();
if (lStatus != NO_ERROR) {
@@ -8884,7 +8890,7 @@
audio_port_handle_t *handle)
{
ALOGV("%s clientUid %d mStandby %d mPortId %d *handle %d", __FUNCTION__,
- client.clientUid, mStandby, mPortId, *handle);
+ client.identity.uid, mStandby, mPortId, *handle);
if (mHalStream == 0) {
return NO_INIT;
}
@@ -8916,8 +8922,7 @@
ret = AudioSystem::getOutputForAttr(&mAttr, &io,
mSessionId,
&stream,
- client.clientPid,
- client.clientUid,
+ client.identity,
&config,
flags,
&deviceId,
@@ -8934,9 +8939,7 @@
ret = AudioSystem::getInputForAttr(&mAttr, &io,
RECORD_RIID_INVALID,
mSessionId,
- client.clientPid,
- client.clientUid,
- client.packageName,
+ client.identity,
&config,
AUDIO_INPUT_FLAG_MMAP_NOIRQ,
&deviceId,
@@ -8976,16 +8979,15 @@
// Given that MmapThread::mAttr is mutable, should a MmapTrack have attributes ?
sp<MmapTrack> track = new MmapTrack(this, attr == nullptr ? mAttr : *attr, mSampleRate, mFormat,
- mChannelMask, mSessionId, isOutput(), client.clientUid,
- client.clientPid, IPCThreadState::self()->getCallingPid(),
- portId);
+ mChannelMask, mSessionId, isOutput(), client.identity,
+ IPCThreadState::self()->getCallingPid(), portId);
if (isOutput()) {
// force volume update when a new track is added
mHalVolFloat = -1.0f;
} else if (!track->isSilenced_l()) {
for (const sp<MmapTrack> &t : mActiveTracks) {
- if (t->isSilenced_l() && t->uid() != client.clientUid)
+ if (t->isSilenced_l() && t->uid() != client.identity.uid)
t->invalidate();
}
}
diff --git a/services/audioflinger/Threads.h b/services/audioflinger/Threads.h
index c974252..5aa5169 100644
--- a/services/audioflinger/Threads.h
+++ b/services/audioflinger/Threads.h
@@ -882,12 +882,11 @@
audio_session_t sessionId,
audio_output_flags_t *flags,
pid_t creatorPid,
+ const media::permission::Identity& identity,
pid_t tid,
- uid_t uid,
status_t *status /*non-NULL*/,
audio_port_handle_t portId,
- const sp<media::IAudioTrackCallback>& callback,
- const std::string& opPackageName);
+ const sp<media::IAudioTrackCallback>& callback);
AudioStreamOut* getOutput() const;
AudioStreamOut* clearOutput();
@@ -1642,12 +1641,11 @@
audio_session_t sessionId,
size_t *pNotificationFrameCount,
pid_t creatorPid,
- uid_t uid,
+ const media::permission::Identity& identity,
audio_input_flags_t *flags,
pid_t tid,
status_t *status /*non-NULL*/,
- audio_port_handle_t portId,
- const String16& opPackageName);
+ audio_port_handle_t portId);
status_t start(RecordTrack* recordTrack,
AudioSystem::sync_event_t event,
diff --git a/services/audioflinger/Tracks.cpp b/services/audioflinger/Tracks.cpp
index 5454778..a86102f 100644
--- a/services/audioflinger/Tracks.cpp
+++ b/services/audioflinger/Tracks.cpp
@@ -65,6 +65,7 @@
using ::android::aidl_utils::binderStatusFromStatusT;
using binder::Status;
+using media::permission::Identity;
using media::VolumeShaper;
// ----------------------------------------------------------------------------
// TrackBase
@@ -237,6 +238,13 @@
}
}
+// TODO b/182392769: use identity util
+Identity audioServerIdentity() {
+ Identity i = Identity();
+ i.uid = AID_AUDIOSERVER;
+ return i;
+}
+
status_t AudioFlinger::ThreadBase::TrackBase::initCheck() const
{
status_t status;
@@ -489,10 +497,11 @@
// static
sp<AudioFlinger::PlaybackThread::OpPlayAudioMonitor>
AudioFlinger::PlaybackThread::OpPlayAudioMonitor::createIfNeeded(
- uid_t uid, const audio_attributes_t& attr, int id, audio_stream_type_t streamType,
- const std::string& opPackageName)
+ const Identity& identity, const audio_attributes_t& attr, int id,
+ audio_stream_type_t streamType)
{
Vector <String16> packages;
+ uid_t uid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(identity.uid));
getPackagesForUid(uid, packages);
if (isServiceUid(uid)) {
if (packages.isEmpty()) {
@@ -515,31 +524,36 @@
return nullptr;
}
- String16 opPackageNameStr(opPackageName.c_str());
- if (opPackageName.empty()) {
+ // TODO b/182392769: use identity util
+ std::optional<std::string> opPackageNameStr = identity.packageName;
+ if (!identity.packageName.has_value()) {
// If no package name is provided by the client, use the first associated with the uid
if (!packages.isEmpty()) {
- opPackageNameStr = packages[0];
+ opPackageNameStr =
+ VALUE_OR_FATAL(legacy2aidl_String16_string(packages[0]));
}
} else {
// If the provided package name is invalid, we force app ops denial by clearing the package
// name passed to OpPlayAudioMonitor
+ String16 opPackageLegacy = VALUE_OR_FATAL(
+ aidl2legacy_string_view_String16(opPackageNameStr.value_or("")));
if (std::find_if(packages.begin(), packages.end(),
- [&opPackageNameStr](const auto& package) {
- return opPackageNameStr == package; }) == packages.end()) {
+ [&opPackageLegacy](const auto& package) {
+ return opPackageLegacy == package; }) == packages.end()) {
ALOGW("The package name(%s) provided does not correspond to the uid %d, "
- "force muting the track", opPackageName.c_str(), uid);
- // Set package name as an empty string so that hasOpPlayAudio will always return false.
- opPackageNameStr = String16("");
+ "force muting the track", opPackageNameStr.value().c_str(), uid);
+ // Set null package name so hasOpPlayAudio will always return false.
+ opPackageNameStr = std::optional<std::string>();
}
}
- return new OpPlayAudioMonitor(uid, attr.usage, id, opPackageNameStr);
+ Identity adjIdentity = identity;
+ adjIdentity.packageName = opPackageNameStr;
+ return new OpPlayAudioMonitor(adjIdentity, attr.usage, id);
}
AudioFlinger::PlaybackThread::OpPlayAudioMonitor::OpPlayAudioMonitor(
- uid_t uid, audio_usage_t usage, int id, const String16& opPackageName)
- : mHasOpPlayAudio(true), mUid(uid), mUsage((int32_t) usage), mId(id),
- mOpPackageName(opPackageName)
+ const Identity& identity, audio_usage_t usage, int id)
+ : mHasOpPlayAudio(true), mIdentity(identity), mUsage((int32_t) usage), mId(id)
{
}
@@ -554,9 +568,11 @@
void AudioFlinger::PlaybackThread::OpPlayAudioMonitor::onFirstRef()
{
checkPlayAudioForUsage();
- if (mOpPackageName.size() != 0) {
+ if (mIdentity.packageName.has_value()) {
mOpCallback = new PlayAudioOpCallback(this);
- mAppOpsManager.startWatchingMode(AppOpsManager::OP_PLAY_AUDIO, mOpPackageName, mOpCallback);
+ mAppOpsManager.startWatchingMode(AppOpsManager::OP_PLAY_AUDIO,
+ VALUE_OR_FATAL(aidl2legacy_string_view_String16(mIdentity.packageName.value_or("")))
+ , mOpCallback);
}
}
@@ -569,11 +585,14 @@
// - not called from PlayAudioOpCallback because the callback is not installed in this case
void AudioFlinger::PlaybackThread::OpPlayAudioMonitor::checkPlayAudioForUsage()
{
- if (mOpPackageName.size() == 0) {
+ if (!mIdentity.packageName.has_value()) {
mHasOpPlayAudio.store(false);
} else {
+ uid_t uid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(mIdentity.uid));
+ String16 packageName = VALUE_OR_FATAL(
+ aidl2legacy_string_view_String16(mIdentity.packageName.value_or("")));
bool hasIt = mAppOpsManager.checkAudioOpNoThrow(AppOpsManager::OP_PLAY_AUDIO,
- mUsage, mUid, mOpPackageName) == AppOpsManager::MODE_ALLOWED;
+ mUsage, uid, packageName) == AppOpsManager::MODE_ALLOWED;
ALOGD("OpPlayAudio: track:%d usage:%d %smuted", mId, mUsage, hasIt ? "not " : "");
mHasOpPlayAudio.store(hasIt);
}
@@ -623,12 +642,11 @@
const sp<IMemory>& sharedBuffer,
audio_session_t sessionId,
pid_t creatorPid,
- uid_t uid,
+ const Identity& identity,
audio_output_flags_t flags,
track_type type,
audio_port_handle_t portId,
- size_t frameCountToBeReady,
- const std::string opPackageName)
+ size_t frameCountToBeReady)
: TrackBase(thread, client, attr, sampleRate, format, channelMask, frameCount,
// TODO: Using unsecurePointer() has some associated security pitfalls
// (see declaration for details).
@@ -636,7 +654,8 @@
// issue (e.g. by copying).
(sharedBuffer != 0) ? sharedBuffer->unsecurePointer() : buffer,
(sharedBuffer != 0) ? sharedBuffer->size() : bufferSize,
- sessionId, creatorPid, uid, true /*isOut*/,
+ sessionId, creatorPid,
+ VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(identity.uid)), true /*isOut*/,
(type == TYPE_PATCH) ? ( buffer == NULL ? ALLOC_LOCAL : ALLOC_NONE) : ALLOC_CBLK,
type,
portId,
@@ -651,8 +670,8 @@
mPresentationCompleteFrames(0),
mFrameMap(16 /* sink-frame-to-track-frame map memory */),
mVolumeHandler(new media::VolumeHandler(sampleRate)),
- mOpPlayAudioMonitor(OpPlayAudioMonitor::createIfNeeded(
- uid, attr, id(), streamType, opPackageName)),
+ mOpPlayAudioMonitor(OpPlayAudioMonitor::createIfNeeded(identity, attr, id(),
+ streamType)),
// mSinkTimestamp
mFrameCountToBeReady(frameCountToBeReady),
mFastIndex(-1),
@@ -674,6 +693,7 @@
return;
}
+ uid_t uid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(identity.uid));
if (!thread->isTrackAllowed_l(channelMask, format, sessionId, uid)) {
ALOGE("%s(%d): no more tracks available", __func__, mId);
releaseCblk(); // this makes the track invalid.
@@ -718,8 +738,10 @@
// HapticGenerator effect, which will generate haptic data, on the track. In that case,
// external vibration is always created for all tracks attached to haptic playback thread.
mAudioVibrationController = new AudioVibrationController(this);
+ std::string packageName = identity.packageName.has_value() ?
+ identity.packageName.value() : "";
mExternalVibration = new os::ExternalVibration(
- mUid, opPackageName, mAttr, mAudioVibrationController);
+ mUid, packageName, mAttr, mAudioVibrationController);
}
// Once this item is logged by the server, the client can add properties.
@@ -1821,12 +1843,12 @@
audio_format_t format,
audio_channel_mask_t channelMask,
size_t frameCount,
- uid_t uid)
+ Identity& identity)
: Track(playbackThread, NULL, AUDIO_STREAM_PATCH,
audio_attributes_t{} /* currently unused for output track */,
sampleRate, format, channelMask, frameCount,
nullptr /* buffer */, (size_t)0 /* bufferSize */, nullptr /* sharedBuffer */,
- AUDIO_SESSION_NONE, getpid(), uid, AUDIO_OUTPUT_FLAG_NONE,
+ AUDIO_SESSION_NONE, getpid(), identity, AUDIO_OUTPUT_FLAG_NONE,
TYPE_OUTPUT),
mActive(false), mSourceThread(sourceThread)
{
@@ -2056,8 +2078,8 @@
audio_attributes_t{} /* currently unused for patch track */,
sampleRate, format, channelMask, frameCount,
buffer, bufferSize, nullptr /* sharedBuffer */,
- AUDIO_SESSION_NONE, getpid(), AID_AUDIOSERVER, flags, TYPE_PATCH,
- AUDIO_PORT_HANDLE_NONE, frameCountToBeReady),
+ AUDIO_SESSION_NONE, getpid(), audioServerIdentity(), flags,
+ TYPE_PATCH, AUDIO_PORT_HANDLE_NONE, frameCountToBeReady),
PatchTrackBase(new ClientProxy(mCblk, mBuffer, frameCount, mFrameSize, true, true),
*playbackThread, timeout)
{
@@ -2194,41 +2216,44 @@
// static
sp<AudioFlinger::RecordThread::OpRecordAudioMonitor>
AudioFlinger::RecordThread::OpRecordAudioMonitor::createIfNeeded(
- uid_t uid, const audio_attributes_t& attr, const String16& opPackageName)
+ const Identity& identity, const audio_attributes_t& attr)
{
- if (isServiceUid(uid)) {
- ALOGV("not silencing record for service uid:%d pack:%s",
- uid, String8(opPackageName).string());
+ if (isServiceUid(identity.uid)) {
+ ALOGV("not silencing record for service %s",
+ identity.toString().c_str());
return nullptr;
}
// Capturing from FM TUNER output is not controlled by OP_RECORD_AUDIO
// because it does not affect users privacy as does capturing from an actual microphone.
if (attr.source == AUDIO_SOURCE_FM_TUNER) {
- ALOGV("not muting FM TUNER capture for uid %d", uid);
+ ALOGV("not muting FM TUNER capture for uid %d", identity.uid);
return nullptr;
}
- if (opPackageName.size() == 0) {
+ if (!identity.packageName.has_value() || identity.packageName.value().size() == 0) {
Vector<String16> packages;
// no package name, happens with SL ES clients
// query package manager to find one
PermissionController permissionController;
- permissionController.getPackagesForUid(uid, packages);
+ permissionController.getPackagesForUid(identity.uid, packages);
if (packages.isEmpty()) {
return nullptr;
} else {
- ALOGV("using pack:%s for uid:%d", String8(packages[0]).string(), uid);
- return new OpRecordAudioMonitor(uid, packages[0]);
+ Identity adjIdentity = identity;
+ adjIdentity.packageName =
+ VALUE_OR_FATAL(legacy2aidl_String16_string(packages[0]));
+ ALOGV("using identity:%s", adjIdentity.toString().c_str());
+ return new OpRecordAudioMonitor(adjIdentity);
}
}
- return new OpRecordAudioMonitor(uid, opPackageName);
+ return new OpRecordAudioMonitor(identity);
}
AudioFlinger::RecordThread::OpRecordAudioMonitor::OpRecordAudioMonitor(
- uid_t uid, const String16& opPackageName)
- : mHasOpRecordAudio(true), mUid(uid), mPackage(opPackageName)
+ const Identity& identity)
+ : mHasOpRecordAudio(true), mIdentity(identity)
{
}
@@ -2244,8 +2269,10 @@
{
checkRecordAudio();
mOpCallback = new RecordAudioOpCallback(this);
- ALOGV("start watching OP_RECORD_AUDIO for pack:%s", String8(mPackage).string());
- mAppOpsManager.startWatchingMode(AppOpsManager::OP_RECORD_AUDIO, mPackage, mOpCallback);
+ ALOGV("start watching OP_RECORD_AUDIO for %s", mIdentity.toString().c_str());
+ mAppOpsManager.startWatchingMode(AppOpsManager::OP_RECORD_AUDIO,
+ VALUE_OR_FATAL(aidl2legacy_string_view_String16(mIdentity.packageName.value_or(""))),
+ mOpCallback);
}
bool AudioFlinger::RecordThread::OpRecordAudioMonitor::hasOpRecordAudio() const {
@@ -2260,14 +2287,17 @@
// - not called from RecordAudioOpCallback because the callback is not installed in this case
void AudioFlinger::RecordThread::OpRecordAudioMonitor::checkRecordAudio()
{
+
const int32_t mode = mAppOpsManager.checkOp(AppOpsManager::OP_RECORD_AUDIO,
- mUid, mPackage);
+ mIdentity.uid, VALUE_OR_FATAL(aidl2legacy_string_view_String16(
+ mIdentity.packageName.value_or(""))));
const bool hasIt = (mode == AppOpsManager::MODE_ALLOWED);
// verbose logging only log when appOp changed
ALOGI_IF(hasIt != mHasOpRecordAudio.load(),
- "OP_RECORD_AUDIO missing, %ssilencing record uid%d pack:%s",
- hasIt ? "un" : "", mUid, String8(mPackage).string());
+ "OP_RECORD_AUDIO missing, %ssilencing record %s",
+ hasIt ? "un" : "", mIdentity.toString().c_str());
mHasOpRecordAudio.store(hasIt);
+
}
AudioFlinger::RecordThread::OpRecordAudioMonitor::RecordAudioOpCallback::RecordAudioOpCallback(
@@ -2361,14 +2391,15 @@
size_t bufferSize,
audio_session_t sessionId,
pid_t creatorPid,
- uid_t uid,
+ const Identity& identity,
audio_input_flags_t flags,
track_type type,
- const String16& opPackageName,
audio_port_handle_t portId)
: TrackBase(thread, client, attr, sampleRate, format,
channelMask, frameCount, buffer, bufferSize, sessionId,
- creatorPid, uid, false /*isOut*/,
+ creatorPid,
+ VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(identity.uid)),
+ false /*isOut*/,
(type == TYPE_DEFAULT) ?
((flags & AUDIO_INPUT_FLAG_FAST) ? ALLOC_PIPE : ALLOC_CBLK) :
((buffer == NULL) ? ALLOC_LOCAL : ALLOC_NONE),
@@ -2380,7 +2411,7 @@
mRecordBufferConverter(NULL),
mFlags(flags),
mSilenced(false),
- mOpRecordAudioMonitor(OpRecordAudioMonitor::createIfNeeded(uid, attr, opPackageName))
+ mOpRecordAudioMonitor(OpRecordAudioMonitor::createIfNeeded(mIdentity, attr))
{
if (mCblk == NULL) {
return;
@@ -2421,7 +2452,9 @@
#endif
// Once this item is logged by the server, the client can add properties.
- mTrackMetrics.logConstructor(creatorPid, uid, id());
+ pid_t pid = VALUE_OR_FATAL(aidl2legacy_int32_t_pid_t(mIdentity.pid));
+ uid_t uid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(mIdentity.uid));
+ mTrackMetrics.logConstructor(pid, uid, id());
}
AudioFlinger::RecordThread::RecordTrack::~RecordTrack()
@@ -2692,11 +2725,12 @@
: RecordTrack(recordThread, NULL,
audio_attributes_t{} /* currently unused for patch track */,
sampleRate, format, channelMask, frameCount,
- buffer, bufferSize, AUDIO_SESSION_NONE, getpid(), AID_AUDIOSERVER,
- flags, TYPE_PATCH, String16()),
+ buffer, bufferSize, AUDIO_SESSION_NONE, getpid(),
+ audioServerIdentity(), flags, TYPE_PATCH),
PatchTrackBase(new ClientProxy(mCblk, mBuffer, frameCount, mFrameSize, false, true),
*recordThread, timeout)
{
+ mIdentity.pid = VALUE_OR_FATAL(legacy2aidl_pid_t_int32_t(getpid()));
ALOGV("%s(%d): sampleRate %d mPeerTimeout %d.%03d sec",
__func__, mId, sampleRate,
(int)mPeerTimeout.tv_sec,
@@ -2970,21 +3004,24 @@
audio_channel_mask_t channelMask,
audio_session_t sessionId,
bool isOut,
- uid_t uid,
- pid_t pid,
+ const Identity& identity,
pid_t creatorPid,
audio_port_handle_t portId)
: TrackBase(thread, NULL, attr, sampleRate, format,
channelMask, (size_t)0 /* frameCount */,
nullptr /* buffer */, (size_t)0 /* bufferSize */,
- sessionId, creatorPid, uid, isOut,
+ sessionId, creatorPid,
+ VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(identity.uid)),
+ isOut,
ALLOC_NONE,
TYPE_DEFAULT, portId,
std::string(AMEDIAMETRICS_KEY_PREFIX_AUDIO_MMAP) + std::to_string(portId)),
- mPid(pid), mSilenced(false), mSilencedNotified(false)
+ mPid(VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(identity.pid))),
+ mSilenced(false), mSilencedNotified(false)
{
// Once this item is logged by the server, the client can add properties.
- mTrackMetrics.logConstructor(creatorPid, uid, id());
+ mTrackMetrics.logConstructor(creatorPid,
+ VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(identity.uid)), id());
}
AudioFlinger::MmapThread::MmapTrack::~MmapTrack()
diff --git a/services/audiopolicy/AudioPolicyInterface.h b/services/audiopolicy/AudioPolicyInterface.h
index 9132086..b0b0179 100644
--- a/services/audiopolicy/AudioPolicyInterface.h
+++ b/services/audiopolicy/AudioPolicyInterface.h
@@ -21,6 +21,7 @@
#include <media/AudioSystem.h>
#include <media/AudioPolicy.h>
#include <media/DeviceDescriptorBase.h>
+#include <android/media/permission/Identity.h>
#include <utils/String8.h>
namespace android {
@@ -122,7 +123,7 @@
audio_io_handle_t *output,
audio_session_t session,
audio_stream_type_t *stream,
- uid_t uid,
+ const media::permission::Identity& identity,
const audio_config_t *config,
audio_output_flags_t *flags,
audio_port_handle_t *selectedDeviceId,
@@ -141,7 +142,7 @@
audio_io_handle_t *input,
audio_unique_id_t riid,
audio_session_t session,
- uid_t uid,
+ const media::permission::Identity& identity,
const audio_config_base_t *config,
audio_input_flags_t flags,
audio_port_handle_t *selectedDeviceId,
diff --git a/services/audiopolicy/fuzzer/Android.bp b/services/audiopolicy/fuzzer/Android.bp
index 5dbcebd..38bdedc 100644
--- a/services/audiopolicy/fuzzer/Android.bp
+++ b/services/audiopolicy/fuzzer/Android.bp
@@ -50,6 +50,7 @@
"libbinder",
"libaudiopolicy",
"libaudiopolicymanagerdefault",
+ "media_permission-aidl-cpp",
],
static_libs: [
"android.hardware.audio.common@7.0-enums",
diff --git a/services/audiopolicy/fuzzer/audiopolicy_fuzzer.cpp b/services/audiopolicy/fuzzer/audiopolicy_fuzzer.cpp
index 692ce08..1177b95 100644
--- a/services/audiopolicy/fuzzer/audiopolicy_fuzzer.cpp
+++ b/services/audiopolicy/fuzzer/audiopolicy_fuzzer.cpp
@@ -26,6 +26,7 @@
#include <Serializer.h>
#include <android-base/file.h>
+#include <android/media/permission/Identity.h>
#include <libxml/parser.h>
#include <libxml/xinclude.h>
#include <media/AudioPolicy.h>
@@ -46,6 +47,8 @@
using namespace ::android::audio::policy::configuration::V7_0;
}
+using media::permission::Identity;
+
static const std::vector<audio_format_t> kAudioFormats = [] {
std::vector<audio_format_t> result;
for (const auto enumVal : xsdc_enum_range<xsd::AudioFormat>{}) {
@@ -246,7 +249,10 @@
*portId = AUDIO_PORT_HANDLE_NONE;
AudioPolicyInterface::output_type_t outputType;
- if (mManager->getOutputForAttr(&attr, output, AUDIO_SESSION_NONE, &stream, 0 /*uid*/, &config,
+ // TODO b/182392769: use identity util
+ Identity i;
+ i.uid = 0;
+ if (mManager->getOutputForAttr(&attr, output, AUDIO_SESSION_NONE, &stream, i, &config,
&flags, selectedDeviceId, portId, {}, &outputType) != OK) {
return false;
}
@@ -270,7 +276,9 @@
*portId = AUDIO_PORT_HANDLE_NONE;
AudioPolicyInterface::input_type_t inputType;
- if (mManager->getInputForAttr(&attr, &input, riid, AUDIO_SESSION_NONE, 0 /*uid*/, &config,
+ Identity i;
+ i.uid = 0;
+ if (mManager->getInputForAttr(&attr, &input, riid, AUDIO_SESSION_NONE, i, &config,
flags, selectedDeviceId, &inputType, portId) != OK) {
return false;
}
diff --git a/services/audiopolicy/managerdefault/Android.bp b/services/audiopolicy/managerdefault/Android.bp
index 5572beb..b111db4 100644
--- a/services/audiopolicy/managerdefault/Android.bp
+++ b/services/audiopolicy/managerdefault/Android.bp
@@ -34,6 +34,8 @@
// a dependency on it in the device makefile. There will be no build time
// conflict with libaudiopolicyenginedefault.
"libaudiopolicyenginedefault",
+ "media_permission-aidl-cpp",
+ "libaudioclient_aidl_conversion",
],
header_libs: [
diff --git a/services/audiopolicy/managerdefault/AudioPolicyManager.cpp b/services/audiopolicy/managerdefault/AudioPolicyManager.cpp
index 6b664dd..a91e6c1 100644
--- a/services/audiopolicy/managerdefault/AudioPolicyManager.cpp
+++ b/services/audiopolicy/managerdefault/AudioPolicyManager.cpp
@@ -52,6 +52,8 @@
namespace android {
+using media::permission::Identity;
+
//FIXME: workaround for truncated touch sounds
// to be removed when the problem is handled by system UI
#define TOUCH_SOUND_FIXED_DELAY_MS 100
@@ -1130,7 +1132,7 @@
audio_io_handle_t *output,
audio_session_t session,
audio_stream_type_t *stream,
- uid_t uid,
+ const Identity& identity,
const audio_config_t *config,
audio_output_flags_t *flags,
audio_port_handle_t *selectedDeviceId,
@@ -1142,6 +1144,8 @@
if (*portId != AUDIO_PORT_HANDLE_NONE) {
return INVALID_OPERATION;
}
+ const uid_t uid = VALUE_OR_RETURN_STATUS(
+ aidl2legacy_int32_t_uid_t(identity.uid));
const audio_port_handle_t requestedPortId = *selectedDeviceId;
audio_attributes_t resultAttr;
bool isRequestedDeviceForExclusiveUse = false;
@@ -2110,7 +2114,7 @@
audio_io_handle_t *input,
audio_unique_id_t riid,
audio_session_t session,
- uid_t uid,
+ const Identity& identity,
const audio_config_base_t *config,
audio_input_flags_t flags,
audio_port_handle_t *selectedDeviceId,
@@ -2129,6 +2133,7 @@
sp<AudioInputDescriptor> inputDesc;
sp<RecordClientDescriptor> clientDesc;
audio_port_handle_t requestedDeviceId = *selectedDeviceId;
+ uid_t uid = VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_uid_t(identity.uid));
bool isSoundTrigger;
// The supplied portId must be AUDIO_PORT_HANDLE_NONE
diff --git a/services/audiopolicy/managerdefault/AudioPolicyManager.h b/services/audiopolicy/managerdefault/AudioPolicyManager.h
index bdf82ef..1757187 100644
--- a/services/audiopolicy/managerdefault/AudioPolicyManager.h
+++ b/services/audiopolicy/managerdefault/AudioPolicyManager.h
@@ -116,7 +116,7 @@
audio_io_handle_t *output,
audio_session_t session,
audio_stream_type_t *stream,
- uid_t uid,
+ const media::permission::Identity& identity,
const audio_config_t *config,
audio_output_flags_t *flags,
audio_port_handle_t *selectedDeviceId,
@@ -130,7 +130,7 @@
audio_io_handle_t *input,
audio_unique_id_t riid,
audio_session_t session,
- uid_t uid,
+ const media::permission::Identity& identity,
const audio_config_base_t *config,
audio_input_flags_t flags,
audio_port_handle_t *selectedDeviceId,
diff --git a/services/audiopolicy/service/Android.bp b/services/audiopolicy/service/Android.bp
index 439f9f0..d5ba756 100644
--- a/services/audiopolicy/service/Android.bp
+++ b/services/audiopolicy/service/Android.bp
@@ -44,10 +44,12 @@
"audiopolicy-aidl-cpp",
"audiopolicy-types-aidl-cpp",
"capture_state_listener-aidl-cpp",
+ "media_permission-aidl-cpp",
],
static_libs: [
"libaudiopolicycomponents",
+ "media_permission-aidl-cpp",
],
header_libs: [
@@ -66,5 +68,6 @@
export_shared_lib_headers: [
"libsensorprivacy",
+ "media_permission-aidl-cpp",
],
}
diff --git a/services/audiopolicy/service/AudioPolicyEffects.cpp b/services/audiopolicy/service/AudioPolicyEffects.cpp
index 5dac55b..8426a77 100644
--- a/services/audiopolicy/service/AudioPolicyEffects.cpp
+++ b/services/audiopolicy/service/AudioPolicyEffects.cpp
@@ -35,6 +35,8 @@
namespace android {
+using media::permission::Identity;
+
// ----------------------------------------------------------------------------
// AudioPolicyEffects Implementation
// ----------------------------------------------------------------------------
@@ -121,7 +123,9 @@
Vector <EffectDesc *> effects = mInputSources.valueAt(index)->mEffects;
for (size_t i = 0; i < effects.size(); i++) {
EffectDesc *effect = effects[i];
- sp<AudioEffect> fx = new AudioEffect(String16("android"));
+ Identity identity;
+ identity.packageName = "android";
+ sp<AudioEffect> fx = new AudioEffect(identity);
fx->set(NULL, &effect->mUuid, -1, 0, 0, audioSession, input);
status_t status = fx->initCheck();
if (status != NO_ERROR && status != ALREADY_EXISTS) {
@@ -270,7 +274,9 @@
Vector <EffectDesc *> effects = mOutputStreams.valueAt(index)->mEffects;
for (size_t i = 0; i < effects.size(); i++) {
EffectDesc *effect = effects[i];
- sp<AudioEffect> fx = new AudioEffect(String16("android"));
+ Identity identity;
+ identity.packageName = "android";
+ sp<AudioEffect> fx = new AudioEffect(identity);
fx->set(NULL, &effect->mUuid, 0, 0, 0, audioSession, output);
status_t status = fx->initCheck();
if (status != NO_ERROR && status != ALREADY_EXISTS) {
@@ -970,7 +976,9 @@
for (const auto& deviceEffectsIter : mDeviceEffects) {
const auto& deviceEffects = deviceEffectsIter.second;
for (const auto& effectDesc : deviceEffects->mEffectDescriptors->mEffects) {
- sp<AudioEffect> fx = new AudioEffect(String16("android"));
+ Identity identity;
+ identity.packageName = "android";
+ sp<AudioEffect> fx = new AudioEffect(identity);
fx->set(EFFECT_UUID_NULL, &effectDesc->mUuid, 0, nullptr,
nullptr, AUDIO_SESSION_DEVICE, AUDIO_IO_HANDLE_NONE,
AudioDeviceTypeAddr{deviceEffects->getDeviceType(),
diff --git a/services/audiopolicy/service/AudioPolicyInterfaceImpl.cpp b/services/audiopolicy/service/AudioPolicyInterfaceImpl.cpp
index 07122cc..bf8f2ee 100644
--- a/services/audiopolicy/service/AudioPolicyInterfaceImpl.cpp
+++ b/services/audiopolicy/service/AudioPolicyInterfaceImpl.cpp
@@ -25,6 +25,7 @@
#include <media/MediaMetricsItem.h>
#include <media/PolicyAidlConversion.h>
#include <utils/Log.h>
+#include <android/media/permission/Identity.h>
#define VALUE_OR_RETURN_BINDER_STATUS(x) \
({ auto _tmp = (x); \
@@ -42,6 +43,7 @@
namespace android {
using binder::Status;
using aidl_utils::binderStatusFromStatusT;
+using media::permission::Identity;
const std::vector<audio_usage_t>& SYSTEM_USAGES = {
AUDIO_USAGE_CALL_ASSISTANT,
@@ -62,15 +64,15 @@
}
status_t AudioPolicyService::validateUsage(audio_usage_t usage) {
- return validateUsage(usage, IPCThreadState::self()->getCallingPid(),
- IPCThreadState::self()->getCallingUid());
+ return validateUsage(usage, getCallingIdentity());
}
-status_t AudioPolicyService::validateUsage(audio_usage_t usage, pid_t pid, uid_t uid) {
+status_t AudioPolicyService::validateUsage(audio_usage_t usage, const Identity& identity) {
if (isSystemUsage(usage)) {
if (isSupportedSystemUsage(usage)) {
- if (!modifyAudioRoutingAllowed(pid, uid)) {
- ALOGE("permission denied: modify audio routing not allowed for uid %d", uid);
+ if (!modifyAudioRoutingAllowed(identity)) {
+ ALOGE(("permission denied: modify audio routing not allowed "
+ "for identity %s"), identity.toString().c_str());
return PERMISSION_DENIED;
}
} else {
@@ -276,8 +278,7 @@
Status AudioPolicyService::getOutputForAttr(const media::AudioAttributesInternal& attrAidl,
int32_t sessionAidl,
- int32_t pidAidl,
- int32_t uidAidl,
+ const Identity& identity,
const media::AudioConfig& configAidl,
int32_t flagsAidl,
int32_t selectedDeviceIdAidl,
@@ -288,8 +289,6 @@
audio_session_t session = VALUE_OR_RETURN_BINDER_STATUS(
aidl2legacy_int32_t_audio_session_t(sessionAidl));
audio_stream_type_t stream = AUDIO_STREAM_DEFAULT;
- pid_t pid = VALUE_OR_RETURN_BINDER_STATUS(aidl2legacy_int32_t_pid_t(pidAidl));
- uid_t uid = VALUE_OR_RETURN_BINDER_STATUS(aidl2legacy_int32_t_uid_t(uidAidl));
audio_config_t config = VALUE_OR_RETURN_BINDER_STATUS(
aidl2legacy_AudioConfig_audio_config_t(configAidl));
audio_output_flags_t flags = VALUE_OR_RETURN_BINDER_STATUS(
@@ -307,22 +306,28 @@
RETURN_IF_BINDER_ERROR(
binderStatusFromStatusT(AudioValidator::validateAudioAttributes(attr, "68953950")));
- RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(validateUsage(attr.usage, pid, uid)));
+ RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(validateUsage(attr.usage, identity)));
ALOGV("%s()", __func__);
Mutex::Autolock _l(mLock);
+ // TODO b/182392553: refactor or remove
+ Identity adjIdentity = identity;
const uid_t callingUid = IPCThreadState::self()->getCallingUid();
- if (!isAudioServerOrMediaServerUid(callingUid) || uid == (uid_t)-1) {
- ALOGW_IF(uid != (uid_t)-1 && uid != callingUid,
- "%s uid %d tried to pass itself off as %d", __func__, callingUid, uid);
- uid = callingUid;
+ if (!isAudioServerOrMediaServerUid(callingUid) || identity.uid == -1) {
+ int32_t callingUidAidl = VALUE_OR_RETURN_BINDER_STATUS(
+ legacy2aidl_uid_t_int32_t(callingUid));
+ ALOGW_IF(identity.uid != -1 && identity.uid != callingUidAidl,
+ "%s uid %d tried to pass itself off as %d", __func__,
+ callingUidAidl, identity.uid);
+ adjIdentity.uid = callingUidAidl;
}
- if (!mPackageManager.allowPlaybackCapture(uid)) {
+ if (!mPackageManager.allowPlaybackCapture(VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_int32_t_uid_t(adjIdentity.uid)))) {
attr.flags = static_cast<audio_flags_mask_t>(attr.flags | AUDIO_FLAG_NO_MEDIA_PROJECTION);
}
if (((attr.flags & (AUDIO_FLAG_BYPASS_INTERRUPTION_POLICY|AUDIO_FLAG_BYPASS_MUTE)) != 0)
- && !bypassInterruptionPolicyAllowed(pid, uid)) {
+ && !bypassInterruptionPolicyAllowed(identity)) {
attr.flags = static_cast<audio_flags_mask_t>(
attr.flags & ~(AUDIO_FLAG_BYPASS_INTERRUPTION_POLICY|AUDIO_FLAG_BYPASS_MUTE));
}
@@ -330,7 +335,7 @@
AudioPolicyInterface::output_type_t outputType;
status_t result = mAudioPolicyManager->getOutputForAttr(&attr, &output, session,
&stream,
- uid,
+ adjIdentity,
&config,
&flags, &selectedDeviceId, &portId,
&secondaryOutputs,
@@ -343,16 +348,16 @@
case AudioPolicyInterface::API_OUTPUT_LEGACY:
break;
case AudioPolicyInterface::API_OUTPUT_TELEPHONY_TX:
- if (!modifyPhoneStateAllowed(pid, uid)) {
+ if (!modifyPhoneStateAllowed(adjIdentity)) {
ALOGE("%s() permission denied: modify phone state not allowed for uid %d",
- __func__, uid);
+ __func__, adjIdentity.uid);
result = PERMISSION_DENIED;
}
break;
case AudioPolicyInterface::API_OUT_MIX_PLAYBACK:
- if (!modifyAudioRoutingAllowed(pid, uid)) {
+ if (!modifyAudioRoutingAllowed(adjIdentity)) {
ALOGE("%s() permission denied: modify audio routing not allowed for uid %d",
- __func__, uid);
+ __func__, adjIdentity.uid);
result = PERMISSION_DENIED;
}
break;
@@ -365,8 +370,8 @@
if (result == NO_ERROR) {
sp<AudioPlaybackClient> client =
- new AudioPlaybackClient(attr, output, uid, pid, session, portId, selectedDeviceId,
- stream);
+ new AudioPlaybackClient(attr, output, adjIdentity, session,
+ portId, selectedDeviceId, stream);
mAudioPlaybackClients.add(portId, client);
_aidl_return->output = VALUE_OR_RETURN_BINDER_STATUS(
@@ -502,9 +507,7 @@
int32_t inputAidl,
int32_t riidAidl,
int32_t sessionAidl,
- int32_t pidAidl,
- int32_t uidAidl,
- const std::string& opPackageNameAidl,
+ const Identity& identity,
const media::AudioConfigBase& configAidl,
int32_t flagsAidl,
int32_t selectedDeviceIdAidl,
@@ -517,10 +520,6 @@
aidl2legacy_int32_t_audio_unique_id_t(riidAidl));
audio_session_t session = VALUE_OR_RETURN_BINDER_STATUS(
aidl2legacy_int32_t_audio_session_t(sessionAidl));
- pid_t pid = VALUE_OR_RETURN_BINDER_STATUS(aidl2legacy_int32_t_pid_t(pidAidl));
- uid_t uid = VALUE_OR_RETURN_BINDER_STATUS(aidl2legacy_int32_t_uid_t(uidAidl));
- String16 opPackageName = VALUE_OR_RETURN_BINDER_STATUS(
- aidl2legacy_string_view_String16(opPackageNameAidl));
audio_config_base_t config = VALUE_OR_RETURN_BINDER_STATUS(
aidl2legacy_AudioConfigBase_audio_config_base_t(configAidl));
audio_input_flags_t flags = VALUE_OR_RETURN_BINDER_STATUS(
@@ -536,7 +535,6 @@
RETURN_IF_BINDER_ERROR(
binderStatusFromStatusT(AudioValidator::validateAudioAttributes(attr, "68953950")));
- RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(validateUsage(attr.usage, pid, uid)));
audio_source_t inputSource = attr.source;
if (inputSource == AUDIO_SOURCE_DEFAULT) {
@@ -552,34 +550,42 @@
return binderStatusFromStatusT(BAD_VALUE);
}
- bool updatePid = (pid == -1);
- const uid_t callingUid = IPCThreadState::self()->getCallingUid();
+ // Make sure identity represents the current caller
+ Identity adjIdentity = identity;
+ // TODO b/182392553: refactor or remove
+ bool updatePid = (identity.pid == -1);
+ const uid_t callingUid =IPCThreadState::self()->getCallingUid();
+ const uid_t currentUid = VALUE_OR_RETURN_BINDER_STATUS(aidl2legacy_int32_t_uid_t(identity.uid));
if (!isAudioServerOrMediaServerUid(callingUid)) {
- ALOGW_IF(uid != (uid_t)-1 && uid != callingUid,
- "%s uid %d tried to pass itself off as %d", __FUNCTION__, callingUid, uid);
- uid = callingUid;
+ ALOGW_IF(currentUid != (uid_t)-1 && currentUid != callingUid,
+ "%s uid %d tried to pass itself off as %d", __FUNCTION__, callingUid,
+ currentUid);
+ adjIdentity.uid = VALUE_OR_RETURN_BINDER_STATUS(legacy2aidl_uid_t_int32_t(callingUid));
updatePid = true;
}
if (updatePid) {
- const pid_t callingPid = IPCThreadState::self()->getCallingPid();
- ALOGW_IF(pid != (pid_t)-1 && pid != callingPid,
+ const int32_t callingPid = VALUE_OR_RETURN_BINDER_STATUS(legacy2aidl_pid_t_int32_t(
+ IPCThreadState::self()->getCallingPid()));
+ ALOGW_IF(identity.pid != -1 && identity.pid != callingPid,
"%s uid %d pid %d tried to pass itself off as pid %d",
- __func__, callingUid, callingPid, pid);
- pid = callingPid;
+ __func__, adjIdentity.uid, callingPid, identity.pid);
+ adjIdentity.pid = callingPid;
}
+ RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(validateUsage(attr.usage, adjIdentity)));
+
// check calling permissions.
// Capturing from FM_TUNER source is controlled by captureTunerAudioInputAllowed() and
// captureAudioOutputAllowed() (deprecated) as this does not affect users privacy
// as does capturing from an actual microphone.
- if (!(recordingAllowed(opPackageName, pid, uid) || attr.source == AUDIO_SOURCE_FM_TUNER)) {
- ALOGE("%s permission denied: recording not allowed for uid %d pid %d",
- __func__, uid, pid);
+ if (!(recordingAllowed(adjIdentity) || attr.source == AUDIO_SOURCE_FM_TUNER)) {
+ ALOGE("%s permission denied: recording not allowed for %s",
+ __func__, adjIdentity.toString().c_str());
return binderStatusFromStatusT(PERMISSION_DENIED);
}
- bool canCaptureOutput = captureAudioOutputAllowed(pid, uid);
+ bool canCaptureOutput = captureAudioOutputAllowed(adjIdentity);
if ((inputSource == AUDIO_SOURCE_VOICE_UPLINK ||
inputSource == AUDIO_SOURCE_VOICE_DOWNLINK ||
inputSource == AUDIO_SOURCE_VOICE_CALL ||
@@ -589,12 +595,12 @@
}
if (inputSource == AUDIO_SOURCE_FM_TUNER
- && !captureTunerAudioInputAllowed(pid, uid)
+ && !captureTunerAudioInputAllowed(adjIdentity)
&& !canCaptureOutput) {
return binderStatusFromStatusT(PERMISSION_DENIED);
}
- bool canCaptureHotword = captureHotwordAllowed(opPackageName, pid, uid);
+ bool canCaptureHotword = captureHotwordAllowed(adjIdentity);
if ((inputSource == AUDIO_SOURCE_HOTWORD) && !canCaptureHotword) {
return binderStatusFromStatusT(PERMISSION_DENIED);
}
@@ -602,7 +608,7 @@
if (((flags & AUDIO_INPUT_FLAG_HW_HOTWORD) != 0)
&& !canCaptureHotword) {
ALOGE("%s: permission denied: hotword mode not allowed"
- " for uid %d pid %d", __func__, uid, pid);
+ " for uid %d pid %d", __func__, adjIdentity.uid, adjIdentity.pid);
return binderStatusFromStatusT(PERMISSION_DENIED);
}
@@ -615,10 +621,11 @@
{
AutoCallerClear acc;
// the audio_in_acoustics_t parameter is ignored by get_input()
- status = mAudioPolicyManager->getInputForAttr(&attr, &input, riid, session, uid,
- &config,
+ status = mAudioPolicyManager->getInputForAttr(&attr, &input, riid, session,
+ adjIdentity, &config,
flags, &selectedDeviceId,
&inputType, &portId);
+
}
audioPolicyEffects = mAudioPolicyEffects;
@@ -639,7 +646,7 @@
}
break;
case AudioPolicyInterface::API_INPUT_MIX_EXT_POLICY_REROUTE:
- if (!modifyAudioRoutingAllowed(pid, uid)) {
+ if (!modifyAudioRoutingAllowed(adjIdentity)) {
ALOGE("getInputForAttr() permission denied: modify audio routing not allowed");
status = PERMISSION_DENIED;
}
@@ -659,8 +666,8 @@
return binderStatusFromStatusT(status);
}
- sp<AudioRecordClient> client = new AudioRecordClient(attr, input, uid, pid, session, portId,
- selectedDeviceId, opPackageName,
+ sp<AudioRecordClient> client = new AudioRecordClient(attr, input, session, portId,
+ selectedDeviceId, adjIdentity,
canCaptureOutput, canCaptureHotword);
mAudioRecordClients.add(portId, client);
}
@@ -711,12 +718,15 @@
client = mAudioRecordClients.valueAt(index);
}
+ std::stringstream msg;
+ msg << "Audio recording on session " << client->session;
+
// check calling permissions
- if (!(startRecording(client->opPackageName, client->pid, client->uid,
- client->attributes.source)
+ if (!(startRecording(client->identity, String16(msg.str().c_str()),
+ client->attributes.source)
|| client->attributes.source == AUDIO_SOURCE_FM_TUNER)) {
- ALOGE("%s permission denied: recording not allowed for uid %d pid %d",
- __func__, client->uid, client->pid);
+ ALOGE("%s permission denied: recording not allowed for identity %s",
+ __func__, client->identity.toString().c_str());
return binderStatusFromStatusT(PERMISSION_DENIED);
}
@@ -760,11 +770,13 @@
item->setCString(kAudioPolicyRqstSrc,
toString(client->attributes.source).c_str());
item->setInt32(kAudioPolicyRqstSession, client->session);
- if (client->opPackageName.size() != 0) {
+ if (client->identity.packageName.has_value() &&
+ client->identity.packageName.value().size() != 0) {
item->setCString(kAudioPolicyRqstPkg,
- std::string(String8(client->opPackageName).string()).c_str());
+ client->identity.packageName.value().c_str());
} else {
- item->setCString(kAudioPolicyRqstPkg, std::to_string(client->uid).c_str());
+ item->setCString(kAudioPolicyRqstPkg,
+ std::to_string(client->identity.uid).c_str());
}
item->setCString(
kAudioPolicyRqstDevice, getDeviceTypeStrForPortId(client->deviceId).c_str());
@@ -780,12 +792,13 @@
item->setCString(kAudioPolicyActiveSrc,
toString(other->attributes.source).c_str());
item->setInt32(kAudioPolicyActiveSession, other->session);
- if (other->opPackageName.size() != 0) {
+ if (other->identity.packageName.has_value() &&
+ other->identity.packageName.value().size() != 0) {
item->setCString(kAudioPolicyActivePkg,
- std::string(String8(other->opPackageName).string()).c_str());
+ other->identity.packageName.value().c_str());
} else {
- item->setCString(kAudioPolicyRqstPkg,
- std::to_string(other->uid).c_str());
+ item->setCString(kAudioPolicyRqstPkg, std::to_string(
+ other->identity.uid).c_str());
}
item->setCString(kAudioPolicyActiveDevice,
getDeviceTypeStrForPortId(other->deviceId).c_str());
@@ -801,8 +814,7 @@
client->active = false;
client->startTimeNs = 0;
updateUidStates_l();
- finishRecording(client->opPackageName, client->uid,
- client->attributes.source);
+ finishRecording(client->identity, client->attributes.source);
}
return binderStatusFromStatusT(status);
@@ -831,8 +843,7 @@
updateUidStates_l();
// finish the recording app op
- finishRecording(client->opPackageName, client->uid,
- client->attributes.source);
+ finishRecording(client->identity, client->attributes.source);
AutoCallerClear acc;
return binderStatusFromStatusT(mAudioPolicyManager->stopInput(portId));
}
@@ -1629,15 +1640,15 @@
bool needCaptureMediaOutput = std::any_of(mixes.begin(), mixes.end(), [](auto& mix) {
return mix.mAllowPrivilegedMediaPlaybackCapture; });
- const uid_t callingUid = IPCThreadState::self()->getCallingUid();
- const pid_t callingPid = IPCThreadState::self()->getCallingPid();
+ const Identity identity = getCallingIdentity();
- if (needCaptureMediaOutput && !captureMediaOutputAllowed(callingPid, callingUid)) {
+
+ if (needCaptureMediaOutput && !captureMediaOutputAllowed(identity)) {
return binderStatusFromStatusT(PERMISSION_DENIED);
}
if (needCaptureVoiceCommunicationOutput &&
- !captureVoiceCommunicationOutputAllowed(callingPid, callingUid)) {
+ !captureVoiceCommunicationOutputAllowed(identity)) {
return binderStatusFromStatusT(PERMISSION_DENIED);
}
diff --git a/services/audiopolicy/service/AudioPolicyService.cpp b/services/audiopolicy/service/AudioPolicyService.cpp
index 90ad81e..35b69d0 100644
--- a/services/audiopolicy/service/AudioPolicyService.cpp
+++ b/services/audiopolicy/service/AudioPolicyService.cpp
@@ -595,23 +595,24 @@
for (size_t i =0; i < mAudioRecordClients.size(); i++) {
sp<AudioRecordClient> current = mAudioRecordClients[i];
+ uid_t currentUid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(current->identity.uid));
if (!current->active || (!isVirtualSource(current->attributes.source)
- && isUserSensorPrivacyEnabledForUid(current->uid))) {
+ && isUserSensorPrivacyEnabledForUid(currentUid))) {
continue;
}
- app_state_t appState = apmStatFromAmState(mUidPolicy->getUidState(current->uid));
+ app_state_t appState = apmStatFromAmState(mUidPolicy->getUidState(currentUid));
// clients which app is in IDLE state are not eligible for top active or
// latest active
if (appState == APP_STATE_IDLE) {
continue;
}
- bool isAccessibility = mUidPolicy->isA11yUid(current->uid);
+ bool isAccessibility = mUidPolicy->isA11yUid(currentUid);
// Clients capturing for Accessibility services or virtual sources are not considered
// for top or latest active to avoid masking regular clients started before
if (!isAccessibility && !isVirtualSource(current->attributes.source)) {
- bool isAssistant = mUidPolicy->isAssistantUid(current->uid);
+ bool isAssistant = mUidPolicy->isAssistantUid(currentUid);
bool isPrivacySensitive =
(current->attributes.flags & AUDIO_FLAG_CAPTURE_PRIVATE) != 0;
@@ -639,9 +640,11 @@
// if audio mode is IN_COMMUNICATION, make sure the audio mode owner
// is marked latest sensitive active even if another app qualifies.
if (current->startTimeNs > latestSensitiveStartNs
- || (isInCommunication && current->uid == mPhoneStateOwnerUid)) {
+ || (isInCommunication && currentUid == mPhoneStateOwnerUid)) {
if (!isInCommunication || latestSensitiveActiveOrComm == nullptr
- || latestSensitiveActiveOrComm->uid != mPhoneStateOwnerUid) {
+ || VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(
+ latestSensitiveActiveOrComm->identity.uid))
+ != mPhoneStateOwnerUid) {
latestSensitiveActiveOrComm = current;
latestSensitiveStartNs = current->startTimeNs;
}
@@ -658,7 +661,7 @@
if (current->attributes.source != AUDIO_SOURCE_HOTWORD) {
onlyHotwordActive = false;
}
- if (current->uid == mPhoneStateOwnerUid) {
+ if (currentUid == mPhoneStateOwnerUid) {
isPhoneStateOwnerActive = true;
}
}
@@ -674,7 +677,9 @@
} else if (latestSensitiveActiveOrComm != nullptr) {
// if audio mode is IN_COMMUNICATION, favor audio mode owner over an app with
// foreground UI in case both are capturing with privacy sensitive flag.
- if (isInCommunication && latestSensitiveActiveOrComm->uid == mPhoneStateOwnerUid) {
+ uid_t latestActiveUid = VALUE_OR_FATAL(
+ aidl2legacy_int32_t_uid_t(latestSensitiveActiveOrComm->identity.uid));
+ if (isInCommunication && latestActiveUid == mPhoneStateOwnerUid) {
topSensitiveActive = latestSensitiveActiveOrComm;
topSensitiveStartNs = latestSensitiveStartNs;
}
@@ -692,20 +697,25 @@
for (size_t i =0; i < mAudioRecordClients.size(); i++) {
sp<AudioRecordClient> current = mAudioRecordClients[i];
+ uid_t currentUid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(
+ current->identity.uid));
if (!current->active) {
continue;
}
audio_source_t source = current->attributes.source;
- bool isTopOrLatestActive = topActive == nullptr ? false : current->uid == topActive->uid;
- bool isTopOrLatestSensitive = topSensitiveActive == nullptr ?
- false : current->uid == topSensitiveActive->uid;
+ bool isTopOrLatestActive = topActive == nullptr ? false :
+ current->identity.uid == topActive->identity.uid;
+ bool isTopOrLatestSensitive = topSensitiveActive == nullptr ? false :
+ current->identity.uid == topSensitiveActive->identity.uid;
auto canCaptureIfInCallOrCommunication = [&](const auto &recordClient) REQUIRES(mLock) {
+ uid_t recordUid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(
+ recordClient->identity.uid));
bool canCaptureCall = recordClient->canCaptureOutput;
bool canCaptureCommunication = recordClient->canCaptureOutput
|| !isPhoneStateOwnerActive
- || recordClient->uid == mPhoneStateOwnerUid;
+ || recordUid == mPhoneStateOwnerUid;
return !(isInCall && !canCaptureCall)
&& !(isInCommunication && !canCaptureCommunication);
};
@@ -724,10 +734,10 @@
if (isVirtualSource(source)) {
// Allow capture for virtual (remote submix, call audio TX or RX...) sources
allowCapture = true;
- } else if (isUserSensorPrivacyEnabledForUid(current->uid)) {
+ } else if (isUserSensorPrivacyEnabledForUid(currentUid)) {
// If sensor privacy is enabled, don't allow capture
allowCapture = false;
- } else if (mUidPolicy->isAssistantUid(current->uid)) {
+ } else if (mUidPolicy->isAssistantUid(currentUid)) {
// For assistant allow capture if:
// An accessibility service is on TOP or a RTT call is active
// AND the source is VOICE_RECOGNITION or HOTWORD
@@ -747,7 +757,7 @@
allowCapture = true;
}
}
- } else if (mUidPolicy->isA11yUid(current->uid)) {
+ } else if (mUidPolicy->isA11yUid(currentUid)) {
// For accessibility service allow capture if:
// The assistant is not on TOP
// AND there is no active privacy sensitive capture or call
@@ -773,7 +783,7 @@
&& canCaptureIfInCallOrCommunication(current)) {
allowCapture = true;
}
- } else if (mUidPolicy->isCurrentImeUid(current->uid)) {
+ } else if (mUidPolicy->isCurrentImeUid(currentUid)) {
// For current InputMethodService allow capture if:
// A RTT call is active AND the source is VOICE_RECOGNITION
if (rttCallActive && source == AUDIO_SOURCE_VOICE_RECOGNITION) {
@@ -781,7 +791,7 @@
}
}
setAppState_l(current->portId,
- allowCapture ? apmStatFromAmState(mUidPolicy->getUidState(current->uid)) :
+ allowCapture ? apmStatFromAmState(mUidPolicy->getUidState(currentUid)) :
APP_STATE_IDLE);
}
}
diff --git a/services/audiopolicy/service/AudioPolicyService.h b/services/audiopolicy/service/AudioPolicyService.h
index a11b2cc..15846ec 100644
--- a/services/audiopolicy/service/AudioPolicyService.h
+++ b/services/audiopolicy/service/AudioPolicyService.h
@@ -38,6 +38,8 @@
#include "CaptureStateNotifier.h"
#include <AudioPolicyInterface.h>
#include <android/hardware/BnSensorPrivacyListener.h>
+#include <android/media/permission/Identity.h>
+
#include <unordered_map>
namespace android {
@@ -79,15 +81,16 @@
media::AudioPolicyForcedConfig* _aidl_return) override;
binder::Status getOutput(media::AudioStreamType stream, int32_t* _aidl_return) override;
binder::Status getOutputForAttr(const media::AudioAttributesInternal& attr, int32_t session,
- int32_t pid, int32_t uid, const media::AudioConfig& config,
+ const media::permission::Identity &identity,
+ const media::AudioConfig& config,
int32_t flags, int32_t selectedDeviceId,
media::GetOutputForAttrResponse* _aidl_return) override;
binder::Status startOutput(int32_t portId) override;
binder::Status stopOutput(int32_t portId) override;
binder::Status releaseOutput(int32_t portId) override;
binder::Status getInputForAttr(const media::AudioAttributesInternal& attr, int32_t input,
- int32_t riid, int32_t session, int32_t pid, int32_t uid,
- const std::string& opPackageName,
+ int32_t riid, int32_t session,
+ const media::permission::Identity &identity,
const media::AudioConfigBase& config, int32_t flags,
int32_t selectedDeviceId,
media::GetInputForAttrResponse* _aidl_return) override;
@@ -339,7 +342,7 @@
bool isSupportedSystemUsage(audio_usage_t usage);
status_t validateUsage(audio_usage_t usage);
- status_t validateUsage(audio_usage_t usage, pid_t pid, uid_t uid);
+ status_t validateUsage(audio_usage_t usage, const media::permission::Identity& identity);
bool isUserSensorPrivacyEnabledForUid(uid_t uid);
@@ -784,18 +787,18 @@
class AudioClient : public virtual RefBase {
public:
AudioClient(const audio_attributes_t attributes,
- const audio_io_handle_t io, uid_t uid, pid_t pid,
+ const audio_io_handle_t io,
+ const media::permission::Identity& identity,
const audio_session_t session, audio_port_handle_t portId,
const audio_port_handle_t deviceId) :
- attributes(attributes), io(io), uid(uid), pid(pid),
+ attributes(attributes), io(io), identity(identity),
session(session), portId(portId), deviceId(deviceId), active(false) {}
~AudioClient() override = default;
const audio_attributes_t attributes; // source, flags ...
const audio_io_handle_t io; // audio HAL stream IO handle
- const uid_t uid; // client UID
- const pid_t pid; // client PID
+ const media::permission::Identity& identity; //client identity
const audio_session_t session; // audio session ID
const audio_port_handle_t portId;
const audio_port_handle_t deviceId; // selected input device port ID
@@ -808,16 +811,17 @@
class AudioRecordClient : public AudioClient {
public:
AudioRecordClient(const audio_attributes_t attributes,
- const audio_io_handle_t io, uid_t uid, pid_t pid,
+ const audio_io_handle_t io,
const audio_session_t session, audio_port_handle_t portId,
- const audio_port_handle_t deviceId, const String16& opPackageName,
+ const audio_port_handle_t deviceId,
+ const media::permission::Identity& identity,
bool canCaptureOutput, bool canCaptureHotword) :
- AudioClient(attributes, io, uid, pid, session, portId, deviceId),
- opPackageName(opPackageName), startTimeNs(0),
+ AudioClient(attributes, io, identity,
+ session, portId, deviceId), identity(identity), startTimeNs(0),
canCaptureOutput(canCaptureOutput), canCaptureHotword(canCaptureHotword) {}
~AudioRecordClient() override = default;
- const String16 opPackageName; // client package name
+ const media::permission::Identity identity; // identity of client
nsecs_t startTimeNs;
const bool canCaptureOutput;
const bool canCaptureHotword;
@@ -829,10 +833,11 @@
class AudioPlaybackClient : public AudioClient {
public:
AudioPlaybackClient(const audio_attributes_t attributes,
- const audio_io_handle_t io, uid_t uid, pid_t pid,
+ const audio_io_handle_t io, media::permission::Identity identity,
const audio_session_t session, audio_port_handle_t portId,
audio_port_handle_t deviceId, audio_stream_type_t stream) :
- AudioClient(attributes, io, uid, pid, session, portId, deviceId), stream(stream) {}
+ AudioClient(attributes, io, identity, session, portId,
+ deviceId), stream(stream) {}
~AudioPlaybackClient() override = default;
const audio_stream_type_t stream;
diff --git a/services/audiopolicy/tests/Android.bp b/services/audiopolicy/tests/Android.bp
index d10fcb9..f480210 100644
--- a/services/audiopolicy/tests/Android.bp
+++ b/services/audiopolicy/tests/Android.bp
@@ -25,6 +25,7 @@
"libmedia_helper",
"libutils",
"libxml2",
+ "media_permission-aidl-cpp",
],
static_libs: [
diff --git a/services/audiopolicy/tests/audiopolicymanager_tests.cpp b/services/audiopolicy/tests/audiopolicymanager_tests.cpp
index a8ede90..21ebac13 100644
--- a/services/audiopolicy/tests/audiopolicymanager_tests.cpp
+++ b/services/audiopolicy/tests/audiopolicymanager_tests.cpp
@@ -25,6 +25,7 @@
#define LOG_TAG "APM_Test"
#include <Serializer.h>
#include <android-base/file.h>
+#include <android/media/permission/Identity.h>
#include <media/AudioPolicy.h>
#include <media/PatchBuilder.h>
#include <media/RecordingActivityTracker.h>
@@ -39,6 +40,7 @@
using namespace android;
using testing::UnorderedElementsAre;
+using media::permission::Identity;
TEST(AudioPolicyManagerTestInit, EngineFailure) {
AudioPolicyTestClient client;
@@ -214,8 +216,11 @@
if (!portId) portId = &localPortId;
*portId = AUDIO_PORT_HANDLE_NONE;
AudioPolicyInterface::output_type_t outputType;
+ // TODO b/182392769: use identity util
+ Identity i = Identity();
+ i.uid = 0;
ASSERT_EQ(OK, mManager->getOutputForAttr(
- &attr, output, AUDIO_SESSION_NONE, &stream, 0 /*uid*/, &config, &flags,
+ &attr, output, AUDIO_SESSION_NONE, &stream, i, &config, &flags,
selectedDeviceId, portId, {}, &outputType));
ASSERT_NE(AUDIO_PORT_HANDLE_NONE, *portId);
ASSERT_NE(AUDIO_IO_HANDLE_NONE, *output);
@@ -239,8 +244,11 @@
if (!portId) portId = &localPortId;
*portId = AUDIO_PORT_HANDLE_NONE;
AudioPolicyInterface::input_type_t inputType;
+ // TODO b/182392769: use identity util
+ Identity i = Identity();
+ i.uid = 0;
ASSERT_EQ(OK, mManager->getInputForAttr(
- &attr, &input, riid, AUDIO_SESSION_NONE, 0 /*uid*/, &config, flags,
+ &attr, &input, riid, AUDIO_SESSION_NONE, i, &config, flags,
selectedDeviceId, &inputType, portId));
ASSERT_NE(AUDIO_PORT_HANDLE_NONE, *portId);
}
diff --git a/services/camera/libcameraservice/Android.bp b/services/camera/libcameraservice/Android.bp
index dd37135..a0b35a8 100644
--- a/services/camera/libcameraservice/Android.bp
+++ b/services/camera/libcameraservice/Android.bp
@@ -149,11 +149,13 @@
"android.hardware.camera.device@3.4",
"android.hardware.camera.device@3.5",
"android.hardware.camera.device@3.6",
- "android.hardware.camera.device@3.7"
+ "android.hardware.camera.device@3.7",
+ "media_permission-aidl-cpp",
],
static_libs: [
"libbinderthreadstateutils",
+ "media_permission-aidl-cpp",
],
export_shared_lib_headers: [
diff --git a/services/oboeservice/AAudioEndpointManager.cpp b/services/oboeservice/AAudioEndpointManager.cpp
index 407f6d5..3224cfc 100644
--- a/services/oboeservice/AAudioEndpointManager.cpp
+++ b/services/oboeservice/AAudioEndpointManager.cpp
@@ -24,6 +24,7 @@
#include <mutex>
#include <sstream>
#include <utility/AAudioUtilities.h>
+#include <media/AidlConversion.h>
#include "AAudioClientTracker.h"
#include "AAudioEndpointManager.h"
@@ -182,7 +183,9 @@
// and START calls. This will help preserve app compatibility.
// An app can avoid having this happen by closing their streams when
// the app is paused.
- AAudioClientTracker::getInstance().setExclusiveEnabled(request.getProcessId(), false);
+ pid_t pid = VALUE_OR_FATAL(
+ aidl2legacy_int32_t_pid_t(request.getIdentity().pid));
+ AAudioClientTracker::getInstance().setExclusiveEnabled(pid, false);
endpointToSteal = endpoint; // return it to caller
}
return nullptr;
diff --git a/services/oboeservice/AAudioService.cpp b/services/oboeservice/AAudioService.cpp
index 69e58f6..8baf8dc 100644
--- a/services/oboeservice/AAudioService.cpp
+++ b/services/oboeservice/AAudioService.cpp
@@ -22,7 +22,9 @@
#include <iostream>
#include <sstream>
+#include <android/media/permission/Identity.h>
#include <aaudio/AAudio.h>
+#include <media/AidlConversion.h>
#include <mediautils/ServiceUtilities.h>
#include <utils/String16.h>
@@ -39,16 +41,24 @@
#define MAX_STREAMS_PER_PROCESS 8
#define AIDL_RETURN(x) *_aidl_return = (x); return Status::ok();
+#define VALUE_OR_RETURN_ILLEGAL_ARG_STATUS(x) \
+ ({ auto _tmp = (x); \
+ if (!_tmp.ok()) AIDL_RETURN(AAUDIO_ERROR_ILLEGAL_ARGUMENT); \
+ std::move(_tmp.value()); })
using android::AAudioService;
+using android::media::permission::Identity;
using binder::Status;
android::AAudioService::AAudioService()
: BnAAudioService(),
mAdapter(this) {
- mAudioClient.clientUid = getuid(); // TODO consider using geteuid()
- mAudioClient.clientPid = getpid();
- mAudioClient.packageName = String16("");
+ // TODO consider using geteuid()
+ // TODO b/182392769: use identity util
+ mAudioClient.identity.uid = VALUE_OR_FATAL(legacy2aidl_uid_t_int32_t(getuid()));
+ mAudioClient.identity.pid = VALUE_OR_FATAL(legacy2aidl_pid_t_int32_t(getpid()));
+ mAudioClient.identity.packageName = std::nullopt;
+ mAudioClient.identity.attributionTag = std::nullopt;
AAudioClientTracker::getInstance().setAAudioService(this);
}
@@ -105,8 +115,14 @@
aaudio_sharing_mode_t sharingMode = configurationInput.getSharingMode();
// Enforce limit on client processes.
- pid_t pid = request.getProcessId();
- if (pid != mAudioClient.clientPid) {
+ Identity callingIdentity = request.getIdentity();
+ callingIdentity.pid = VALUE_OR_RETURN_ILLEGAL_ARG_STATUS(
+ legacy2aidl_pid_t_int32_t(IPCThreadState::self()->getCallingPid()));
+ callingIdentity.uid = VALUE_OR_RETURN_ILLEGAL_ARG_STATUS(
+ legacy2aidl_uid_t_int32_t(IPCThreadState::self()->getCallingUid()));
+ pid_t pid = VALUE_OR_RETURN_ILLEGAL_ARG_STATUS(
+ aidl2legacy_int32_t_pid_t(callingIdentity.pid));
+ if (callingIdentity.pid != mAudioClient.identity.pid) {
int32_t count = AAudioClientTracker::getInstance().getStreamCount(pid);
if (count >= MAX_STREAMS_PER_PROCESS) {
ALOGE("openStream(): exceeded max streams per process %d >= %d",
@@ -121,7 +137,7 @@
}
if (sharingMode == AAUDIO_SHARING_MODE_EXCLUSIVE
- && AAudioClientTracker::getInstance().isExclusiveEnabled(request.getProcessId())) {
+ && AAudioClientTracker::getInstance().isExclusiveEnabled(pid)) {
// only trust audioserver for in service indication
bool inService = false;
if (isCallerInService()) {
@@ -154,7 +170,6 @@
} else {
aaudio_handle_t handle = mStreamTracker.addStreamForHandle(serviceStream.get());
serviceStream->setHandle(handle);
- pid_t pid = request.getProcessId();
AAudioClientTracker::getInstance().registerClientStream(pid, serviceStream);
paramsOut.copyFrom(*serviceStream);
*_paramsOut = std::move(paramsOut).parcelable();
@@ -266,8 +281,10 @@
}
bool AAudioService::isCallerInService() {
- return mAudioClient.clientPid == IPCThreadState::self()->getCallingPid() &&
- mAudioClient.clientUid == IPCThreadState::self()->getCallingUid();
+ pid_t clientPid = VALUE_OR_FATAL(aidl2legacy_int32_t_pid_t(mAudioClient.identity.pid));
+ uid_t clientUid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(mAudioClient.identity.uid));
+ return clientPid == IPCThreadState::self()->getCallingPid() &&
+ clientUid == IPCThreadState::self()->getCallingUid();
}
aaudio_result_t AAudioService::closeStream(sp<AAudioServiceStreamBase> serviceStream) {
@@ -290,9 +307,11 @@
// Only allow owner or the aaudio service to access the stream.
const uid_t callingUserId = IPCThreadState::self()->getCallingUid();
const uid_t ownerUserId = serviceStream->getOwnerUserId();
+ const uid_t clientUid = VALUE_OR_FATAL(
+ aidl2legacy_int32_t_uid_t(mAudioClient.identity.uid));
bool callerOwnsIt = callingUserId == ownerUserId;
- bool serverCalling = callingUserId == mAudioClient.clientUid;
- bool serverOwnsIt = ownerUserId == mAudioClient.clientUid;
+ bool serverCalling = callingUserId == clientUid;
+ bool serverOwnsIt = ownerUserId == clientUid;
bool allowed = callerOwnsIt || serverCalling || serverOwnsIt;
if (!allowed) {
ALOGE("AAudioService: calling uid %d cannot access stream 0x%08X owned by %d",
diff --git a/services/oboeservice/AAudioServiceEndpointMMAP.cpp b/services/oboeservice/AAudioServiceEndpointMMAP.cpp
index 85b2057..556710d 100644
--- a/services/oboeservice/AAudioServiceEndpointMMAP.cpp
+++ b/services/oboeservice/AAudioServiceEndpointMMAP.cpp
@@ -73,9 +73,12 @@
aaudio_result_t AAudioServiceEndpointMMAP::open(const aaudio::AAudioStreamRequest &request) {
aaudio_result_t result = AAUDIO_OK;
copyFrom(request.getConstantConfiguration());
- mMmapClient.clientUid = request.getUserId();
- mMmapClient.clientPid = request.getProcessId();
- mMmapClient.packageName.setTo(String16(""));
+ mMmapClient.identity = request.getIdentity();
+ // TODO b/182392769: use identity util
+ mMmapClient.identity.uid = VALUE_OR_FATAL(
+ legacy2aidl_uid_t_int32_t(IPCThreadState::self()->getCallingUid()));
+ mMmapClient.identity.pid = VALUE_OR_FATAL(
+ legacy2aidl_pid_t_int32_t(IPCThreadState::self()->getCallingPid()));
audio_format_t audioFormat = getFormat();
@@ -159,8 +162,8 @@
this, // callback
mMmapStream,
&mPortHandle);
- ALOGD("%s() mMapClient.uid = %d, pid = %d => portHandle = %d\n",
- __func__, mMmapClient.clientUid, mMmapClient.clientPid, mPortHandle);
+ ALOGD("%s() mMapClient.identity = %s => portHandle = %d\n",
+ __func__, mMmapClient.identity.toString().c_str(), mPortHandle);
if (status != OK) {
// This can happen if the resource is busy or the config does
// not match the hardware.
@@ -208,8 +211,9 @@
setBufferCapacity(mMmapBufferinfo.buffer_size_frames);
if (!isBufferShareable) {
// Exclusive mode can only be used by the service because the FD cannot be shared.
- uid_t audioServiceUid = getuid();
- if ((mMmapClient.clientUid != audioServiceUid) &&
+ int32_t audioServiceUid =
+ VALUE_OR_FATAL(legacy2aidl_uid_t_int32_t(getuid()));
+ if ((mMmapClient.identity.uid != audioServiceUid) &&
getSharingMode() == AAUDIO_SHARING_MODE_EXCLUSIVE) {
ALOGW("%s() - exclusive FD cannot be used by client", __func__);
result = AAUDIO_ERROR_UNAVAILABLE;
diff --git a/services/oboeservice/AAudioServiceStreamBase.cpp b/services/oboeservice/AAudioServiceStreamBase.cpp
index 7edc25c..694094c 100644
--- a/services/oboeservice/AAudioServiceStreamBase.cpp
+++ b/services/oboeservice/AAudioServiceStreamBase.cpp
@@ -39,6 +39,8 @@
using namespace android; // TODO just import names needed
using namespace aaudio; // TODO just import names needed
+using media::permission::Identity;
+
/**
* Base class for streams in the service.
* @return
@@ -48,9 +50,7 @@
: mTimestampThread("AATime")
, mAtomicStreamTimestamp()
, mAudioService(audioService) {
- mMmapClient.clientUid = -1;
- mMmapClient.clientPid = -1;
- mMmapClient.packageName = String16("");
+ mMmapClient.identity = Identity();
}
AAudioServiceStreamBase::~AAudioServiceStreamBase() {
@@ -82,7 +82,7 @@
result << " 0x" << std::setfill('0') << std::setw(8) << std::hex << mHandle
<< std::dec << std::setfill(' ') ;
- result << std::setw(6) << mMmapClient.clientUid;
+ result << std::setw(6) << mMmapClient.identity.uid;
result << std::setw(7) << mClientHandle;
result << std::setw(4) << (isRunning() ? "yes" : " no");
result << std::setw(6) << getState();
@@ -128,9 +128,12 @@
AAudioEndpointManager &mEndpointManager = AAudioEndpointManager::getInstance();
aaudio_result_t result = AAUDIO_OK;
- mMmapClient.clientUid = request.getUserId();
- mMmapClient.clientPid = request.getProcessId();
- mMmapClient.packageName.setTo(String16("")); // TODO What should we do here?
+ mMmapClient.identity = request.getIdentity();
+ // TODO b/182392769: use identity util
+ mMmapClient.identity.uid = VALUE_OR_FATAL(
+ legacy2aidl_uid_t_int32_t(IPCThreadState::self()->getCallingUid()));
+ mMmapClient.identity.pid = VALUE_OR_FATAL(
+ legacy2aidl_pid_t_int32_t(IPCThreadState::self()->getCallingPid()));
// Limit scope of lock to avoid recursive lock in close().
{
diff --git a/services/oboeservice/AAudioServiceStreamBase.h b/services/oboeservice/AAudioServiceStreamBase.h
index 0f752b7..06c9f21 100644
--- a/services/oboeservice/AAudioServiceStreamBase.h
+++ b/services/oboeservice/AAudioServiceStreamBase.h
@@ -21,6 +21,7 @@
#include <mutex>
#include <android-base/thread_annotations.h>
+#include <media/AidlConversion.h>
#include <media/AudioClient.h>
#include <utils/RefBase.h>
@@ -159,11 +160,11 @@
}
uid_t getOwnerUserId() const {
- return mMmapClient.clientUid;
+ return VALUE_OR_FATAL(android::aidl2legacy_int32_t_uid_t(mMmapClient.identity.uid));
}
pid_t getOwnerProcessId() const {
- return mMmapClient.clientPid;
+ return VALUE_OR_FATAL(android::aidl2legacy_int32_t_pid_t(mMmapClient.identity.pid));
}
aaudio_handle_t getHandle() const {
diff --git a/services/oboeservice/Android.bp b/services/oboeservice/Android.bp
index 21f3247..a419dd5 100644
--- a/services/oboeservice/Android.bp
+++ b/services/oboeservice/Android.bp
@@ -66,10 +66,13 @@
"liblog",
"libutils",
"aaudio-aidl-cpp",
+ "media_permission-aidl-cpp",
+ "libaudioclient_aidl_conversion",
],
export_shared_lib_headers: [
"libaaudio_internal",
+ "media_permission-aidl-cpp",
],
header_libs: [
diff --git a/services/oboeservice/fuzzer/Android.bp b/services/oboeservice/fuzzer/Android.bp
index 78ef3fc..f4e8a81 100644
--- a/services/oboeservice/fuzzer/Android.bp
+++ b/services/oboeservice/fuzzer/Android.bp
@@ -46,6 +46,8 @@
"liblog",
"libutils",
"aaudio-aidl-cpp",
+ "media_permission-aidl-cpp",
+ "libaudioclient_aidl_conversion",
],
static_libs: [
"libaaudioservice",
diff --git a/services/oboeservice/fuzzer/oboeservice_fuzzer.cpp b/services/oboeservice/fuzzer/oboeservice_fuzzer.cpp
index 163eae8..8e508d3 100644
--- a/services/oboeservice/fuzzer/oboeservice_fuzzer.cpp
+++ b/services/oboeservice/fuzzer/oboeservice_fuzzer.cpp
@@ -23,6 +23,7 @@
#include <AAudioService.h>
#include <aaudio/AAudio.h>
#include "aaudio/BnAAudioClient.h"
+#include <android/media/permission/Identity.h>
#define UNUSED_PARAM __attribute__((unused))
@@ -294,8 +295,11 @@
? fdp.ConsumeIntegral<int32_t>()
: kAAudioFormats[fdp.ConsumeIntegralInRange<int32_t>(0, kNumAAudioFormats - 1)]));
- request.setUserId(getuid());
- request.setProcessId(getpid());
+ // TODO b/182392769: use identity util
+ media::permission::Identity identity;
+ identity.uid = getuid();
+ identity.pid = getpid();
+ request.setIdentity(identity);
request.setInService(fdp.ConsumeBool());
request.getConfiguration().setDeviceId(fdp.ConsumeIntegral<int32_t>());