blob: 2eb272e111517b664c6f8429220dc052ea14e84d [file] [log] [blame]
Eric Laurent2d388ec2014-03-07 13:25:54 -08001/*
2 * Copyright (C) 2009 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
Eric Laurentdce54a12014-03-10 12:19:46 -070017#define LOG_TAG "AudioPolicyIntefaceImpl"
Eric Laurent2d388ec2014-03-07 13:25:54 -080018//#define LOG_NDEBUG 0
19
Eric Laurent2d388ec2014-03-07 13:25:54 -080020#include "AudioPolicyService.h"
Ray Essick84e84a52018-05-03 18:45:07 -070021#include "TypeConverter.h"
Eric Laurentd7fe0862018-07-14 16:48:01 -070022#include <media/MediaAnalyticsItem.h>
Kevin Rocardbe201852019-02-20 22:33:28 -080023#include <media/AudioPolicy.h>
Eric Laurentd7fe0862018-07-14 16:48:01 -070024#include <utils/Log.h>
Eric Laurent2d388ec2014-03-07 13:25:54 -080025
Eric Laurent2d388ec2014-03-07 13:25:54 -080026namespace android {
27
28
29// ----------------------------------------------------------------------------
30
31status_t AudioPolicyService::setDeviceConnectionState(audio_devices_t device,
32 audio_policy_dev_state_t state,
Paul McLeane743a472015-01-28 11:07:31 -080033 const char *device_address,
Aniket Kumar Lata4e464702019-01-10 23:38:46 -080034 const char *device_name,
35 audio_format_t encodedFormat)
Eric Laurent2d388ec2014-03-07 13:25:54 -080036{
Eric Laurentdce54a12014-03-10 12:19:46 -070037 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -080038 return NO_INIT;
39 }
40 if (!settingsAllowed()) {
41 return PERMISSION_DENIED;
42 }
Eric Laurent2d388ec2014-03-07 13:25:54 -080043 if (state != AUDIO_POLICY_DEVICE_STATE_AVAILABLE &&
44 state != AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE) {
45 return BAD_VALUE;
46 }
47
48 ALOGV("setDeviceConnectionState()");
49 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -070050 AutoCallerClear acc;
Paul McLeane743a472015-01-28 11:07:31 -080051 return mAudioPolicyManager->setDeviceConnectionState(device, state,
Aniket Kumar Lata4e464702019-01-10 23:38:46 -080052 device_address, device_name, encodedFormat);
Eric Laurent2d388ec2014-03-07 13:25:54 -080053}
54
55audio_policy_dev_state_t AudioPolicyService::getDeviceConnectionState(
56 audio_devices_t device,
57 const char *device_address)
58{
Eric Laurentdce54a12014-03-10 12:19:46 -070059 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -080060 return AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE;
61 }
Eric Laurent10b71232018-04-13 18:14:44 -070062 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -070063 return mAudioPolicyManager->getDeviceConnectionState(device,
Eric Laurent2d388ec2014-03-07 13:25:54 -080064 device_address);
65}
66
Pavlin Radoslavovf862bc62016-12-26 18:57:22 -080067status_t AudioPolicyService::handleDeviceConfigChange(audio_devices_t device,
68 const char *device_address,
Aniket Kumar Lata4e464702019-01-10 23:38:46 -080069 const char *device_name,
70 audio_format_t encodedFormat)
Pavlin Radoslavovf862bc62016-12-26 18:57:22 -080071{
72 if (mAudioPolicyManager == NULL) {
73 return NO_INIT;
74 }
75 if (!settingsAllowed()) {
76 return PERMISSION_DENIED;
77 }
Pavlin Radoslavovf862bc62016-12-26 18:57:22 -080078
79 ALOGV("handleDeviceConfigChange()");
80 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -070081 AutoCallerClear acc;
Pavlin Radoslavovf862bc62016-12-26 18:57:22 -080082 return mAudioPolicyManager->handleDeviceConfigChange(device, device_address,
Aniket Kumar Lata4e464702019-01-10 23:38:46 -080083 device_name, encodedFormat);
Pavlin Radoslavovf862bc62016-12-26 18:57:22 -080084}
85
Eric Laurent2d388ec2014-03-07 13:25:54 -080086status_t AudioPolicyService::setPhoneState(audio_mode_t state)
87{
Eric Laurentdce54a12014-03-10 12:19:46 -070088 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -080089 return NO_INIT;
90 }
91 if (!settingsAllowed()) {
92 return PERMISSION_DENIED;
93 }
94 if (uint32_t(state) >= AUDIO_MODE_CNT) {
95 return BAD_VALUE;
96 }
97
98 ALOGV("setPhoneState()");
99
Eric Laurentbeb07fe2015-09-16 15:49:30 -0700100 // acquire lock before calling setMode() so that setMode() + setPhoneState() are an atomic
101 // operation from policy manager standpoint (no other operation (e.g track start or stop)
102 // can be interleaved).
103 Mutex::Autolock _l(mLock);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800104 // TODO: check if it is more appropriate to do it in platform specific policy manager
105 AudioSystem::setMode(state);
106
Eric Laurent10b71232018-04-13 18:14:44 -0700107 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700108 mAudioPolicyManager->setPhoneState(state);
Eric Laurentbb6c9a02014-09-25 14:11:47 -0700109 mPhoneState = state;
Eric Laurent2d388ec2014-03-07 13:25:54 -0800110 return NO_ERROR;
111}
112
Eric Laurentbb6c9a02014-09-25 14:11:47 -0700113audio_mode_t AudioPolicyService::getPhoneState()
114{
115 Mutex::Autolock _l(mLock);
116 return mPhoneState;
117}
118
Eric Laurent2d388ec2014-03-07 13:25:54 -0800119status_t AudioPolicyService::setForceUse(audio_policy_force_use_t usage,
120 audio_policy_forced_cfg_t config)
121{
Eric Laurentdce54a12014-03-10 12:19:46 -0700122 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800123 return NO_INIT;
124 }
Eric Laurente17378d2018-05-09 14:43:01 -0700125
126 if (!modifyAudioRoutingAllowed()) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800127 return PERMISSION_DENIED;
128 }
Eric Laurente17378d2018-05-09 14:43:01 -0700129
Eric Laurent2d388ec2014-03-07 13:25:54 -0800130 if (usage < 0 || usage >= AUDIO_POLICY_FORCE_USE_CNT) {
131 return BAD_VALUE;
132 }
133 if (config < 0 || config >= AUDIO_POLICY_FORCE_CFG_CNT) {
134 return BAD_VALUE;
135 }
136 ALOGV("setForceUse()");
137 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700138 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700139 mAudioPolicyManager->setForceUse(usage, config);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800140 return NO_ERROR;
141}
142
143audio_policy_forced_cfg_t AudioPolicyService::getForceUse(audio_policy_force_use_t usage)
144{
Eric Laurentdce54a12014-03-10 12:19:46 -0700145 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800146 return AUDIO_POLICY_FORCE_NONE;
147 }
148 if (usage < 0 || usage >= AUDIO_POLICY_FORCE_USE_CNT) {
149 return AUDIO_POLICY_FORCE_NONE;
150 }
Eric Laurent10b71232018-04-13 18:14:44 -0700151 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700152 return mAudioPolicyManager->getForceUse(usage);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800153}
154
Eric Laurentf4e63452017-11-06 19:31:46 +0000155audio_io_handle_t AudioPolicyService::getOutput(audio_stream_type_t stream)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800156{
Eric Laurent223fd5c2014-11-11 13:43:36 -0800157 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
Eric Laurentb1322c72014-10-30 14:59:13 -0700158 return AUDIO_IO_HANDLE_NONE;
Eric Laurentdea15412014-10-28 15:46:45 -0700159 }
Eric Laurentdce54a12014-03-10 12:19:46 -0700160 if (mAudioPolicyManager == NULL) {
Eric Laurentb1322c72014-10-30 14:59:13 -0700161 return AUDIO_IO_HANDLE_NONE;
Eric Laurent2d388ec2014-03-07 13:25:54 -0800162 }
163 ALOGV("getOutput()");
164 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700165 AutoCallerClear acc;
Eric Laurentf4e63452017-11-06 19:31:46 +0000166 return mAudioPolicyManager->getOutput(stream);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800167}
168
Kevin Rocard8be94972019-02-22 13:26:25 -0800169status_t AudioPolicyService::getOutputForAttr(const audio_attributes_t *originalAttr,
Eric Laurente83b55d2014-11-14 10:06:21 -0800170 audio_io_handle_t *output,
171 audio_session_t session,
172 audio_stream_type_t *stream,
Nadav Bar766fb022018-01-07 12:18:03 +0200173 pid_t pid,
Eric Laurent8c7e6da2015-04-21 17:37:00 -0700174 uid_t uid,
Eric Laurent20b9ef02016-12-05 11:03:16 -0800175 const audio_config_t *config,
Eric Laurente83b55d2014-11-14 10:06:21 -0800176 audio_output_flags_t flags,
Eric Laurent9ae8c592017-06-22 17:17:09 -0700177 audio_port_handle_t *selectedDeviceId,
Kevin Rocard153f92d2018-12-18 18:33:28 -0800178 audio_port_handle_t *portId,
179 std::vector<audio_io_handle_t> *secondaryOutputs)
Jean-Michel Trivi5bd3f382014-06-13 16:06:54 -0700180{
181 if (mAudioPolicyManager == NULL) {
Eric Laurente83b55d2014-11-14 10:06:21 -0800182 return NO_INIT;
Jean-Michel Trivi5bd3f382014-06-13 16:06:54 -0700183 }
Eric Laurentf4e63452017-11-06 19:31:46 +0000184 ALOGV("getOutputForAttr()");
Jean-Michel Trivi5bd3f382014-06-13 16:06:54 -0700185 Mutex::Autolock _l(mLock);
Eric Laurent8c7e6da2015-04-21 17:37:00 -0700186
Marco Nelissendcb346b2015-09-09 10:47:29 -0700187 const uid_t callingUid = IPCThreadState::self()->getCallingUid();
Andy Hung4ef19fa2018-05-15 19:35:29 -0700188 if (!isAudioServerOrMediaServerUid(callingUid) || uid == (uid_t)-1) {
Marco Nelissendcb346b2015-09-09 10:47:29 -0700189 ALOGW_IF(uid != (uid_t)-1 && uid != callingUid,
190 "%s uid %d tried to pass itself off as %d", __FUNCTION__, callingUid, uid);
191 uid = callingUid;
Eric Laurent8c7e6da2015-04-21 17:37:00 -0700192 }
Kevin Rocard8be94972019-02-22 13:26:25 -0800193 audio_attributes_t attr = *originalAttr;
194 if (!mPackageManager.allowPlaybackCapture(uid)) {
Kevin Rocard36b17552019-03-07 18:48:07 -0800195 attr.flags |= AUDIO_FLAG_NO_MEDIA_PROJECTION;
Kevin Rocard8be94972019-02-22 13:26:25 -0800196 }
Nadav Bar766fb022018-01-07 12:18:03 +0200197 audio_output_flags_t originalFlags = flags;
Eric Laurent10b71232018-04-13 18:14:44 -0700198 AutoCallerClear acc;
Kevin Rocard8be94972019-02-22 13:26:25 -0800199 status_t result = mAudioPolicyManager->getOutputForAttr(&attr, output, session, stream, uid,
Eric Laurent20b9ef02016-12-05 11:03:16 -0800200 config,
Kevin Rocard153f92d2018-12-18 18:33:28 -0800201 &flags, selectedDeviceId, portId,
202 secondaryOutputs);
Nadav Bar766fb022018-01-07 12:18:03 +0200203
204 // FIXME: Introduce a way to check for the the telephony device before opening the output
205 if ((result == NO_ERROR) &&
206 (flags & AUDIO_OUTPUT_FLAG_INCALL_MUSIC) &&
207 !modifyPhoneStateAllowed(pid, uid)) {
208 // If the app tries to play music through the telephony device and doesn't have permission
209 // the fallback to the default output device.
Eric Laurent8fc147b2018-07-22 19:13:55 -0700210 mAudioPolicyManager->releaseOutput(*portId);
Nadav Bar766fb022018-01-07 12:18:03 +0200211 flags = originalFlags;
212 *selectedDeviceId = AUDIO_PORT_HANDLE_NONE;
213 *portId = AUDIO_PORT_HANDLE_NONE;
Kevin Rocard153f92d2018-12-18 18:33:28 -0800214 secondaryOutputs->clear();
Kevin Rocard8be94972019-02-22 13:26:25 -0800215 result = mAudioPolicyManager->getOutputForAttr(&attr, output, session, stream, uid, config,
Kevin Rocard153f92d2018-12-18 18:33:28 -0800216 &flags, selectedDeviceId, portId,
217 secondaryOutputs);
Nadav Bar766fb022018-01-07 12:18:03 +0200218 }
Eric Laurentd7fe0862018-07-14 16:48:01 -0700219
220 if (result == NO_ERROR) {
221 sp <AudioPlaybackClient> client =
Kevin Rocard8be94972019-02-22 13:26:25 -0800222 new AudioPlaybackClient(attr, *output, uid, pid, session, *selectedDeviceId, *stream);
Eric Laurentd7fe0862018-07-14 16:48:01 -0700223 mAudioPlaybackClients.add(*portId, client);
224 }
Nadav Bar766fb022018-01-07 12:18:03 +0200225 return result;
Jean-Michel Trivi5bd3f382014-06-13 16:06:54 -0700226}
227
Eric Laurentbcfe5be2019-04-09 19:56:39 -0700228void AudioPolicyService::getPlaybackClientAndEffects(audio_port_handle_t portId,
229 sp<AudioPlaybackClient>& client,
230 sp<AudioPolicyEffects>& effects,
231 const char *context)
232{
233 Mutex::Autolock _l(mLock);
234 const ssize_t index = mAudioPlaybackClients.indexOfKey(portId);
235 if (index < 0) {
236 ALOGE("%s AudioTrack client not found for portId %d", context, portId);
237 return;
238 }
239 client = mAudioPlaybackClients.valueAt(index);
240 effects = mAudioPolicyEffects;
241}
242
Eric Laurentd7fe0862018-07-14 16:48:01 -0700243status_t AudioPolicyService::startOutput(audio_port_handle_t portId)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800244{
Eric Laurentdce54a12014-03-10 12:19:46 -0700245 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800246 return NO_INIT;
247 }
248 ALOGV("startOutput()");
Eric Laurentd7fe0862018-07-14 16:48:01 -0700249 sp<AudioPlaybackClient> client;
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700250 sp<AudioPolicyEffects>audioPolicyEffects;
Eric Laurentbcfe5be2019-04-09 19:56:39 -0700251
252 getPlaybackClientAndEffects(portId, client, audioPolicyEffects, __func__);
253
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700254 if (audioPolicyEffects != 0) {
255 // create audio processors according to stream
Eric Laurentd7fe0862018-07-14 16:48:01 -0700256 status_t status = audioPolicyEffects->addOutputSessionEffects(
257 client->io, client->stream, client->session);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700258 if (status != NO_ERROR && status != ALREADY_EXISTS) {
Eric Laurentd7fe0862018-07-14 16:48:01 -0700259 ALOGW("Failed to add effects on session %d", client->session);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700260 }
261 }
262 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700263 AutoCallerClear acc;
Eric Laurent8fc147b2018-07-22 19:13:55 -0700264 status_t status = mAudioPolicyManager->startOutput(portId);
Eric Laurentd7fe0862018-07-14 16:48:01 -0700265 if (status == NO_ERROR) {
266 client->active = true;
267 }
268 return status;
Eric Laurent2d388ec2014-03-07 13:25:54 -0800269}
270
Eric Laurentd7fe0862018-07-14 16:48:01 -0700271status_t AudioPolicyService::stopOutput(audio_port_handle_t portId)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800272{
Eric Laurentdce54a12014-03-10 12:19:46 -0700273 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800274 return NO_INIT;
275 }
276 ALOGV("stopOutput()");
Eric Laurentd7fe0862018-07-14 16:48:01 -0700277 mOutputCommandThread->stopOutputCommand(portId);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800278 return NO_ERROR;
279}
280
Eric Laurentd7fe0862018-07-14 16:48:01 -0700281status_t AudioPolicyService::doStopOutput(audio_port_handle_t portId)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800282{
Eric Laurentd7fe0862018-07-14 16:48:01 -0700283 ALOGV("doStopOutput");
284 sp<AudioPlaybackClient> client;
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700285 sp<AudioPolicyEffects>audioPolicyEffects;
Eric Laurentd7fe0862018-07-14 16:48:01 -0700286
Eric Laurentbcfe5be2019-04-09 19:56:39 -0700287 getPlaybackClientAndEffects(portId, client, audioPolicyEffects, __func__);
288
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700289 if (audioPolicyEffects != 0) {
290 // release audio processors from the stream
Eric Laurentd7fe0862018-07-14 16:48:01 -0700291 status_t status = audioPolicyEffects->releaseOutputSessionEffects(
292 client->io, client->stream, client->session);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700293 if (status != NO_ERROR && status != ALREADY_EXISTS) {
Eric Laurentd7fe0862018-07-14 16:48:01 -0700294 ALOGW("Failed to release effects on session %d", client->session);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700295 }
296 }
297 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700298 AutoCallerClear acc;
Eric Laurent8fc147b2018-07-22 19:13:55 -0700299 status_t status = mAudioPolicyManager->stopOutput(portId);
Eric Laurentd7fe0862018-07-14 16:48:01 -0700300 if (status == NO_ERROR) {
301 client->active = false;
302 }
303 return status;
Eric Laurent2d388ec2014-03-07 13:25:54 -0800304}
305
Eric Laurentd7fe0862018-07-14 16:48:01 -0700306void AudioPolicyService::releaseOutput(audio_port_handle_t portId)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800307{
Eric Laurentdce54a12014-03-10 12:19:46 -0700308 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800309 return;
310 }
311 ALOGV("releaseOutput()");
Eric Laurentd7fe0862018-07-14 16:48:01 -0700312 mOutputCommandThread->releaseOutputCommand(portId);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800313}
314
Eric Laurentd7fe0862018-07-14 16:48:01 -0700315void AudioPolicyService::doReleaseOutput(audio_port_handle_t portId)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800316{
317 ALOGV("doReleaseOutput from tid %d", gettid());
Eric Laurentbcfe5be2019-04-09 19:56:39 -0700318 sp<AudioPlaybackClient> client;
319 sp<AudioPolicyEffects> audioPolicyEffects;
320
321 getPlaybackClientAndEffects(portId, client, audioPolicyEffects, __func__);
322
323 if (audioPolicyEffects != 0 && client->active) {
324 // clean up effects if output was not stopped before being released
325 audioPolicyEffects->releaseOutputSessionEffects(
326 client->io, client->stream, client->session);
Eric Laurentd7fe0862018-07-14 16:48:01 -0700327 }
Eric Laurentbcfe5be2019-04-09 19:56:39 -0700328 Mutex::Autolock _l(mLock);
Eric Laurentd4007242019-03-27 12:42:16 -0700329 mAudioPlaybackClients.removeItem(portId);
Eric Laurentd7fe0862018-07-14 16:48:01 -0700330
Eric Laurent10b71232018-04-13 18:14:44 -0700331 // called from internal thread: no need to clear caller identity
Eric Laurent8fc147b2018-07-22 19:13:55 -0700332 mAudioPolicyManager->releaseOutput(portId);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800333}
334
Eric Laurentcaf7f482014-11-25 17:50:47 -0800335status_t AudioPolicyService::getInputForAttr(const audio_attributes_t *attr,
336 audio_io_handle_t *input,
337 audio_session_t session,
Eric Laurentb2379ba2016-05-23 17:42:12 -0700338 pid_t pid,
Eric Laurent8c7e6da2015-04-21 17:37:00 -0700339 uid_t uid,
Eric Laurentfee19762018-01-29 18:44:13 -0800340 const String16& opPackageName,
Eric Laurent20b9ef02016-12-05 11:03:16 -0800341 const audio_config_base_t *config,
Paul McLean466dc8e2015-04-17 13:15:36 -0600342 audio_input_flags_t flags,
Eric Laurent9ae8c592017-06-22 17:17:09 -0700343 audio_port_handle_t *selectedDeviceId,
Eric Laurent20b9ef02016-12-05 11:03:16 -0800344 audio_port_handle_t *portId)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800345{
Eric Laurentdce54a12014-03-10 12:19:46 -0700346 if (mAudioPolicyManager == NULL) {
Eric Laurentcaf7f482014-11-25 17:50:47 -0800347 return NO_INIT;
Eric Laurent2d388ec2014-03-07 13:25:54 -0800348 }
Eric Laurent7dca8a82018-01-29 18:44:26 -0800349
Eric Laurent2d388ec2014-03-07 13:25:54 -0800350 // already checked by client, but double-check in case the client wrapper is bypassed
Eric Laurentae4b6ec2019-01-15 18:34:38 -0800351 if ((attr->source < AUDIO_SOURCE_DEFAULT)
352 || (attr->source >= AUDIO_SOURCE_CNT
353 && attr->source != AUDIO_SOURCE_HOTWORD
354 && attr->source != AUDIO_SOURCE_FM_TUNER
355 && attr->source != AUDIO_SOURCE_ECHO_REFERENCE)) {
Eric Laurentcaf7f482014-11-25 17:50:47 -0800356 return BAD_VALUE;
Eric Laurent2d388ec2014-03-07 13:25:54 -0800357 }
358
Eric Laurentb2379ba2016-05-23 17:42:12 -0700359 bool updatePid = (pid == -1);
Marco Nelissendcb346b2015-09-09 10:47:29 -0700360 const uid_t callingUid = IPCThreadState::self()->getCallingUid();
Andy Hung4ef19fa2018-05-15 19:35:29 -0700361 if (!isAudioServerOrMediaServerUid(callingUid)) {
Eric Laurent9f39f8d2016-05-25 12:34:48 -0700362 ALOGW_IF(uid != (uid_t)-1 && uid != callingUid,
Marco Nelissendcb346b2015-09-09 10:47:29 -0700363 "%s uid %d tried to pass itself off as %d", __FUNCTION__, callingUid, uid);
364 uid = callingUid;
Eric Laurentb2379ba2016-05-23 17:42:12 -0700365 updatePid = true;
366 }
367
368 if (updatePid) {
369 const pid_t callingPid = IPCThreadState::self()->getCallingPid();
Eric Laurent9f39f8d2016-05-25 12:34:48 -0700370 ALOGW_IF(pid != (pid_t)-1 && pid != callingPid,
Eric Laurentb2379ba2016-05-23 17:42:12 -0700371 "%s uid %d pid %d tried to pass itself off as pid %d",
372 __func__, callingUid, callingPid, pid);
373 pid = callingPid;
Eric Laurent8c7e6da2015-04-21 17:37:00 -0700374 }
375
Eric Laurent7dca8a82018-01-29 18:44:26 -0800376 // check calling permissions
377 if (!recordingAllowed(opPackageName, pid, uid)) {
378 ALOGE("%s permission denied: recording not allowed for uid %d pid %d",
379 __func__, uid, pid);
380 return PERMISSION_DENIED;
381 }
382
Eric Laurent1ff16a72019-03-14 18:35:04 -0700383 bool canCaptureOutput = captureAudioOutputAllowed(pid, uid);
Nadav Bar744be482018-05-08 13:26:21 +0300384 if ((attr->source == AUDIO_SOURCE_VOICE_UPLINK ||
385 attr->source == AUDIO_SOURCE_VOICE_DOWNLINK ||
Eric Laurentae4b6ec2019-01-15 18:34:38 -0800386 attr->source == AUDIO_SOURCE_VOICE_CALL ||
387 attr->source == AUDIO_SOURCE_ECHO_REFERENCE) &&
Eric Laurent1ff16a72019-03-14 18:35:04 -0700388 !canCaptureOutput) {
Nadav Bar744be482018-05-08 13:26:21 +0300389 return PERMISSION_DENIED;
390 }
391
jiabin68e0df72019-03-18 17:55:35 -0700392 bool canCaptureHotword = captureHotwordAllowed(opPackageName, pid, uid);
Eric Laurent1ff16a72019-03-14 18:35:04 -0700393 if ((attr->source == AUDIO_SOURCE_HOTWORD) && !canCaptureHotword) {
Eric Laurent7504b9e2017-08-15 18:17:26 -0700394 return BAD_VALUE;
395 }
396
397 sp<AudioPolicyEffects>audioPolicyEffects;
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700398 {
Eric Laurent7504b9e2017-08-15 18:17:26 -0700399 status_t status;
400 AudioPolicyInterface::input_type_t inputType;
401
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700402 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700403 {
404 AutoCallerClear acc;
405 // the audio_in_acoustics_t parameter is ignored by get_input()
406 status = mAudioPolicyManager->getInputForAttr(attr, input, session, uid,
407 config,
408 flags, selectedDeviceId,
409 &inputType, portId);
410 }
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700411 audioPolicyEffects = mAudioPolicyEffects;
Jean-Michel Trivi97bb33f2014-12-12 16:23:43 -0800412
413 if (status == NO_ERROR) {
414 // enforce permission (if any) required for each type of input
415 switch (inputType) {
Kevin Rocard25f9b052019-02-27 15:08:54 -0800416 case AudioPolicyInterface::API_INPUT_MIX_PUBLIC_CAPTURE_PLAYBACK:
417 // this use case has been validated in audio service with a MediaProjection token,
418 // and doesn't rely on regular permissions
Jean-Michel Trivi97bb33f2014-12-12 16:23:43 -0800419 case AudioPolicyInterface::API_INPUT_LEGACY:
420 break;
Eric Laurent82db2692015-08-07 13:59:42 -0700421 case AudioPolicyInterface::API_INPUT_TELEPHONY_RX:
422 // FIXME: use the same permission as for remote submix for now.
Jean-Michel Trivi97bb33f2014-12-12 16:23:43 -0800423 case AudioPolicyInterface::API_INPUT_MIX_CAPTURE:
Eric Laurent1ff16a72019-03-14 18:35:04 -0700424 if (!canCaptureOutput) {
Jean-Michel Trivi97bb33f2014-12-12 16:23:43 -0800425 ALOGE("getInputForAttr() permission denied: capture not allowed");
426 status = PERMISSION_DENIED;
427 }
428 break;
429 case AudioPolicyInterface::API_INPUT_MIX_EXT_POLICY_REROUTE:
430 if (!modifyAudioRoutingAllowed()) {
431 ALOGE("getInputForAttr() permission denied: modify audio routing not allowed");
432 status = PERMISSION_DENIED;
433 }
434 break;
435 case AudioPolicyInterface::API_INPUT_INVALID:
436 default:
437 LOG_ALWAYS_FATAL("getInputForAttr() encountered an invalid input type %d",
438 (int)inputType);
439 }
440 }
441
442 if (status != NO_ERROR) {
443 if (status == PERMISSION_DENIED) {
Eric Laurent10b71232018-04-13 18:14:44 -0700444 AutoCallerClear acc;
Eric Laurent8fc147b2018-07-22 19:13:55 -0700445 mAudioPolicyManager->releaseInput(*portId);
Jean-Michel Trivi97bb33f2014-12-12 16:23:43 -0800446 }
447 return status;
448 }
Eric Laurentfee19762018-01-29 18:44:13 -0800449
Eric Laurentd7fe0862018-07-14 16:48:01 -0700450 sp<AudioRecordClient> client = new AudioRecordClient(*attr, *input, uid, pid, session,
Eric Laurent1ff16a72019-03-14 18:35:04 -0700451 *selectedDeviceId, opPackageName,
452 canCaptureOutput, canCaptureHotword);
Eric Laurentfee19762018-01-29 18:44:13 -0800453 mAudioRecordClients.add(*portId, client);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700454 }
Jean-Michel Trivi97bb33f2014-12-12 16:23:43 -0800455
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700456 if (audioPolicyEffects != 0) {
457 // create audio pre processors according to input source
Eric Laurentcaf7f482014-11-25 17:50:47 -0800458 status_t status = audioPolicyEffects->addInputEffects(*input, attr->source, session);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700459 if (status != NO_ERROR && status != ALREADY_EXISTS) {
Eric Laurentcaf7f482014-11-25 17:50:47 -0800460 ALOGW("Failed to add effects on input %d", *input);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700461 }
Eric Laurent2d388ec2014-03-07 13:25:54 -0800462 }
Eric Laurentcaf7f482014-11-25 17:50:47 -0800463 return NO_ERROR;
Eric Laurent2d388ec2014-03-07 13:25:54 -0800464}
465
Eric Laurent99fcae42018-05-17 16:59:18 -0700466std::string AudioPolicyService::getDeviceTypeStrForPortId(audio_port_handle_t portId) {
Eric Laurent99fcae42018-05-17 16:59:18 -0700467 struct audio_port port = {};
468 port.id = portId;
469 status_t status = mAudioPolicyManager->getAudioPort(&port);
470 if (status == NO_ERROR && port.type == AUDIO_PORT_TYPE_DEVICE) {
Andy Hung9b181952019-02-25 14:53:36 -0800471 return toString(port.ext.device.type);
Eric Laurent99fcae42018-05-17 16:59:18 -0700472 }
Andy Hung9b181952019-02-25 14:53:36 -0800473 return {};
Eric Laurent99fcae42018-05-17 16:59:18 -0700474}
475
Eric Laurent4eb58f12018-12-07 16:41:02 -0800476status_t AudioPolicyService::startInput(audio_port_handle_t portId)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800477{
Eric Laurentdce54a12014-03-10 12:19:46 -0700478 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800479 return NO_INIT;
480 }
Eric Laurent7dca8a82018-01-29 18:44:26 -0800481 sp<AudioRecordClient> client;
482 {
483 Mutex::Autolock _l(mLock);
Svet Ganovf4ddfef2018-01-16 07:37:58 -0800484
Eric Laurent7dca8a82018-01-29 18:44:26 -0800485 ssize_t index = mAudioRecordClients.indexOfKey(portId);
486 if (index < 0) {
487 return INVALID_OPERATION;
488 }
489 client = mAudioRecordClients.valueAt(index);
Eric Laurentfee19762018-01-29 18:44:13 -0800490 }
Eric Laurent7dca8a82018-01-29 18:44:26 -0800491
492 // check calling permissions
Svet Ganov6e641372018-03-02 09:21:30 -0800493 if (!startRecording(client->opPackageName, client->pid, client->uid)) {
Eric Laurent7dca8a82018-01-29 18:44:26 -0800494 ALOGE("%s permission denied: recording not allowed for uid %d pid %d",
495 __func__, client->uid, client->pid);
496 return PERMISSION_DENIED;
497 }
Eric Laurentfee19762018-01-29 18:44:13 -0800498
Eric Laurentdf628922018-12-06 21:45:51 +0000499 Mutex::Autolock _l(mLock);
Eric Laurent4eb58f12018-12-07 16:41:02 -0800500
501 client->active = true;
502 client->startTimeNs = systemTime();
503 updateUidStates_l();
Eric Laurentfee19762018-01-29 18:44:13 -0800504
Eric Laurent10b71232018-04-13 18:14:44 -0700505 status_t status;
506 {
507 AutoCallerClear acc;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800508 status = mAudioPolicyManager->startInput(portId);
Ray Essick84e84a52018-05-03 18:45:07 -0700509
510 }
511
Ray Essickf6a57cd2018-05-22 16:20:54 -0700512 // including successes gets very verbose
513 if (status != NO_ERROR) {
Ray Essick84e84a52018-05-03 18:45:07 -0700514
515 static constexpr char kAudioPolicy[] = "audiopolicy";
516
Ray Essick84e84a52018-05-03 18:45:07 -0700517 static constexpr char kAudioPolicyStatus[] = "android.media.audiopolicy.status";
518 static constexpr char kAudioPolicyRqstSrc[] = "android.media.audiopolicy.rqst.src";
519 static constexpr char kAudioPolicyRqstPkg[] = "android.media.audiopolicy.rqst.pkg";
520 static constexpr char kAudioPolicyRqstSession[] = "android.media.audiopolicy.rqst.session";
Eric Laurent99fcae42018-05-17 16:59:18 -0700521 static constexpr char kAudioPolicyRqstDevice[] =
522 "android.media.audiopolicy.rqst.device";
Ray Essick84e84a52018-05-03 18:45:07 -0700523 static constexpr char kAudioPolicyActiveSrc[] = "android.media.audiopolicy.active.src";
524 static constexpr char kAudioPolicyActivePkg[] = "android.media.audiopolicy.active.pkg";
Eric Laurent99fcae42018-05-17 16:59:18 -0700525 static constexpr char kAudioPolicyActiveSession[] =
526 "android.media.audiopolicy.active.session";
527 static constexpr char kAudioPolicyActiveDevice[] =
528 "android.media.audiopolicy.active.device";
Ray Essick84e84a52018-05-03 18:45:07 -0700529
Ray Essick6a305222019-01-28 20:33:18 -0800530 MediaAnalyticsItem *item = MediaAnalyticsItem::create(kAudioPolicy);
Ray Essick84e84a52018-05-03 18:45:07 -0700531 if (item != NULL) {
532
Ray Essick84e84a52018-05-03 18:45:07 -0700533 item->setInt32(kAudioPolicyStatus, status);
534
Eric Laurent99fcae42018-05-17 16:59:18 -0700535 item->setCString(kAudioPolicyRqstSrc,
Andy Hung9b181952019-02-25 14:53:36 -0800536 toString(client->attributes.source).c_str());
Ray Essick84e84a52018-05-03 18:45:07 -0700537 item->setInt32(kAudioPolicyRqstSession, client->session);
Ray Essick51866952018-05-30 11:22:27 -0700538 if (client->opPackageName.size() != 0) {
539 item->setCString(kAudioPolicyRqstPkg,
540 std::string(String8(client->opPackageName).string()).c_str());
541 } else {
Kevin Rocardfbdfebe2018-06-18 12:30:40 -0700542 item->setCString(kAudioPolicyRqstPkg, std::to_string(client->uid).c_str());
Ray Essick51866952018-05-30 11:22:27 -0700543 }
Eric Laurent99fcae42018-05-17 16:59:18 -0700544 item->setCString(
545 kAudioPolicyRqstDevice, getDeviceTypeStrForPortId(client->deviceId).c_str());
546
Eric Laurent4eb58f12018-12-07 16:41:02 -0800547 int count = mAudioRecordClients.size();
548 for (int i = 0; i < count ; i++) {
549 if (portId == mAudioRecordClients.keyAt(i)) {
550 continue;
551 }
552 sp<AudioRecordClient> other = mAudioRecordClients.valueAt(i);
553 if (other->active) {
554 // keeps the last of the clients marked active
555 item->setCString(kAudioPolicyActiveSrc,
Andy Hung9b181952019-02-25 14:53:36 -0800556 toString(other->attributes.source).c_str());
Eric Laurent4eb58f12018-12-07 16:41:02 -0800557 item->setInt32(kAudioPolicyActiveSession, other->session);
558 if (other->opPackageName.size() != 0) {
559 item->setCString(kAudioPolicyActivePkg,
560 std::string(String8(other->opPackageName).string()).c_str());
561 } else {
562 item->setCString(kAudioPolicyRqstPkg,
563 std::to_string(other->uid).c_str());
Ray Essick84e84a52018-05-03 18:45:07 -0700564 }
Eric Laurent4eb58f12018-12-07 16:41:02 -0800565 item->setCString(kAudioPolicyActiveDevice,
566 getDeviceTypeStrForPortId(other->deviceId).c_str());
Ray Essick84e84a52018-05-03 18:45:07 -0700567 }
568 }
569 item->selfrecord();
570 delete item;
571 item = NULL;
572 }
Eric Laurent4eb58f12018-12-07 16:41:02 -0800573 client->active = false;
574 client->startTimeNs = 0;
575 updateUidStates_l();
Svet Ganov6e641372018-03-02 09:21:30 -0800576 finishRecording(client->opPackageName, client->uid);
Eric Laurentfb66dd92016-01-28 18:32:03 -0800577 }
578
579 return status;
Eric Laurent2d388ec2014-03-07 13:25:54 -0800580}
581
Eric Laurentfee19762018-01-29 18:44:13 -0800582status_t AudioPolicyService::stopInput(audio_port_handle_t portId)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800583{
Eric Laurentdce54a12014-03-10 12:19:46 -0700584 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800585 return NO_INIT;
586 }
Eric Laurent4eb58f12018-12-07 16:41:02 -0800587
Eric Laurent2d388ec2014-03-07 13:25:54 -0800588 Mutex::Autolock _l(mLock);
589
Eric Laurentfee19762018-01-29 18:44:13 -0800590 ssize_t index = mAudioRecordClients.indexOfKey(portId);
591 if (index < 0) {
592 return INVALID_OPERATION;
593 }
594 sp<AudioRecordClient> client = mAudioRecordClients.valueAt(index);
595
Ray Essick84e84a52018-05-03 18:45:07 -0700596 client->active = false;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800597 client->startTimeNs = 0;
598
599 updateUidStates_l();
Ray Essick84e84a52018-05-03 18:45:07 -0700600
Svet Ganov6e641372018-03-02 09:21:30 -0800601 // finish the recording app op
602 finishRecording(client->opPackageName, client->uid);
Eric Laurent10b71232018-04-13 18:14:44 -0700603 AutoCallerClear acc;
Eric Laurent8fc147b2018-07-22 19:13:55 -0700604 return mAudioPolicyManager->stopInput(portId);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800605}
606
Eric Laurentfee19762018-01-29 18:44:13 -0800607void AudioPolicyService::releaseInput(audio_port_handle_t portId)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800608{
Eric Laurentdce54a12014-03-10 12:19:46 -0700609 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800610 return;
611 }
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700612 sp<AudioPolicyEffects>audioPolicyEffects;
Eric Laurentfee19762018-01-29 18:44:13 -0800613 sp<AudioRecordClient> client;
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700614 {
615 Mutex::Autolock _l(mLock);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700616 audioPolicyEffects = mAudioPolicyEffects;
Eric Laurentfee19762018-01-29 18:44:13 -0800617 ssize_t index = mAudioRecordClients.indexOfKey(portId);
618 if (index < 0) {
619 return;
620 }
621 client = mAudioRecordClients.valueAt(index);
Eric Laurent4eb58f12018-12-07 16:41:02 -0800622
623 if (client->active) {
624 ALOGW("%s releasing active client portId %d", __FUNCTION__, portId);
625 client->active = false;
626 client->startTimeNs = 0;
627 updateUidStates_l();
628 }
629
Eric Laurentfee19762018-01-29 18:44:13 -0800630 mAudioRecordClients.removeItem(portId);
631 }
632 if (client == 0) {
633 return;
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700634 }
635 if (audioPolicyEffects != 0) {
636 // release audio processors from the input
Eric Laurentd7fe0862018-07-14 16:48:01 -0700637 status_t status = audioPolicyEffects->releaseInputEffects(client->io, client->session);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700638 if(status != NO_ERROR) {
Eric Laurentd7fe0862018-07-14 16:48:01 -0700639 ALOGW("Failed to release effects on input %d", client->io);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700640 }
Eric Laurent2d388ec2014-03-07 13:25:54 -0800641 }
Eric Laurentf10c7092016-12-06 17:09:56 -0800642 {
643 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700644 AutoCallerClear acc;
Eric Laurent8fc147b2018-07-22 19:13:55 -0700645 mAudioPolicyManager->releaseInput(portId);
Eric Laurentf10c7092016-12-06 17:09:56 -0800646 }
Eric Laurent2d388ec2014-03-07 13:25:54 -0800647}
648
649status_t AudioPolicyService::initStreamVolume(audio_stream_type_t stream,
650 int indexMin,
651 int indexMax)
652{
Eric Laurentdce54a12014-03-10 12:19:46 -0700653 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800654 return NO_INIT;
655 }
656 if (!settingsAllowed()) {
657 return PERMISSION_DENIED;
658 }
Eric Laurent223fd5c2014-11-11 13:43:36 -0800659 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800660 return BAD_VALUE;
661 }
662 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700663 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700664 mAudioPolicyManager->initStreamVolume(stream, indexMin, indexMax);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800665 return NO_ERROR;
666}
667
668status_t AudioPolicyService::setStreamVolumeIndex(audio_stream_type_t stream,
669 int index,
670 audio_devices_t device)
671{
Eric Laurentdce54a12014-03-10 12:19:46 -0700672 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800673 return NO_INIT;
674 }
675 if (!settingsAllowed()) {
676 return PERMISSION_DENIED;
677 }
Eric Laurent223fd5c2014-11-11 13:43:36 -0800678 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800679 return BAD_VALUE;
680 }
681 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700682 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700683 return mAudioPolicyManager->setStreamVolumeIndex(stream,
684 index,
685 device);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800686}
687
688status_t AudioPolicyService::getStreamVolumeIndex(audio_stream_type_t stream,
689 int *index,
690 audio_devices_t device)
691{
Eric Laurentdce54a12014-03-10 12:19:46 -0700692 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800693 return NO_INIT;
694 }
Eric Laurent223fd5c2014-11-11 13:43:36 -0800695 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800696 return BAD_VALUE;
697 }
698 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700699 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700700 return mAudioPolicyManager->getStreamVolumeIndex(stream,
701 index,
702 device);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800703}
704
François Gaffiecfe17322018-11-07 13:41:29 +0100705status_t AudioPolicyService::setVolumeIndexForAttributes(const audio_attributes_t &attributes,
706 int index, audio_devices_t device)
707{
708 if (mAudioPolicyManager == NULL) {
709 return NO_INIT;
710 }
711 if (!settingsAllowed()) {
712 return PERMISSION_DENIED;
713 }
714 Mutex::Autolock _l(mLock);
715 AutoCallerClear acc;
716 return mAudioPolicyManager->setVolumeIndexForAttributes(attributes, index, device);
717}
718
719status_t AudioPolicyService::getVolumeIndexForAttributes(const audio_attributes_t &attributes,
720 int &index, audio_devices_t device)
721{
722 if (mAudioPolicyManager == NULL) {
723 return NO_INIT;
724 }
725 Mutex::Autolock _l(mLock);
726 AutoCallerClear acc;
727 return mAudioPolicyManager->getVolumeIndexForAttributes(attributes, index, device);
728}
729
730status_t AudioPolicyService::getMinVolumeIndexForAttributes(const audio_attributes_t &attributes,
731 int &index)
732{
733 if (mAudioPolicyManager == NULL) {
734 return NO_INIT;
735 }
736 Mutex::Autolock _l(mLock);
737 AutoCallerClear acc;
738 return mAudioPolicyManager->getMinVolumeIndexForAttributes(attributes, index);
739}
740
741status_t AudioPolicyService::getMaxVolumeIndexForAttributes(const audio_attributes_t &attributes,
742 int &index)
743{
744 if (mAudioPolicyManager == NULL) {
745 return NO_INIT;
746 }
747 Mutex::Autolock _l(mLock);
748 AutoCallerClear acc;
749 return mAudioPolicyManager->getMaxVolumeIndexForAttributes(attributes, index);
750}
751
Eric Laurent2d388ec2014-03-07 13:25:54 -0800752uint32_t AudioPolicyService::getStrategyForStream(audio_stream_type_t stream)
753{
Eric Laurent223fd5c2014-11-11 13:43:36 -0800754 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
François Gaffiec005e562018-11-06 15:04:49 +0100755 return PRODUCT_STRATEGY_NONE;
Eric Laurentdea15412014-10-28 15:46:45 -0700756 }
Eric Laurentdce54a12014-03-10 12:19:46 -0700757 if (mAudioPolicyManager == NULL) {
François Gaffiec005e562018-11-06 15:04:49 +0100758 return PRODUCT_STRATEGY_NONE;
Eric Laurent2d388ec2014-03-07 13:25:54 -0800759 }
François Gaffiec005e562018-11-06 15:04:49 +0100760 // DO NOT LOCK, may be called from AudioFlinger with lock held, reaching deadlock
Eric Laurent10b71232018-04-13 18:14:44 -0700761 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700762 return mAudioPolicyManager->getStrategyForStream(stream);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800763}
764
765//audio policy: use audio_device_t appropriately
766
767audio_devices_t AudioPolicyService::getDevicesForStream(audio_stream_type_t stream)
768{
Eric Laurent223fd5c2014-11-11 13:43:36 -0800769 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
Eric Laurentb1322c72014-10-30 14:59:13 -0700770 return AUDIO_DEVICE_NONE;
Eric Laurentdea15412014-10-28 15:46:45 -0700771 }
Eric Laurentdce54a12014-03-10 12:19:46 -0700772 if (mAudioPolicyManager == NULL) {
Eric Laurentb1322c72014-10-30 14:59:13 -0700773 return AUDIO_DEVICE_NONE;
Eric Laurent2d388ec2014-03-07 13:25:54 -0800774 }
Haynes Mathew Georgedfb9f3b2015-10-26 18:22:13 -0700775 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700776 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700777 return mAudioPolicyManager->getDevicesForStream(stream);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800778}
779
780audio_io_handle_t AudioPolicyService::getOutputForEffect(const effect_descriptor_t *desc)
781{
782 // FIXME change return type to status_t, and return NO_INIT here
Eric Laurentdce54a12014-03-10 12:19:46 -0700783 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800784 return 0;
785 }
786 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700787 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700788 return mAudioPolicyManager->getOutputForEffect(desc);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800789}
790
791status_t AudioPolicyService::registerEffect(const effect_descriptor_t *desc,
792 audio_io_handle_t io,
793 uint32_t strategy,
Glenn Kastend848eb42016-03-08 13:42:11 -0800794 audio_session_t session,
Eric Laurent2d388ec2014-03-07 13:25:54 -0800795 int id)
796{
Eric Laurentdce54a12014-03-10 12:19:46 -0700797 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800798 return NO_INIT;
799 }
Haynes Mathew Georgebab7bf42015-10-30 18:02:23 -0700800 Mutex::Autolock _l(mEffectsLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700801 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700802 return mAudioPolicyManager->registerEffect(desc, io, strategy, session, id);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800803}
804
805status_t AudioPolicyService::unregisterEffect(int id)
806{
Eric Laurentdce54a12014-03-10 12:19:46 -0700807 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800808 return NO_INIT;
809 }
Haynes Mathew Georgebab7bf42015-10-30 18:02:23 -0700810 Mutex::Autolock _l(mEffectsLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700811 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700812 return mAudioPolicyManager->unregisterEffect(id);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800813}
814
815status_t AudioPolicyService::setEffectEnabled(int id, bool enabled)
816{
Eric Laurentdce54a12014-03-10 12:19:46 -0700817 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800818 return NO_INIT;
819 }
Haynes Mathew Georgebab7bf42015-10-30 18:02:23 -0700820 Mutex::Autolock _l(mEffectsLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700821 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700822 return mAudioPolicyManager->setEffectEnabled(id, enabled);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800823}
824
825bool AudioPolicyService::isStreamActive(audio_stream_type_t stream, uint32_t inPastMs) const
826{
Eric Laurent223fd5c2014-11-11 13:43:36 -0800827 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
Eric Laurentb1322c72014-10-30 14:59:13 -0700828 return false;
Eric Laurentdea15412014-10-28 15:46:45 -0700829 }
Eric Laurentdce54a12014-03-10 12:19:46 -0700830 if (mAudioPolicyManager == NULL) {
Eric Laurentb1322c72014-10-30 14:59:13 -0700831 return false;
Eric Laurent2d388ec2014-03-07 13:25:54 -0800832 }
833 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700834 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700835 return mAudioPolicyManager->isStreamActive(stream, inPastMs);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800836}
837
838bool AudioPolicyService::isStreamActiveRemotely(audio_stream_type_t stream, uint32_t inPastMs) const
839{
Eric Laurent223fd5c2014-11-11 13:43:36 -0800840 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
Eric Laurentb1322c72014-10-30 14:59:13 -0700841 return false;
Eric Laurentdea15412014-10-28 15:46:45 -0700842 }
Eric Laurentdce54a12014-03-10 12:19:46 -0700843 if (mAudioPolicyManager == NULL) {
Eric Laurentb1322c72014-10-30 14:59:13 -0700844 return false;
Eric Laurent2d388ec2014-03-07 13:25:54 -0800845 }
846 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700847 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700848 return mAudioPolicyManager->isStreamActiveRemotely(stream, inPastMs);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800849}
850
851bool AudioPolicyService::isSourceActive(audio_source_t source) const
852{
Eric Laurentdce54a12014-03-10 12:19:46 -0700853 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800854 return false;
855 }
856 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700857 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700858 return mAudioPolicyManager->isSourceActive(source);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800859}
860
Ari Hausman-Cohen24628312018-08-13 15:01:09 -0700861status_t AudioPolicyService::getAudioPolicyEffects(sp<AudioPolicyEffects>& audioPolicyEffects)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800862{
Eric Laurentdce54a12014-03-10 12:19:46 -0700863 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800864 return NO_INIT;
865 }
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700866 {
867 Mutex::Autolock _l(mLock);
868 audioPolicyEffects = mAudioPolicyEffects;
869 }
870 if (audioPolicyEffects == 0) {
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700871 return NO_INIT;
872 }
Ari Hausman-Cohen24628312018-08-13 15:01:09 -0700873
874 return OK;
875}
876
877status_t AudioPolicyService::queryDefaultPreProcessing(audio_session_t audioSession,
878 effect_descriptor_t *descriptors,
879 uint32_t *count)
880{
881 sp<AudioPolicyEffects>audioPolicyEffects;
882 status_t status = getAudioPolicyEffects(audioPolicyEffects);
883 if (status != OK) {
884 *count = 0;
885 return status;
886 }
Eric Laurentfb66dd92016-01-28 18:32:03 -0800887 return audioPolicyEffects->queryDefaultInputEffects(
888 (audio_session_t)audioSession, descriptors, count);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800889}
890
Ari Hausman-Cohen24628312018-08-13 15:01:09 -0700891status_t AudioPolicyService::addSourceDefaultEffect(const effect_uuid_t *type,
892 const String16& opPackageName,
893 const effect_uuid_t *uuid,
894 int32_t priority,
895 audio_source_t source,
896 audio_unique_id_t* id)
897{
898 sp<AudioPolicyEffects>audioPolicyEffects;
899 status_t status = getAudioPolicyEffects(audioPolicyEffects);
900 if (status != OK) {
901 return status;
902 }
903 if (!modifyDefaultAudioEffectsAllowed()) {
904 return PERMISSION_DENIED;
905 }
906 return audioPolicyEffects->addSourceDefaultEffect(
907 type, opPackageName, uuid, priority, source, id);
908}
909
Ari Hausman-Cohen433722e2018-04-24 14:25:22 -0700910status_t AudioPolicyService::addStreamDefaultEffect(const effect_uuid_t *type,
911 const String16& opPackageName,
912 const effect_uuid_t *uuid,
913 int32_t priority,
914 audio_usage_t usage,
915 audio_unique_id_t* id)
916{
Ari Hausman-Cohen24628312018-08-13 15:01:09 -0700917 sp<AudioPolicyEffects>audioPolicyEffects;
918 status_t status = getAudioPolicyEffects(audioPolicyEffects);
919 if (status != OK) {
920 return status;
Ari Hausman-Cohen433722e2018-04-24 14:25:22 -0700921 }
922 if (!modifyDefaultAudioEffectsAllowed()) {
923 return PERMISSION_DENIED;
924 }
Ari Hausman-Cohen433722e2018-04-24 14:25:22 -0700925 return audioPolicyEffects->addStreamDefaultEffect(
926 type, opPackageName, uuid, priority, usage, id);
927}
928
Ari Hausman-Cohen24628312018-08-13 15:01:09 -0700929status_t AudioPolicyService::removeSourceDefaultEffect(audio_unique_id_t id)
Ari Hausman-Cohen433722e2018-04-24 14:25:22 -0700930{
Ari Hausman-Cohen24628312018-08-13 15:01:09 -0700931 sp<AudioPolicyEffects>audioPolicyEffects;
932 status_t status = getAudioPolicyEffects(audioPolicyEffects);
933 if (status != OK) {
934 return status;
Ari Hausman-Cohen433722e2018-04-24 14:25:22 -0700935 }
936 if (!modifyDefaultAudioEffectsAllowed()) {
937 return PERMISSION_DENIED;
938 }
Ari Hausman-Cohen24628312018-08-13 15:01:09 -0700939 return audioPolicyEffects->removeSourceDefaultEffect(id);
940}
941
942status_t AudioPolicyService::removeStreamDefaultEffect(audio_unique_id_t id)
943{
Ari Hausman-Cohen433722e2018-04-24 14:25:22 -0700944 sp<AudioPolicyEffects>audioPolicyEffects;
Ari Hausman-Cohen24628312018-08-13 15:01:09 -0700945 status_t status = getAudioPolicyEffects(audioPolicyEffects);
946 if (status != OK) {
947 return status;
Ari Hausman-Cohen433722e2018-04-24 14:25:22 -0700948 }
Ari Hausman-Cohen24628312018-08-13 15:01:09 -0700949 if (!modifyDefaultAudioEffectsAllowed()) {
950 return PERMISSION_DENIED;
Ari Hausman-Cohen433722e2018-04-24 14:25:22 -0700951 }
952 return audioPolicyEffects->removeStreamDefaultEffect(id);
953}
954
Kevin Rocardb99cc752019-03-21 20:52:24 -0700955status_t AudioPolicyService::setAllowedCapturePolicy(uid_t uid, audio_flags_mask_t capturePolicy) {
956 Mutex::Autolock _l(mLock);
957 if (mAudioPolicyManager == NULL) {
958 ALOGV("%s() mAudioPolicyManager == NULL", __func__);
959 return NO_INIT;
960 }
961 uint_t callingUid = IPCThreadState::self()->getCallingUid();
962 if (uid != callingUid) {
963 ALOGD("%s() uid invalid %d != %d", __func__, uid, callingUid);
964 return PERMISSION_DENIED;
965 }
966 return mAudioPolicyManager->setAllowedCapturePolicy(uid, capturePolicy);
967}
968
Eric Laurent2d388ec2014-03-07 13:25:54 -0800969bool AudioPolicyService::isOffloadSupported(const audio_offload_info_t& info)
970{
Eric Laurentdce54a12014-03-10 12:19:46 -0700971 if (mAudioPolicyManager == NULL) {
972 ALOGV("mAudioPolicyManager == NULL");
Eric Laurent2d388ec2014-03-07 13:25:54 -0800973 return false;
974 }
Andy Hung2ddee192015-12-18 17:34:44 -0800975 Mutex::Autolock _l(mLock);
Haynes Mathew Georgebab7bf42015-10-30 18:02:23 -0700976 Mutex::Autolock _le(mEffectsLock); // isOffloadSupported queries for
977 // non-offloadable effects
Eric Laurent10b71232018-04-13 18:14:44 -0700978 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700979 return mAudioPolicyManager->isOffloadSupported(info);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800980}
981
Michael Chana94fbb22018-04-24 14:31:19 +1000982bool AudioPolicyService::isDirectOutputSupported(const audio_config_base_t& config,
983 const audio_attributes_t& attributes) {
984 if (mAudioPolicyManager == NULL) {
985 ALOGV("mAudioPolicyManager == NULL");
986 return false;
987 }
988 Mutex::Autolock _l(mLock);
989 return mAudioPolicyManager->isDirectOutputSupported(config, attributes);
990}
991
992
Eric Laurent6a94d692014-05-20 11:18:06 -0700993status_t AudioPolicyService::listAudioPorts(audio_port_role_t role,
994 audio_port_type_t type,
Eric Laurent203b1a12014-04-01 10:34:16 -0700995 unsigned int *num_ports,
Eric Laurent6a94d692014-05-20 11:18:06 -0700996 struct audio_port *ports,
997 unsigned int *generation)
Eric Laurent203b1a12014-04-01 10:34:16 -0700998{
Eric Laurent6a94d692014-05-20 11:18:06 -0700999 Mutex::Autolock _l(mLock);
1000 if (mAudioPolicyManager == NULL) {
1001 return NO_INIT;
1002 }
Eric Laurent10b71232018-04-13 18:14:44 -07001003 AutoCallerClear acc;
Eric Laurent6a94d692014-05-20 11:18:06 -07001004 return mAudioPolicyManager->listAudioPorts(role, type, num_ports, ports, generation);
Eric Laurent203b1a12014-04-01 10:34:16 -07001005}
1006
Eric Laurent6a94d692014-05-20 11:18:06 -07001007status_t AudioPolicyService::getAudioPort(struct audio_port *port)
Eric Laurent203b1a12014-04-01 10:34:16 -07001008{
Eric Laurent6a94d692014-05-20 11:18:06 -07001009 Mutex::Autolock _l(mLock);
1010 if (mAudioPolicyManager == NULL) {
1011 return NO_INIT;
1012 }
Eric Laurent10b71232018-04-13 18:14:44 -07001013 AutoCallerClear acc;
Eric Laurent6a94d692014-05-20 11:18:06 -07001014 return mAudioPolicyManager->getAudioPort(port);
Eric Laurent203b1a12014-04-01 10:34:16 -07001015}
1016
Eric Laurent6a94d692014-05-20 11:18:06 -07001017status_t AudioPolicyService::createAudioPatch(const struct audio_patch *patch,
1018 audio_patch_handle_t *handle)
Eric Laurent203b1a12014-04-01 10:34:16 -07001019{
Eric Laurent6a94d692014-05-20 11:18:06 -07001020 Mutex::Autolock _l(mLock);
Eric Laurent5284ed52014-05-29 14:37:38 -07001021 if(!modifyAudioRoutingAllowed()) {
1022 return PERMISSION_DENIED;
1023 }
Eric Laurent6a94d692014-05-20 11:18:06 -07001024 if (mAudioPolicyManager == NULL) {
1025 return NO_INIT;
1026 }
Eric Laurent10b71232018-04-13 18:14:44 -07001027 AutoCallerClear acc;
Eric Laurent6a94d692014-05-20 11:18:06 -07001028 return mAudioPolicyManager->createAudioPatch(patch, handle,
1029 IPCThreadState::self()->getCallingUid());
Eric Laurent203b1a12014-04-01 10:34:16 -07001030}
1031
Eric Laurent6a94d692014-05-20 11:18:06 -07001032status_t AudioPolicyService::releaseAudioPatch(audio_patch_handle_t handle)
Eric Laurent203b1a12014-04-01 10:34:16 -07001033{
Eric Laurent6a94d692014-05-20 11:18:06 -07001034 Mutex::Autolock _l(mLock);
Eric Laurent5284ed52014-05-29 14:37:38 -07001035 if(!modifyAudioRoutingAllowed()) {
1036 return PERMISSION_DENIED;
1037 }
Eric Laurent6a94d692014-05-20 11:18:06 -07001038 if (mAudioPolicyManager == NULL) {
1039 return NO_INIT;
1040 }
Eric Laurent10b71232018-04-13 18:14:44 -07001041 AutoCallerClear acc;
Eric Laurent6a94d692014-05-20 11:18:06 -07001042 return mAudioPolicyManager->releaseAudioPatch(handle,
1043 IPCThreadState::self()->getCallingUid());
Eric Laurent203b1a12014-04-01 10:34:16 -07001044}
1045
1046status_t AudioPolicyService::listAudioPatches(unsigned int *num_patches,
Eric Laurent6a94d692014-05-20 11:18:06 -07001047 struct audio_patch *patches,
1048 unsigned int *generation)
Eric Laurent203b1a12014-04-01 10:34:16 -07001049{
Eric Laurent6a94d692014-05-20 11:18:06 -07001050 Mutex::Autolock _l(mLock);
1051 if (mAudioPolicyManager == NULL) {
1052 return NO_INIT;
1053 }
Eric Laurent10b71232018-04-13 18:14:44 -07001054 AutoCallerClear acc;
Eric Laurent6a94d692014-05-20 11:18:06 -07001055 return mAudioPolicyManager->listAudioPatches(num_patches, patches, generation);
Eric Laurent203b1a12014-04-01 10:34:16 -07001056}
1057
Eric Laurent6a94d692014-05-20 11:18:06 -07001058status_t AudioPolicyService::setAudioPortConfig(const struct audio_port_config *config)
Eric Laurent203b1a12014-04-01 10:34:16 -07001059{
Eric Laurent6a94d692014-05-20 11:18:06 -07001060 Mutex::Autolock _l(mLock);
Eric Laurent5284ed52014-05-29 14:37:38 -07001061 if(!modifyAudioRoutingAllowed()) {
1062 return PERMISSION_DENIED;
1063 }
Eric Laurent6a94d692014-05-20 11:18:06 -07001064 if (mAudioPolicyManager == NULL) {
1065 return NO_INIT;
1066 }
Eric Laurent10b71232018-04-13 18:14:44 -07001067 AutoCallerClear acc;
Eric Laurent6a94d692014-05-20 11:18:06 -07001068 return mAudioPolicyManager->setAudioPortConfig(config);
Eric Laurent203b1a12014-04-01 10:34:16 -07001069}
Eric Laurent2d388ec2014-03-07 13:25:54 -08001070
Eric Laurentdf3dc7e2014-07-27 18:39:40 -07001071status_t AudioPolicyService::acquireSoundTriggerSession(audio_session_t *session,
1072 audio_io_handle_t *ioHandle,
1073 audio_devices_t *device)
1074{
Andy Hungf759b8c2017-08-15 12:48:54 -07001075 Mutex::Autolock _l(mLock);
Eric Laurentdf3dc7e2014-07-27 18:39:40 -07001076 if (mAudioPolicyManager == NULL) {
1077 return NO_INIT;
1078 }
Eric Laurent10b71232018-04-13 18:14:44 -07001079 AutoCallerClear acc;
Eric Laurentdf3dc7e2014-07-27 18:39:40 -07001080 return mAudioPolicyManager->acquireSoundTriggerSession(session, ioHandle, device);
1081}
1082
1083status_t AudioPolicyService::releaseSoundTriggerSession(audio_session_t session)
1084{
Andy Hungf759b8c2017-08-15 12:48:54 -07001085 Mutex::Autolock _l(mLock);
Eric Laurentdf3dc7e2014-07-27 18:39:40 -07001086 if (mAudioPolicyManager == NULL) {
1087 return NO_INIT;
1088 }
Eric Laurent10b71232018-04-13 18:14:44 -07001089 AutoCallerClear acc;
Eric Laurentdf3dc7e2014-07-27 18:39:40 -07001090 return mAudioPolicyManager->releaseSoundTriggerSession(session);
1091}
1092
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -07001093status_t AudioPolicyService::registerPolicyMixes(const Vector<AudioMix>& mixes, bool registration)
Eric Laurentbaac1832014-12-01 17:52:59 -08001094{
1095 Mutex::Autolock _l(mLock);
Kevin Rocardbe201852019-02-20 22:33:28 -08001096
1097 // loopback|render only need a MediaProjection (checked in caller AudioService.java)
1098 bool needModifyAudioRouting = std::any_of(mixes.begin(), mixes.end(), [](auto& mix) {
1099 return !is_mix_loopback_render(mix.mRouteFlags); });
1100 if (needModifyAudioRouting && !modifyAudioRoutingAllowed()) {
Eric Laurentbaac1832014-12-01 17:52:59 -08001101 return PERMISSION_DENIED;
1102 }
Kevin Rocardbe201852019-02-20 22:33:28 -08001103
Kevin Rocard36b17552019-03-07 18:48:07 -08001104 bool needCaptureMediaOutput = std::any_of(mixes.begin(), mixes.end(), [](auto& mix) {
1105 return mix.mAllowPrivilegedPlaybackCapture; });
1106 const uid_t callingUid = IPCThreadState::self()->getCallingUid();
1107 const pid_t callingPid = IPCThreadState::self()->getCallingPid();
1108 if (needCaptureMediaOutput && !captureMediaOutputAllowed(callingPid, callingUid)) {
1109 return PERMISSION_DENIED;
1110 }
1111
Eric Laurentbaac1832014-12-01 17:52:59 -08001112 if (mAudioPolicyManager == NULL) {
1113 return NO_INIT;
1114 }
Eric Laurent10b71232018-04-13 18:14:44 -07001115 AutoCallerClear acc;
Eric Laurentbaac1832014-12-01 17:52:59 -08001116 if (registration) {
1117 return mAudioPolicyManager->registerPolicyMixes(mixes);
1118 } else {
1119 return mAudioPolicyManager->unregisterPolicyMixes(mixes);
1120 }
1121}
1122
Jean-Michel Trivibda70da2018-12-19 07:30:15 -08001123status_t AudioPolicyService::setUidDeviceAffinities(uid_t uid,
1124 const Vector<AudioDeviceTypeAddr>& devices) {
1125 Mutex::Autolock _l(mLock);
1126 if(!modifyAudioRoutingAllowed()) {
1127 return PERMISSION_DENIED;
1128 }
1129 if (mAudioPolicyManager == NULL) {
1130 return NO_INIT;
1131 }
1132 AutoCallerClear acc;
1133 return mAudioPolicyManager->setUidDeviceAffinities(uid, devices);
1134}
1135
1136status_t AudioPolicyService::removeUidDeviceAffinities(uid_t uid) {
1137 Mutex::Autolock _l(mLock);
1138 if(!modifyAudioRoutingAllowed()) {
1139 return PERMISSION_DENIED;
1140 }
1141 if (mAudioPolicyManager == NULL) {
1142 return NO_INIT;
1143 }
1144 AutoCallerClear acc;
1145 return mAudioPolicyManager->removeUidDeviceAffinities(uid);
1146}
1147
Eric Laurent554a2772015-04-10 11:29:24 -07001148status_t AudioPolicyService::startAudioSource(const struct audio_port_config *source,
Eric Laurent3e6c7e12018-07-27 17:09:23 -07001149 const audio_attributes_t *attributes,
1150 audio_port_handle_t *portId)
Eric Laurent554a2772015-04-10 11:29:24 -07001151{
1152 Mutex::Autolock _l(mLock);
1153 if (mAudioPolicyManager == NULL) {
1154 return NO_INIT;
1155 }
Hongwei Wang5cd1f1d2019-03-26 15:21:11 -07001156 // startAudioSource should be created as the calling uid
1157 const uid_t callingUid = IPCThreadState::self()->getCallingUid();
Eric Laurent10b71232018-04-13 18:14:44 -07001158 AutoCallerClear acc;
Hongwei Wang5cd1f1d2019-03-26 15:21:11 -07001159 return mAudioPolicyManager->startAudioSource(source, attributes, portId, callingUid);
Eric Laurent554a2772015-04-10 11:29:24 -07001160}
1161
Eric Laurent3e6c7e12018-07-27 17:09:23 -07001162status_t AudioPolicyService::stopAudioSource(audio_port_handle_t portId)
Eric Laurent554a2772015-04-10 11:29:24 -07001163{
1164 Mutex::Autolock _l(mLock);
1165 if (mAudioPolicyManager == NULL) {
1166 return NO_INIT;
1167 }
Eric Laurent10b71232018-04-13 18:14:44 -07001168 AutoCallerClear acc;
Eric Laurent3e6c7e12018-07-27 17:09:23 -07001169 return mAudioPolicyManager->stopAudioSource(portId);
Eric Laurent554a2772015-04-10 11:29:24 -07001170}
1171
Andy Hung2ddee192015-12-18 17:34:44 -08001172status_t AudioPolicyService::setMasterMono(bool mono)
1173{
1174 if (mAudioPolicyManager == NULL) {
1175 return NO_INIT;
1176 }
1177 if (!settingsAllowed()) {
1178 return PERMISSION_DENIED;
1179 }
1180 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -07001181 AutoCallerClear acc;
Andy Hung2ddee192015-12-18 17:34:44 -08001182 return mAudioPolicyManager->setMasterMono(mono);
1183}
1184
1185status_t AudioPolicyService::getMasterMono(bool *mono)
1186{
1187 if (mAudioPolicyManager == NULL) {
1188 return NO_INIT;
1189 }
1190 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -07001191 AutoCallerClear acc;
Andy Hung2ddee192015-12-18 17:34:44 -08001192 return mAudioPolicyManager->getMasterMono(mono);
1193}
1194
Eric Laurentac9cef52017-06-09 15:46:26 -07001195
1196float AudioPolicyService::getStreamVolumeDB(
1197 audio_stream_type_t stream, int index, audio_devices_t device)
1198{
1199 if (mAudioPolicyManager == NULL) {
1200 return NAN;
1201 }
1202 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -07001203 AutoCallerClear acc;
Eric Laurentac9cef52017-06-09 15:46:26 -07001204 return mAudioPolicyManager->getStreamVolumeDB(stream, index, device);
1205}
1206
jiabin81772902018-04-02 17:52:27 -07001207status_t AudioPolicyService::getSurroundFormats(unsigned int *numSurroundFormats,
1208 audio_format_t *surroundFormats,
1209 bool *surroundFormatsEnabled,
1210 bool reported)
1211{
1212 if (mAudioPolicyManager == NULL) {
1213 return NO_INIT;
1214 }
1215 Mutex::Autolock _l(mLock);
1216 AutoCallerClear acc;
1217 return mAudioPolicyManager->getSurroundFormats(numSurroundFormats, surroundFormats,
1218 surroundFormatsEnabled, reported);
1219}
1220
Arun Mirpuri11029ad2018-12-19 20:45:19 -08001221status_t AudioPolicyService::getHwOffloadEncodingFormatsSupportedForA2DP(
1222 std::vector<audio_format_t> *formats)
1223{
1224 if (mAudioPolicyManager == NULL) {
1225 return NO_INIT;
1226 }
1227 Mutex::Autolock _l(mLock);
1228 AutoCallerClear acc;
1229 return mAudioPolicyManager->getHwOffloadEncodingFormatsSupportedForA2DP(formats);
1230}
1231
jiabin81772902018-04-02 17:52:27 -07001232status_t AudioPolicyService::setSurroundFormatEnabled(audio_format_t audioFormat, bool enabled)
1233{
1234 if (mAudioPolicyManager == NULL) {
1235 return NO_INIT;
1236 }
1237 Mutex::Autolock _l(mLock);
1238 AutoCallerClear acc;
1239 return mAudioPolicyManager->setSurroundFormatEnabled(audioFormat, enabled);
1240}
Eric Laurentac9cef52017-06-09 15:46:26 -07001241
Eric Laurentb78763e2018-10-17 10:08:02 -07001242status_t AudioPolicyService::setAssistantUid(uid_t uid)
1243{
1244 Mutex::Autolock _l(mLock);
1245 mUidPolicy->setAssistantUid(uid);
1246 return NO_ERROR;
1247}
1248
1249status_t AudioPolicyService::setA11yServicesUids(const std::vector<uid_t>& uids)
1250{
1251 Mutex::Autolock _l(mLock);
1252 mUidPolicy->setA11yUids(uids);
1253 return NO_ERROR;
1254}
1255
jiabin6012f912018-11-02 17:06:30 -07001256bool AudioPolicyService::isHapticPlaybackSupported()
1257{
1258 if (mAudioPolicyManager == NULL) {
1259 ALOGW("%s, mAudioPolicyManager == NULL", __func__);
1260 return false;
1261 }
1262 Mutex::Autolock _l(mLock);
1263 AutoCallerClear acc;
1264 return mAudioPolicyManager->isHapticPlaybackSupported();
1265}
1266
François Gaffied0ba9ed2018-11-05 11:50:42 +01001267status_t AudioPolicyService::listAudioProductStrategies(AudioProductStrategyVector &strategies)
1268{
1269 if (mAudioPolicyManager == NULL) {
1270 return NO_INIT;
1271 }
1272 Mutex::Autolock _l(mLock);
1273 return mAudioPolicyManager->listAudioProductStrategies(strategies);
1274}
1275
François Gaffie4b2018b2018-11-07 11:18:59 +01001276status_t AudioPolicyService::getProductStrategyFromAudioAttributes(
1277 const AudioAttributes &aa, product_strategy_t &productStrategy)
François Gaffied0ba9ed2018-11-05 11:50:42 +01001278{
1279 if (mAudioPolicyManager == NULL) {
François Gaffie4b2018b2018-11-07 11:18:59 +01001280 return NO_INIT;
François Gaffied0ba9ed2018-11-05 11:50:42 +01001281 }
1282 Mutex::Autolock _l(mLock);
François Gaffie4b2018b2018-11-07 11:18:59 +01001283 return mAudioPolicyManager->getProductStrategyFromAudioAttributes(aa, productStrategy);
1284}
1285
1286status_t AudioPolicyService::listAudioVolumeGroups(AudioVolumeGroupVector &groups)
1287{
1288 if (mAudioPolicyManager == NULL) {
1289 return NO_INIT;
1290 }
1291 Mutex::Autolock _l(mLock);
1292 return mAudioPolicyManager->listAudioVolumeGroups(groups);
1293}
1294
1295status_t AudioPolicyService::getVolumeGroupFromAudioAttributes(const AudioAttributes &aa,
1296 volume_group_t &volumeGroup)
1297{
1298 if (mAudioPolicyManager == NULL) {
1299 return NO_INIT;
1300 }
1301 Mutex::Autolock _l(mLock);
1302 return mAudioPolicyManager->getVolumeGroupFromAudioAttributes(aa, volumeGroup);
François Gaffied0ba9ed2018-11-05 11:50:42 +01001303}
Mikhail Naganov1b2a7942017-12-08 10:18:09 -08001304} // namespace android