blob: a1b6b0fb06d03fd38abf74a3c29aee1db992e84c [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>
23#include <mediautils/ServiceUtilities.h>
Kevin Rocardbe201852019-02-20 22:33:28 -080024#include <media/AudioPolicy.h>
Eric Laurentd7fe0862018-07-14 16:48:01 -070025#include <utils/Log.h>
Eric Laurent2d388ec2014-03-07 13:25:54 -080026
Eric Laurent2d388ec2014-03-07 13:25:54 -080027namespace android {
28
29
30// ----------------------------------------------------------------------------
31
32status_t AudioPolicyService::setDeviceConnectionState(audio_devices_t device,
33 audio_policy_dev_state_t state,
Paul McLeane743a472015-01-28 11:07:31 -080034 const char *device_address,
Aniket Kumar Lata4e464702019-01-10 23:38:46 -080035 const char *device_name,
36 audio_format_t encodedFormat)
Eric Laurent2d388ec2014-03-07 13:25:54 -080037{
Eric Laurentdce54a12014-03-10 12:19:46 -070038 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -080039 return NO_INIT;
40 }
41 if (!settingsAllowed()) {
42 return PERMISSION_DENIED;
43 }
Eric Laurent2d388ec2014-03-07 13:25:54 -080044 if (state != AUDIO_POLICY_DEVICE_STATE_AVAILABLE &&
45 state != AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE) {
46 return BAD_VALUE;
47 }
48
49 ALOGV("setDeviceConnectionState()");
50 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -070051 AutoCallerClear acc;
Paul McLeane743a472015-01-28 11:07:31 -080052 return mAudioPolicyManager->setDeviceConnectionState(device, state,
Aniket Kumar Lata4e464702019-01-10 23:38:46 -080053 device_address, device_name, encodedFormat);
Eric Laurent2d388ec2014-03-07 13:25:54 -080054}
55
56audio_policy_dev_state_t AudioPolicyService::getDeviceConnectionState(
57 audio_devices_t device,
58 const char *device_address)
59{
Eric Laurentdce54a12014-03-10 12:19:46 -070060 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -080061 return AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE;
62 }
Eric Laurent10b71232018-04-13 18:14:44 -070063 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -070064 return mAudioPolicyManager->getDeviceConnectionState(device,
Eric Laurent2d388ec2014-03-07 13:25:54 -080065 device_address);
66}
67
Pavlin Radoslavovf862bc62016-12-26 18:57:22 -080068status_t AudioPolicyService::handleDeviceConfigChange(audio_devices_t device,
69 const char *device_address,
Aniket Kumar Lata4e464702019-01-10 23:38:46 -080070 const char *device_name,
71 audio_format_t encodedFormat)
Pavlin Radoslavovf862bc62016-12-26 18:57:22 -080072{
73 if (mAudioPolicyManager == NULL) {
74 return NO_INIT;
75 }
76 if (!settingsAllowed()) {
77 return PERMISSION_DENIED;
78 }
Pavlin Radoslavovf862bc62016-12-26 18:57:22 -080079
80 ALOGV("handleDeviceConfigChange()");
81 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -070082 AutoCallerClear acc;
Pavlin Radoslavovf862bc62016-12-26 18:57:22 -080083 return mAudioPolicyManager->handleDeviceConfigChange(device, device_address,
Aniket Kumar Lata4e464702019-01-10 23:38:46 -080084 device_name, encodedFormat);
Pavlin Radoslavovf862bc62016-12-26 18:57:22 -080085}
86
Eric Laurent2d388ec2014-03-07 13:25:54 -080087status_t AudioPolicyService::setPhoneState(audio_mode_t state)
88{
Eric Laurentdce54a12014-03-10 12:19:46 -070089 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -080090 return NO_INIT;
91 }
92 if (!settingsAllowed()) {
93 return PERMISSION_DENIED;
94 }
95 if (uint32_t(state) >= AUDIO_MODE_CNT) {
96 return BAD_VALUE;
97 }
98
99 ALOGV("setPhoneState()");
100
Eric Laurentbeb07fe2015-09-16 15:49:30 -0700101 // acquire lock before calling setMode() so that setMode() + setPhoneState() are an atomic
102 // operation from policy manager standpoint (no other operation (e.g track start or stop)
103 // can be interleaved).
104 Mutex::Autolock _l(mLock);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800105 // TODO: check if it is more appropriate to do it in platform specific policy manager
106 AudioSystem::setMode(state);
107
Eric Laurent10b71232018-04-13 18:14:44 -0700108 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700109 mAudioPolicyManager->setPhoneState(state);
Eric Laurentbb6c9a02014-09-25 14:11:47 -0700110 mPhoneState = state;
Eric Laurent2d388ec2014-03-07 13:25:54 -0800111 return NO_ERROR;
112}
113
Eric Laurentbb6c9a02014-09-25 14:11:47 -0700114audio_mode_t AudioPolicyService::getPhoneState()
115{
116 Mutex::Autolock _l(mLock);
117 return mPhoneState;
118}
119
Eric Laurent2d388ec2014-03-07 13:25:54 -0800120status_t AudioPolicyService::setForceUse(audio_policy_force_use_t usage,
121 audio_policy_forced_cfg_t config)
122{
Eric Laurentdce54a12014-03-10 12:19:46 -0700123 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800124 return NO_INIT;
125 }
Eric Laurente17378d2018-05-09 14:43:01 -0700126
127 if (!modifyAudioRoutingAllowed()) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800128 return PERMISSION_DENIED;
129 }
Eric Laurente17378d2018-05-09 14:43:01 -0700130
Eric Laurent2d388ec2014-03-07 13:25:54 -0800131 if (usage < 0 || usage >= AUDIO_POLICY_FORCE_USE_CNT) {
132 return BAD_VALUE;
133 }
134 if (config < 0 || config >= AUDIO_POLICY_FORCE_CFG_CNT) {
135 return BAD_VALUE;
136 }
137 ALOGV("setForceUse()");
138 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700139 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700140 mAudioPolicyManager->setForceUse(usage, config);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800141 return NO_ERROR;
142}
143
144audio_policy_forced_cfg_t AudioPolicyService::getForceUse(audio_policy_force_use_t usage)
145{
Eric Laurentdce54a12014-03-10 12:19:46 -0700146 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800147 return AUDIO_POLICY_FORCE_NONE;
148 }
149 if (usage < 0 || usage >= AUDIO_POLICY_FORCE_USE_CNT) {
150 return AUDIO_POLICY_FORCE_NONE;
151 }
Eric Laurent10b71232018-04-13 18:14:44 -0700152 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700153 return mAudioPolicyManager->getForceUse(usage);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800154}
155
Eric Laurentf4e63452017-11-06 19:31:46 +0000156audio_io_handle_t AudioPolicyService::getOutput(audio_stream_type_t stream)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800157{
Eric Laurent223fd5c2014-11-11 13:43:36 -0800158 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
Eric Laurentb1322c72014-10-30 14:59:13 -0700159 return AUDIO_IO_HANDLE_NONE;
Eric Laurentdea15412014-10-28 15:46:45 -0700160 }
Eric Laurentdce54a12014-03-10 12:19:46 -0700161 if (mAudioPolicyManager == NULL) {
Eric Laurentb1322c72014-10-30 14:59:13 -0700162 return AUDIO_IO_HANDLE_NONE;
Eric Laurent2d388ec2014-03-07 13:25:54 -0800163 }
164 ALOGV("getOutput()");
165 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700166 AutoCallerClear acc;
Eric Laurentf4e63452017-11-06 19:31:46 +0000167 return mAudioPolicyManager->getOutput(stream);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800168}
169
Eric Laurente83b55d2014-11-14 10:06:21 -0800170status_t AudioPolicyService::getOutputForAttr(const audio_attributes_t *attr,
171 audio_io_handle_t *output,
172 audio_session_t session,
173 audio_stream_type_t *stream,
Nadav Bar766fb022018-01-07 12:18:03 +0200174 pid_t pid,
Eric Laurent8c7e6da2015-04-21 17:37:00 -0700175 uid_t uid,
Eric Laurent20b9ef02016-12-05 11:03:16 -0800176 const audio_config_t *config,
Eric Laurente83b55d2014-11-14 10:06:21 -0800177 audio_output_flags_t flags,
Eric Laurent9ae8c592017-06-22 17:17:09 -0700178 audio_port_handle_t *selectedDeviceId,
Kevin Rocard153f92d2018-12-18 18:33:28 -0800179 audio_port_handle_t *portId,
180 std::vector<audio_io_handle_t> *secondaryOutputs)
Jean-Michel Trivi5bd3f382014-06-13 16:06:54 -0700181{
182 if (mAudioPolicyManager == NULL) {
Eric Laurente83b55d2014-11-14 10:06:21 -0800183 return NO_INIT;
Jean-Michel Trivi5bd3f382014-06-13 16:06:54 -0700184 }
Eric Laurentf4e63452017-11-06 19:31:46 +0000185 ALOGV("getOutputForAttr()");
Jean-Michel Trivi5bd3f382014-06-13 16:06:54 -0700186 Mutex::Autolock _l(mLock);
Eric Laurent8c7e6da2015-04-21 17:37:00 -0700187
Marco Nelissendcb346b2015-09-09 10:47:29 -0700188 const uid_t callingUid = IPCThreadState::self()->getCallingUid();
Andy Hung4ef19fa2018-05-15 19:35:29 -0700189 if (!isAudioServerOrMediaServerUid(callingUid) || uid == (uid_t)-1) {
Marco Nelissendcb346b2015-09-09 10:47:29 -0700190 ALOGW_IF(uid != (uid_t)-1 && uid != callingUid,
191 "%s uid %d tried to pass itself off as %d", __FUNCTION__, callingUid, uid);
192 uid = callingUid;
Eric Laurent8c7e6da2015-04-21 17:37:00 -0700193 }
Nadav Bar766fb022018-01-07 12:18:03 +0200194 audio_output_flags_t originalFlags = flags;
Eric Laurent10b71232018-04-13 18:14:44 -0700195 AutoCallerClear acc;
Nadav Bar766fb022018-01-07 12:18:03 +0200196 status_t result = mAudioPolicyManager->getOutputForAttr(attr, output, session, stream, uid,
Eric Laurent20b9ef02016-12-05 11:03:16 -0800197 config,
Kevin Rocard153f92d2018-12-18 18:33:28 -0800198 &flags, selectedDeviceId, portId,
199 secondaryOutputs);
Nadav Bar766fb022018-01-07 12:18:03 +0200200
201 // FIXME: Introduce a way to check for the the telephony device before opening the output
202 if ((result == NO_ERROR) &&
203 (flags & AUDIO_OUTPUT_FLAG_INCALL_MUSIC) &&
204 !modifyPhoneStateAllowed(pid, uid)) {
205 // If the app tries to play music through the telephony device and doesn't have permission
206 // the fallback to the default output device.
Eric Laurent8fc147b2018-07-22 19:13:55 -0700207 mAudioPolicyManager->releaseOutput(*portId);
Nadav Bar766fb022018-01-07 12:18:03 +0200208 flags = originalFlags;
209 *selectedDeviceId = AUDIO_PORT_HANDLE_NONE;
210 *portId = AUDIO_PORT_HANDLE_NONE;
Kevin Rocard153f92d2018-12-18 18:33:28 -0800211 secondaryOutputs->clear();
212 result = mAudioPolicyManager->getOutputForAttr(attr, output, session, stream, uid, config,
213 &flags, selectedDeviceId, portId,
214 secondaryOutputs);
Nadav Bar766fb022018-01-07 12:18:03 +0200215 }
Eric Laurentd7fe0862018-07-14 16:48:01 -0700216
217 if (result == NO_ERROR) {
218 sp <AudioPlaybackClient> client =
219 new AudioPlaybackClient(*attr, *output, uid, pid, session, *selectedDeviceId, *stream);
220 mAudioPlaybackClients.add(*portId, client);
221 }
Nadav Bar766fb022018-01-07 12:18:03 +0200222 return result;
Jean-Michel Trivi5bd3f382014-06-13 16:06:54 -0700223}
224
Eric Laurentd7fe0862018-07-14 16:48:01 -0700225status_t AudioPolicyService::startOutput(audio_port_handle_t portId)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800226{
Eric Laurentdce54a12014-03-10 12:19:46 -0700227 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800228 return NO_INIT;
229 }
230 ALOGV("startOutput()");
Eric Laurentd7fe0862018-07-14 16:48:01 -0700231 sp<AudioPlaybackClient> client;
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700232 sp<AudioPolicyEffects>audioPolicyEffects;
233 {
234 Mutex::Autolock _l(mLock);
Eric Laurentd7fe0862018-07-14 16:48:01 -0700235 const ssize_t index = mAudioPlaybackClients.indexOfKey(portId);
236 if (index < 0) {
237 ALOGE("%s AudioTrack client not found for portId %d", __FUNCTION__, portId);
238 return INVALID_OPERATION;
239 }
240 client = mAudioPlaybackClients.valueAt(index);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700241 audioPolicyEffects = mAudioPolicyEffects;
bryant_liuba2b4392014-06-11 16:49:30 +0800242 }
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700243 if (audioPolicyEffects != 0) {
244 // create audio processors according to stream
Eric Laurentd7fe0862018-07-14 16:48:01 -0700245 status_t status = audioPolicyEffects->addOutputSessionEffects(
246 client->io, client->stream, client->session);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700247 if (status != NO_ERROR && status != ALREADY_EXISTS) {
Eric Laurentd7fe0862018-07-14 16:48:01 -0700248 ALOGW("Failed to add effects on session %d", client->session);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700249 }
250 }
251 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700252 AutoCallerClear acc;
Eric Laurent8fc147b2018-07-22 19:13:55 -0700253 status_t status = mAudioPolicyManager->startOutput(portId);
Eric Laurentd7fe0862018-07-14 16:48:01 -0700254 if (status == NO_ERROR) {
255 client->active = true;
256 }
257 return status;
Eric Laurent2d388ec2014-03-07 13:25:54 -0800258}
259
Eric Laurentd7fe0862018-07-14 16:48:01 -0700260status_t AudioPolicyService::stopOutput(audio_port_handle_t portId)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800261{
Eric Laurentdce54a12014-03-10 12:19:46 -0700262 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800263 return NO_INIT;
264 }
265 ALOGV("stopOutput()");
Eric Laurentd7fe0862018-07-14 16:48:01 -0700266 mOutputCommandThread->stopOutputCommand(portId);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800267 return NO_ERROR;
268}
269
Eric Laurentd7fe0862018-07-14 16:48:01 -0700270status_t AudioPolicyService::doStopOutput(audio_port_handle_t portId)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800271{
Eric Laurentd7fe0862018-07-14 16:48:01 -0700272 ALOGV("doStopOutput");
273 sp<AudioPlaybackClient> client;
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700274 sp<AudioPolicyEffects>audioPolicyEffects;
275 {
276 Mutex::Autolock _l(mLock);
Eric Laurentd7fe0862018-07-14 16:48:01 -0700277
278 const ssize_t index = mAudioPlaybackClients.indexOfKey(portId);
279 if (index < 0) {
280 ALOGE("%s AudioTrack client not found for portId %d", __FUNCTION__, portId);
281 return INVALID_OPERATION;
282 }
283 client = mAudioPlaybackClients.valueAt(index);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700284 audioPolicyEffects = mAudioPolicyEffects;
bryant_liuba2b4392014-06-11 16:49:30 +0800285 }
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700286 if (audioPolicyEffects != 0) {
287 // release audio processors from the stream
Eric Laurentd7fe0862018-07-14 16:48:01 -0700288 status_t status = audioPolicyEffects->releaseOutputSessionEffects(
289 client->io, client->stream, client->session);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700290 if (status != NO_ERROR && status != ALREADY_EXISTS) {
Eric Laurentd7fe0862018-07-14 16:48:01 -0700291 ALOGW("Failed to release effects on session %d", client->session);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700292 }
293 }
294 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700295 AutoCallerClear acc;
Eric Laurent8fc147b2018-07-22 19:13:55 -0700296 status_t status = mAudioPolicyManager->stopOutput(portId);
Eric Laurentd7fe0862018-07-14 16:48:01 -0700297 if (status == NO_ERROR) {
298 client->active = false;
299 }
300 return status;
Eric Laurent2d388ec2014-03-07 13:25:54 -0800301}
302
Eric Laurentd7fe0862018-07-14 16:48:01 -0700303void AudioPolicyService::releaseOutput(audio_port_handle_t portId)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800304{
Eric Laurentdce54a12014-03-10 12:19:46 -0700305 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800306 return;
307 }
308 ALOGV("releaseOutput()");
Eric Laurentd7fe0862018-07-14 16:48:01 -0700309 mOutputCommandThread->releaseOutputCommand(portId);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800310}
311
Eric Laurentd7fe0862018-07-14 16:48:01 -0700312void AudioPolicyService::doReleaseOutput(audio_port_handle_t portId)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800313{
314 ALOGV("doReleaseOutput from tid %d", gettid());
315 Mutex::Autolock _l(mLock);
Eric Laurentd7fe0862018-07-14 16:48:01 -0700316 const ssize_t index = mAudioPlaybackClients.indexOfKey(portId);
317 if (index < 0) {
318 ALOGE("%s AudioTrack client not found for portId %d", __FUNCTION__, portId);
319 return;
320 }
321 sp<AudioPlaybackClient> client = mAudioPlaybackClients.valueAt(index);
322 mAudioRecordClients.removeItem(portId);
323
Eric Laurent10b71232018-04-13 18:14:44 -0700324 // called from internal thread: no need to clear caller identity
Eric Laurent8fc147b2018-07-22 19:13:55 -0700325 mAudioPolicyManager->releaseOutput(portId);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800326}
327
Eric Laurentcaf7f482014-11-25 17:50:47 -0800328status_t AudioPolicyService::getInputForAttr(const audio_attributes_t *attr,
329 audio_io_handle_t *input,
330 audio_session_t session,
Eric Laurentb2379ba2016-05-23 17:42:12 -0700331 pid_t pid,
Eric Laurent8c7e6da2015-04-21 17:37:00 -0700332 uid_t uid,
Eric Laurentfee19762018-01-29 18:44:13 -0800333 const String16& opPackageName,
Eric Laurent20b9ef02016-12-05 11:03:16 -0800334 const audio_config_base_t *config,
Paul McLean466dc8e2015-04-17 13:15:36 -0600335 audio_input_flags_t flags,
Eric Laurent9ae8c592017-06-22 17:17:09 -0700336 audio_port_handle_t *selectedDeviceId,
Eric Laurent20b9ef02016-12-05 11:03:16 -0800337 audio_port_handle_t *portId)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800338{
Eric Laurentdce54a12014-03-10 12:19:46 -0700339 if (mAudioPolicyManager == NULL) {
Eric Laurentcaf7f482014-11-25 17:50:47 -0800340 return NO_INIT;
Eric Laurent2d388ec2014-03-07 13:25:54 -0800341 }
Eric Laurent7dca8a82018-01-29 18:44:26 -0800342
Eric Laurent2d388ec2014-03-07 13:25:54 -0800343 // already checked by client, but double-check in case the client wrapper is bypassed
Eric Laurentae4b6ec2019-01-15 18:34:38 -0800344 if ((attr->source < AUDIO_SOURCE_DEFAULT)
345 || (attr->source >= AUDIO_SOURCE_CNT
346 && attr->source != AUDIO_SOURCE_HOTWORD
347 && attr->source != AUDIO_SOURCE_FM_TUNER
348 && attr->source != AUDIO_SOURCE_ECHO_REFERENCE)) {
Eric Laurentcaf7f482014-11-25 17:50:47 -0800349 return BAD_VALUE;
Eric Laurent2d388ec2014-03-07 13:25:54 -0800350 }
351
Eric Laurentb2379ba2016-05-23 17:42:12 -0700352 bool updatePid = (pid == -1);
Marco Nelissendcb346b2015-09-09 10:47:29 -0700353 const uid_t callingUid = IPCThreadState::self()->getCallingUid();
Andy Hung4ef19fa2018-05-15 19:35:29 -0700354 if (!isAudioServerOrMediaServerUid(callingUid)) {
Eric Laurent9f39f8d2016-05-25 12:34:48 -0700355 ALOGW_IF(uid != (uid_t)-1 && uid != callingUid,
Marco Nelissendcb346b2015-09-09 10:47:29 -0700356 "%s uid %d tried to pass itself off as %d", __FUNCTION__, callingUid, uid);
357 uid = callingUid;
Eric Laurentb2379ba2016-05-23 17:42:12 -0700358 updatePid = true;
359 }
360
361 if (updatePid) {
362 const pid_t callingPid = IPCThreadState::self()->getCallingPid();
Eric Laurent9f39f8d2016-05-25 12:34:48 -0700363 ALOGW_IF(pid != (pid_t)-1 && pid != callingPid,
Eric Laurentb2379ba2016-05-23 17:42:12 -0700364 "%s uid %d pid %d tried to pass itself off as pid %d",
365 __func__, callingUid, callingPid, pid);
366 pid = callingPid;
Eric Laurent8c7e6da2015-04-21 17:37:00 -0700367 }
368
Eric Laurent7dca8a82018-01-29 18:44:26 -0800369 // check calling permissions
370 if (!recordingAllowed(opPackageName, pid, uid)) {
371 ALOGE("%s permission denied: recording not allowed for uid %d pid %d",
372 __func__, uid, pid);
373 return PERMISSION_DENIED;
374 }
375
Nadav Bar744be482018-05-08 13:26:21 +0300376 if ((attr->source == AUDIO_SOURCE_VOICE_UPLINK ||
377 attr->source == AUDIO_SOURCE_VOICE_DOWNLINK ||
Eric Laurentae4b6ec2019-01-15 18:34:38 -0800378 attr->source == AUDIO_SOURCE_VOICE_CALL ||
379 attr->source == AUDIO_SOURCE_ECHO_REFERENCE) &&
Nadav Bar744be482018-05-08 13:26:21 +0300380 !captureAudioOutputAllowed(pid, uid)) {
381 return PERMISSION_DENIED;
382 }
383
Eric Laurent7504b9e2017-08-15 18:17:26 -0700384 if ((attr->source == AUDIO_SOURCE_HOTWORD) && !captureHotwordAllowed(pid, uid)) {
385 return BAD_VALUE;
386 }
387
388 sp<AudioPolicyEffects>audioPolicyEffects;
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700389 {
Eric Laurent7504b9e2017-08-15 18:17:26 -0700390 status_t status;
391 AudioPolicyInterface::input_type_t inputType;
392
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700393 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700394 {
395 AutoCallerClear acc;
396 // the audio_in_acoustics_t parameter is ignored by get_input()
397 status = mAudioPolicyManager->getInputForAttr(attr, input, session, uid,
398 config,
399 flags, selectedDeviceId,
400 &inputType, portId);
401 }
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700402 audioPolicyEffects = mAudioPolicyEffects;
Jean-Michel Trivi97bb33f2014-12-12 16:23:43 -0800403
404 if (status == NO_ERROR) {
405 // enforce permission (if any) required for each type of input
406 switch (inputType) {
407 case AudioPolicyInterface::API_INPUT_LEGACY:
408 break;
Eric Laurent82db2692015-08-07 13:59:42 -0700409 case AudioPolicyInterface::API_INPUT_TELEPHONY_RX:
410 // FIXME: use the same permission as for remote submix for now.
Jean-Michel Trivi97bb33f2014-12-12 16:23:43 -0800411 case AudioPolicyInterface::API_INPUT_MIX_CAPTURE:
Eric Laurentb2379ba2016-05-23 17:42:12 -0700412 if (!captureAudioOutputAllowed(pid, uid)) {
Jean-Michel Trivi97bb33f2014-12-12 16:23:43 -0800413 ALOGE("getInputForAttr() permission denied: capture not allowed");
414 status = PERMISSION_DENIED;
415 }
416 break;
417 case AudioPolicyInterface::API_INPUT_MIX_EXT_POLICY_REROUTE:
418 if (!modifyAudioRoutingAllowed()) {
419 ALOGE("getInputForAttr() permission denied: modify audio routing not allowed");
420 status = PERMISSION_DENIED;
421 }
422 break;
423 case AudioPolicyInterface::API_INPUT_INVALID:
424 default:
425 LOG_ALWAYS_FATAL("getInputForAttr() encountered an invalid input type %d",
426 (int)inputType);
427 }
428 }
429
430 if (status != NO_ERROR) {
431 if (status == PERMISSION_DENIED) {
Eric Laurent10b71232018-04-13 18:14:44 -0700432 AutoCallerClear acc;
Eric Laurent8fc147b2018-07-22 19:13:55 -0700433 mAudioPolicyManager->releaseInput(*portId);
Jean-Michel Trivi97bb33f2014-12-12 16:23:43 -0800434 }
435 return status;
436 }
Eric Laurentfee19762018-01-29 18:44:13 -0800437
Eric Laurentd7fe0862018-07-14 16:48:01 -0700438 sp<AudioRecordClient> client = new AudioRecordClient(*attr, *input, uid, pid, session,
439 *selectedDeviceId, opPackageName);
Eric Laurentfee19762018-01-29 18:44:13 -0800440 mAudioRecordClients.add(*portId, client);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700441 }
Jean-Michel Trivi97bb33f2014-12-12 16:23:43 -0800442
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700443 if (audioPolicyEffects != 0) {
444 // create audio pre processors according to input source
Eric Laurentcaf7f482014-11-25 17:50:47 -0800445 status_t status = audioPolicyEffects->addInputEffects(*input, attr->source, session);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700446 if (status != NO_ERROR && status != ALREADY_EXISTS) {
Eric Laurentcaf7f482014-11-25 17:50:47 -0800447 ALOGW("Failed to add effects on input %d", *input);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700448 }
Eric Laurent2d388ec2014-03-07 13:25:54 -0800449 }
Eric Laurentcaf7f482014-11-25 17:50:47 -0800450 return NO_ERROR;
Eric Laurent2d388ec2014-03-07 13:25:54 -0800451}
452
Eric Laurent99fcae42018-05-17 16:59:18 -0700453std::string AudioPolicyService::getDeviceTypeStrForPortId(audio_port_handle_t portId) {
Eric Laurent99fcae42018-05-17 16:59:18 -0700454 struct audio_port port = {};
455 port.id = portId;
456 status_t status = mAudioPolicyManager->getAudioPort(&port);
457 if (status == NO_ERROR && port.type == AUDIO_PORT_TYPE_DEVICE) {
Andy Hung9b181952019-02-25 14:53:36 -0800458 return toString(port.ext.device.type);
Eric Laurent99fcae42018-05-17 16:59:18 -0700459 }
Andy Hung9b181952019-02-25 14:53:36 -0800460 return {};
Eric Laurent99fcae42018-05-17 16:59:18 -0700461}
462
Eric Laurent4eb58f12018-12-07 16:41:02 -0800463status_t AudioPolicyService::startInput(audio_port_handle_t portId)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800464{
Eric Laurentdce54a12014-03-10 12:19:46 -0700465 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800466 return NO_INIT;
467 }
Eric Laurent7dca8a82018-01-29 18:44:26 -0800468 sp<AudioRecordClient> client;
469 {
470 Mutex::Autolock _l(mLock);
Svet Ganovf4ddfef2018-01-16 07:37:58 -0800471
Eric Laurent7dca8a82018-01-29 18:44:26 -0800472 ssize_t index = mAudioRecordClients.indexOfKey(portId);
473 if (index < 0) {
474 return INVALID_OPERATION;
475 }
476 client = mAudioRecordClients.valueAt(index);
Eric Laurentfee19762018-01-29 18:44:13 -0800477 }
Eric Laurent7dca8a82018-01-29 18:44:26 -0800478
479 // check calling permissions
Svet Ganov6e641372018-03-02 09:21:30 -0800480 if (!startRecording(client->opPackageName, client->pid, client->uid)) {
Eric Laurent7dca8a82018-01-29 18:44:26 -0800481 ALOGE("%s permission denied: recording not allowed for uid %d pid %d",
482 __func__, client->uid, client->pid);
483 return PERMISSION_DENIED;
484 }
Eric Laurentfee19762018-01-29 18:44:13 -0800485
Eric Laurentdf628922018-12-06 21:45:51 +0000486 Mutex::Autolock _l(mLock);
Eric Laurent4eb58f12018-12-07 16:41:02 -0800487
488 client->active = true;
489 client->startTimeNs = systemTime();
490 updateUidStates_l();
Eric Laurentfee19762018-01-29 18:44:13 -0800491
Eric Laurent10b71232018-04-13 18:14:44 -0700492 status_t status;
493 {
494 AutoCallerClear acc;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800495 status = mAudioPolicyManager->startInput(portId);
Ray Essick84e84a52018-05-03 18:45:07 -0700496
497 }
498
Ray Essickf6a57cd2018-05-22 16:20:54 -0700499 // including successes gets very verbose
500 if (status != NO_ERROR) {
Ray Essick84e84a52018-05-03 18:45:07 -0700501
502 static constexpr char kAudioPolicy[] = "audiopolicy";
503
Ray Essick84e84a52018-05-03 18:45:07 -0700504 static constexpr char kAudioPolicyStatus[] = "android.media.audiopolicy.status";
505 static constexpr char kAudioPolicyRqstSrc[] = "android.media.audiopolicy.rqst.src";
506 static constexpr char kAudioPolicyRqstPkg[] = "android.media.audiopolicy.rqst.pkg";
507 static constexpr char kAudioPolicyRqstSession[] = "android.media.audiopolicy.rqst.session";
Eric Laurent99fcae42018-05-17 16:59:18 -0700508 static constexpr char kAudioPolicyRqstDevice[] =
509 "android.media.audiopolicy.rqst.device";
Ray Essick84e84a52018-05-03 18:45:07 -0700510 static constexpr char kAudioPolicyActiveSrc[] = "android.media.audiopolicy.active.src";
511 static constexpr char kAudioPolicyActivePkg[] = "android.media.audiopolicy.active.pkg";
Eric Laurent99fcae42018-05-17 16:59:18 -0700512 static constexpr char kAudioPolicyActiveSession[] =
513 "android.media.audiopolicy.active.session";
514 static constexpr char kAudioPolicyActiveDevice[] =
515 "android.media.audiopolicy.active.device";
Ray Essick84e84a52018-05-03 18:45:07 -0700516
Ray Essick6a305222019-01-28 20:33:18 -0800517 MediaAnalyticsItem *item = MediaAnalyticsItem::create(kAudioPolicy);
Ray Essick84e84a52018-05-03 18:45:07 -0700518 if (item != NULL) {
519
Ray Essick84e84a52018-05-03 18:45:07 -0700520 item->setInt32(kAudioPolicyStatus, status);
521
Eric Laurent99fcae42018-05-17 16:59:18 -0700522 item->setCString(kAudioPolicyRqstSrc,
Andy Hung9b181952019-02-25 14:53:36 -0800523 toString(client->attributes.source).c_str());
Ray Essick84e84a52018-05-03 18:45:07 -0700524 item->setInt32(kAudioPolicyRqstSession, client->session);
Ray Essick51866952018-05-30 11:22:27 -0700525 if (client->opPackageName.size() != 0) {
526 item->setCString(kAudioPolicyRqstPkg,
527 std::string(String8(client->opPackageName).string()).c_str());
528 } else {
Kevin Rocardfbdfebe2018-06-18 12:30:40 -0700529 item->setCString(kAudioPolicyRqstPkg, std::to_string(client->uid).c_str());
Ray Essick51866952018-05-30 11:22:27 -0700530 }
Eric Laurent99fcae42018-05-17 16:59:18 -0700531 item->setCString(
532 kAudioPolicyRqstDevice, getDeviceTypeStrForPortId(client->deviceId).c_str());
533
Eric Laurent4eb58f12018-12-07 16:41:02 -0800534 int count = mAudioRecordClients.size();
535 for (int i = 0; i < count ; i++) {
536 if (portId == mAudioRecordClients.keyAt(i)) {
537 continue;
538 }
539 sp<AudioRecordClient> other = mAudioRecordClients.valueAt(i);
540 if (other->active) {
541 // keeps the last of the clients marked active
542 item->setCString(kAudioPolicyActiveSrc,
Andy Hung9b181952019-02-25 14:53:36 -0800543 toString(other->attributes.source).c_str());
Eric Laurent4eb58f12018-12-07 16:41:02 -0800544 item->setInt32(kAudioPolicyActiveSession, other->session);
545 if (other->opPackageName.size() != 0) {
546 item->setCString(kAudioPolicyActivePkg,
547 std::string(String8(other->opPackageName).string()).c_str());
548 } else {
549 item->setCString(kAudioPolicyRqstPkg,
550 std::to_string(other->uid).c_str());
Ray Essick84e84a52018-05-03 18:45:07 -0700551 }
Eric Laurent4eb58f12018-12-07 16:41:02 -0800552 item->setCString(kAudioPolicyActiveDevice,
553 getDeviceTypeStrForPortId(other->deviceId).c_str());
Ray Essick84e84a52018-05-03 18:45:07 -0700554 }
555 }
556 item->selfrecord();
557 delete item;
558 item = NULL;
559 }
Eric Laurent4eb58f12018-12-07 16:41:02 -0800560 client->active = false;
561 client->startTimeNs = 0;
562 updateUidStates_l();
Svet Ganov6e641372018-03-02 09:21:30 -0800563 finishRecording(client->opPackageName, client->uid);
Eric Laurentfb66dd92016-01-28 18:32:03 -0800564 }
565
566 return status;
Eric Laurent2d388ec2014-03-07 13:25:54 -0800567}
568
Eric Laurentfee19762018-01-29 18:44:13 -0800569status_t AudioPolicyService::stopInput(audio_port_handle_t portId)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800570{
Eric Laurentdce54a12014-03-10 12:19:46 -0700571 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800572 return NO_INIT;
573 }
Eric Laurent4eb58f12018-12-07 16:41:02 -0800574
Eric Laurent2d388ec2014-03-07 13:25:54 -0800575 Mutex::Autolock _l(mLock);
576
Eric Laurentfee19762018-01-29 18:44:13 -0800577 ssize_t index = mAudioRecordClients.indexOfKey(portId);
578 if (index < 0) {
579 return INVALID_OPERATION;
580 }
581 sp<AudioRecordClient> client = mAudioRecordClients.valueAt(index);
582
Ray Essick84e84a52018-05-03 18:45:07 -0700583 client->active = false;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800584 client->startTimeNs = 0;
585
586 updateUidStates_l();
Ray Essick84e84a52018-05-03 18:45:07 -0700587
Svet Ganov6e641372018-03-02 09:21:30 -0800588 // finish the recording app op
589 finishRecording(client->opPackageName, client->uid);
Eric Laurent10b71232018-04-13 18:14:44 -0700590 AutoCallerClear acc;
Eric Laurent8fc147b2018-07-22 19:13:55 -0700591 return mAudioPolicyManager->stopInput(portId);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800592}
593
Eric Laurentfee19762018-01-29 18:44:13 -0800594void AudioPolicyService::releaseInput(audio_port_handle_t portId)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800595{
Eric Laurentdce54a12014-03-10 12:19:46 -0700596 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800597 return;
598 }
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700599 sp<AudioPolicyEffects>audioPolicyEffects;
Eric Laurentfee19762018-01-29 18:44:13 -0800600 sp<AudioRecordClient> client;
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700601 {
602 Mutex::Autolock _l(mLock);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700603 audioPolicyEffects = mAudioPolicyEffects;
Eric Laurentfee19762018-01-29 18:44:13 -0800604 ssize_t index = mAudioRecordClients.indexOfKey(portId);
605 if (index < 0) {
606 return;
607 }
608 client = mAudioRecordClients.valueAt(index);
Eric Laurent4eb58f12018-12-07 16:41:02 -0800609
610 if (client->active) {
611 ALOGW("%s releasing active client portId %d", __FUNCTION__, portId);
612 client->active = false;
613 client->startTimeNs = 0;
614 updateUidStates_l();
615 }
616
Eric Laurentfee19762018-01-29 18:44:13 -0800617 mAudioRecordClients.removeItem(portId);
618 }
619 if (client == 0) {
620 return;
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700621 }
622 if (audioPolicyEffects != 0) {
623 // release audio processors from the input
Eric Laurentd7fe0862018-07-14 16:48:01 -0700624 status_t status = audioPolicyEffects->releaseInputEffects(client->io, client->session);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700625 if(status != NO_ERROR) {
Eric Laurentd7fe0862018-07-14 16:48:01 -0700626 ALOGW("Failed to release effects on input %d", client->io);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700627 }
Eric Laurent2d388ec2014-03-07 13:25:54 -0800628 }
Eric Laurentf10c7092016-12-06 17:09:56 -0800629 {
630 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700631 AutoCallerClear acc;
Eric Laurent8fc147b2018-07-22 19:13:55 -0700632 mAudioPolicyManager->releaseInput(portId);
Eric Laurentf10c7092016-12-06 17:09:56 -0800633 }
Eric Laurent2d388ec2014-03-07 13:25:54 -0800634}
635
636status_t AudioPolicyService::initStreamVolume(audio_stream_type_t stream,
637 int indexMin,
638 int indexMax)
639{
Eric Laurentdce54a12014-03-10 12:19:46 -0700640 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800641 return NO_INIT;
642 }
643 if (!settingsAllowed()) {
644 return PERMISSION_DENIED;
645 }
Eric Laurent223fd5c2014-11-11 13:43:36 -0800646 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800647 return BAD_VALUE;
648 }
649 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700650 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700651 mAudioPolicyManager->initStreamVolume(stream, indexMin, indexMax);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800652 return NO_ERROR;
653}
654
655status_t AudioPolicyService::setStreamVolumeIndex(audio_stream_type_t stream,
656 int index,
657 audio_devices_t device)
658{
Eric Laurentdce54a12014-03-10 12:19:46 -0700659 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800660 return NO_INIT;
661 }
662 if (!settingsAllowed()) {
663 return PERMISSION_DENIED;
664 }
Eric Laurent223fd5c2014-11-11 13:43:36 -0800665 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800666 return BAD_VALUE;
667 }
668 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700669 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700670 return mAudioPolicyManager->setStreamVolumeIndex(stream,
671 index,
672 device);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800673}
674
675status_t AudioPolicyService::getStreamVolumeIndex(audio_stream_type_t stream,
676 int *index,
677 audio_devices_t device)
678{
Eric Laurentdce54a12014-03-10 12:19:46 -0700679 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800680 return NO_INIT;
681 }
Eric Laurent223fd5c2014-11-11 13:43:36 -0800682 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800683 return BAD_VALUE;
684 }
685 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700686 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700687 return mAudioPolicyManager->getStreamVolumeIndex(stream,
688 index,
689 device);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800690}
691
François Gaffiecfe17322018-11-07 13:41:29 +0100692status_t AudioPolicyService::setVolumeIndexForAttributes(const audio_attributes_t &attributes,
693 int index, audio_devices_t device)
694{
695 if (mAudioPolicyManager == NULL) {
696 return NO_INIT;
697 }
698 if (!settingsAllowed()) {
699 return PERMISSION_DENIED;
700 }
701 Mutex::Autolock _l(mLock);
702 AutoCallerClear acc;
703 return mAudioPolicyManager->setVolumeIndexForAttributes(attributes, index, device);
704}
705
706status_t AudioPolicyService::getVolumeIndexForAttributes(const audio_attributes_t &attributes,
707 int &index, audio_devices_t device)
708{
709 if (mAudioPolicyManager == NULL) {
710 return NO_INIT;
711 }
712 Mutex::Autolock _l(mLock);
713 AutoCallerClear acc;
714 return mAudioPolicyManager->getVolumeIndexForAttributes(attributes, index, device);
715}
716
717status_t AudioPolicyService::getMinVolumeIndexForAttributes(const audio_attributes_t &attributes,
718 int &index)
719{
720 if (mAudioPolicyManager == NULL) {
721 return NO_INIT;
722 }
723 Mutex::Autolock _l(mLock);
724 AutoCallerClear acc;
725 return mAudioPolicyManager->getMinVolumeIndexForAttributes(attributes, index);
726}
727
728status_t AudioPolicyService::getMaxVolumeIndexForAttributes(const audio_attributes_t &attributes,
729 int &index)
730{
731 if (mAudioPolicyManager == NULL) {
732 return NO_INIT;
733 }
734 Mutex::Autolock _l(mLock);
735 AutoCallerClear acc;
736 return mAudioPolicyManager->getMaxVolumeIndexForAttributes(attributes, index);
737}
738
Eric Laurent2d388ec2014-03-07 13:25:54 -0800739uint32_t AudioPolicyService::getStrategyForStream(audio_stream_type_t stream)
740{
Eric Laurent223fd5c2014-11-11 13:43:36 -0800741 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
François Gaffiec005e562018-11-06 15:04:49 +0100742 return PRODUCT_STRATEGY_NONE;
Eric Laurentdea15412014-10-28 15:46:45 -0700743 }
Eric Laurentdce54a12014-03-10 12:19:46 -0700744 if (mAudioPolicyManager == NULL) {
François Gaffiec005e562018-11-06 15:04:49 +0100745 return PRODUCT_STRATEGY_NONE;
Eric Laurent2d388ec2014-03-07 13:25:54 -0800746 }
François Gaffiec005e562018-11-06 15:04:49 +0100747 // DO NOT LOCK, may be called from AudioFlinger with lock held, reaching deadlock
Eric Laurent10b71232018-04-13 18:14:44 -0700748 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700749 return mAudioPolicyManager->getStrategyForStream(stream);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800750}
751
752//audio policy: use audio_device_t appropriately
753
754audio_devices_t AudioPolicyService::getDevicesForStream(audio_stream_type_t stream)
755{
Eric Laurent223fd5c2014-11-11 13:43:36 -0800756 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
Eric Laurentb1322c72014-10-30 14:59:13 -0700757 return AUDIO_DEVICE_NONE;
Eric Laurentdea15412014-10-28 15:46:45 -0700758 }
Eric Laurentdce54a12014-03-10 12:19:46 -0700759 if (mAudioPolicyManager == NULL) {
Eric Laurentb1322c72014-10-30 14:59:13 -0700760 return AUDIO_DEVICE_NONE;
Eric Laurent2d388ec2014-03-07 13:25:54 -0800761 }
Haynes Mathew Georgedfb9f3b2015-10-26 18:22:13 -0700762 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700763 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700764 return mAudioPolicyManager->getDevicesForStream(stream);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800765}
766
767audio_io_handle_t AudioPolicyService::getOutputForEffect(const effect_descriptor_t *desc)
768{
769 // FIXME change return type to status_t, and return NO_INIT here
Eric Laurentdce54a12014-03-10 12:19:46 -0700770 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800771 return 0;
772 }
773 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700774 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700775 return mAudioPolicyManager->getOutputForEffect(desc);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800776}
777
778status_t AudioPolicyService::registerEffect(const effect_descriptor_t *desc,
779 audio_io_handle_t io,
780 uint32_t strategy,
Glenn Kastend848eb42016-03-08 13:42:11 -0800781 audio_session_t session,
Eric Laurent2d388ec2014-03-07 13:25:54 -0800782 int id)
783{
Eric Laurentdce54a12014-03-10 12:19:46 -0700784 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800785 return NO_INIT;
786 }
Haynes Mathew Georgebab7bf42015-10-30 18:02:23 -0700787 Mutex::Autolock _l(mEffectsLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700788 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700789 return mAudioPolicyManager->registerEffect(desc, io, strategy, session, id);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800790}
791
792status_t AudioPolicyService::unregisterEffect(int id)
793{
Eric Laurentdce54a12014-03-10 12:19:46 -0700794 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800795 return NO_INIT;
796 }
Haynes Mathew Georgebab7bf42015-10-30 18:02:23 -0700797 Mutex::Autolock _l(mEffectsLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700798 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700799 return mAudioPolicyManager->unregisterEffect(id);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800800}
801
802status_t AudioPolicyService::setEffectEnabled(int id, bool enabled)
803{
Eric Laurentdce54a12014-03-10 12:19:46 -0700804 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800805 return NO_INIT;
806 }
Haynes Mathew Georgebab7bf42015-10-30 18:02:23 -0700807 Mutex::Autolock _l(mEffectsLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700808 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700809 return mAudioPolicyManager->setEffectEnabled(id, enabled);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800810}
811
812bool AudioPolicyService::isStreamActive(audio_stream_type_t stream, uint32_t inPastMs) const
813{
Eric Laurent223fd5c2014-11-11 13:43:36 -0800814 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
Eric Laurentb1322c72014-10-30 14:59:13 -0700815 return false;
Eric Laurentdea15412014-10-28 15:46:45 -0700816 }
Eric Laurentdce54a12014-03-10 12:19:46 -0700817 if (mAudioPolicyManager == NULL) {
Eric Laurentb1322c72014-10-30 14:59:13 -0700818 return false;
Eric Laurent2d388ec2014-03-07 13:25:54 -0800819 }
820 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700821 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700822 return mAudioPolicyManager->isStreamActive(stream, inPastMs);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800823}
824
825bool AudioPolicyService::isStreamActiveRemotely(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->isStreamActiveRemotely(stream, inPastMs);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800836}
837
838bool AudioPolicyService::isSourceActive(audio_source_t source) const
839{
Eric Laurentdce54a12014-03-10 12:19:46 -0700840 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800841 return false;
842 }
843 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700844 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700845 return mAudioPolicyManager->isSourceActive(source);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800846}
847
Ari Hausman-Cohen24628312018-08-13 15:01:09 -0700848status_t AudioPolicyService::getAudioPolicyEffects(sp<AudioPolicyEffects>& audioPolicyEffects)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800849{
Eric Laurentdce54a12014-03-10 12:19:46 -0700850 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800851 return NO_INIT;
852 }
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700853 {
854 Mutex::Autolock _l(mLock);
855 audioPolicyEffects = mAudioPolicyEffects;
856 }
857 if (audioPolicyEffects == 0) {
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700858 return NO_INIT;
859 }
Ari Hausman-Cohen24628312018-08-13 15:01:09 -0700860
861 return OK;
862}
863
864status_t AudioPolicyService::queryDefaultPreProcessing(audio_session_t audioSession,
865 effect_descriptor_t *descriptors,
866 uint32_t *count)
867{
868 sp<AudioPolicyEffects>audioPolicyEffects;
869 status_t status = getAudioPolicyEffects(audioPolicyEffects);
870 if (status != OK) {
871 *count = 0;
872 return status;
873 }
Eric Laurentfb66dd92016-01-28 18:32:03 -0800874 return audioPolicyEffects->queryDefaultInputEffects(
875 (audio_session_t)audioSession, descriptors, count);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800876}
877
Ari Hausman-Cohen24628312018-08-13 15:01:09 -0700878status_t AudioPolicyService::addSourceDefaultEffect(const effect_uuid_t *type,
879 const String16& opPackageName,
880 const effect_uuid_t *uuid,
881 int32_t priority,
882 audio_source_t source,
883 audio_unique_id_t* id)
884{
885 sp<AudioPolicyEffects>audioPolicyEffects;
886 status_t status = getAudioPolicyEffects(audioPolicyEffects);
887 if (status != OK) {
888 return status;
889 }
890 if (!modifyDefaultAudioEffectsAllowed()) {
891 return PERMISSION_DENIED;
892 }
893 return audioPolicyEffects->addSourceDefaultEffect(
894 type, opPackageName, uuid, priority, source, id);
895}
896
Ari Hausman-Cohen433722e2018-04-24 14:25:22 -0700897status_t AudioPolicyService::addStreamDefaultEffect(const effect_uuid_t *type,
898 const String16& opPackageName,
899 const effect_uuid_t *uuid,
900 int32_t priority,
901 audio_usage_t usage,
902 audio_unique_id_t* id)
903{
Ari Hausman-Cohen24628312018-08-13 15:01:09 -0700904 sp<AudioPolicyEffects>audioPolicyEffects;
905 status_t status = getAudioPolicyEffects(audioPolicyEffects);
906 if (status != OK) {
907 return status;
Ari Hausman-Cohen433722e2018-04-24 14:25:22 -0700908 }
909 if (!modifyDefaultAudioEffectsAllowed()) {
910 return PERMISSION_DENIED;
911 }
Ari Hausman-Cohen433722e2018-04-24 14:25:22 -0700912 return audioPolicyEffects->addStreamDefaultEffect(
913 type, opPackageName, uuid, priority, usage, id);
914}
915
Ari Hausman-Cohen24628312018-08-13 15:01:09 -0700916status_t AudioPolicyService::removeSourceDefaultEffect(audio_unique_id_t id)
Ari Hausman-Cohen433722e2018-04-24 14:25:22 -0700917{
Ari Hausman-Cohen24628312018-08-13 15:01:09 -0700918 sp<AudioPolicyEffects>audioPolicyEffects;
919 status_t status = getAudioPolicyEffects(audioPolicyEffects);
920 if (status != OK) {
921 return status;
Ari Hausman-Cohen433722e2018-04-24 14:25:22 -0700922 }
923 if (!modifyDefaultAudioEffectsAllowed()) {
924 return PERMISSION_DENIED;
925 }
Ari Hausman-Cohen24628312018-08-13 15:01:09 -0700926 return audioPolicyEffects->removeSourceDefaultEffect(id);
927}
928
929status_t AudioPolicyService::removeStreamDefaultEffect(audio_unique_id_t id)
930{
Ari Hausman-Cohen433722e2018-04-24 14:25:22 -0700931 sp<AudioPolicyEffects>audioPolicyEffects;
Ari Hausman-Cohen24628312018-08-13 15:01:09 -0700932 status_t status = getAudioPolicyEffects(audioPolicyEffects);
933 if (status != OK) {
934 return status;
Ari Hausman-Cohen433722e2018-04-24 14:25:22 -0700935 }
Ari Hausman-Cohen24628312018-08-13 15:01:09 -0700936 if (!modifyDefaultAudioEffectsAllowed()) {
937 return PERMISSION_DENIED;
Ari Hausman-Cohen433722e2018-04-24 14:25:22 -0700938 }
939 return audioPolicyEffects->removeStreamDefaultEffect(id);
940}
941
Eric Laurent2d388ec2014-03-07 13:25:54 -0800942bool AudioPolicyService::isOffloadSupported(const audio_offload_info_t& info)
943{
Eric Laurentdce54a12014-03-10 12:19:46 -0700944 if (mAudioPolicyManager == NULL) {
945 ALOGV("mAudioPolicyManager == NULL");
Eric Laurent2d388ec2014-03-07 13:25:54 -0800946 return false;
947 }
Andy Hung2ddee192015-12-18 17:34:44 -0800948 Mutex::Autolock _l(mLock);
Haynes Mathew Georgebab7bf42015-10-30 18:02:23 -0700949 Mutex::Autolock _le(mEffectsLock); // isOffloadSupported queries for
950 // non-offloadable effects
Eric Laurent10b71232018-04-13 18:14:44 -0700951 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700952 return mAudioPolicyManager->isOffloadSupported(info);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800953}
954
Michael Chana94fbb22018-04-24 14:31:19 +1000955bool AudioPolicyService::isDirectOutputSupported(const audio_config_base_t& config,
956 const audio_attributes_t& attributes) {
957 if (mAudioPolicyManager == NULL) {
958 ALOGV("mAudioPolicyManager == NULL");
959 return false;
960 }
961 Mutex::Autolock _l(mLock);
962 return mAudioPolicyManager->isDirectOutputSupported(config, attributes);
963}
964
965
Eric Laurent6a94d692014-05-20 11:18:06 -0700966status_t AudioPolicyService::listAudioPorts(audio_port_role_t role,
967 audio_port_type_t type,
Eric Laurent203b1a12014-04-01 10:34:16 -0700968 unsigned int *num_ports,
Eric Laurent6a94d692014-05-20 11:18:06 -0700969 struct audio_port *ports,
970 unsigned int *generation)
Eric Laurent203b1a12014-04-01 10:34:16 -0700971{
Eric Laurent6a94d692014-05-20 11:18:06 -0700972 Mutex::Autolock _l(mLock);
973 if (mAudioPolicyManager == NULL) {
974 return NO_INIT;
975 }
Eric Laurent10b71232018-04-13 18:14:44 -0700976 AutoCallerClear acc;
Eric Laurent6a94d692014-05-20 11:18:06 -0700977 return mAudioPolicyManager->listAudioPorts(role, type, num_ports, ports, generation);
Eric Laurent203b1a12014-04-01 10:34:16 -0700978}
979
Eric Laurent6a94d692014-05-20 11:18:06 -0700980status_t AudioPolicyService::getAudioPort(struct audio_port *port)
Eric Laurent203b1a12014-04-01 10:34:16 -0700981{
Eric Laurent6a94d692014-05-20 11:18:06 -0700982 Mutex::Autolock _l(mLock);
983 if (mAudioPolicyManager == NULL) {
984 return NO_INIT;
985 }
Eric Laurent10b71232018-04-13 18:14:44 -0700986 AutoCallerClear acc;
Eric Laurent6a94d692014-05-20 11:18:06 -0700987 return mAudioPolicyManager->getAudioPort(port);
Eric Laurent203b1a12014-04-01 10:34:16 -0700988}
989
Eric Laurent6a94d692014-05-20 11:18:06 -0700990status_t AudioPolicyService::createAudioPatch(const struct audio_patch *patch,
991 audio_patch_handle_t *handle)
Eric Laurent203b1a12014-04-01 10:34:16 -0700992{
Eric Laurent6a94d692014-05-20 11:18:06 -0700993 Mutex::Autolock _l(mLock);
Eric Laurent5284ed52014-05-29 14:37:38 -0700994 if(!modifyAudioRoutingAllowed()) {
995 return PERMISSION_DENIED;
996 }
Eric Laurent6a94d692014-05-20 11:18:06 -0700997 if (mAudioPolicyManager == NULL) {
998 return NO_INIT;
999 }
Eric Laurent10b71232018-04-13 18:14:44 -07001000 AutoCallerClear acc;
Eric Laurent6a94d692014-05-20 11:18:06 -07001001 return mAudioPolicyManager->createAudioPatch(patch, handle,
1002 IPCThreadState::self()->getCallingUid());
Eric Laurent203b1a12014-04-01 10:34:16 -07001003}
1004
Eric Laurent6a94d692014-05-20 11:18:06 -07001005status_t AudioPolicyService::releaseAudioPatch(audio_patch_handle_t handle)
Eric Laurent203b1a12014-04-01 10:34:16 -07001006{
Eric Laurent6a94d692014-05-20 11:18:06 -07001007 Mutex::Autolock _l(mLock);
Eric Laurent5284ed52014-05-29 14:37:38 -07001008 if(!modifyAudioRoutingAllowed()) {
1009 return PERMISSION_DENIED;
1010 }
Eric Laurent6a94d692014-05-20 11:18:06 -07001011 if (mAudioPolicyManager == NULL) {
1012 return NO_INIT;
1013 }
Eric Laurent10b71232018-04-13 18:14:44 -07001014 AutoCallerClear acc;
Eric Laurent6a94d692014-05-20 11:18:06 -07001015 return mAudioPolicyManager->releaseAudioPatch(handle,
1016 IPCThreadState::self()->getCallingUid());
Eric Laurent203b1a12014-04-01 10:34:16 -07001017}
1018
1019status_t AudioPolicyService::listAudioPatches(unsigned int *num_patches,
Eric Laurent6a94d692014-05-20 11:18:06 -07001020 struct audio_patch *patches,
1021 unsigned int *generation)
Eric Laurent203b1a12014-04-01 10:34:16 -07001022{
Eric Laurent6a94d692014-05-20 11:18:06 -07001023 Mutex::Autolock _l(mLock);
1024 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->listAudioPatches(num_patches, patches, generation);
Eric Laurent203b1a12014-04-01 10:34:16 -07001029}
1030
Eric Laurent6a94d692014-05-20 11:18:06 -07001031status_t AudioPolicyService::setAudioPortConfig(const struct audio_port_config *config)
Eric Laurent203b1a12014-04-01 10:34:16 -07001032{
Eric Laurent6a94d692014-05-20 11:18:06 -07001033 Mutex::Autolock _l(mLock);
Eric Laurent5284ed52014-05-29 14:37:38 -07001034 if(!modifyAudioRoutingAllowed()) {
1035 return PERMISSION_DENIED;
1036 }
Eric Laurent6a94d692014-05-20 11:18:06 -07001037 if (mAudioPolicyManager == NULL) {
1038 return NO_INIT;
1039 }
Eric Laurent10b71232018-04-13 18:14:44 -07001040 AutoCallerClear acc;
Eric Laurent6a94d692014-05-20 11:18:06 -07001041 return mAudioPolicyManager->setAudioPortConfig(config);
Eric Laurent203b1a12014-04-01 10:34:16 -07001042}
Eric Laurent2d388ec2014-03-07 13:25:54 -08001043
Eric Laurentdf3dc7e2014-07-27 18:39:40 -07001044status_t AudioPolicyService::acquireSoundTriggerSession(audio_session_t *session,
1045 audio_io_handle_t *ioHandle,
1046 audio_devices_t *device)
1047{
Andy Hungf759b8c2017-08-15 12:48:54 -07001048 Mutex::Autolock _l(mLock);
Eric Laurentdf3dc7e2014-07-27 18:39:40 -07001049 if (mAudioPolicyManager == NULL) {
1050 return NO_INIT;
1051 }
Eric Laurent10b71232018-04-13 18:14:44 -07001052 AutoCallerClear acc;
Eric Laurentdf3dc7e2014-07-27 18:39:40 -07001053 return mAudioPolicyManager->acquireSoundTriggerSession(session, ioHandle, device);
1054}
1055
1056status_t AudioPolicyService::releaseSoundTriggerSession(audio_session_t session)
1057{
Andy Hungf759b8c2017-08-15 12:48:54 -07001058 Mutex::Autolock _l(mLock);
Eric Laurentdf3dc7e2014-07-27 18:39:40 -07001059 if (mAudioPolicyManager == NULL) {
1060 return NO_INIT;
1061 }
Eric Laurent10b71232018-04-13 18:14:44 -07001062 AutoCallerClear acc;
Eric Laurentdf3dc7e2014-07-27 18:39:40 -07001063 return mAudioPolicyManager->releaseSoundTriggerSession(session);
1064}
1065
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -07001066status_t AudioPolicyService::registerPolicyMixes(const Vector<AudioMix>& mixes, bool registration)
Eric Laurentbaac1832014-12-01 17:52:59 -08001067{
1068 Mutex::Autolock _l(mLock);
Kevin Rocardbe201852019-02-20 22:33:28 -08001069
1070 // loopback|render only need a MediaProjection (checked in caller AudioService.java)
1071 bool needModifyAudioRouting = std::any_of(mixes.begin(), mixes.end(), [](auto& mix) {
1072 return !is_mix_loopback_render(mix.mRouteFlags); });
1073 if (needModifyAudioRouting && !modifyAudioRoutingAllowed()) {
Eric Laurentbaac1832014-12-01 17:52:59 -08001074 return PERMISSION_DENIED;
1075 }
Kevin Rocardbe201852019-02-20 22:33:28 -08001076
Eric Laurentbaac1832014-12-01 17:52:59 -08001077 if (mAudioPolicyManager == NULL) {
1078 return NO_INIT;
1079 }
Eric Laurent10b71232018-04-13 18:14:44 -07001080 AutoCallerClear acc;
Eric Laurentbaac1832014-12-01 17:52:59 -08001081 if (registration) {
1082 return mAudioPolicyManager->registerPolicyMixes(mixes);
1083 } else {
1084 return mAudioPolicyManager->unregisterPolicyMixes(mixes);
1085 }
1086}
1087
Jean-Michel Trivibda70da2018-12-19 07:30:15 -08001088status_t AudioPolicyService::setUidDeviceAffinities(uid_t uid,
1089 const Vector<AudioDeviceTypeAddr>& devices) {
1090 Mutex::Autolock _l(mLock);
1091 if(!modifyAudioRoutingAllowed()) {
1092 return PERMISSION_DENIED;
1093 }
1094 if (mAudioPolicyManager == NULL) {
1095 return NO_INIT;
1096 }
1097 AutoCallerClear acc;
1098 return mAudioPolicyManager->setUidDeviceAffinities(uid, devices);
1099}
1100
1101status_t AudioPolicyService::removeUidDeviceAffinities(uid_t uid) {
1102 Mutex::Autolock _l(mLock);
1103 if(!modifyAudioRoutingAllowed()) {
1104 return PERMISSION_DENIED;
1105 }
1106 if (mAudioPolicyManager == NULL) {
1107 return NO_INIT;
1108 }
1109 AutoCallerClear acc;
1110 return mAudioPolicyManager->removeUidDeviceAffinities(uid);
1111}
1112
Eric Laurent554a2772015-04-10 11:29:24 -07001113status_t AudioPolicyService::startAudioSource(const struct audio_port_config *source,
Eric Laurent3e6c7e12018-07-27 17:09:23 -07001114 const audio_attributes_t *attributes,
1115 audio_port_handle_t *portId)
Eric Laurent554a2772015-04-10 11:29:24 -07001116{
1117 Mutex::Autolock _l(mLock);
1118 if (mAudioPolicyManager == NULL) {
1119 return NO_INIT;
1120 }
Eric Laurent10b71232018-04-13 18:14:44 -07001121 AutoCallerClear acc;
Eric Laurent3e6c7e12018-07-27 17:09:23 -07001122 return mAudioPolicyManager->startAudioSource(source, attributes, portId,
Eric Laurentd60560a2015-04-10 11:31:20 -07001123 IPCThreadState::self()->getCallingUid());
Eric Laurent554a2772015-04-10 11:29:24 -07001124}
1125
Eric Laurent3e6c7e12018-07-27 17:09:23 -07001126status_t AudioPolicyService::stopAudioSource(audio_port_handle_t portId)
Eric Laurent554a2772015-04-10 11:29:24 -07001127{
1128 Mutex::Autolock _l(mLock);
1129 if (mAudioPolicyManager == NULL) {
1130 return NO_INIT;
1131 }
Eric Laurent10b71232018-04-13 18:14:44 -07001132 AutoCallerClear acc;
Eric Laurent3e6c7e12018-07-27 17:09:23 -07001133 return mAudioPolicyManager->stopAudioSource(portId);
Eric Laurent554a2772015-04-10 11:29:24 -07001134}
1135
Andy Hung2ddee192015-12-18 17:34:44 -08001136status_t AudioPolicyService::setMasterMono(bool mono)
1137{
1138 if (mAudioPolicyManager == NULL) {
1139 return NO_INIT;
1140 }
1141 if (!settingsAllowed()) {
1142 return PERMISSION_DENIED;
1143 }
1144 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -07001145 AutoCallerClear acc;
Andy Hung2ddee192015-12-18 17:34:44 -08001146 return mAudioPolicyManager->setMasterMono(mono);
1147}
1148
1149status_t AudioPolicyService::getMasterMono(bool *mono)
1150{
1151 if (mAudioPolicyManager == NULL) {
1152 return NO_INIT;
1153 }
1154 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -07001155 AutoCallerClear acc;
Andy Hung2ddee192015-12-18 17:34:44 -08001156 return mAudioPolicyManager->getMasterMono(mono);
1157}
1158
Eric Laurentac9cef52017-06-09 15:46:26 -07001159
1160float AudioPolicyService::getStreamVolumeDB(
1161 audio_stream_type_t stream, int index, audio_devices_t device)
1162{
1163 if (mAudioPolicyManager == NULL) {
1164 return NAN;
1165 }
1166 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -07001167 AutoCallerClear acc;
Eric Laurentac9cef52017-06-09 15:46:26 -07001168 return mAudioPolicyManager->getStreamVolumeDB(stream, index, device);
1169}
1170
jiabin81772902018-04-02 17:52:27 -07001171status_t AudioPolicyService::getSurroundFormats(unsigned int *numSurroundFormats,
1172 audio_format_t *surroundFormats,
1173 bool *surroundFormatsEnabled,
1174 bool reported)
1175{
1176 if (mAudioPolicyManager == NULL) {
1177 return NO_INIT;
1178 }
1179 Mutex::Autolock _l(mLock);
1180 AutoCallerClear acc;
1181 return mAudioPolicyManager->getSurroundFormats(numSurroundFormats, surroundFormats,
1182 surroundFormatsEnabled, reported);
1183}
1184
Arun Mirpuri11029ad2018-12-19 20:45:19 -08001185status_t AudioPolicyService::getHwOffloadEncodingFormatsSupportedForA2DP(
1186 std::vector<audio_format_t> *formats)
1187{
1188 if (mAudioPolicyManager == NULL) {
1189 return NO_INIT;
1190 }
1191 Mutex::Autolock _l(mLock);
1192 AutoCallerClear acc;
1193 return mAudioPolicyManager->getHwOffloadEncodingFormatsSupportedForA2DP(formats);
1194}
1195
jiabin81772902018-04-02 17:52:27 -07001196status_t AudioPolicyService::setSurroundFormatEnabled(audio_format_t audioFormat, bool enabled)
1197{
1198 if (mAudioPolicyManager == NULL) {
1199 return NO_INIT;
1200 }
1201 Mutex::Autolock _l(mLock);
1202 AutoCallerClear acc;
1203 return mAudioPolicyManager->setSurroundFormatEnabled(audioFormat, enabled);
1204}
Eric Laurentac9cef52017-06-09 15:46:26 -07001205
Eric Laurentb78763e2018-10-17 10:08:02 -07001206status_t AudioPolicyService::setAssistantUid(uid_t uid)
1207{
1208 Mutex::Autolock _l(mLock);
1209 mUidPolicy->setAssistantUid(uid);
1210 return NO_ERROR;
1211}
1212
1213status_t AudioPolicyService::setA11yServicesUids(const std::vector<uid_t>& uids)
1214{
1215 Mutex::Autolock _l(mLock);
1216 mUidPolicy->setA11yUids(uids);
1217 return NO_ERROR;
1218}
1219
jiabin6012f912018-11-02 17:06:30 -07001220bool AudioPolicyService::isHapticPlaybackSupported()
1221{
1222 if (mAudioPolicyManager == NULL) {
1223 ALOGW("%s, mAudioPolicyManager == NULL", __func__);
1224 return false;
1225 }
1226 Mutex::Autolock _l(mLock);
1227 AutoCallerClear acc;
1228 return mAudioPolicyManager->isHapticPlaybackSupported();
1229}
1230
François Gaffied0ba9ed2018-11-05 11:50:42 +01001231status_t AudioPolicyService::listAudioProductStrategies(AudioProductStrategyVector &strategies)
1232{
1233 if (mAudioPolicyManager == NULL) {
1234 return NO_INIT;
1235 }
1236 Mutex::Autolock _l(mLock);
1237 return mAudioPolicyManager->listAudioProductStrategies(strategies);
1238}
1239
François Gaffie4b2018b2018-11-07 11:18:59 +01001240status_t AudioPolicyService::getProductStrategyFromAudioAttributes(
1241 const AudioAttributes &aa, product_strategy_t &productStrategy)
François Gaffied0ba9ed2018-11-05 11:50:42 +01001242{
1243 if (mAudioPolicyManager == NULL) {
François Gaffie4b2018b2018-11-07 11:18:59 +01001244 return NO_INIT;
François Gaffied0ba9ed2018-11-05 11:50:42 +01001245 }
1246 Mutex::Autolock _l(mLock);
François Gaffie4b2018b2018-11-07 11:18:59 +01001247 return mAudioPolicyManager->getProductStrategyFromAudioAttributes(aa, productStrategy);
1248}
1249
1250status_t AudioPolicyService::listAudioVolumeGroups(AudioVolumeGroupVector &groups)
1251{
1252 if (mAudioPolicyManager == NULL) {
1253 return NO_INIT;
1254 }
1255 Mutex::Autolock _l(mLock);
1256 return mAudioPolicyManager->listAudioVolumeGroups(groups);
1257}
1258
1259status_t AudioPolicyService::getVolumeGroupFromAudioAttributes(const AudioAttributes &aa,
1260 volume_group_t &volumeGroup)
1261{
1262 if (mAudioPolicyManager == NULL) {
1263 return NO_INIT;
1264 }
1265 Mutex::Autolock _l(mLock);
1266 return mAudioPolicyManager->getVolumeGroupFromAudioAttributes(aa, volumeGroup);
François Gaffied0ba9ed2018-11-05 11:50:42 +01001267}
Mikhail Naganov1b2a7942017-12-08 10:18:09 -08001268} // namespace android