blob: 01614ceb8c6402cfa0bc2d7bbc18951a88207097 [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"
Ray Essickf27e9872019-12-07 06:28:46 -080022#include <media/MediaMetricsItem.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
Eric Laurent42984412019-05-09 17:57:03 -0700169status_t AudioPolicyService::getOutputForAttr(audio_attributes_t *attr,
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 Laurent8a1095a2019-11-08 14:44:16 -0800184 ALOGV("%s()", __func__);
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,
Eric Laurent8a1095a2019-11-08 14:44:16 -0800190 "%s uid %d tried to pass itself off as %d", __func__, callingUid, uid);
Marco Nelissendcb346b2015-09-09 10:47:29 -0700191 uid = callingUid;
Eric Laurent8c7e6da2015-04-21 17:37:00 -0700192 }
Kevin Rocard8be94972019-02-22 13:26:25 -0800193 if (!mPackageManager.allowPlaybackCapture(uid)) {
Eric Laurent42984412019-05-09 17:57:03 -0700194 attr->flags |= AUDIO_FLAG_NO_MEDIA_PROJECTION;
195 }
Eric Laurent6ede98f2019-06-11 14:50:30 -0700196 if (((attr->flags & (AUDIO_FLAG_BYPASS_INTERRUPTION_POLICY|AUDIO_FLAG_BYPASS_MUTE)) != 0)
197 && !bypassInterruptionPolicyAllowed(pid, uid)) {
Eric Laurent42984412019-05-09 17:57:03 -0700198 attr->flags &= ~(AUDIO_FLAG_BYPASS_INTERRUPTION_POLICY|AUDIO_FLAG_BYPASS_MUTE);
Kevin Rocard8be94972019-02-22 13:26:25 -0800199 }
Eric Laurent10b71232018-04-13 18:14:44 -0700200 AutoCallerClear acc;
Eric Laurent8a1095a2019-11-08 14:44:16 -0800201 AudioPolicyInterface::output_type_t outputType;
Eric Laurent42984412019-05-09 17:57:03 -0700202 status_t result = mAudioPolicyManager->getOutputForAttr(attr, output, session, stream, uid,
Eric Laurent20b9ef02016-12-05 11:03:16 -0800203 config,
Kevin Rocard153f92d2018-12-18 18:33:28 -0800204 &flags, selectedDeviceId, portId,
Eric Laurent8a1095a2019-11-08 14:44:16 -0800205 secondaryOutputs,
206 &outputType);
Nadav Bar766fb022018-01-07 12:18:03 +0200207
208 // FIXME: Introduce a way to check for the the telephony device before opening the output
Eric Laurent8a1095a2019-11-08 14:44:16 -0800209 if (result == NO_ERROR) {
210 // enforce permission (if any) required for each type of input
211 switch (outputType) {
212 case AudioPolicyInterface::API_OUTPUT_LEGACY:
213 break;
214 case AudioPolicyInterface::API_OUTPUT_TELEPHONY_TX:
215 if (!modifyPhoneStateAllowed(pid, uid)) {
216 ALOGE("%s() permission denied: modify phone state not allowed for uid %d",
217 __func__, uid);
218 result = PERMISSION_DENIED;
219 }
220 break;
221 case AudioPolicyInterface::API_OUT_MIX_PLAYBACK:
222 if (!modifyAudioRoutingAllowed(pid, uid)) {
223 ALOGE("%s() permission denied: modify audio routing not allowed for uid %d",
224 __func__, uid);
225 result = PERMISSION_DENIED;
226 }
227 break;
228 case AudioPolicyInterface::API_OUTPUT_INVALID:
229 default:
230 LOG_ALWAYS_FATAL("%s() encountered an invalid output type %d",
231 __func__, (int)outputType);
232 }
Nadav Bar766fb022018-01-07 12:18:03 +0200233 }
Eric Laurentd7fe0862018-07-14 16:48:01 -0700234
235 if (result == NO_ERROR) {
236 sp <AudioPlaybackClient> client =
Eric Laurent5ada82e2019-08-29 17:53:54 -0700237 new AudioPlaybackClient(*attr, *output, uid, pid, session, *portId, *selectedDeviceId, *stream);
Eric Laurentd7fe0862018-07-14 16:48:01 -0700238 mAudioPlaybackClients.add(*portId, client);
239 }
Nadav Bar766fb022018-01-07 12:18:03 +0200240 return result;
Jean-Michel Trivi5bd3f382014-06-13 16:06:54 -0700241}
242
Eric Laurentbcfe5be2019-04-09 19:56:39 -0700243void AudioPolicyService::getPlaybackClientAndEffects(audio_port_handle_t portId,
244 sp<AudioPlaybackClient>& client,
245 sp<AudioPolicyEffects>& effects,
246 const char *context)
247{
248 Mutex::Autolock _l(mLock);
249 const ssize_t index = mAudioPlaybackClients.indexOfKey(portId);
250 if (index < 0) {
251 ALOGE("%s AudioTrack client not found for portId %d", context, portId);
252 return;
253 }
254 client = mAudioPlaybackClients.valueAt(index);
255 effects = mAudioPolicyEffects;
256}
257
Eric Laurentd7fe0862018-07-14 16:48:01 -0700258status_t AudioPolicyService::startOutput(audio_port_handle_t portId)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800259{
Eric Laurentdce54a12014-03-10 12:19:46 -0700260 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800261 return NO_INIT;
262 }
263 ALOGV("startOutput()");
Eric Laurentd7fe0862018-07-14 16:48:01 -0700264 sp<AudioPlaybackClient> client;
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700265 sp<AudioPolicyEffects>audioPolicyEffects;
Eric Laurentbcfe5be2019-04-09 19:56:39 -0700266
267 getPlaybackClientAndEffects(portId, client, audioPolicyEffects, __func__);
268
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700269 if (audioPolicyEffects != 0) {
270 // create audio processors according to stream
Eric Laurentd7fe0862018-07-14 16:48:01 -0700271 status_t status = audioPolicyEffects->addOutputSessionEffects(
272 client->io, client->stream, client->session);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700273 if (status != NO_ERROR && status != ALREADY_EXISTS) {
Eric Laurentd7fe0862018-07-14 16:48:01 -0700274 ALOGW("Failed to add effects on session %d", client->session);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700275 }
276 }
277 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700278 AutoCallerClear acc;
Eric Laurent8fc147b2018-07-22 19:13:55 -0700279 status_t status = mAudioPolicyManager->startOutput(portId);
Eric Laurentd7fe0862018-07-14 16:48:01 -0700280 if (status == NO_ERROR) {
281 client->active = true;
282 }
283 return status;
Eric Laurent2d388ec2014-03-07 13:25:54 -0800284}
285
Eric Laurentd7fe0862018-07-14 16:48:01 -0700286status_t AudioPolicyService::stopOutput(audio_port_handle_t portId)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800287{
Eric Laurentdce54a12014-03-10 12:19:46 -0700288 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800289 return NO_INIT;
290 }
291 ALOGV("stopOutput()");
Eric Laurentd7fe0862018-07-14 16:48:01 -0700292 mOutputCommandThread->stopOutputCommand(portId);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800293 return NO_ERROR;
294}
295
Eric Laurentd7fe0862018-07-14 16:48:01 -0700296status_t AudioPolicyService::doStopOutput(audio_port_handle_t portId)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800297{
Eric Laurentd7fe0862018-07-14 16:48:01 -0700298 ALOGV("doStopOutput");
299 sp<AudioPlaybackClient> client;
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700300 sp<AudioPolicyEffects>audioPolicyEffects;
Eric Laurentd7fe0862018-07-14 16:48:01 -0700301
Eric Laurentbcfe5be2019-04-09 19:56:39 -0700302 getPlaybackClientAndEffects(portId, client, audioPolicyEffects, __func__);
303
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700304 if (audioPolicyEffects != 0) {
305 // release audio processors from the stream
Eric Laurentd7fe0862018-07-14 16:48:01 -0700306 status_t status = audioPolicyEffects->releaseOutputSessionEffects(
307 client->io, client->stream, client->session);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700308 if (status != NO_ERROR && status != ALREADY_EXISTS) {
Eric Laurentd7fe0862018-07-14 16:48:01 -0700309 ALOGW("Failed to release effects on session %d", client->session);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700310 }
311 }
312 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700313 AutoCallerClear acc;
Eric Laurent8fc147b2018-07-22 19:13:55 -0700314 status_t status = mAudioPolicyManager->stopOutput(portId);
Eric Laurentd7fe0862018-07-14 16:48:01 -0700315 if (status == NO_ERROR) {
316 client->active = false;
317 }
318 return status;
Eric Laurent2d388ec2014-03-07 13:25:54 -0800319}
320
Eric Laurentd7fe0862018-07-14 16:48:01 -0700321void AudioPolicyService::releaseOutput(audio_port_handle_t portId)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800322{
Eric Laurentdce54a12014-03-10 12:19:46 -0700323 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800324 return;
325 }
326 ALOGV("releaseOutput()");
Eric Laurentd7fe0862018-07-14 16:48:01 -0700327 mOutputCommandThread->releaseOutputCommand(portId);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800328}
329
Eric Laurentd7fe0862018-07-14 16:48:01 -0700330void AudioPolicyService::doReleaseOutput(audio_port_handle_t portId)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800331{
332 ALOGV("doReleaseOutput from tid %d", gettid());
Eric Laurentbcfe5be2019-04-09 19:56:39 -0700333 sp<AudioPlaybackClient> client;
334 sp<AudioPolicyEffects> audioPolicyEffects;
335
336 getPlaybackClientAndEffects(portId, client, audioPolicyEffects, __func__);
337
338 if (audioPolicyEffects != 0 && client->active) {
339 // clean up effects if output was not stopped before being released
340 audioPolicyEffects->releaseOutputSessionEffects(
341 client->io, client->stream, client->session);
Eric Laurentd7fe0862018-07-14 16:48:01 -0700342 }
Eric Laurentbcfe5be2019-04-09 19:56:39 -0700343 Mutex::Autolock _l(mLock);
Eric Laurentd4007242019-03-27 12:42:16 -0700344 mAudioPlaybackClients.removeItem(portId);
Eric Laurentd7fe0862018-07-14 16:48:01 -0700345
Eric Laurent10b71232018-04-13 18:14:44 -0700346 // called from internal thread: no need to clear caller identity
Eric Laurent8fc147b2018-07-22 19:13:55 -0700347 mAudioPolicyManager->releaseOutput(portId);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800348}
349
Eric Laurentcaf7f482014-11-25 17:50:47 -0800350status_t AudioPolicyService::getInputForAttr(const audio_attributes_t *attr,
351 audio_io_handle_t *input,
Mikhail Naganov2996f672019-04-18 12:29:59 -0700352 audio_unique_id_t riid,
Eric Laurentcaf7f482014-11-25 17:50:47 -0800353 audio_session_t session,
Eric Laurentb2379ba2016-05-23 17:42:12 -0700354 pid_t pid,
Eric Laurent8c7e6da2015-04-21 17:37:00 -0700355 uid_t uid,
Eric Laurentfee19762018-01-29 18:44:13 -0800356 const String16& opPackageName,
Eric Laurent20b9ef02016-12-05 11:03:16 -0800357 const audio_config_base_t *config,
Paul McLean466dc8e2015-04-17 13:15:36 -0600358 audio_input_flags_t flags,
Eric Laurent9ae8c592017-06-22 17:17:09 -0700359 audio_port_handle_t *selectedDeviceId,
Eric Laurent20b9ef02016-12-05 11:03:16 -0800360 audio_port_handle_t *portId)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800361{
Eric Laurentdce54a12014-03-10 12:19:46 -0700362 if (mAudioPolicyManager == NULL) {
Eric Laurentcaf7f482014-11-25 17:50:47 -0800363 return NO_INIT;
Eric Laurent2d388ec2014-03-07 13:25:54 -0800364 }
Eric Laurent7dca8a82018-01-29 18:44:26 -0800365
Eric Laurent2d388ec2014-03-07 13:25:54 -0800366 // already checked by client, but double-check in case the client wrapper is bypassed
Eric Laurentae4b6ec2019-01-15 18:34:38 -0800367 if ((attr->source < AUDIO_SOURCE_DEFAULT)
368 || (attr->source >= AUDIO_SOURCE_CNT
369 && attr->source != AUDIO_SOURCE_HOTWORD
370 && attr->source != AUDIO_SOURCE_FM_TUNER
371 && attr->source != AUDIO_SOURCE_ECHO_REFERENCE)) {
Eric Laurentcaf7f482014-11-25 17:50:47 -0800372 return BAD_VALUE;
Eric Laurent2d388ec2014-03-07 13:25:54 -0800373 }
374
Eric Laurentb2379ba2016-05-23 17:42:12 -0700375 bool updatePid = (pid == -1);
Marco Nelissendcb346b2015-09-09 10:47:29 -0700376 const uid_t callingUid = IPCThreadState::self()->getCallingUid();
Andy Hung4ef19fa2018-05-15 19:35:29 -0700377 if (!isAudioServerOrMediaServerUid(callingUid)) {
Eric Laurent9f39f8d2016-05-25 12:34:48 -0700378 ALOGW_IF(uid != (uid_t)-1 && uid != callingUid,
Marco Nelissendcb346b2015-09-09 10:47:29 -0700379 "%s uid %d tried to pass itself off as %d", __FUNCTION__, callingUid, uid);
380 uid = callingUid;
Eric Laurentb2379ba2016-05-23 17:42:12 -0700381 updatePid = true;
382 }
383
384 if (updatePid) {
385 const pid_t callingPid = IPCThreadState::self()->getCallingPid();
Eric Laurent9f39f8d2016-05-25 12:34:48 -0700386 ALOGW_IF(pid != (pid_t)-1 && pid != callingPid,
Eric Laurentb2379ba2016-05-23 17:42:12 -0700387 "%s uid %d pid %d tried to pass itself off as pid %d",
388 __func__, callingUid, callingPid, pid);
389 pid = callingPid;
Eric Laurent8c7e6da2015-04-21 17:37:00 -0700390 }
391
Eric Laurent58a0dd82019-10-24 12:42:17 -0700392 // check calling permissions.
393 // Capturing from FM_TUNER source is controlled by captureAudioOutputAllowed() only as this
394 // does not affect users privacy as does capturing from an actual microphone.
395 if (!(recordingAllowed(opPackageName, pid, uid) || attr->source == AUDIO_SOURCE_FM_TUNER)) {
Eric Laurent7dca8a82018-01-29 18:44:26 -0800396 ALOGE("%s permission denied: recording not allowed for uid %d pid %d",
397 __func__, uid, pid);
398 return PERMISSION_DENIED;
399 }
400
Eric Laurent1ff16a72019-03-14 18:35:04 -0700401 bool canCaptureOutput = captureAudioOutputAllowed(pid, uid);
Nadav Bar744be482018-05-08 13:26:21 +0300402 if ((attr->source == AUDIO_SOURCE_VOICE_UPLINK ||
403 attr->source == AUDIO_SOURCE_VOICE_DOWNLINK ||
Eric Laurentae4b6ec2019-01-15 18:34:38 -0800404 attr->source == AUDIO_SOURCE_VOICE_CALL ||
Eric Laurent58a0dd82019-10-24 12:42:17 -0700405 attr->source == AUDIO_SOURCE_ECHO_REFERENCE||
406 attr->source == AUDIO_SOURCE_FM_TUNER) &&
Eric Laurent1ff16a72019-03-14 18:35:04 -0700407 !canCaptureOutput) {
Nadav Bar744be482018-05-08 13:26:21 +0300408 return PERMISSION_DENIED;
409 }
410
jiabin68e0df72019-03-18 17:55:35 -0700411 bool canCaptureHotword = captureHotwordAllowed(opPackageName, pid, uid);
Eric Laurent1ff16a72019-03-14 18:35:04 -0700412 if ((attr->source == AUDIO_SOURCE_HOTWORD) && !canCaptureHotword) {
Eric Laurent7504b9e2017-08-15 18:17:26 -0700413 return BAD_VALUE;
414 }
415
416 sp<AudioPolicyEffects>audioPolicyEffects;
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700417 {
Eric Laurent7504b9e2017-08-15 18:17:26 -0700418 status_t status;
419 AudioPolicyInterface::input_type_t inputType;
420
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700421 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700422 {
423 AutoCallerClear acc;
424 // the audio_in_acoustics_t parameter is ignored by get_input()
Mikhail Naganov2996f672019-04-18 12:29:59 -0700425 status = mAudioPolicyManager->getInputForAttr(attr, input, riid, session, uid,
Eric Laurent10b71232018-04-13 18:14:44 -0700426 config,
427 flags, selectedDeviceId,
428 &inputType, portId);
429 }
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700430 audioPolicyEffects = mAudioPolicyEffects;
Jean-Michel Trivi97bb33f2014-12-12 16:23:43 -0800431
432 if (status == NO_ERROR) {
433 // enforce permission (if any) required for each type of input
434 switch (inputType) {
Kevin Rocard25f9b052019-02-27 15:08:54 -0800435 case AudioPolicyInterface::API_INPUT_MIX_PUBLIC_CAPTURE_PLAYBACK:
436 // this use case has been validated in audio service with a MediaProjection token,
437 // and doesn't rely on regular permissions
Jean-Michel Trivi97bb33f2014-12-12 16:23:43 -0800438 case AudioPolicyInterface::API_INPUT_LEGACY:
439 break;
Eric Laurent82db2692015-08-07 13:59:42 -0700440 case AudioPolicyInterface::API_INPUT_TELEPHONY_RX:
441 // FIXME: use the same permission as for remote submix for now.
Jean-Michel Trivi97bb33f2014-12-12 16:23:43 -0800442 case AudioPolicyInterface::API_INPUT_MIX_CAPTURE:
Eric Laurent1ff16a72019-03-14 18:35:04 -0700443 if (!canCaptureOutput) {
Jean-Michel Trivi97bb33f2014-12-12 16:23:43 -0800444 ALOGE("getInputForAttr() permission denied: capture not allowed");
445 status = PERMISSION_DENIED;
446 }
447 break;
448 case AudioPolicyInterface::API_INPUT_MIX_EXT_POLICY_REROUTE:
Eric Laurent8a1095a2019-11-08 14:44:16 -0800449 if (!modifyAudioRoutingAllowed(pid, uid)) {
Jean-Michel Trivi97bb33f2014-12-12 16:23:43 -0800450 ALOGE("getInputForAttr() permission denied: modify audio routing not allowed");
451 status = PERMISSION_DENIED;
452 }
453 break;
454 case AudioPolicyInterface::API_INPUT_INVALID:
455 default:
456 LOG_ALWAYS_FATAL("getInputForAttr() encountered an invalid input type %d",
457 (int)inputType);
458 }
459 }
460
461 if (status != NO_ERROR) {
462 if (status == PERMISSION_DENIED) {
Eric Laurent10b71232018-04-13 18:14:44 -0700463 AutoCallerClear acc;
Eric Laurent8fc147b2018-07-22 19:13:55 -0700464 mAudioPolicyManager->releaseInput(*portId);
Jean-Michel Trivi97bb33f2014-12-12 16:23:43 -0800465 }
466 return status;
467 }
Eric Laurentfee19762018-01-29 18:44:13 -0800468
Eric Laurent5ada82e2019-08-29 17:53:54 -0700469 sp<AudioRecordClient> client = new AudioRecordClient(*attr, *input, uid, pid, session, *portId,
Eric Laurent1ff16a72019-03-14 18:35:04 -0700470 *selectedDeviceId, opPackageName,
471 canCaptureOutput, canCaptureHotword);
Eric Laurentfee19762018-01-29 18:44:13 -0800472 mAudioRecordClients.add(*portId, client);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700473 }
Jean-Michel Trivi97bb33f2014-12-12 16:23:43 -0800474
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700475 if (audioPolicyEffects != 0) {
476 // create audio pre processors according to input source
Eric Laurentcaf7f482014-11-25 17:50:47 -0800477 status_t status = audioPolicyEffects->addInputEffects(*input, attr->source, session);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700478 if (status != NO_ERROR && status != ALREADY_EXISTS) {
Eric Laurentcaf7f482014-11-25 17:50:47 -0800479 ALOGW("Failed to add effects on input %d", *input);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700480 }
Eric Laurent2d388ec2014-03-07 13:25:54 -0800481 }
Eric Laurentcaf7f482014-11-25 17:50:47 -0800482 return NO_ERROR;
Eric Laurent2d388ec2014-03-07 13:25:54 -0800483}
484
Eric Laurent99fcae42018-05-17 16:59:18 -0700485std::string AudioPolicyService::getDeviceTypeStrForPortId(audio_port_handle_t portId) {
Eric Laurent99fcae42018-05-17 16:59:18 -0700486 struct audio_port port = {};
487 port.id = portId;
488 status_t status = mAudioPolicyManager->getAudioPort(&port);
489 if (status == NO_ERROR && port.type == AUDIO_PORT_TYPE_DEVICE) {
Andy Hung9b181952019-02-25 14:53:36 -0800490 return toString(port.ext.device.type);
Eric Laurent99fcae42018-05-17 16:59:18 -0700491 }
Andy Hung9b181952019-02-25 14:53:36 -0800492 return {};
Eric Laurent99fcae42018-05-17 16:59:18 -0700493}
494
Eric Laurent4eb58f12018-12-07 16:41:02 -0800495status_t AudioPolicyService::startInput(audio_port_handle_t portId)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800496{
Eric Laurentdce54a12014-03-10 12:19:46 -0700497 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800498 return NO_INIT;
499 }
Eric Laurent7dca8a82018-01-29 18:44:26 -0800500 sp<AudioRecordClient> client;
501 {
502 Mutex::Autolock _l(mLock);
Svet Ganovf4ddfef2018-01-16 07:37:58 -0800503
Eric Laurent7dca8a82018-01-29 18:44:26 -0800504 ssize_t index = mAudioRecordClients.indexOfKey(portId);
505 if (index < 0) {
506 return INVALID_OPERATION;
507 }
508 client = mAudioRecordClients.valueAt(index);
Eric Laurentfee19762018-01-29 18:44:13 -0800509 }
Eric Laurent7dca8a82018-01-29 18:44:26 -0800510
511 // check calling permissions
Eric Laurent58a0dd82019-10-24 12:42:17 -0700512 if (!(startRecording(client->opPackageName, client->pid, client->uid)
513 || client->attributes.source == AUDIO_SOURCE_FM_TUNER)) {
Eric Laurent7dca8a82018-01-29 18:44:26 -0800514 ALOGE("%s permission denied: recording not allowed for uid %d pid %d",
515 __func__, client->uid, client->pid);
516 return PERMISSION_DENIED;
517 }
Eric Laurentfee19762018-01-29 18:44:13 -0800518
Eric Laurentdf628922018-12-06 21:45:51 +0000519 Mutex::Autolock _l(mLock);
Eric Laurent4eb58f12018-12-07 16:41:02 -0800520
521 client->active = true;
522 client->startTimeNs = systemTime();
523 updateUidStates_l();
Eric Laurentfee19762018-01-29 18:44:13 -0800524
Eric Laurent10b71232018-04-13 18:14:44 -0700525 status_t status;
526 {
527 AutoCallerClear acc;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800528 status = mAudioPolicyManager->startInput(portId);
Ray Essick84e84a52018-05-03 18:45:07 -0700529
530 }
531
Ray Essickf6a57cd2018-05-22 16:20:54 -0700532 // including successes gets very verbose
Ray Essick6ce27e52019-02-15 10:58:05 -0800533 // but once we cut over to westworld, log them all.
Ray Essickf6a57cd2018-05-22 16:20:54 -0700534 if (status != NO_ERROR) {
Ray Essick84e84a52018-05-03 18:45:07 -0700535
536 static constexpr char kAudioPolicy[] = "audiopolicy";
537
Ray Essick84e84a52018-05-03 18:45:07 -0700538 static constexpr char kAudioPolicyStatus[] = "android.media.audiopolicy.status";
539 static constexpr char kAudioPolicyRqstSrc[] = "android.media.audiopolicy.rqst.src";
540 static constexpr char kAudioPolicyRqstPkg[] = "android.media.audiopolicy.rqst.pkg";
541 static constexpr char kAudioPolicyRqstSession[] = "android.media.audiopolicy.rqst.session";
Eric Laurent99fcae42018-05-17 16:59:18 -0700542 static constexpr char kAudioPolicyRqstDevice[] =
543 "android.media.audiopolicy.rqst.device";
Ray Essick84e84a52018-05-03 18:45:07 -0700544 static constexpr char kAudioPolicyActiveSrc[] = "android.media.audiopolicy.active.src";
545 static constexpr char kAudioPolicyActivePkg[] = "android.media.audiopolicy.active.pkg";
Eric Laurent99fcae42018-05-17 16:59:18 -0700546 static constexpr char kAudioPolicyActiveSession[] =
547 "android.media.audiopolicy.active.session";
548 static constexpr char kAudioPolicyActiveDevice[] =
549 "android.media.audiopolicy.active.device";
Ray Essick84e84a52018-05-03 18:45:07 -0700550
Ray Essickf27e9872019-12-07 06:28:46 -0800551 mediametrics::Item *item = mediametrics::Item::create(kAudioPolicy);
Ray Essick84e84a52018-05-03 18:45:07 -0700552 if (item != NULL) {
553
Ray Essick84e84a52018-05-03 18:45:07 -0700554 item->setInt32(kAudioPolicyStatus, status);
555
Eric Laurent99fcae42018-05-17 16:59:18 -0700556 item->setCString(kAudioPolicyRqstSrc,
Andy Hung9b181952019-02-25 14:53:36 -0800557 toString(client->attributes.source).c_str());
Ray Essick84e84a52018-05-03 18:45:07 -0700558 item->setInt32(kAudioPolicyRqstSession, client->session);
Ray Essick51866952018-05-30 11:22:27 -0700559 if (client->opPackageName.size() != 0) {
560 item->setCString(kAudioPolicyRqstPkg,
561 std::string(String8(client->opPackageName).string()).c_str());
562 } else {
Kevin Rocardfbdfebe2018-06-18 12:30:40 -0700563 item->setCString(kAudioPolicyRqstPkg, std::to_string(client->uid).c_str());
Ray Essick51866952018-05-30 11:22:27 -0700564 }
Eric Laurent99fcae42018-05-17 16:59:18 -0700565 item->setCString(
566 kAudioPolicyRqstDevice, getDeviceTypeStrForPortId(client->deviceId).c_str());
567
Eric Laurent4eb58f12018-12-07 16:41:02 -0800568 int count = mAudioRecordClients.size();
569 for (int i = 0; i < count ; i++) {
570 if (portId == mAudioRecordClients.keyAt(i)) {
571 continue;
572 }
573 sp<AudioRecordClient> other = mAudioRecordClients.valueAt(i);
574 if (other->active) {
575 // keeps the last of the clients marked active
576 item->setCString(kAudioPolicyActiveSrc,
Andy Hung9b181952019-02-25 14:53:36 -0800577 toString(other->attributes.source).c_str());
Eric Laurent4eb58f12018-12-07 16:41:02 -0800578 item->setInt32(kAudioPolicyActiveSession, other->session);
579 if (other->opPackageName.size() != 0) {
580 item->setCString(kAudioPolicyActivePkg,
581 std::string(String8(other->opPackageName).string()).c_str());
582 } else {
583 item->setCString(kAudioPolicyRqstPkg,
584 std::to_string(other->uid).c_str());
Ray Essick84e84a52018-05-03 18:45:07 -0700585 }
Eric Laurent4eb58f12018-12-07 16:41:02 -0800586 item->setCString(kAudioPolicyActiveDevice,
587 getDeviceTypeStrForPortId(other->deviceId).c_str());
Ray Essick84e84a52018-05-03 18:45:07 -0700588 }
589 }
590 item->selfrecord();
591 delete item;
592 item = NULL;
593 }
Ray Essick6ce27e52019-02-15 10:58:05 -0800594 }
595
596 if (status != NO_ERROR) {
Eric Laurent4eb58f12018-12-07 16:41:02 -0800597 client->active = false;
598 client->startTimeNs = 0;
599 updateUidStates_l();
Svet Ganov6e641372018-03-02 09:21:30 -0800600 finishRecording(client->opPackageName, client->uid);
Eric Laurentfb66dd92016-01-28 18:32:03 -0800601 }
602
603 return status;
Eric Laurent2d388ec2014-03-07 13:25:54 -0800604}
605
Eric Laurentfee19762018-01-29 18:44:13 -0800606status_t AudioPolicyService::stopInput(audio_port_handle_t portId)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800607{
Eric Laurentdce54a12014-03-10 12:19:46 -0700608 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800609 return NO_INIT;
610 }
Eric Laurent4eb58f12018-12-07 16:41:02 -0800611
Eric Laurent2d388ec2014-03-07 13:25:54 -0800612 Mutex::Autolock _l(mLock);
613
Eric Laurentfee19762018-01-29 18:44:13 -0800614 ssize_t index = mAudioRecordClients.indexOfKey(portId);
615 if (index < 0) {
616 return INVALID_OPERATION;
617 }
618 sp<AudioRecordClient> client = mAudioRecordClients.valueAt(index);
619
Ray Essick84e84a52018-05-03 18:45:07 -0700620 client->active = false;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800621 client->startTimeNs = 0;
622
623 updateUidStates_l();
Ray Essick84e84a52018-05-03 18:45:07 -0700624
Svet Ganov6e641372018-03-02 09:21:30 -0800625 // finish the recording app op
626 finishRecording(client->opPackageName, client->uid);
Eric Laurent10b71232018-04-13 18:14:44 -0700627 AutoCallerClear acc;
Eric Laurent8fc147b2018-07-22 19:13:55 -0700628 return mAudioPolicyManager->stopInput(portId);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800629}
630
Eric Laurentfee19762018-01-29 18:44:13 -0800631void AudioPolicyService::releaseInput(audio_port_handle_t portId)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800632{
Eric Laurentdce54a12014-03-10 12:19:46 -0700633 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800634 return;
635 }
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700636 sp<AudioPolicyEffects>audioPolicyEffects;
Eric Laurentfee19762018-01-29 18:44:13 -0800637 sp<AudioRecordClient> client;
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700638 {
639 Mutex::Autolock _l(mLock);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700640 audioPolicyEffects = mAudioPolicyEffects;
Eric Laurentfee19762018-01-29 18:44:13 -0800641 ssize_t index = mAudioRecordClients.indexOfKey(portId);
642 if (index < 0) {
643 return;
644 }
645 client = mAudioRecordClients.valueAt(index);
Eric Laurent4eb58f12018-12-07 16:41:02 -0800646
647 if (client->active) {
648 ALOGW("%s releasing active client portId %d", __FUNCTION__, portId);
649 client->active = false;
650 client->startTimeNs = 0;
651 updateUidStates_l();
652 }
653
Eric Laurentfee19762018-01-29 18:44:13 -0800654 mAudioRecordClients.removeItem(portId);
655 }
656 if (client == 0) {
657 return;
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700658 }
659 if (audioPolicyEffects != 0) {
660 // release audio processors from the input
Eric Laurentd7fe0862018-07-14 16:48:01 -0700661 status_t status = audioPolicyEffects->releaseInputEffects(client->io, client->session);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700662 if(status != NO_ERROR) {
Eric Laurentd7fe0862018-07-14 16:48:01 -0700663 ALOGW("Failed to release effects on input %d", client->io);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700664 }
Eric Laurent2d388ec2014-03-07 13:25:54 -0800665 }
Eric Laurentf10c7092016-12-06 17:09:56 -0800666 {
667 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700668 AutoCallerClear acc;
Eric Laurent8fc147b2018-07-22 19:13:55 -0700669 mAudioPolicyManager->releaseInput(portId);
Eric Laurentf10c7092016-12-06 17:09:56 -0800670 }
Eric Laurent2d388ec2014-03-07 13:25:54 -0800671}
672
673status_t AudioPolicyService::initStreamVolume(audio_stream_type_t stream,
674 int indexMin,
675 int indexMax)
676{
Eric Laurentdce54a12014-03-10 12:19:46 -0700677 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800678 return NO_INIT;
679 }
680 if (!settingsAllowed()) {
681 return PERMISSION_DENIED;
682 }
Eric Laurent223fd5c2014-11-11 13:43:36 -0800683 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800684 return BAD_VALUE;
685 }
686 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700687 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700688 mAudioPolicyManager->initStreamVolume(stream, indexMin, indexMax);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800689 return NO_ERROR;
690}
691
692status_t AudioPolicyService::setStreamVolumeIndex(audio_stream_type_t stream,
693 int index,
694 audio_devices_t device)
695{
Eric Laurentdce54a12014-03-10 12:19:46 -0700696 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800697 return NO_INIT;
698 }
699 if (!settingsAllowed()) {
700 return PERMISSION_DENIED;
701 }
Eric Laurent223fd5c2014-11-11 13:43:36 -0800702 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800703 return BAD_VALUE;
704 }
705 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700706 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700707 return mAudioPolicyManager->setStreamVolumeIndex(stream,
708 index,
709 device);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800710}
711
712status_t AudioPolicyService::getStreamVolumeIndex(audio_stream_type_t stream,
713 int *index,
714 audio_devices_t device)
715{
Eric Laurentdce54a12014-03-10 12:19:46 -0700716 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800717 return NO_INIT;
718 }
Eric Laurent223fd5c2014-11-11 13:43:36 -0800719 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800720 return BAD_VALUE;
721 }
722 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700723 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700724 return mAudioPolicyManager->getStreamVolumeIndex(stream,
725 index,
726 device);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800727}
728
François Gaffiecfe17322018-11-07 13:41:29 +0100729status_t AudioPolicyService::setVolumeIndexForAttributes(const audio_attributes_t &attributes,
730 int index, audio_devices_t device)
731{
732 if (mAudioPolicyManager == NULL) {
733 return NO_INIT;
734 }
735 if (!settingsAllowed()) {
736 return PERMISSION_DENIED;
737 }
738 Mutex::Autolock _l(mLock);
739 AutoCallerClear acc;
740 return mAudioPolicyManager->setVolumeIndexForAttributes(attributes, index, device);
741}
742
743status_t AudioPolicyService::getVolumeIndexForAttributes(const audio_attributes_t &attributes,
744 int &index, audio_devices_t device)
745{
746 if (mAudioPolicyManager == NULL) {
747 return NO_INIT;
748 }
749 Mutex::Autolock _l(mLock);
750 AutoCallerClear acc;
751 return mAudioPolicyManager->getVolumeIndexForAttributes(attributes, index, device);
752}
753
754status_t AudioPolicyService::getMinVolumeIndexForAttributes(const audio_attributes_t &attributes,
755 int &index)
756{
757 if (mAudioPolicyManager == NULL) {
758 return NO_INIT;
759 }
760 Mutex::Autolock _l(mLock);
761 AutoCallerClear acc;
762 return mAudioPolicyManager->getMinVolumeIndexForAttributes(attributes, index);
763}
764
765status_t AudioPolicyService::getMaxVolumeIndexForAttributes(const audio_attributes_t &attributes,
766 int &index)
767{
768 if (mAudioPolicyManager == NULL) {
769 return NO_INIT;
770 }
771 Mutex::Autolock _l(mLock);
772 AutoCallerClear acc;
773 return mAudioPolicyManager->getMaxVolumeIndexForAttributes(attributes, index);
774}
775
Eric Laurent2d388ec2014-03-07 13:25:54 -0800776uint32_t AudioPolicyService::getStrategyForStream(audio_stream_type_t stream)
777{
Eric Laurent223fd5c2014-11-11 13:43:36 -0800778 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
François Gaffiec005e562018-11-06 15:04:49 +0100779 return PRODUCT_STRATEGY_NONE;
Eric Laurentdea15412014-10-28 15:46:45 -0700780 }
Eric Laurentdce54a12014-03-10 12:19:46 -0700781 if (mAudioPolicyManager == NULL) {
François Gaffiec005e562018-11-06 15:04:49 +0100782 return PRODUCT_STRATEGY_NONE;
Eric Laurent2d388ec2014-03-07 13:25:54 -0800783 }
François Gaffiec005e562018-11-06 15:04:49 +0100784 // DO NOT LOCK, may be called from AudioFlinger with lock held, reaching deadlock
Eric Laurent10b71232018-04-13 18:14:44 -0700785 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700786 return mAudioPolicyManager->getStrategyForStream(stream);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800787}
788
789//audio policy: use audio_device_t appropriately
790
791audio_devices_t AudioPolicyService::getDevicesForStream(audio_stream_type_t stream)
792{
Eric Laurent223fd5c2014-11-11 13:43:36 -0800793 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
Eric Laurentb1322c72014-10-30 14:59:13 -0700794 return AUDIO_DEVICE_NONE;
Eric Laurentdea15412014-10-28 15:46:45 -0700795 }
Eric Laurentdce54a12014-03-10 12:19:46 -0700796 if (mAudioPolicyManager == NULL) {
Eric Laurentb1322c72014-10-30 14:59:13 -0700797 return AUDIO_DEVICE_NONE;
Eric Laurent2d388ec2014-03-07 13:25:54 -0800798 }
Haynes Mathew Georgedfb9f3b2015-10-26 18:22:13 -0700799 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700800 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700801 return mAudioPolicyManager->getDevicesForStream(stream);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800802}
803
Jean-Michel Trivif41599b2020-01-07 14:22:08 -0800804status_t AudioPolicyService::getDevicesForAttributes(const AudioAttributes &aa,
805 AudioDeviceTypeAddrVector *devices) const
806{
807 if (mAudioPolicyManager == NULL) {
808 return NO_INIT;
809 }
810 Mutex::Autolock _l(mLock);
811 AutoCallerClear acc;
812 return mAudioPolicyManager->getDevicesForAttributes(aa.getAttributes(), devices);
813}
814
Eric Laurent2d388ec2014-03-07 13:25:54 -0800815audio_io_handle_t AudioPolicyService::getOutputForEffect(const effect_descriptor_t *desc)
816{
817 // FIXME change return type to status_t, and return NO_INIT here
Eric Laurentdce54a12014-03-10 12:19:46 -0700818 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800819 return 0;
820 }
821 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700822 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700823 return mAudioPolicyManager->getOutputForEffect(desc);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800824}
825
826status_t AudioPolicyService::registerEffect(const effect_descriptor_t *desc,
827 audio_io_handle_t io,
828 uint32_t strategy,
Glenn Kastend848eb42016-03-08 13:42:11 -0800829 audio_session_t session,
Eric Laurent2d388ec2014-03-07 13:25:54 -0800830 int id)
831{
Eric Laurentdce54a12014-03-10 12:19:46 -0700832 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800833 return NO_INIT;
834 }
Eric Laurent6c796322019-04-09 14:13:17 -0700835 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700836 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700837 return mAudioPolicyManager->registerEffect(desc, io, strategy, session, id);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800838}
839
840status_t AudioPolicyService::unregisterEffect(int id)
841{
Eric Laurentdce54a12014-03-10 12:19:46 -0700842 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800843 return NO_INIT;
844 }
Eric Laurent6c796322019-04-09 14:13:17 -0700845 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700846 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700847 return mAudioPolicyManager->unregisterEffect(id);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800848}
849
850status_t AudioPolicyService::setEffectEnabled(int id, bool enabled)
851{
Eric Laurentdce54a12014-03-10 12:19:46 -0700852 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800853 return NO_INIT;
854 }
Eric Laurent6c796322019-04-09 14:13:17 -0700855 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700856 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700857 return mAudioPolicyManager->setEffectEnabled(id, enabled);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800858}
859
Eric Laurent6c796322019-04-09 14:13:17 -0700860status_t AudioPolicyService::moveEffectsToIo(const std::vector<int>& ids, audio_io_handle_t io)
861{
862 if (mAudioPolicyManager == NULL) {
863 return NO_INIT;
864 }
865 Mutex::Autolock _l(mLock);
866 AutoCallerClear acc;
867 return mAudioPolicyManager->moveEffectsToIo(ids, io);
868}
869
Eric Laurent2d388ec2014-03-07 13:25:54 -0800870bool AudioPolicyService::isStreamActive(audio_stream_type_t stream, uint32_t inPastMs) const
871{
Eric Laurent223fd5c2014-11-11 13:43:36 -0800872 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
Eric Laurentb1322c72014-10-30 14:59:13 -0700873 return false;
Eric Laurentdea15412014-10-28 15:46:45 -0700874 }
Eric Laurentdce54a12014-03-10 12:19:46 -0700875 if (mAudioPolicyManager == NULL) {
Eric Laurentb1322c72014-10-30 14:59:13 -0700876 return false;
Eric Laurent2d388ec2014-03-07 13:25:54 -0800877 }
878 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700879 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700880 return mAudioPolicyManager->isStreamActive(stream, inPastMs);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800881}
882
883bool AudioPolicyService::isStreamActiveRemotely(audio_stream_type_t stream, uint32_t inPastMs) const
884{
Eric Laurent223fd5c2014-11-11 13:43:36 -0800885 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
Eric Laurentb1322c72014-10-30 14:59:13 -0700886 return false;
Eric Laurentdea15412014-10-28 15:46:45 -0700887 }
Eric Laurentdce54a12014-03-10 12:19:46 -0700888 if (mAudioPolicyManager == NULL) {
Eric Laurentb1322c72014-10-30 14:59:13 -0700889 return false;
Eric Laurent2d388ec2014-03-07 13:25:54 -0800890 }
891 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700892 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700893 return mAudioPolicyManager->isStreamActiveRemotely(stream, inPastMs);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800894}
895
896bool AudioPolicyService::isSourceActive(audio_source_t source) const
897{
Eric Laurentdce54a12014-03-10 12:19:46 -0700898 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800899 return false;
900 }
901 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700902 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700903 return mAudioPolicyManager->isSourceActive(source);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800904}
905
Ari Hausman-Cohen24628312018-08-13 15:01:09 -0700906status_t AudioPolicyService::getAudioPolicyEffects(sp<AudioPolicyEffects>& audioPolicyEffects)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800907{
Eric Laurentdce54a12014-03-10 12:19:46 -0700908 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800909 return NO_INIT;
910 }
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700911 {
912 Mutex::Autolock _l(mLock);
913 audioPolicyEffects = mAudioPolicyEffects;
914 }
915 if (audioPolicyEffects == 0) {
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700916 return NO_INIT;
917 }
Ari Hausman-Cohen24628312018-08-13 15:01:09 -0700918
919 return OK;
920}
921
922status_t AudioPolicyService::queryDefaultPreProcessing(audio_session_t audioSession,
923 effect_descriptor_t *descriptors,
924 uint32_t *count)
925{
926 sp<AudioPolicyEffects>audioPolicyEffects;
927 status_t status = getAudioPolicyEffects(audioPolicyEffects);
928 if (status != OK) {
929 *count = 0;
930 return status;
931 }
Eric Laurentfb66dd92016-01-28 18:32:03 -0800932 return audioPolicyEffects->queryDefaultInputEffects(
933 (audio_session_t)audioSession, descriptors, count);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800934}
935
Ari Hausman-Cohen24628312018-08-13 15:01:09 -0700936status_t AudioPolicyService::addSourceDefaultEffect(const effect_uuid_t *type,
937 const String16& opPackageName,
938 const effect_uuid_t *uuid,
939 int32_t priority,
940 audio_source_t source,
941 audio_unique_id_t* id)
942{
943 sp<AudioPolicyEffects>audioPolicyEffects;
944 status_t status = getAudioPolicyEffects(audioPolicyEffects);
945 if (status != OK) {
946 return status;
947 }
948 if (!modifyDefaultAudioEffectsAllowed()) {
949 return PERMISSION_DENIED;
950 }
951 return audioPolicyEffects->addSourceDefaultEffect(
952 type, opPackageName, uuid, priority, source, id);
953}
954
Ari Hausman-Cohen433722e2018-04-24 14:25:22 -0700955status_t AudioPolicyService::addStreamDefaultEffect(const effect_uuid_t *type,
956 const String16& opPackageName,
957 const effect_uuid_t *uuid,
958 int32_t priority,
959 audio_usage_t usage,
960 audio_unique_id_t* id)
961{
Ari Hausman-Cohen24628312018-08-13 15:01:09 -0700962 sp<AudioPolicyEffects>audioPolicyEffects;
963 status_t status = getAudioPolicyEffects(audioPolicyEffects);
964 if (status != OK) {
965 return status;
Ari Hausman-Cohen433722e2018-04-24 14:25:22 -0700966 }
967 if (!modifyDefaultAudioEffectsAllowed()) {
968 return PERMISSION_DENIED;
969 }
Ari Hausman-Cohen433722e2018-04-24 14:25:22 -0700970 return audioPolicyEffects->addStreamDefaultEffect(
971 type, opPackageName, uuid, priority, usage, id);
972}
973
Ari Hausman-Cohen24628312018-08-13 15:01:09 -0700974status_t AudioPolicyService::removeSourceDefaultEffect(audio_unique_id_t id)
Ari Hausman-Cohen433722e2018-04-24 14:25:22 -0700975{
Ari Hausman-Cohen24628312018-08-13 15:01:09 -0700976 sp<AudioPolicyEffects>audioPolicyEffects;
977 status_t status = getAudioPolicyEffects(audioPolicyEffects);
978 if (status != OK) {
979 return status;
Ari Hausman-Cohen433722e2018-04-24 14:25:22 -0700980 }
981 if (!modifyDefaultAudioEffectsAllowed()) {
982 return PERMISSION_DENIED;
983 }
Ari Hausman-Cohen24628312018-08-13 15:01:09 -0700984 return audioPolicyEffects->removeSourceDefaultEffect(id);
985}
986
987status_t AudioPolicyService::removeStreamDefaultEffect(audio_unique_id_t id)
988{
Ari Hausman-Cohen433722e2018-04-24 14:25:22 -0700989 sp<AudioPolicyEffects>audioPolicyEffects;
Ari Hausman-Cohen24628312018-08-13 15:01:09 -0700990 status_t status = getAudioPolicyEffects(audioPolicyEffects);
991 if (status != OK) {
992 return status;
Ari Hausman-Cohen433722e2018-04-24 14:25:22 -0700993 }
Ari Hausman-Cohen24628312018-08-13 15:01:09 -0700994 if (!modifyDefaultAudioEffectsAllowed()) {
995 return PERMISSION_DENIED;
Ari Hausman-Cohen433722e2018-04-24 14:25:22 -0700996 }
997 return audioPolicyEffects->removeStreamDefaultEffect(id);
998}
999
Kevin Rocardb99cc752019-03-21 20:52:24 -07001000status_t AudioPolicyService::setAllowedCapturePolicy(uid_t uid, audio_flags_mask_t capturePolicy) {
1001 Mutex::Autolock _l(mLock);
1002 if (mAudioPolicyManager == NULL) {
1003 ALOGV("%s() mAudioPolicyManager == NULL", __func__);
1004 return NO_INIT;
1005 }
1006 uint_t callingUid = IPCThreadState::self()->getCallingUid();
1007 if (uid != callingUid) {
1008 ALOGD("%s() uid invalid %d != %d", __func__, uid, callingUid);
1009 return PERMISSION_DENIED;
1010 }
1011 return mAudioPolicyManager->setAllowedCapturePolicy(uid, capturePolicy);
1012}
1013
Eric Laurent2d388ec2014-03-07 13:25:54 -08001014bool AudioPolicyService::isOffloadSupported(const audio_offload_info_t& info)
1015{
Eric Laurentdce54a12014-03-10 12:19:46 -07001016 if (mAudioPolicyManager == NULL) {
1017 ALOGV("mAudioPolicyManager == NULL");
Eric Laurent2d388ec2014-03-07 13:25:54 -08001018 return false;
1019 }
Andy Hung2ddee192015-12-18 17:34:44 -08001020 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -07001021 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -07001022 return mAudioPolicyManager->isOffloadSupported(info);
Eric Laurent2d388ec2014-03-07 13:25:54 -08001023}
1024
Michael Chana94fbb22018-04-24 14:31:19 +10001025bool AudioPolicyService::isDirectOutputSupported(const audio_config_base_t& config,
1026 const audio_attributes_t& attributes) {
1027 if (mAudioPolicyManager == NULL) {
1028 ALOGV("mAudioPolicyManager == NULL");
1029 return false;
1030 }
1031 Mutex::Autolock _l(mLock);
1032 return mAudioPolicyManager->isDirectOutputSupported(config, attributes);
1033}
1034
1035
Eric Laurent6a94d692014-05-20 11:18:06 -07001036status_t AudioPolicyService::listAudioPorts(audio_port_role_t role,
1037 audio_port_type_t type,
Eric Laurent203b1a12014-04-01 10:34:16 -07001038 unsigned int *num_ports,
Eric Laurent6a94d692014-05-20 11:18:06 -07001039 struct audio_port *ports,
1040 unsigned int *generation)
Eric Laurent203b1a12014-04-01 10:34:16 -07001041{
Eric Laurent6a94d692014-05-20 11:18:06 -07001042 Mutex::Autolock _l(mLock);
1043 if (mAudioPolicyManager == NULL) {
1044 return NO_INIT;
1045 }
Eric Laurent10b71232018-04-13 18:14:44 -07001046 AutoCallerClear acc;
Eric Laurent6a94d692014-05-20 11:18:06 -07001047 return mAudioPolicyManager->listAudioPorts(role, type, num_ports, ports, generation);
Eric Laurent203b1a12014-04-01 10:34:16 -07001048}
1049
Eric Laurent6a94d692014-05-20 11:18:06 -07001050status_t AudioPolicyService::getAudioPort(struct audio_port *port)
Eric Laurent203b1a12014-04-01 10:34:16 -07001051{
Eric Laurent6a94d692014-05-20 11:18:06 -07001052 Mutex::Autolock _l(mLock);
1053 if (mAudioPolicyManager == NULL) {
1054 return NO_INIT;
1055 }
Eric Laurent10b71232018-04-13 18:14:44 -07001056 AutoCallerClear acc;
Eric Laurent6a94d692014-05-20 11:18:06 -07001057 return mAudioPolicyManager->getAudioPort(port);
Eric Laurent203b1a12014-04-01 10:34:16 -07001058}
1059
Eric Laurent6a94d692014-05-20 11:18:06 -07001060status_t AudioPolicyService::createAudioPatch(const struct audio_patch *patch,
1061 audio_patch_handle_t *handle)
Eric Laurent203b1a12014-04-01 10:34:16 -07001062{
Eric Laurent6a94d692014-05-20 11:18:06 -07001063 Mutex::Autolock _l(mLock);
Eric Laurent5284ed52014-05-29 14:37:38 -07001064 if(!modifyAudioRoutingAllowed()) {
1065 return PERMISSION_DENIED;
1066 }
Eric Laurent6a94d692014-05-20 11:18:06 -07001067 if (mAudioPolicyManager == NULL) {
1068 return NO_INIT;
1069 }
Eric Laurent10b71232018-04-13 18:14:44 -07001070 AutoCallerClear acc;
Eric Laurent6a94d692014-05-20 11:18:06 -07001071 return mAudioPolicyManager->createAudioPatch(patch, handle,
1072 IPCThreadState::self()->getCallingUid());
Eric Laurent203b1a12014-04-01 10:34:16 -07001073}
1074
Eric Laurent6a94d692014-05-20 11:18:06 -07001075status_t AudioPolicyService::releaseAudioPatch(audio_patch_handle_t handle)
Eric Laurent203b1a12014-04-01 10:34:16 -07001076{
Eric Laurent6a94d692014-05-20 11:18:06 -07001077 Mutex::Autolock _l(mLock);
Eric Laurent5284ed52014-05-29 14:37:38 -07001078 if(!modifyAudioRoutingAllowed()) {
1079 return PERMISSION_DENIED;
1080 }
Eric Laurent6a94d692014-05-20 11:18:06 -07001081 if (mAudioPolicyManager == NULL) {
1082 return NO_INIT;
1083 }
Eric Laurent10b71232018-04-13 18:14:44 -07001084 AutoCallerClear acc;
Eric Laurent6a94d692014-05-20 11:18:06 -07001085 return mAudioPolicyManager->releaseAudioPatch(handle,
1086 IPCThreadState::self()->getCallingUid());
Eric Laurent203b1a12014-04-01 10:34:16 -07001087}
1088
1089status_t AudioPolicyService::listAudioPatches(unsigned int *num_patches,
Eric Laurent6a94d692014-05-20 11:18:06 -07001090 struct audio_patch *patches,
1091 unsigned int *generation)
Eric Laurent203b1a12014-04-01 10:34:16 -07001092{
Eric Laurent6a94d692014-05-20 11:18:06 -07001093 Mutex::Autolock _l(mLock);
1094 if (mAudioPolicyManager == NULL) {
1095 return NO_INIT;
1096 }
Eric Laurent10b71232018-04-13 18:14:44 -07001097 AutoCallerClear acc;
Eric Laurent6a94d692014-05-20 11:18:06 -07001098 return mAudioPolicyManager->listAudioPatches(num_patches, patches, generation);
Eric Laurent203b1a12014-04-01 10:34:16 -07001099}
1100
Eric Laurent6a94d692014-05-20 11:18:06 -07001101status_t AudioPolicyService::setAudioPortConfig(const struct audio_port_config *config)
Eric Laurent203b1a12014-04-01 10:34:16 -07001102{
Eric Laurent6a94d692014-05-20 11:18:06 -07001103 Mutex::Autolock _l(mLock);
Eric Laurent5284ed52014-05-29 14:37:38 -07001104 if(!modifyAudioRoutingAllowed()) {
1105 return PERMISSION_DENIED;
1106 }
Eric Laurent6a94d692014-05-20 11:18:06 -07001107 if (mAudioPolicyManager == NULL) {
1108 return NO_INIT;
1109 }
Eric Laurent10b71232018-04-13 18:14:44 -07001110 AutoCallerClear acc;
Eric Laurent6a94d692014-05-20 11:18:06 -07001111 return mAudioPolicyManager->setAudioPortConfig(config);
Eric Laurent203b1a12014-04-01 10:34:16 -07001112}
Eric Laurent2d388ec2014-03-07 13:25:54 -08001113
Eric Laurentdf3dc7e2014-07-27 18:39:40 -07001114status_t AudioPolicyService::acquireSoundTriggerSession(audio_session_t *session,
1115 audio_io_handle_t *ioHandle,
1116 audio_devices_t *device)
1117{
Andy Hungf759b8c2017-08-15 12:48:54 -07001118 Mutex::Autolock _l(mLock);
Eric Laurentdf3dc7e2014-07-27 18:39:40 -07001119 if (mAudioPolicyManager == NULL) {
1120 return NO_INIT;
1121 }
Eric Laurent10b71232018-04-13 18:14:44 -07001122 AutoCallerClear acc;
Eric Laurentdf3dc7e2014-07-27 18:39:40 -07001123 return mAudioPolicyManager->acquireSoundTriggerSession(session, ioHandle, device);
1124}
1125
1126status_t AudioPolicyService::releaseSoundTriggerSession(audio_session_t session)
1127{
Andy Hungf759b8c2017-08-15 12:48:54 -07001128 Mutex::Autolock _l(mLock);
Eric Laurentdf3dc7e2014-07-27 18:39:40 -07001129 if (mAudioPolicyManager == NULL) {
1130 return NO_INIT;
1131 }
Eric Laurent10b71232018-04-13 18:14:44 -07001132 AutoCallerClear acc;
Eric Laurentdf3dc7e2014-07-27 18:39:40 -07001133 return mAudioPolicyManager->releaseSoundTriggerSession(session);
1134}
1135
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -07001136status_t AudioPolicyService::registerPolicyMixes(const Vector<AudioMix>& mixes, bool registration)
Eric Laurentbaac1832014-12-01 17:52:59 -08001137{
1138 Mutex::Autolock _l(mLock);
Kevin Rocardbe201852019-02-20 22:33:28 -08001139
1140 // loopback|render only need a MediaProjection (checked in caller AudioService.java)
1141 bool needModifyAudioRouting = std::any_of(mixes.begin(), mixes.end(), [](auto& mix) {
1142 return !is_mix_loopback_render(mix.mRouteFlags); });
1143 if (needModifyAudioRouting && !modifyAudioRoutingAllowed()) {
Eric Laurentbaac1832014-12-01 17:52:59 -08001144 return PERMISSION_DENIED;
1145 }
Kevin Rocardbe201852019-02-20 22:33:28 -08001146
Kevin Rocard36b17552019-03-07 18:48:07 -08001147 bool needCaptureMediaOutput = std::any_of(mixes.begin(), mixes.end(), [](auto& mix) {
1148 return mix.mAllowPrivilegedPlaybackCapture; });
1149 const uid_t callingUid = IPCThreadState::self()->getCallingUid();
1150 const pid_t callingPid = IPCThreadState::self()->getCallingPid();
1151 if (needCaptureMediaOutput && !captureMediaOutputAllowed(callingPid, callingUid)) {
1152 return PERMISSION_DENIED;
1153 }
1154
Eric Laurentbaac1832014-12-01 17:52:59 -08001155 if (mAudioPolicyManager == NULL) {
1156 return NO_INIT;
1157 }
Eric Laurent10b71232018-04-13 18:14:44 -07001158 AutoCallerClear acc;
Eric Laurentbaac1832014-12-01 17:52:59 -08001159 if (registration) {
1160 return mAudioPolicyManager->registerPolicyMixes(mixes);
1161 } else {
1162 return mAudioPolicyManager->unregisterPolicyMixes(mixes);
1163 }
1164}
1165
Jean-Michel Trivibda70da2018-12-19 07:30:15 -08001166status_t AudioPolicyService::setUidDeviceAffinities(uid_t uid,
1167 const Vector<AudioDeviceTypeAddr>& devices) {
1168 Mutex::Autolock _l(mLock);
1169 if(!modifyAudioRoutingAllowed()) {
1170 return PERMISSION_DENIED;
1171 }
1172 if (mAudioPolicyManager == NULL) {
1173 return NO_INIT;
1174 }
1175 AutoCallerClear acc;
1176 return mAudioPolicyManager->setUidDeviceAffinities(uid, devices);
1177}
1178
1179status_t AudioPolicyService::removeUidDeviceAffinities(uid_t uid) {
1180 Mutex::Autolock _l(mLock);
1181 if(!modifyAudioRoutingAllowed()) {
1182 return PERMISSION_DENIED;
1183 }
1184 if (mAudioPolicyManager == NULL) {
1185 return NO_INIT;
1186 }
1187 AutoCallerClear acc;
1188 return mAudioPolicyManager->removeUidDeviceAffinities(uid);
1189}
1190
Eric Laurent554a2772015-04-10 11:29:24 -07001191status_t AudioPolicyService::startAudioSource(const struct audio_port_config *source,
Eric Laurent3e6c7e12018-07-27 17:09:23 -07001192 const audio_attributes_t *attributes,
1193 audio_port_handle_t *portId)
Eric Laurent554a2772015-04-10 11:29:24 -07001194{
1195 Mutex::Autolock _l(mLock);
1196 if (mAudioPolicyManager == NULL) {
1197 return NO_INIT;
1198 }
Hongwei Wang5cd1f1d2019-03-26 15:21:11 -07001199 // startAudioSource should be created as the calling uid
1200 const uid_t callingUid = IPCThreadState::self()->getCallingUid();
Eric Laurent10b71232018-04-13 18:14:44 -07001201 AutoCallerClear acc;
Hongwei Wang5cd1f1d2019-03-26 15:21:11 -07001202 return mAudioPolicyManager->startAudioSource(source, attributes, portId, callingUid);
Eric Laurent554a2772015-04-10 11:29:24 -07001203}
1204
Eric Laurent3e6c7e12018-07-27 17:09:23 -07001205status_t AudioPolicyService::stopAudioSource(audio_port_handle_t portId)
Eric Laurent554a2772015-04-10 11:29:24 -07001206{
1207 Mutex::Autolock _l(mLock);
1208 if (mAudioPolicyManager == NULL) {
1209 return NO_INIT;
1210 }
Eric Laurent10b71232018-04-13 18:14:44 -07001211 AutoCallerClear acc;
Eric Laurent3e6c7e12018-07-27 17:09:23 -07001212 return mAudioPolicyManager->stopAudioSource(portId);
Eric Laurent554a2772015-04-10 11:29:24 -07001213}
1214
Andy Hung2ddee192015-12-18 17:34:44 -08001215status_t AudioPolicyService::setMasterMono(bool mono)
1216{
1217 if (mAudioPolicyManager == NULL) {
1218 return NO_INIT;
1219 }
1220 if (!settingsAllowed()) {
1221 return PERMISSION_DENIED;
1222 }
1223 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -07001224 AutoCallerClear acc;
Andy Hung2ddee192015-12-18 17:34:44 -08001225 return mAudioPolicyManager->setMasterMono(mono);
1226}
1227
1228status_t AudioPolicyService::getMasterMono(bool *mono)
1229{
1230 if (mAudioPolicyManager == NULL) {
1231 return NO_INIT;
1232 }
1233 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -07001234 AutoCallerClear acc;
Andy Hung2ddee192015-12-18 17:34:44 -08001235 return mAudioPolicyManager->getMasterMono(mono);
1236}
1237
Eric Laurentac9cef52017-06-09 15:46:26 -07001238
1239float AudioPolicyService::getStreamVolumeDB(
1240 audio_stream_type_t stream, int index, audio_devices_t device)
1241{
1242 if (mAudioPolicyManager == NULL) {
1243 return NAN;
1244 }
1245 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -07001246 AutoCallerClear acc;
Eric Laurentac9cef52017-06-09 15:46:26 -07001247 return mAudioPolicyManager->getStreamVolumeDB(stream, index, device);
1248}
1249
jiabin81772902018-04-02 17:52:27 -07001250status_t AudioPolicyService::getSurroundFormats(unsigned int *numSurroundFormats,
1251 audio_format_t *surroundFormats,
1252 bool *surroundFormatsEnabled,
1253 bool reported)
1254{
1255 if (mAudioPolicyManager == NULL) {
1256 return NO_INIT;
1257 }
1258 Mutex::Autolock _l(mLock);
1259 AutoCallerClear acc;
1260 return mAudioPolicyManager->getSurroundFormats(numSurroundFormats, surroundFormats,
1261 surroundFormatsEnabled, reported);
1262}
1263
Arun Mirpuri11029ad2018-12-19 20:45:19 -08001264status_t AudioPolicyService::getHwOffloadEncodingFormatsSupportedForA2DP(
1265 std::vector<audio_format_t> *formats)
1266{
1267 if (mAudioPolicyManager == NULL) {
1268 return NO_INIT;
1269 }
1270 Mutex::Autolock _l(mLock);
1271 AutoCallerClear acc;
1272 return mAudioPolicyManager->getHwOffloadEncodingFormatsSupportedForA2DP(formats);
1273}
1274
jiabin81772902018-04-02 17:52:27 -07001275status_t AudioPolicyService::setSurroundFormatEnabled(audio_format_t audioFormat, bool enabled)
1276{
1277 if (mAudioPolicyManager == NULL) {
1278 return NO_INIT;
1279 }
1280 Mutex::Autolock _l(mLock);
1281 AutoCallerClear acc;
1282 return mAudioPolicyManager->setSurroundFormatEnabled(audioFormat, enabled);
1283}
Eric Laurentac9cef52017-06-09 15:46:26 -07001284
Eric Laurentb78763e2018-10-17 10:08:02 -07001285status_t AudioPolicyService::setAssistantUid(uid_t uid)
1286{
1287 Mutex::Autolock _l(mLock);
1288 mUidPolicy->setAssistantUid(uid);
1289 return NO_ERROR;
1290}
1291
1292status_t AudioPolicyService::setA11yServicesUids(const std::vector<uid_t>& uids)
1293{
1294 Mutex::Autolock _l(mLock);
1295 mUidPolicy->setA11yUids(uids);
1296 return NO_ERROR;
1297}
1298
jiabin6012f912018-11-02 17:06:30 -07001299bool AudioPolicyService::isHapticPlaybackSupported()
1300{
1301 if (mAudioPolicyManager == NULL) {
1302 ALOGW("%s, mAudioPolicyManager == NULL", __func__);
1303 return false;
1304 }
1305 Mutex::Autolock _l(mLock);
1306 AutoCallerClear acc;
1307 return mAudioPolicyManager->isHapticPlaybackSupported();
1308}
1309
François Gaffied0ba9ed2018-11-05 11:50:42 +01001310status_t AudioPolicyService::listAudioProductStrategies(AudioProductStrategyVector &strategies)
1311{
1312 if (mAudioPolicyManager == NULL) {
1313 return NO_INIT;
1314 }
1315 Mutex::Autolock _l(mLock);
1316 return mAudioPolicyManager->listAudioProductStrategies(strategies);
1317}
1318
François Gaffie4b2018b2018-11-07 11:18:59 +01001319status_t AudioPolicyService::getProductStrategyFromAudioAttributes(
1320 const AudioAttributes &aa, product_strategy_t &productStrategy)
François Gaffied0ba9ed2018-11-05 11:50:42 +01001321{
1322 if (mAudioPolicyManager == NULL) {
François Gaffie4b2018b2018-11-07 11:18:59 +01001323 return NO_INIT;
François Gaffied0ba9ed2018-11-05 11:50:42 +01001324 }
1325 Mutex::Autolock _l(mLock);
François Gaffie4b2018b2018-11-07 11:18:59 +01001326 return mAudioPolicyManager->getProductStrategyFromAudioAttributes(aa, productStrategy);
1327}
1328
1329status_t AudioPolicyService::listAudioVolumeGroups(AudioVolumeGroupVector &groups)
1330{
1331 if (mAudioPolicyManager == NULL) {
1332 return NO_INIT;
1333 }
1334 Mutex::Autolock _l(mLock);
1335 return mAudioPolicyManager->listAudioVolumeGroups(groups);
1336}
1337
1338status_t AudioPolicyService::getVolumeGroupFromAudioAttributes(const AudioAttributes &aa,
1339 volume_group_t &volumeGroup)
1340{
1341 if (mAudioPolicyManager == NULL) {
1342 return NO_INIT;
1343 }
1344 Mutex::Autolock _l(mLock);
1345 return mAudioPolicyManager->getVolumeGroupFromAudioAttributes(aa, volumeGroup);
François Gaffied0ba9ed2018-11-05 11:50:42 +01001346}
Eric Laurent6ede98f2019-06-11 14:50:30 -07001347
1348status_t AudioPolicyService::setRttEnabled(bool enabled)
1349{
1350 Mutex::Autolock _l(mLock);
1351 mUidPolicy->setRttEnabled(enabled);
1352 return NO_ERROR;
1353}
1354
Eric Laurent8340e672019-11-06 11:01:08 -08001355bool AudioPolicyService::isCallScreenModeSupported()
1356{
1357 if (mAudioPolicyManager == NULL) {
1358 ALOGW("%s, mAudioPolicyManager == NULL", __func__);
1359 return false;
1360 }
1361 Mutex::Autolock _l(mLock);
1362 AutoCallerClear acc;
1363 return mAudioPolicyManager->isCallScreenModeSupported();
1364}
1365
Jean-Michel Trivi30857152019-11-01 11:04:15 -07001366status_t AudioPolicyService::setPreferredDeviceForStrategy(product_strategy_t strategy,
1367 const AudioDeviceTypeAddr &device)
1368{
1369 if (mAudioPolicyManager == NULL) {
1370 return NO_INIT;
1371 }
1372 Mutex::Autolock _l(mLock);
1373 return mAudioPolicyManager->setPreferredDeviceForStrategy(strategy, device);
1374}
1375
1376status_t AudioPolicyService::removePreferredDeviceForStrategy(product_strategy_t strategy)
1377{
1378 if (mAudioPolicyManager == NULL) {
1379 return NO_INIT;
1380 }
1381 Mutex::Autolock _l(mLock);
1382 return mAudioPolicyManager->removePreferredDeviceForStrategy(strategy);
1383}
1384
1385status_t AudioPolicyService::getPreferredDeviceForStrategy(product_strategy_t strategy,
1386 AudioDeviceTypeAddr &device)
1387{
1388 if (mAudioPolicyManager == NULL) {
1389 return NO_INIT;
1390 }
1391 Mutex::Autolock _l(mLock);
1392 return mAudioPolicyManager->getPreferredDeviceForStrategy(strategy, device);
1393}
1394
Mikhail Naganov1b2a7942017-12-08 10:18:09 -08001395} // namespace android