blob: cf24c13ad5ab1a631af5307139e3e16dde2b6424 [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
20#include <utils/Log.h>
21#include "AudioPolicyService.h"
22#include "ServiceUtilities.h"
23
Eric Laurent2d388ec2014-03-07 13:25:54 -080024namespace android {
25
26
27// ----------------------------------------------------------------------------
28
29status_t AudioPolicyService::setDeviceConnectionState(audio_devices_t device,
30 audio_policy_dev_state_t state,
Paul McLeane743a472015-01-28 11:07:31 -080031 const char *device_address,
32 const char *device_name)
Eric Laurent2d388ec2014-03-07 13:25:54 -080033{
Eric Laurentdce54a12014-03-10 12:19:46 -070034 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -080035 return NO_INIT;
36 }
37 if (!settingsAllowed()) {
38 return PERMISSION_DENIED;
39 }
Eric Laurent2d388ec2014-03-07 13:25:54 -080040 if (state != AUDIO_POLICY_DEVICE_STATE_AVAILABLE &&
41 state != AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE) {
42 return BAD_VALUE;
43 }
44
45 ALOGV("setDeviceConnectionState()");
46 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -070047 AutoCallerClear acc;
Paul McLeane743a472015-01-28 11:07:31 -080048 return mAudioPolicyManager->setDeviceConnectionState(device, state,
49 device_address, device_name);
Eric Laurent2d388ec2014-03-07 13:25:54 -080050}
51
52audio_policy_dev_state_t AudioPolicyService::getDeviceConnectionState(
53 audio_devices_t device,
54 const char *device_address)
55{
Eric Laurentdce54a12014-03-10 12:19:46 -070056 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -080057 return AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE;
58 }
Eric Laurent10b71232018-04-13 18:14:44 -070059 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -070060 return mAudioPolicyManager->getDeviceConnectionState(device,
Eric Laurent2d388ec2014-03-07 13:25:54 -080061 device_address);
62}
63
Pavlin Radoslavovf862bc62016-12-26 18:57:22 -080064status_t AudioPolicyService::handleDeviceConfigChange(audio_devices_t device,
65 const char *device_address,
66 const char *device_name)
67{
68 if (mAudioPolicyManager == NULL) {
69 return NO_INIT;
70 }
71 if (!settingsAllowed()) {
72 return PERMISSION_DENIED;
73 }
Pavlin Radoslavovf862bc62016-12-26 18:57:22 -080074
75 ALOGV("handleDeviceConfigChange()");
76 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -070077 AutoCallerClear acc;
Pavlin Radoslavovf862bc62016-12-26 18:57:22 -080078 return mAudioPolicyManager->handleDeviceConfigChange(device, device_address,
79 device_name);
80}
81
Eric Laurent2d388ec2014-03-07 13:25:54 -080082status_t AudioPolicyService::setPhoneState(audio_mode_t state)
83{
Eric Laurentdce54a12014-03-10 12:19:46 -070084 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -080085 return NO_INIT;
86 }
87 if (!settingsAllowed()) {
88 return PERMISSION_DENIED;
89 }
90 if (uint32_t(state) >= AUDIO_MODE_CNT) {
91 return BAD_VALUE;
92 }
93
94 ALOGV("setPhoneState()");
95
Eric Laurentbeb07fe2015-09-16 15:49:30 -070096 // acquire lock before calling setMode() so that setMode() + setPhoneState() are an atomic
97 // operation from policy manager standpoint (no other operation (e.g track start or stop)
98 // can be interleaved).
99 Mutex::Autolock _l(mLock);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800100 // TODO: check if it is more appropriate to do it in platform specific policy manager
101 AudioSystem::setMode(state);
102
Eric Laurent10b71232018-04-13 18:14:44 -0700103 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700104 mAudioPolicyManager->setPhoneState(state);
Eric Laurentbb6c9a02014-09-25 14:11:47 -0700105 mPhoneState = state;
Eric Laurent2d388ec2014-03-07 13:25:54 -0800106 return NO_ERROR;
107}
108
Eric Laurentbb6c9a02014-09-25 14:11:47 -0700109audio_mode_t AudioPolicyService::getPhoneState()
110{
111 Mutex::Autolock _l(mLock);
112 return mPhoneState;
113}
114
Eric Laurent2d388ec2014-03-07 13:25:54 -0800115status_t AudioPolicyService::setForceUse(audio_policy_force_use_t usage,
116 audio_policy_forced_cfg_t config)
117{
Eric Laurentdce54a12014-03-10 12:19:46 -0700118 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800119 return NO_INIT;
120 }
121 if (!settingsAllowed()) {
122 return PERMISSION_DENIED;
123 }
124 if (usage < 0 || usage >= AUDIO_POLICY_FORCE_USE_CNT) {
125 return BAD_VALUE;
126 }
127 if (config < 0 || config >= AUDIO_POLICY_FORCE_CFG_CNT) {
128 return BAD_VALUE;
129 }
130 ALOGV("setForceUse()");
131 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700132 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700133 mAudioPolicyManager->setForceUse(usage, config);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800134 return NO_ERROR;
135}
136
137audio_policy_forced_cfg_t AudioPolicyService::getForceUse(audio_policy_force_use_t usage)
138{
Eric Laurentdce54a12014-03-10 12:19:46 -0700139 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800140 return AUDIO_POLICY_FORCE_NONE;
141 }
142 if (usage < 0 || usage >= AUDIO_POLICY_FORCE_USE_CNT) {
143 return AUDIO_POLICY_FORCE_NONE;
144 }
Eric Laurent10b71232018-04-13 18:14:44 -0700145 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700146 return mAudioPolicyManager->getForceUse(usage);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800147}
148
Eric Laurentf4e63452017-11-06 19:31:46 +0000149audio_io_handle_t AudioPolicyService::getOutput(audio_stream_type_t stream)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800150{
Eric Laurent223fd5c2014-11-11 13:43:36 -0800151 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
Eric Laurentb1322c72014-10-30 14:59:13 -0700152 return AUDIO_IO_HANDLE_NONE;
Eric Laurentdea15412014-10-28 15:46:45 -0700153 }
Eric Laurentdce54a12014-03-10 12:19:46 -0700154 if (mAudioPolicyManager == NULL) {
Eric Laurentb1322c72014-10-30 14:59:13 -0700155 return AUDIO_IO_HANDLE_NONE;
Eric Laurent2d388ec2014-03-07 13:25:54 -0800156 }
157 ALOGV("getOutput()");
158 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700159 AutoCallerClear acc;
Eric Laurentf4e63452017-11-06 19:31:46 +0000160 return mAudioPolicyManager->getOutput(stream);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800161}
162
Eric Laurente83b55d2014-11-14 10:06:21 -0800163status_t AudioPolicyService::getOutputForAttr(const audio_attributes_t *attr,
164 audio_io_handle_t *output,
165 audio_session_t session,
166 audio_stream_type_t *stream,
Nadav Bar766fb022018-01-07 12:18:03 +0200167 pid_t pid,
Eric Laurent8c7e6da2015-04-21 17:37:00 -0700168 uid_t uid,
Eric Laurent20b9ef02016-12-05 11:03:16 -0800169 const audio_config_t *config,
Eric Laurente83b55d2014-11-14 10:06:21 -0800170 audio_output_flags_t flags,
Eric Laurent9ae8c592017-06-22 17:17:09 -0700171 audio_port_handle_t *selectedDeviceId,
Eric Laurent20b9ef02016-12-05 11:03:16 -0800172 audio_port_handle_t *portId)
Jean-Michel Trivi5bd3f382014-06-13 16:06:54 -0700173{
174 if (mAudioPolicyManager == NULL) {
Eric Laurente83b55d2014-11-14 10:06:21 -0800175 return NO_INIT;
Jean-Michel Trivi5bd3f382014-06-13 16:06:54 -0700176 }
Eric Laurentf4e63452017-11-06 19:31:46 +0000177 ALOGV("getOutputForAttr()");
Jean-Michel Trivi5bd3f382014-06-13 16:06:54 -0700178 Mutex::Autolock _l(mLock);
Eric Laurent8c7e6da2015-04-21 17:37:00 -0700179
Marco Nelissendcb346b2015-09-09 10:47:29 -0700180 const uid_t callingUid = IPCThreadState::self()->getCallingUid();
181 if (!isTrustedCallingUid(callingUid) || uid == (uid_t)-1) {
182 ALOGW_IF(uid != (uid_t)-1 && uid != callingUid,
183 "%s uid %d tried to pass itself off as %d", __FUNCTION__, callingUid, uid);
184 uid = callingUid;
Eric Laurent8c7e6da2015-04-21 17:37:00 -0700185 }
Nadav Bar766fb022018-01-07 12:18:03 +0200186 audio_output_flags_t originalFlags = flags;
Eric Laurent10b71232018-04-13 18:14:44 -0700187 AutoCallerClear acc;
Nadav Bar766fb022018-01-07 12:18:03 +0200188 status_t result = mAudioPolicyManager->getOutputForAttr(attr, output, session, stream, uid,
Eric Laurent20b9ef02016-12-05 11:03:16 -0800189 config,
Nadav Bar766fb022018-01-07 12:18:03 +0200190 &flags, selectedDeviceId, portId);
191
192 // FIXME: Introduce a way to check for the the telephony device before opening the output
193 if ((result == NO_ERROR) &&
194 (flags & AUDIO_OUTPUT_FLAG_INCALL_MUSIC) &&
195 !modifyPhoneStateAllowed(pid, uid)) {
196 // If the app tries to play music through the telephony device and doesn't have permission
197 // the fallback to the default output device.
198 mAudioPolicyManager->releaseOutput(*output, *stream, session);
199 flags = originalFlags;
200 *selectedDeviceId = AUDIO_PORT_HANDLE_NONE;
201 *portId = AUDIO_PORT_HANDLE_NONE;
202 result = mAudioPolicyManager->getOutputForAttr(attr, output, session, stream, uid,
203 config,
204 &flags, selectedDeviceId, portId);
205 }
206 return result;
Jean-Michel Trivi5bd3f382014-06-13 16:06:54 -0700207}
208
Eric Laurent2d388ec2014-03-07 13:25:54 -0800209status_t AudioPolicyService::startOutput(audio_io_handle_t output,
210 audio_stream_type_t stream,
Eric Laurente83b55d2014-11-14 10:06:21 -0800211 audio_session_t session)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800212{
Eric Laurentdea15412014-10-28 15:46:45 -0700213 if (uint32_t(stream) >= AUDIO_STREAM_CNT) {
214 return BAD_VALUE;
215 }
Eric Laurentdce54a12014-03-10 12:19:46 -0700216 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800217 return NO_INIT;
218 }
219 ALOGV("startOutput()");
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700220 sp<AudioPolicyEffects>audioPolicyEffects;
221 {
222 Mutex::Autolock _l(mLock);
223 audioPolicyEffects = mAudioPolicyEffects;
bryant_liuba2b4392014-06-11 16:49:30 +0800224 }
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700225 if (audioPolicyEffects != 0) {
226 // create audio processors according to stream
227 status_t status = audioPolicyEffects->addOutputSessionEffects(output, stream, session);
228 if (status != NO_ERROR && status != ALREADY_EXISTS) {
229 ALOGW("Failed to add effects on session %d", session);
230 }
231 }
232 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700233 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700234 return mAudioPolicyManager->startOutput(output, stream, session);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800235}
236
237status_t AudioPolicyService::stopOutput(audio_io_handle_t output,
238 audio_stream_type_t stream,
Eric Laurente83b55d2014-11-14 10:06:21 -0800239 audio_session_t session)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800240{
Eric Laurentdea15412014-10-28 15:46:45 -0700241 if (uint32_t(stream) >= AUDIO_STREAM_CNT) {
242 return BAD_VALUE;
243 }
Eric Laurentdce54a12014-03-10 12:19:46 -0700244 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800245 return NO_INIT;
246 }
247 ALOGV("stopOutput()");
248 mOutputCommandThread->stopOutputCommand(output, stream, session);
249 return NO_ERROR;
250}
251
252status_t AudioPolicyService::doStopOutput(audio_io_handle_t output,
253 audio_stream_type_t stream,
Eric Laurente83b55d2014-11-14 10:06:21 -0800254 audio_session_t session)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800255{
256 ALOGV("doStopOutput from tid %d", gettid());
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700257 sp<AudioPolicyEffects>audioPolicyEffects;
258 {
259 Mutex::Autolock _l(mLock);
260 audioPolicyEffects = mAudioPolicyEffects;
bryant_liuba2b4392014-06-11 16:49:30 +0800261 }
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700262 if (audioPolicyEffects != 0) {
263 // release audio processors from the stream
264 status_t status = audioPolicyEffects->releaseOutputSessionEffects(output, stream, session);
265 if (status != NO_ERROR && status != ALREADY_EXISTS) {
266 ALOGW("Failed to release effects on session %d", session);
267 }
268 }
269 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700270 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700271 return mAudioPolicyManager->stopOutput(output, stream, session);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800272}
273
Eric Laurente83b55d2014-11-14 10:06:21 -0800274void AudioPolicyService::releaseOutput(audio_io_handle_t output,
275 audio_stream_type_t stream,
276 audio_session_t session)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800277{
Eric Laurentdce54a12014-03-10 12:19:46 -0700278 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800279 return;
280 }
281 ALOGV("releaseOutput()");
Eric Laurente83b55d2014-11-14 10:06:21 -0800282 mOutputCommandThread->releaseOutputCommand(output, stream, session);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800283}
284
Eric Laurente83b55d2014-11-14 10:06:21 -0800285void AudioPolicyService::doReleaseOutput(audio_io_handle_t output,
286 audio_stream_type_t stream,
287 audio_session_t session)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800288{
289 ALOGV("doReleaseOutput from tid %d", gettid());
290 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700291 // called from internal thread: no need to clear caller identity
Eric Laurente83b55d2014-11-14 10:06:21 -0800292 mAudioPolicyManager->releaseOutput(output, stream, session);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800293}
294
Eric Laurentcaf7f482014-11-25 17:50:47 -0800295status_t AudioPolicyService::getInputForAttr(const audio_attributes_t *attr,
296 audio_io_handle_t *input,
297 audio_session_t session,
Eric Laurentb2379ba2016-05-23 17:42:12 -0700298 pid_t pid,
Eric Laurent8c7e6da2015-04-21 17:37:00 -0700299 uid_t uid,
Eric Laurentfee19762018-01-29 18:44:13 -0800300 const String16& opPackageName,
Eric Laurent20b9ef02016-12-05 11:03:16 -0800301 const audio_config_base_t *config,
Paul McLean466dc8e2015-04-17 13:15:36 -0600302 audio_input_flags_t flags,
Eric Laurent9ae8c592017-06-22 17:17:09 -0700303 audio_port_handle_t *selectedDeviceId,
Eric Laurent20b9ef02016-12-05 11:03:16 -0800304 audio_port_handle_t *portId)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800305{
Eric Laurentdce54a12014-03-10 12:19:46 -0700306 if (mAudioPolicyManager == NULL) {
Eric Laurentcaf7f482014-11-25 17:50:47 -0800307 return NO_INIT;
Eric Laurent2d388ec2014-03-07 13:25:54 -0800308 }
Eric Laurent7dca8a82018-01-29 18:44:26 -0800309
Eric Laurent2d388ec2014-03-07 13:25:54 -0800310 // already checked by client, but double-check in case the client wrapper is bypassed
Eric Laurentfe231122017-11-17 17:48:06 -0800311 if (attr->source < AUDIO_SOURCE_DEFAULT && attr->source >= AUDIO_SOURCE_CNT &&
312 attr->source != AUDIO_SOURCE_HOTWORD && attr->source != AUDIO_SOURCE_FM_TUNER) {
Eric Laurentcaf7f482014-11-25 17:50:47 -0800313 return BAD_VALUE;
Eric Laurent2d388ec2014-03-07 13:25:54 -0800314 }
315
Eric Laurentb2379ba2016-05-23 17:42:12 -0700316 bool updatePid = (pid == -1);
Marco Nelissendcb346b2015-09-09 10:47:29 -0700317 const uid_t callingUid = IPCThreadState::self()->getCallingUid();
Eric Laurentb2379ba2016-05-23 17:42:12 -0700318 if (!isTrustedCallingUid(callingUid)) {
Eric Laurent9f39f8d2016-05-25 12:34:48 -0700319 ALOGW_IF(uid != (uid_t)-1 && uid != callingUid,
Marco Nelissendcb346b2015-09-09 10:47:29 -0700320 "%s uid %d tried to pass itself off as %d", __FUNCTION__, callingUid, uid);
321 uid = callingUid;
Eric Laurentb2379ba2016-05-23 17:42:12 -0700322 updatePid = true;
323 }
324
325 if (updatePid) {
326 const pid_t callingPid = IPCThreadState::self()->getCallingPid();
Eric Laurent9f39f8d2016-05-25 12:34:48 -0700327 ALOGW_IF(pid != (pid_t)-1 && pid != callingPid,
Eric Laurentb2379ba2016-05-23 17:42:12 -0700328 "%s uid %d pid %d tried to pass itself off as pid %d",
329 __func__, callingUid, callingPid, pid);
330 pid = callingPid;
Eric Laurent8c7e6da2015-04-21 17:37:00 -0700331 }
332
Eric Laurent7dca8a82018-01-29 18:44:26 -0800333 // check calling permissions
334 if (!recordingAllowed(opPackageName, pid, uid)) {
335 ALOGE("%s permission denied: recording not allowed for uid %d pid %d",
336 __func__, uid, pid);
337 return PERMISSION_DENIED;
338 }
339
Eric Laurent7504b9e2017-08-15 18:17:26 -0700340 if ((attr->source == AUDIO_SOURCE_HOTWORD) && !captureHotwordAllowed(pid, uid)) {
341 return BAD_VALUE;
342 }
343
344 sp<AudioPolicyEffects>audioPolicyEffects;
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700345 {
Eric Laurent7504b9e2017-08-15 18:17:26 -0700346 status_t status;
347 AudioPolicyInterface::input_type_t inputType;
348
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700349 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700350 {
351 AutoCallerClear acc;
352 // the audio_in_acoustics_t parameter is ignored by get_input()
353 status = mAudioPolicyManager->getInputForAttr(attr, input, session, uid,
354 config,
355 flags, selectedDeviceId,
356 &inputType, portId);
357 }
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700358 audioPolicyEffects = mAudioPolicyEffects;
Jean-Michel Trivi97bb33f2014-12-12 16:23:43 -0800359
360 if (status == NO_ERROR) {
361 // enforce permission (if any) required for each type of input
362 switch (inputType) {
363 case AudioPolicyInterface::API_INPUT_LEGACY:
364 break;
Eric Laurent82db2692015-08-07 13:59:42 -0700365 case AudioPolicyInterface::API_INPUT_TELEPHONY_RX:
366 // FIXME: use the same permission as for remote submix for now.
Jean-Michel Trivi97bb33f2014-12-12 16:23:43 -0800367 case AudioPolicyInterface::API_INPUT_MIX_CAPTURE:
Eric Laurentb2379ba2016-05-23 17:42:12 -0700368 if (!captureAudioOutputAllowed(pid, uid)) {
Jean-Michel Trivi97bb33f2014-12-12 16:23:43 -0800369 ALOGE("getInputForAttr() permission denied: capture not allowed");
370 status = PERMISSION_DENIED;
371 }
372 break;
373 case AudioPolicyInterface::API_INPUT_MIX_EXT_POLICY_REROUTE:
374 if (!modifyAudioRoutingAllowed()) {
375 ALOGE("getInputForAttr() permission denied: modify audio routing not allowed");
376 status = PERMISSION_DENIED;
377 }
378 break;
379 case AudioPolicyInterface::API_INPUT_INVALID:
380 default:
381 LOG_ALWAYS_FATAL("getInputForAttr() encountered an invalid input type %d",
382 (int)inputType);
383 }
384 }
385
386 if (status != NO_ERROR) {
387 if (status == PERMISSION_DENIED) {
Eric Laurent10b71232018-04-13 18:14:44 -0700388 AutoCallerClear acc;
Jean-Michel Trivi97bb33f2014-12-12 16:23:43 -0800389 mAudioPolicyManager->releaseInput(*input, session);
390 }
391 return status;
392 }
Eric Laurentfee19762018-01-29 18:44:13 -0800393
394 sp<AudioRecordClient> client =
395 new AudioRecordClient(*attr, *input, uid, pid, opPackageName, session);
396 client->active = false;
397 client->isConcurrent = false;
398 client->isVirtualDevice = false; //TODO : update from APM->getInputForAttr()
399 mAudioRecordClients.add(*portId, client);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700400 }
Jean-Michel Trivi97bb33f2014-12-12 16:23:43 -0800401
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700402 if (audioPolicyEffects != 0) {
403 // create audio pre processors according to input source
Eric Laurentcaf7f482014-11-25 17:50:47 -0800404 status_t status = audioPolicyEffects->addInputEffects(*input, attr->source, session);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700405 if (status != NO_ERROR && status != ALREADY_EXISTS) {
Eric Laurentcaf7f482014-11-25 17:50:47 -0800406 ALOGW("Failed to add effects on input %d", *input);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700407 }
Eric Laurent2d388ec2014-03-07 13:25:54 -0800408 }
Eric Laurentcaf7f482014-11-25 17:50:47 -0800409 return NO_ERROR;
Eric Laurent2d388ec2014-03-07 13:25:54 -0800410}
411
Eric Laurentfee19762018-01-29 18:44:13 -0800412status_t AudioPolicyService::startInput(audio_port_handle_t portId, bool *silenced)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800413{
Eric Laurentdce54a12014-03-10 12:19:46 -0700414 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800415 return NO_INIT;
416 }
Eric Laurent7dca8a82018-01-29 18:44:26 -0800417 sp<AudioRecordClient> client;
418 {
419 Mutex::Autolock _l(mLock);
Svet Ganovf4ddfef2018-01-16 07:37:58 -0800420
Eric Laurent7dca8a82018-01-29 18:44:26 -0800421 ssize_t index = mAudioRecordClients.indexOfKey(portId);
422 if (index < 0) {
423 return INVALID_OPERATION;
424 }
425 client = mAudioRecordClients.valueAt(index);
Eric Laurentfee19762018-01-29 18:44:13 -0800426 }
Eric Laurent7dca8a82018-01-29 18:44:26 -0800427
428 // check calling permissions
Svet Ganov6e641372018-03-02 09:21:30 -0800429 if (!startRecording(client->opPackageName, client->pid, client->uid)) {
Eric Laurent7dca8a82018-01-29 18:44:26 -0800430 ALOGE("%s permission denied: recording not allowed for uid %d pid %d",
431 __func__, client->uid, client->pid);
432 return PERMISSION_DENIED;
433 }
Eric Laurentfee19762018-01-29 18:44:13 -0800434
435 // If UID inactive it records silence until becoming active
436 *silenced = !mUidPolicy->isUidActive(client->uid) && !client->isVirtualDevice;
437
Eric Laurent7dca8a82018-01-29 18:44:26 -0800438 Mutex::Autolock _l(mLock);
Svet Ganovf4ddfef2018-01-16 07:37:58 -0800439 AudioPolicyInterface::concurrency_type__mask_t concurrency =
440 AudioPolicyInterface::API_INPUT_CONCURRENCY_NONE;
Eric Laurentfee19762018-01-29 18:44:13 -0800441
Eric Laurent10b71232018-04-13 18:14:44 -0700442 status_t status;
443 {
444 AutoCallerClear acc;
445 status = mAudioPolicyManager->startInput(
446 client->input, client->session, *silenced, &concurrency);
447 }
Eric Laurent2d388ec2014-03-07 13:25:54 -0800448
Eric Laurentfb66dd92016-01-28 18:32:03 -0800449 if (status == NO_ERROR) {
Eric Laurent43423352016-02-05 11:57:57 -0800450 LOG_ALWAYS_FATAL_IF(concurrency & ~AudioPolicyInterface::API_INPUT_CONCURRENCY_ALL,
451 "startInput(): invalid concurrency type %d", (int)concurrency);
452
Eric Laurentfb66dd92016-01-28 18:32:03 -0800453 // enforce permission (if any) required for each type of concurrency
Eric Laurent43423352016-02-05 11:57:57 -0800454 if (concurrency & AudioPolicyInterface::API_INPUT_CONCURRENCY_CALL) {
Eric Laurentfb66dd92016-01-28 18:32:03 -0800455 //TODO: check incall capture permission
Eric Laurent43423352016-02-05 11:57:57 -0800456 }
457 if (concurrency & AudioPolicyInterface::API_INPUT_CONCURRENCY_CAPTURE) {
Eric Laurentfb66dd92016-01-28 18:32:03 -0800458 //TODO: check concurrent capture permission
Eric Laurentfb66dd92016-01-28 18:32:03 -0800459 }
Svet Ganov6e641372018-03-02 09:21:30 -0800460 } else {
461 finishRecording(client->opPackageName, client->uid);
Eric Laurentfb66dd92016-01-28 18:32:03 -0800462 }
463
464 return status;
Eric Laurent2d388ec2014-03-07 13:25:54 -0800465}
466
Eric Laurentfee19762018-01-29 18:44:13 -0800467status_t AudioPolicyService::stopInput(audio_port_handle_t portId)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800468{
Eric Laurentdce54a12014-03-10 12:19:46 -0700469 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800470 return NO_INIT;
471 }
472 Mutex::Autolock _l(mLock);
473
Eric Laurentfee19762018-01-29 18:44:13 -0800474 ssize_t index = mAudioRecordClients.indexOfKey(portId);
475 if (index < 0) {
476 return INVALID_OPERATION;
477 }
478 sp<AudioRecordClient> client = mAudioRecordClients.valueAt(index);
479
Svet Ganov6e641372018-03-02 09:21:30 -0800480 // finish the recording app op
481 finishRecording(client->opPackageName, client->uid);
Eric Laurent10b71232018-04-13 18:14:44 -0700482 AutoCallerClear acc;
Eric Laurentfee19762018-01-29 18:44:13 -0800483 return mAudioPolicyManager->stopInput(client->input, client->session);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800484}
485
Eric Laurentfee19762018-01-29 18:44:13 -0800486void AudioPolicyService::releaseInput(audio_port_handle_t portId)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800487{
Eric Laurentdce54a12014-03-10 12:19:46 -0700488 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800489 return;
490 }
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700491 sp<AudioPolicyEffects>audioPolicyEffects;
Eric Laurentfee19762018-01-29 18:44:13 -0800492 sp<AudioRecordClient> client;
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700493 {
494 Mutex::Autolock _l(mLock);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700495 audioPolicyEffects = mAudioPolicyEffects;
Eric Laurentfee19762018-01-29 18:44:13 -0800496 ssize_t index = mAudioRecordClients.indexOfKey(portId);
497 if (index < 0) {
498 return;
499 }
500 client = mAudioRecordClients.valueAt(index);
501 mAudioRecordClients.removeItem(portId);
502 }
503 if (client == 0) {
504 return;
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700505 }
506 if (audioPolicyEffects != 0) {
507 // release audio processors from the input
Eric Laurentfee19762018-01-29 18:44:13 -0800508 status_t status = audioPolicyEffects->releaseInputEffects(client->input, client->session);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700509 if(status != NO_ERROR) {
Eric Laurentfee19762018-01-29 18:44:13 -0800510 ALOGW("Failed to release effects on input %d", client->input);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700511 }
Eric Laurent2d388ec2014-03-07 13:25:54 -0800512 }
Eric Laurentf10c7092016-12-06 17:09:56 -0800513 {
514 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700515 AutoCallerClear acc;
Eric Laurentfee19762018-01-29 18:44:13 -0800516 mAudioPolicyManager->releaseInput(client->input, client->session);
Eric Laurentf10c7092016-12-06 17:09:56 -0800517 }
Eric Laurent2d388ec2014-03-07 13:25:54 -0800518}
519
520status_t AudioPolicyService::initStreamVolume(audio_stream_type_t stream,
521 int indexMin,
522 int indexMax)
523{
Eric Laurentdce54a12014-03-10 12:19:46 -0700524 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800525 return NO_INIT;
526 }
527 if (!settingsAllowed()) {
528 return PERMISSION_DENIED;
529 }
Eric Laurent223fd5c2014-11-11 13:43:36 -0800530 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800531 return BAD_VALUE;
532 }
533 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700534 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700535 mAudioPolicyManager->initStreamVolume(stream, indexMin, indexMax);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800536 return NO_ERROR;
537}
538
539status_t AudioPolicyService::setStreamVolumeIndex(audio_stream_type_t stream,
540 int index,
541 audio_devices_t device)
542{
Eric Laurentdce54a12014-03-10 12:19:46 -0700543 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800544 return NO_INIT;
545 }
546 if (!settingsAllowed()) {
547 return PERMISSION_DENIED;
548 }
Eric Laurent223fd5c2014-11-11 13:43:36 -0800549 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800550 return BAD_VALUE;
551 }
552 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700553 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700554 return mAudioPolicyManager->setStreamVolumeIndex(stream,
555 index,
556 device);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800557}
558
559status_t AudioPolicyService::getStreamVolumeIndex(audio_stream_type_t stream,
560 int *index,
561 audio_devices_t device)
562{
Eric Laurentdce54a12014-03-10 12:19:46 -0700563 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800564 return NO_INIT;
565 }
Eric Laurent223fd5c2014-11-11 13:43:36 -0800566 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800567 return BAD_VALUE;
568 }
569 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700570 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700571 return mAudioPolicyManager->getStreamVolumeIndex(stream,
572 index,
573 device);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800574}
575
576uint32_t AudioPolicyService::getStrategyForStream(audio_stream_type_t stream)
577{
Eric Laurent223fd5c2014-11-11 13:43:36 -0800578 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
Eric Laurentb1322c72014-10-30 14:59:13 -0700579 return 0;
Eric Laurentdea15412014-10-28 15:46:45 -0700580 }
Eric Laurentdce54a12014-03-10 12:19:46 -0700581 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800582 return 0;
583 }
Eric Laurent10b71232018-04-13 18:14:44 -0700584 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700585 return mAudioPolicyManager->getStrategyForStream(stream);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800586}
587
588//audio policy: use audio_device_t appropriately
589
590audio_devices_t AudioPolicyService::getDevicesForStream(audio_stream_type_t stream)
591{
Eric Laurent223fd5c2014-11-11 13:43:36 -0800592 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
Eric Laurentb1322c72014-10-30 14:59:13 -0700593 return AUDIO_DEVICE_NONE;
Eric Laurentdea15412014-10-28 15:46:45 -0700594 }
Eric Laurentdce54a12014-03-10 12:19:46 -0700595 if (mAudioPolicyManager == NULL) {
Eric Laurentb1322c72014-10-30 14:59:13 -0700596 return AUDIO_DEVICE_NONE;
Eric Laurent2d388ec2014-03-07 13:25:54 -0800597 }
Haynes Mathew Georgedfb9f3b2015-10-26 18:22:13 -0700598 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700599 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700600 return mAudioPolicyManager->getDevicesForStream(stream);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800601}
602
603audio_io_handle_t AudioPolicyService::getOutputForEffect(const effect_descriptor_t *desc)
604{
605 // FIXME change return type to status_t, and return NO_INIT here
Eric Laurentdce54a12014-03-10 12:19:46 -0700606 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800607 return 0;
608 }
609 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700610 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700611 return mAudioPolicyManager->getOutputForEffect(desc);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800612}
613
614status_t AudioPolicyService::registerEffect(const effect_descriptor_t *desc,
615 audio_io_handle_t io,
616 uint32_t strategy,
Glenn Kastend848eb42016-03-08 13:42:11 -0800617 audio_session_t session,
Eric Laurent2d388ec2014-03-07 13:25:54 -0800618 int id)
619{
Eric Laurentdce54a12014-03-10 12:19:46 -0700620 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800621 return NO_INIT;
622 }
Haynes Mathew Georgebab7bf42015-10-30 18:02:23 -0700623 Mutex::Autolock _l(mEffectsLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700624 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700625 return mAudioPolicyManager->registerEffect(desc, io, strategy, session, id);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800626}
627
628status_t AudioPolicyService::unregisterEffect(int id)
629{
Eric Laurentdce54a12014-03-10 12:19:46 -0700630 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800631 return NO_INIT;
632 }
Haynes Mathew Georgebab7bf42015-10-30 18:02:23 -0700633 Mutex::Autolock _l(mEffectsLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700634 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700635 return mAudioPolicyManager->unregisterEffect(id);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800636}
637
638status_t AudioPolicyService::setEffectEnabled(int id, bool enabled)
639{
Eric Laurentdce54a12014-03-10 12:19:46 -0700640 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800641 return NO_INIT;
642 }
Haynes Mathew Georgebab7bf42015-10-30 18:02:23 -0700643 Mutex::Autolock _l(mEffectsLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700644 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700645 return mAudioPolicyManager->setEffectEnabled(id, enabled);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800646}
647
648bool AudioPolicyService::isStreamActive(audio_stream_type_t stream, uint32_t inPastMs) const
649{
Eric Laurent223fd5c2014-11-11 13:43:36 -0800650 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
Eric Laurentb1322c72014-10-30 14:59:13 -0700651 return false;
Eric Laurentdea15412014-10-28 15:46:45 -0700652 }
Eric Laurentdce54a12014-03-10 12:19:46 -0700653 if (mAudioPolicyManager == NULL) {
Eric Laurentb1322c72014-10-30 14:59:13 -0700654 return false;
Eric Laurent2d388ec2014-03-07 13:25:54 -0800655 }
656 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700657 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700658 return mAudioPolicyManager->isStreamActive(stream, inPastMs);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800659}
660
661bool AudioPolicyService::isStreamActiveRemotely(audio_stream_type_t stream, uint32_t inPastMs) const
662{
Eric Laurent223fd5c2014-11-11 13:43:36 -0800663 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
Eric Laurentb1322c72014-10-30 14:59:13 -0700664 return false;
Eric Laurentdea15412014-10-28 15:46:45 -0700665 }
Eric Laurentdce54a12014-03-10 12:19:46 -0700666 if (mAudioPolicyManager == NULL) {
Eric Laurentb1322c72014-10-30 14:59:13 -0700667 return false;
Eric Laurent2d388ec2014-03-07 13:25:54 -0800668 }
669 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700670 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700671 return mAudioPolicyManager->isStreamActiveRemotely(stream, inPastMs);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800672}
673
674bool AudioPolicyService::isSourceActive(audio_source_t source) const
675{
Eric Laurentdce54a12014-03-10 12:19:46 -0700676 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800677 return false;
678 }
679 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700680 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700681 return mAudioPolicyManager->isSourceActive(source);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800682}
683
Glenn Kastend848eb42016-03-08 13:42:11 -0800684status_t AudioPolicyService::queryDefaultPreProcessing(audio_session_t audioSession,
Eric Laurent2d388ec2014-03-07 13:25:54 -0800685 effect_descriptor_t *descriptors,
686 uint32_t *count)
687{
Eric Laurentdce54a12014-03-10 12:19:46 -0700688 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800689 *count = 0;
690 return NO_INIT;
691 }
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700692 sp<AudioPolicyEffects>audioPolicyEffects;
693 {
694 Mutex::Autolock _l(mLock);
695 audioPolicyEffects = mAudioPolicyEffects;
696 }
697 if (audioPolicyEffects == 0) {
698 *count = 0;
699 return NO_INIT;
700 }
Eric Laurentfb66dd92016-01-28 18:32:03 -0800701 return audioPolicyEffects->queryDefaultInputEffects(
702 (audio_session_t)audioSession, descriptors, count);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800703}
704
705bool AudioPolicyService::isOffloadSupported(const audio_offload_info_t& info)
706{
Eric Laurentdce54a12014-03-10 12:19:46 -0700707 if (mAudioPolicyManager == NULL) {
708 ALOGV("mAudioPolicyManager == NULL");
Eric Laurent2d388ec2014-03-07 13:25:54 -0800709 return false;
710 }
Andy Hung2ddee192015-12-18 17:34:44 -0800711 Mutex::Autolock _l(mLock);
Haynes Mathew Georgebab7bf42015-10-30 18:02:23 -0700712 Mutex::Autolock _le(mEffectsLock); // isOffloadSupported queries for
713 // non-offloadable effects
Eric Laurent10b71232018-04-13 18:14:44 -0700714 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700715 return mAudioPolicyManager->isOffloadSupported(info);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800716}
717
Eric Laurent6a94d692014-05-20 11:18:06 -0700718status_t AudioPolicyService::listAudioPorts(audio_port_role_t role,
719 audio_port_type_t type,
Eric Laurent203b1a12014-04-01 10:34:16 -0700720 unsigned int *num_ports,
Eric Laurent6a94d692014-05-20 11:18:06 -0700721 struct audio_port *ports,
722 unsigned int *generation)
Eric Laurent203b1a12014-04-01 10:34:16 -0700723{
Eric Laurent6a94d692014-05-20 11:18:06 -0700724 Mutex::Autolock _l(mLock);
725 if (mAudioPolicyManager == NULL) {
726 return NO_INIT;
727 }
Eric Laurent10b71232018-04-13 18:14:44 -0700728 AutoCallerClear acc;
Eric Laurent6a94d692014-05-20 11:18:06 -0700729 return mAudioPolicyManager->listAudioPorts(role, type, num_ports, ports, generation);
Eric Laurent203b1a12014-04-01 10:34:16 -0700730}
731
Eric Laurent6a94d692014-05-20 11:18:06 -0700732status_t AudioPolicyService::getAudioPort(struct audio_port *port)
Eric Laurent203b1a12014-04-01 10:34:16 -0700733{
Eric Laurent6a94d692014-05-20 11:18:06 -0700734 Mutex::Autolock _l(mLock);
735 if (mAudioPolicyManager == NULL) {
736 return NO_INIT;
737 }
Eric Laurent10b71232018-04-13 18:14:44 -0700738 AutoCallerClear acc;
Eric Laurent6a94d692014-05-20 11:18:06 -0700739 return mAudioPolicyManager->getAudioPort(port);
Eric Laurent203b1a12014-04-01 10:34:16 -0700740}
741
Eric Laurent6a94d692014-05-20 11:18:06 -0700742status_t AudioPolicyService::createAudioPatch(const struct audio_patch *patch,
743 audio_patch_handle_t *handle)
Eric Laurent203b1a12014-04-01 10:34:16 -0700744{
Eric Laurent6a94d692014-05-20 11:18:06 -0700745 Mutex::Autolock _l(mLock);
Eric Laurent5284ed52014-05-29 14:37:38 -0700746 if(!modifyAudioRoutingAllowed()) {
747 return PERMISSION_DENIED;
748 }
Eric Laurent6a94d692014-05-20 11:18:06 -0700749 if (mAudioPolicyManager == NULL) {
750 return NO_INIT;
751 }
Eric Laurent10b71232018-04-13 18:14:44 -0700752 AutoCallerClear acc;
Eric Laurent6a94d692014-05-20 11:18:06 -0700753 return mAudioPolicyManager->createAudioPatch(patch, handle,
754 IPCThreadState::self()->getCallingUid());
Eric Laurent203b1a12014-04-01 10:34:16 -0700755}
756
Eric Laurent6a94d692014-05-20 11:18:06 -0700757status_t AudioPolicyService::releaseAudioPatch(audio_patch_handle_t handle)
Eric Laurent203b1a12014-04-01 10:34:16 -0700758{
Eric Laurent6a94d692014-05-20 11:18:06 -0700759 Mutex::Autolock _l(mLock);
Eric Laurent5284ed52014-05-29 14:37:38 -0700760 if(!modifyAudioRoutingAllowed()) {
761 return PERMISSION_DENIED;
762 }
Eric Laurent6a94d692014-05-20 11:18:06 -0700763 if (mAudioPolicyManager == NULL) {
764 return NO_INIT;
765 }
Eric Laurent10b71232018-04-13 18:14:44 -0700766 AutoCallerClear acc;
Eric Laurent6a94d692014-05-20 11:18:06 -0700767 return mAudioPolicyManager->releaseAudioPatch(handle,
768 IPCThreadState::self()->getCallingUid());
Eric Laurent203b1a12014-04-01 10:34:16 -0700769}
770
771status_t AudioPolicyService::listAudioPatches(unsigned int *num_patches,
Eric Laurent6a94d692014-05-20 11:18:06 -0700772 struct audio_patch *patches,
773 unsigned int *generation)
Eric Laurent203b1a12014-04-01 10:34:16 -0700774{
Eric Laurent6a94d692014-05-20 11:18:06 -0700775 Mutex::Autolock _l(mLock);
776 if (mAudioPolicyManager == NULL) {
777 return NO_INIT;
778 }
Eric Laurent10b71232018-04-13 18:14:44 -0700779 AutoCallerClear acc;
Eric Laurent6a94d692014-05-20 11:18:06 -0700780 return mAudioPolicyManager->listAudioPatches(num_patches, patches, generation);
Eric Laurent203b1a12014-04-01 10:34:16 -0700781}
782
Eric Laurent6a94d692014-05-20 11:18:06 -0700783status_t AudioPolicyService::setAudioPortConfig(const struct audio_port_config *config)
Eric Laurent203b1a12014-04-01 10:34:16 -0700784{
Eric Laurent6a94d692014-05-20 11:18:06 -0700785 Mutex::Autolock _l(mLock);
Eric Laurent5284ed52014-05-29 14:37:38 -0700786 if(!modifyAudioRoutingAllowed()) {
787 return PERMISSION_DENIED;
788 }
Eric Laurent6a94d692014-05-20 11:18:06 -0700789 if (mAudioPolicyManager == NULL) {
790 return NO_INIT;
791 }
Eric Laurent10b71232018-04-13 18:14:44 -0700792 AutoCallerClear acc;
Eric Laurent6a94d692014-05-20 11:18:06 -0700793 return mAudioPolicyManager->setAudioPortConfig(config);
Eric Laurent203b1a12014-04-01 10:34:16 -0700794}
Eric Laurent2d388ec2014-03-07 13:25:54 -0800795
Eric Laurentdf3dc7e2014-07-27 18:39:40 -0700796status_t AudioPolicyService::acquireSoundTriggerSession(audio_session_t *session,
797 audio_io_handle_t *ioHandle,
798 audio_devices_t *device)
799{
Andy Hungf759b8c2017-08-15 12:48:54 -0700800 Mutex::Autolock _l(mLock);
Eric Laurentdf3dc7e2014-07-27 18:39:40 -0700801 if (mAudioPolicyManager == NULL) {
802 return NO_INIT;
803 }
Eric Laurent10b71232018-04-13 18:14:44 -0700804 AutoCallerClear acc;
Eric Laurentdf3dc7e2014-07-27 18:39:40 -0700805 return mAudioPolicyManager->acquireSoundTriggerSession(session, ioHandle, device);
806}
807
808status_t AudioPolicyService::releaseSoundTriggerSession(audio_session_t session)
809{
Andy Hungf759b8c2017-08-15 12:48:54 -0700810 Mutex::Autolock _l(mLock);
Eric Laurentdf3dc7e2014-07-27 18:39:40 -0700811 if (mAudioPolicyManager == NULL) {
812 return NO_INIT;
813 }
Eric Laurent10b71232018-04-13 18:14:44 -0700814 AutoCallerClear acc;
Eric Laurentdf3dc7e2014-07-27 18:39:40 -0700815 return mAudioPolicyManager->releaseSoundTriggerSession(session);
816}
817
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700818status_t AudioPolicyService::registerPolicyMixes(const Vector<AudioMix>& mixes, bool registration)
Eric Laurentbaac1832014-12-01 17:52:59 -0800819{
820 Mutex::Autolock _l(mLock);
821 if(!modifyAudioRoutingAllowed()) {
822 return PERMISSION_DENIED;
823 }
824 if (mAudioPolicyManager == NULL) {
825 return NO_INIT;
826 }
Eric Laurent10b71232018-04-13 18:14:44 -0700827 AutoCallerClear acc;
Eric Laurentbaac1832014-12-01 17:52:59 -0800828 if (registration) {
829 return mAudioPolicyManager->registerPolicyMixes(mixes);
830 } else {
831 return mAudioPolicyManager->unregisterPolicyMixes(mixes);
832 }
833}
834
Eric Laurent554a2772015-04-10 11:29:24 -0700835status_t AudioPolicyService::startAudioSource(const struct audio_port_config *source,
836 const audio_attributes_t *attributes,
Glenn Kasten559d4392016-03-29 13:42:57 -0700837 audio_patch_handle_t *handle)
Eric Laurent554a2772015-04-10 11:29:24 -0700838{
839 Mutex::Autolock _l(mLock);
840 if (mAudioPolicyManager == NULL) {
841 return NO_INIT;
842 }
Eric Laurent10b71232018-04-13 18:14:44 -0700843 AutoCallerClear acc;
Eric Laurentd60560a2015-04-10 11:31:20 -0700844 return mAudioPolicyManager->startAudioSource(source, attributes, handle,
845 IPCThreadState::self()->getCallingUid());
Eric Laurent554a2772015-04-10 11:29:24 -0700846}
847
Glenn Kasten559d4392016-03-29 13:42:57 -0700848status_t AudioPolicyService::stopAudioSource(audio_patch_handle_t handle)
Eric Laurent554a2772015-04-10 11:29:24 -0700849{
850 Mutex::Autolock _l(mLock);
851 if (mAudioPolicyManager == NULL) {
852 return NO_INIT;
853 }
Eric Laurent10b71232018-04-13 18:14:44 -0700854 AutoCallerClear acc;
Eric Laurent554a2772015-04-10 11:29:24 -0700855 return mAudioPolicyManager->stopAudioSource(handle);
856}
857
Andy Hung2ddee192015-12-18 17:34:44 -0800858status_t AudioPolicyService::setMasterMono(bool mono)
859{
860 if (mAudioPolicyManager == NULL) {
861 return NO_INIT;
862 }
863 if (!settingsAllowed()) {
864 return PERMISSION_DENIED;
865 }
866 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700867 AutoCallerClear acc;
Andy Hung2ddee192015-12-18 17:34:44 -0800868 return mAudioPolicyManager->setMasterMono(mono);
869}
870
871status_t AudioPolicyService::getMasterMono(bool *mono)
872{
873 if (mAudioPolicyManager == NULL) {
874 return NO_INIT;
875 }
876 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700877 AutoCallerClear acc;
Andy Hung2ddee192015-12-18 17:34:44 -0800878 return mAudioPolicyManager->getMasterMono(mono);
879}
880
Eric Laurentac9cef52017-06-09 15:46:26 -0700881
882float AudioPolicyService::getStreamVolumeDB(
883 audio_stream_type_t stream, int index, audio_devices_t device)
884{
885 if (mAudioPolicyManager == NULL) {
886 return NAN;
887 }
888 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700889 AutoCallerClear acc;
Eric Laurentac9cef52017-06-09 15:46:26 -0700890 return mAudioPolicyManager->getStreamVolumeDB(stream, index, device);
891}
892
893
Mikhail Naganov1b2a7942017-12-08 10:18:09 -0800894} // namespace android