blob: 538e51e71447c551d0901c4e1dade4c9250b8dfe [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>
24#include <utils/Log.h>
Eric Laurent2d388ec2014-03-07 13:25:54 -080025
Eric Laurent2d388ec2014-03-07 13:25:54 -080026namespace android {
27
28
29// ----------------------------------------------------------------------------
30
31status_t AudioPolicyService::setDeviceConnectionState(audio_devices_t device,
32 audio_policy_dev_state_t state,
Paul McLeane743a472015-01-28 11:07:31 -080033 const char *device_address,
Aniket Kumar Lata4e464702019-01-10 23:38:46 -080034 const char *device_name,
35 audio_format_t encodedFormat)
Eric Laurent2d388ec2014-03-07 13:25:54 -080036{
Eric Laurentdce54a12014-03-10 12:19:46 -070037 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -080038 return NO_INIT;
39 }
40 if (!settingsAllowed()) {
41 return PERMISSION_DENIED;
42 }
Eric Laurent2d388ec2014-03-07 13:25:54 -080043 if (state != AUDIO_POLICY_DEVICE_STATE_AVAILABLE &&
44 state != AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE) {
45 return BAD_VALUE;
46 }
47
48 ALOGV("setDeviceConnectionState()");
49 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -070050 AutoCallerClear acc;
Paul McLeane743a472015-01-28 11:07:31 -080051 return mAudioPolicyManager->setDeviceConnectionState(device, state,
Aniket Kumar Lata4e464702019-01-10 23:38:46 -080052 device_address, device_name, encodedFormat);
Eric Laurent2d388ec2014-03-07 13:25:54 -080053}
54
55audio_policy_dev_state_t AudioPolicyService::getDeviceConnectionState(
56 audio_devices_t device,
57 const char *device_address)
58{
Eric Laurentdce54a12014-03-10 12:19:46 -070059 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -080060 return AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE;
61 }
Eric Laurent10b71232018-04-13 18:14:44 -070062 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -070063 return mAudioPolicyManager->getDeviceConnectionState(device,
Eric Laurent2d388ec2014-03-07 13:25:54 -080064 device_address);
65}
66
Pavlin Radoslavovf862bc62016-12-26 18:57:22 -080067status_t AudioPolicyService::handleDeviceConfigChange(audio_devices_t device,
68 const char *device_address,
Aniket Kumar Lata4e464702019-01-10 23:38:46 -080069 const char *device_name,
70 audio_format_t encodedFormat)
Pavlin Radoslavovf862bc62016-12-26 18:57:22 -080071{
72 if (mAudioPolicyManager == NULL) {
73 return NO_INIT;
74 }
75 if (!settingsAllowed()) {
76 return PERMISSION_DENIED;
77 }
Pavlin Radoslavovf862bc62016-12-26 18:57:22 -080078
79 ALOGV("handleDeviceConfigChange()");
80 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -070081 AutoCallerClear acc;
Pavlin Radoslavovf862bc62016-12-26 18:57:22 -080082 return mAudioPolicyManager->handleDeviceConfigChange(device, device_address,
Aniket Kumar Lata4e464702019-01-10 23:38:46 -080083 device_name, encodedFormat);
Pavlin Radoslavovf862bc62016-12-26 18:57:22 -080084}
85
Eric Laurent2d388ec2014-03-07 13:25:54 -080086status_t AudioPolicyService::setPhoneState(audio_mode_t state)
87{
Eric Laurentdce54a12014-03-10 12:19:46 -070088 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -080089 return NO_INIT;
90 }
91 if (!settingsAllowed()) {
92 return PERMISSION_DENIED;
93 }
94 if (uint32_t(state) >= AUDIO_MODE_CNT) {
95 return BAD_VALUE;
96 }
97
98 ALOGV("setPhoneState()");
99
Eric Laurentbeb07fe2015-09-16 15:49:30 -0700100 // acquire lock before calling setMode() so that setMode() + setPhoneState() are an atomic
101 // operation from policy manager standpoint (no other operation (e.g track start or stop)
102 // can be interleaved).
103 Mutex::Autolock _l(mLock);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800104 // TODO: check if it is more appropriate to do it in platform specific policy manager
105 AudioSystem::setMode(state);
106
Eric Laurent10b71232018-04-13 18:14:44 -0700107 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700108 mAudioPolicyManager->setPhoneState(state);
Eric Laurentbb6c9a02014-09-25 14:11:47 -0700109 mPhoneState = state;
Eric Laurent2d388ec2014-03-07 13:25:54 -0800110 return NO_ERROR;
111}
112
Eric Laurentbb6c9a02014-09-25 14:11:47 -0700113audio_mode_t AudioPolicyService::getPhoneState()
114{
115 Mutex::Autolock _l(mLock);
116 return mPhoneState;
117}
118
Eric Laurent2d388ec2014-03-07 13:25:54 -0800119status_t AudioPolicyService::setForceUse(audio_policy_force_use_t usage,
120 audio_policy_forced_cfg_t config)
121{
Eric Laurentdce54a12014-03-10 12:19:46 -0700122 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800123 return NO_INIT;
124 }
Eric Laurente17378d2018-05-09 14:43:01 -0700125
126 if (!modifyAudioRoutingAllowed()) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800127 return PERMISSION_DENIED;
128 }
Eric Laurente17378d2018-05-09 14:43:01 -0700129
Eric Laurent2d388ec2014-03-07 13:25:54 -0800130 if (usage < 0 || usage >= AUDIO_POLICY_FORCE_USE_CNT) {
131 return BAD_VALUE;
132 }
133 if (config < 0 || config >= AUDIO_POLICY_FORCE_CFG_CNT) {
134 return BAD_VALUE;
135 }
136 ALOGV("setForceUse()");
137 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700138 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700139 mAudioPolicyManager->setForceUse(usage, config);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800140 return NO_ERROR;
141}
142
143audio_policy_forced_cfg_t AudioPolicyService::getForceUse(audio_policy_force_use_t usage)
144{
Eric Laurentdce54a12014-03-10 12:19:46 -0700145 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800146 return AUDIO_POLICY_FORCE_NONE;
147 }
148 if (usage < 0 || usage >= AUDIO_POLICY_FORCE_USE_CNT) {
149 return AUDIO_POLICY_FORCE_NONE;
150 }
Eric Laurent10b71232018-04-13 18:14:44 -0700151 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700152 return mAudioPolicyManager->getForceUse(usage);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800153}
154
Eric Laurentf4e63452017-11-06 19:31:46 +0000155audio_io_handle_t AudioPolicyService::getOutput(audio_stream_type_t stream)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800156{
Eric Laurent223fd5c2014-11-11 13:43:36 -0800157 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
Eric Laurentb1322c72014-10-30 14:59:13 -0700158 return AUDIO_IO_HANDLE_NONE;
Eric Laurentdea15412014-10-28 15:46:45 -0700159 }
Eric Laurentdce54a12014-03-10 12:19:46 -0700160 if (mAudioPolicyManager == NULL) {
Eric Laurentb1322c72014-10-30 14:59:13 -0700161 return AUDIO_IO_HANDLE_NONE;
Eric Laurent2d388ec2014-03-07 13:25:54 -0800162 }
163 ALOGV("getOutput()");
164 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700165 AutoCallerClear acc;
Eric Laurentf4e63452017-11-06 19:31:46 +0000166 return mAudioPolicyManager->getOutput(stream);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800167}
168
Eric Laurente83b55d2014-11-14 10:06:21 -0800169status_t AudioPolicyService::getOutputForAttr(const audio_attributes_t *attr,
170 audio_io_handle_t *output,
171 audio_session_t session,
172 audio_stream_type_t *stream,
Nadav Bar766fb022018-01-07 12:18:03 +0200173 pid_t pid,
Eric Laurent8c7e6da2015-04-21 17:37:00 -0700174 uid_t uid,
Eric Laurent20b9ef02016-12-05 11:03:16 -0800175 const audio_config_t *config,
Eric Laurente83b55d2014-11-14 10:06:21 -0800176 audio_output_flags_t flags,
Eric Laurent9ae8c592017-06-22 17:17:09 -0700177 audio_port_handle_t *selectedDeviceId,
Kevin Rocard153f92d2018-12-18 18:33:28 -0800178 audio_port_handle_t *portId,
179 std::vector<audio_io_handle_t> *secondaryOutputs)
Jean-Michel Trivi5bd3f382014-06-13 16:06:54 -0700180{
181 if (mAudioPolicyManager == NULL) {
Eric Laurente83b55d2014-11-14 10:06:21 -0800182 return NO_INIT;
Jean-Michel Trivi5bd3f382014-06-13 16:06:54 -0700183 }
Eric Laurentf4e63452017-11-06 19:31:46 +0000184 ALOGV("getOutputForAttr()");
Jean-Michel Trivi5bd3f382014-06-13 16:06:54 -0700185 Mutex::Autolock _l(mLock);
Eric Laurent8c7e6da2015-04-21 17:37:00 -0700186
Marco Nelissendcb346b2015-09-09 10:47:29 -0700187 const uid_t callingUid = IPCThreadState::self()->getCallingUid();
Andy Hung4ef19fa2018-05-15 19:35:29 -0700188 if (!isAudioServerOrMediaServerUid(callingUid) || uid == (uid_t)-1) {
Marco Nelissendcb346b2015-09-09 10:47:29 -0700189 ALOGW_IF(uid != (uid_t)-1 && uid != callingUid,
190 "%s uid %d tried to pass itself off as %d", __FUNCTION__, callingUid, uid);
191 uid = callingUid;
Eric Laurent8c7e6da2015-04-21 17:37:00 -0700192 }
Nadav Bar766fb022018-01-07 12:18:03 +0200193 audio_output_flags_t originalFlags = flags;
Eric Laurent10b71232018-04-13 18:14:44 -0700194 AutoCallerClear acc;
Nadav Bar766fb022018-01-07 12:18:03 +0200195 status_t result = mAudioPolicyManager->getOutputForAttr(attr, output, session, stream, uid,
Eric Laurent20b9ef02016-12-05 11:03:16 -0800196 config,
Kevin Rocard153f92d2018-12-18 18:33:28 -0800197 &flags, selectedDeviceId, portId,
198 secondaryOutputs);
Nadav Bar766fb022018-01-07 12:18:03 +0200199
200 // FIXME: Introduce a way to check for the the telephony device before opening the output
201 if ((result == NO_ERROR) &&
202 (flags & AUDIO_OUTPUT_FLAG_INCALL_MUSIC) &&
203 !modifyPhoneStateAllowed(pid, uid)) {
204 // If the app tries to play music through the telephony device and doesn't have permission
205 // the fallback to the default output device.
Eric Laurent8fc147b2018-07-22 19:13:55 -0700206 mAudioPolicyManager->releaseOutput(*portId);
Nadav Bar766fb022018-01-07 12:18:03 +0200207 flags = originalFlags;
208 *selectedDeviceId = AUDIO_PORT_HANDLE_NONE;
209 *portId = AUDIO_PORT_HANDLE_NONE;
Kevin Rocard153f92d2018-12-18 18:33:28 -0800210 secondaryOutputs->clear();
211 result = mAudioPolicyManager->getOutputForAttr(attr, output, session, stream, uid, config,
212 &flags, selectedDeviceId, portId,
213 secondaryOutputs);
Nadav Bar766fb022018-01-07 12:18:03 +0200214 }
Eric Laurentd7fe0862018-07-14 16:48:01 -0700215
216 if (result == NO_ERROR) {
217 sp <AudioPlaybackClient> client =
218 new AudioPlaybackClient(*attr, *output, uid, pid, session, *selectedDeviceId, *stream);
219 mAudioPlaybackClients.add(*portId, client);
220 }
Nadav Bar766fb022018-01-07 12:18:03 +0200221 return result;
Jean-Michel Trivi5bd3f382014-06-13 16:06:54 -0700222}
223
Eric Laurentd7fe0862018-07-14 16:48:01 -0700224status_t AudioPolicyService::startOutput(audio_port_handle_t portId)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800225{
Eric Laurentdce54a12014-03-10 12:19:46 -0700226 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800227 return NO_INIT;
228 }
229 ALOGV("startOutput()");
Eric Laurentd7fe0862018-07-14 16:48:01 -0700230 sp<AudioPlaybackClient> client;
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700231 sp<AudioPolicyEffects>audioPolicyEffects;
232 {
233 Mutex::Autolock _l(mLock);
Eric Laurentd7fe0862018-07-14 16:48:01 -0700234 const ssize_t index = mAudioPlaybackClients.indexOfKey(portId);
235 if (index < 0) {
236 ALOGE("%s AudioTrack client not found for portId %d", __FUNCTION__, portId);
237 return INVALID_OPERATION;
238 }
239 client = mAudioPlaybackClients.valueAt(index);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700240 audioPolicyEffects = mAudioPolicyEffects;
bryant_liuba2b4392014-06-11 16:49:30 +0800241 }
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700242 if (audioPolicyEffects != 0) {
243 // create audio processors according to stream
Eric Laurentd7fe0862018-07-14 16:48:01 -0700244 status_t status = audioPolicyEffects->addOutputSessionEffects(
245 client->io, client->stream, client->session);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700246 if (status != NO_ERROR && status != ALREADY_EXISTS) {
Eric Laurentd7fe0862018-07-14 16:48:01 -0700247 ALOGW("Failed to add effects on session %d", client->session);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700248 }
249 }
250 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700251 AutoCallerClear acc;
Eric Laurent8fc147b2018-07-22 19:13:55 -0700252 status_t status = mAudioPolicyManager->startOutput(portId);
Eric Laurentd7fe0862018-07-14 16:48:01 -0700253 if (status == NO_ERROR) {
254 client->active = true;
255 }
256 return status;
Eric Laurent2d388ec2014-03-07 13:25:54 -0800257}
258
Eric Laurentd7fe0862018-07-14 16:48:01 -0700259status_t AudioPolicyService::stopOutput(audio_port_handle_t portId)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800260{
Eric Laurentdce54a12014-03-10 12:19:46 -0700261 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800262 return NO_INIT;
263 }
264 ALOGV("stopOutput()");
Eric Laurentd7fe0862018-07-14 16:48:01 -0700265 mOutputCommandThread->stopOutputCommand(portId);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800266 return NO_ERROR;
267}
268
Eric Laurentd7fe0862018-07-14 16:48:01 -0700269status_t AudioPolicyService::doStopOutput(audio_port_handle_t portId)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800270{
Eric Laurentd7fe0862018-07-14 16:48:01 -0700271 ALOGV("doStopOutput");
272 sp<AudioPlaybackClient> client;
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700273 sp<AudioPolicyEffects>audioPolicyEffects;
274 {
275 Mutex::Autolock _l(mLock);
Eric Laurentd7fe0862018-07-14 16:48:01 -0700276
277 const ssize_t index = mAudioPlaybackClients.indexOfKey(portId);
278 if (index < 0) {
279 ALOGE("%s AudioTrack client not found for portId %d", __FUNCTION__, portId);
280 return INVALID_OPERATION;
281 }
282 client = mAudioPlaybackClients.valueAt(index);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700283 audioPolicyEffects = mAudioPolicyEffects;
bryant_liuba2b4392014-06-11 16:49:30 +0800284 }
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700285 if (audioPolicyEffects != 0) {
286 // release audio processors from the stream
Eric Laurentd7fe0862018-07-14 16:48:01 -0700287 status_t status = audioPolicyEffects->releaseOutputSessionEffects(
288 client->io, client->stream, client->session);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700289 if (status != NO_ERROR && status != ALREADY_EXISTS) {
Eric Laurentd7fe0862018-07-14 16:48:01 -0700290 ALOGW("Failed to release effects on session %d", client->session);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700291 }
292 }
293 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700294 AutoCallerClear acc;
Eric Laurent8fc147b2018-07-22 19:13:55 -0700295 status_t status = mAudioPolicyManager->stopOutput(portId);
Eric Laurentd7fe0862018-07-14 16:48:01 -0700296 if (status == NO_ERROR) {
297 client->active = false;
298 }
299 return status;
Eric Laurent2d388ec2014-03-07 13:25:54 -0800300}
301
Eric Laurentd7fe0862018-07-14 16:48:01 -0700302void AudioPolicyService::releaseOutput(audio_port_handle_t portId)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800303{
Eric Laurentdce54a12014-03-10 12:19:46 -0700304 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800305 return;
306 }
307 ALOGV("releaseOutput()");
Eric Laurentd7fe0862018-07-14 16:48:01 -0700308 mOutputCommandThread->releaseOutputCommand(portId);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800309}
310
Eric Laurentd7fe0862018-07-14 16:48:01 -0700311void AudioPolicyService::doReleaseOutput(audio_port_handle_t portId)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800312{
313 ALOGV("doReleaseOutput from tid %d", gettid());
314 Mutex::Autolock _l(mLock);
Eric Laurentd7fe0862018-07-14 16:48:01 -0700315 const ssize_t index = mAudioPlaybackClients.indexOfKey(portId);
316 if (index < 0) {
317 ALOGE("%s AudioTrack client not found for portId %d", __FUNCTION__, portId);
318 return;
319 }
320 sp<AudioPlaybackClient> client = mAudioPlaybackClients.valueAt(index);
321 mAudioRecordClients.removeItem(portId);
322
Eric Laurent10b71232018-04-13 18:14:44 -0700323 // called from internal thread: no need to clear caller identity
Eric Laurent8fc147b2018-07-22 19:13:55 -0700324 mAudioPolicyManager->releaseOutput(portId);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800325}
326
Eric Laurentcaf7f482014-11-25 17:50:47 -0800327status_t AudioPolicyService::getInputForAttr(const audio_attributes_t *attr,
328 audio_io_handle_t *input,
329 audio_session_t session,
Eric Laurentb2379ba2016-05-23 17:42:12 -0700330 pid_t pid,
Eric Laurent8c7e6da2015-04-21 17:37:00 -0700331 uid_t uid,
Eric Laurentfee19762018-01-29 18:44:13 -0800332 const String16& opPackageName,
Eric Laurent20b9ef02016-12-05 11:03:16 -0800333 const audio_config_base_t *config,
Paul McLean466dc8e2015-04-17 13:15:36 -0600334 audio_input_flags_t flags,
Eric Laurent9ae8c592017-06-22 17:17:09 -0700335 audio_port_handle_t *selectedDeviceId,
Eric Laurent20b9ef02016-12-05 11:03:16 -0800336 audio_port_handle_t *portId)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800337{
Eric Laurentdce54a12014-03-10 12:19:46 -0700338 if (mAudioPolicyManager == NULL) {
Eric Laurentcaf7f482014-11-25 17:50:47 -0800339 return NO_INIT;
Eric Laurent2d388ec2014-03-07 13:25:54 -0800340 }
Eric Laurent7dca8a82018-01-29 18:44:26 -0800341
Eric Laurent2d388ec2014-03-07 13:25:54 -0800342 // already checked by client, but double-check in case the client wrapper is bypassed
Eric Laurentae4b6ec2019-01-15 18:34:38 -0800343 if ((attr->source < AUDIO_SOURCE_DEFAULT)
344 || (attr->source >= AUDIO_SOURCE_CNT
345 && attr->source != AUDIO_SOURCE_HOTWORD
346 && attr->source != AUDIO_SOURCE_FM_TUNER
347 && attr->source != AUDIO_SOURCE_ECHO_REFERENCE)) {
Eric Laurentcaf7f482014-11-25 17:50:47 -0800348 return BAD_VALUE;
Eric Laurent2d388ec2014-03-07 13:25:54 -0800349 }
350
Eric Laurentb2379ba2016-05-23 17:42:12 -0700351 bool updatePid = (pid == -1);
Marco Nelissendcb346b2015-09-09 10:47:29 -0700352 const uid_t callingUid = IPCThreadState::self()->getCallingUid();
Andy Hung4ef19fa2018-05-15 19:35:29 -0700353 if (!isAudioServerOrMediaServerUid(callingUid)) {
Eric Laurent9f39f8d2016-05-25 12:34:48 -0700354 ALOGW_IF(uid != (uid_t)-1 && uid != callingUid,
Marco Nelissendcb346b2015-09-09 10:47:29 -0700355 "%s uid %d tried to pass itself off as %d", __FUNCTION__, callingUid, uid);
356 uid = callingUid;
Eric Laurentb2379ba2016-05-23 17:42:12 -0700357 updatePid = true;
358 }
359
360 if (updatePid) {
361 const pid_t callingPid = IPCThreadState::self()->getCallingPid();
Eric Laurent9f39f8d2016-05-25 12:34:48 -0700362 ALOGW_IF(pid != (pid_t)-1 && pid != callingPid,
Eric Laurentb2379ba2016-05-23 17:42:12 -0700363 "%s uid %d pid %d tried to pass itself off as pid %d",
364 __func__, callingUid, callingPid, pid);
365 pid = callingPid;
Eric Laurent8c7e6da2015-04-21 17:37:00 -0700366 }
367
Eric Laurent7dca8a82018-01-29 18:44:26 -0800368 // check calling permissions
369 if (!recordingAllowed(opPackageName, pid, uid)) {
370 ALOGE("%s permission denied: recording not allowed for uid %d pid %d",
371 __func__, uid, pid);
372 return PERMISSION_DENIED;
373 }
374
Nadav Bar744be482018-05-08 13:26:21 +0300375 if ((attr->source == AUDIO_SOURCE_VOICE_UPLINK ||
376 attr->source == AUDIO_SOURCE_VOICE_DOWNLINK ||
Eric Laurentae4b6ec2019-01-15 18:34:38 -0800377 attr->source == AUDIO_SOURCE_VOICE_CALL ||
378 attr->source == AUDIO_SOURCE_ECHO_REFERENCE) &&
Nadav Bar744be482018-05-08 13:26:21 +0300379 !captureAudioOutputAllowed(pid, uid)) {
380 return PERMISSION_DENIED;
381 }
382
Eric Laurent7504b9e2017-08-15 18:17:26 -0700383 if ((attr->source == AUDIO_SOURCE_HOTWORD) && !captureHotwordAllowed(pid, uid)) {
384 return BAD_VALUE;
385 }
386
387 sp<AudioPolicyEffects>audioPolicyEffects;
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700388 {
Eric Laurent7504b9e2017-08-15 18:17:26 -0700389 status_t status;
390 AudioPolicyInterface::input_type_t inputType;
391
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700392 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700393 {
394 AutoCallerClear acc;
395 // the audio_in_acoustics_t parameter is ignored by get_input()
396 status = mAudioPolicyManager->getInputForAttr(attr, input, session, uid,
397 config,
398 flags, selectedDeviceId,
399 &inputType, portId);
400 }
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700401 audioPolicyEffects = mAudioPolicyEffects;
Jean-Michel Trivi97bb33f2014-12-12 16:23:43 -0800402
403 if (status == NO_ERROR) {
404 // enforce permission (if any) required for each type of input
405 switch (inputType) {
406 case AudioPolicyInterface::API_INPUT_LEGACY:
407 break;
Eric Laurent82db2692015-08-07 13:59:42 -0700408 case AudioPolicyInterface::API_INPUT_TELEPHONY_RX:
409 // FIXME: use the same permission as for remote submix for now.
Jean-Michel Trivi97bb33f2014-12-12 16:23:43 -0800410 case AudioPolicyInterface::API_INPUT_MIX_CAPTURE:
Eric Laurentb2379ba2016-05-23 17:42:12 -0700411 if (!captureAudioOutputAllowed(pid, uid)) {
Jean-Michel Trivi97bb33f2014-12-12 16:23:43 -0800412 ALOGE("getInputForAttr() permission denied: capture not allowed");
413 status = PERMISSION_DENIED;
414 }
415 break;
416 case AudioPolicyInterface::API_INPUT_MIX_EXT_POLICY_REROUTE:
417 if (!modifyAudioRoutingAllowed()) {
418 ALOGE("getInputForAttr() permission denied: modify audio routing not allowed");
419 status = PERMISSION_DENIED;
420 }
421 break;
422 case AudioPolicyInterface::API_INPUT_INVALID:
423 default:
424 LOG_ALWAYS_FATAL("getInputForAttr() encountered an invalid input type %d",
425 (int)inputType);
426 }
427 }
428
429 if (status != NO_ERROR) {
430 if (status == PERMISSION_DENIED) {
Eric Laurent10b71232018-04-13 18:14:44 -0700431 AutoCallerClear acc;
Eric Laurent8fc147b2018-07-22 19:13:55 -0700432 mAudioPolicyManager->releaseInput(*portId);
Jean-Michel Trivi97bb33f2014-12-12 16:23:43 -0800433 }
434 return status;
435 }
Eric Laurentfee19762018-01-29 18:44:13 -0800436
Eric Laurentd7fe0862018-07-14 16:48:01 -0700437 sp<AudioRecordClient> client = new AudioRecordClient(*attr, *input, uid, pid, session,
438 *selectedDeviceId, opPackageName);
Eric Laurentfee19762018-01-29 18:44:13 -0800439 mAudioRecordClients.add(*portId, client);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700440 }
Jean-Michel Trivi97bb33f2014-12-12 16:23:43 -0800441
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700442 if (audioPolicyEffects != 0) {
443 // create audio pre processors according to input source
Eric Laurentcaf7f482014-11-25 17:50:47 -0800444 status_t status = audioPolicyEffects->addInputEffects(*input, attr->source, session);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700445 if (status != NO_ERROR && status != ALREADY_EXISTS) {
Eric Laurentcaf7f482014-11-25 17:50:47 -0800446 ALOGW("Failed to add effects on input %d", *input);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700447 }
Eric Laurent2d388ec2014-03-07 13:25:54 -0800448 }
Eric Laurentcaf7f482014-11-25 17:50:47 -0800449 return NO_ERROR;
Eric Laurent2d388ec2014-03-07 13:25:54 -0800450}
451
Eric Laurent99fcae42018-05-17 16:59:18 -0700452std::string AudioPolicyService::getDeviceTypeStrForPortId(audio_port_handle_t portId) {
Eric Laurent99fcae42018-05-17 16:59:18 -0700453 struct audio_port port = {};
454 port.id = portId;
455 status_t status = mAudioPolicyManager->getAudioPort(&port);
456 if (status == NO_ERROR && port.type == AUDIO_PORT_TYPE_DEVICE) {
Andy Hung9b181952019-02-25 14:53:36 -0800457 return toString(port.ext.device.type);
Eric Laurent99fcae42018-05-17 16:59:18 -0700458 }
Andy Hung9b181952019-02-25 14:53:36 -0800459 return {};
Eric Laurent99fcae42018-05-17 16:59:18 -0700460}
461
Eric Laurent4eb58f12018-12-07 16:41:02 -0800462status_t AudioPolicyService::startInput(audio_port_handle_t portId)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800463{
Eric Laurentdce54a12014-03-10 12:19:46 -0700464 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800465 return NO_INIT;
466 }
Eric Laurent7dca8a82018-01-29 18:44:26 -0800467 sp<AudioRecordClient> client;
468 {
469 Mutex::Autolock _l(mLock);
Svet Ganovf4ddfef2018-01-16 07:37:58 -0800470
Eric Laurent7dca8a82018-01-29 18:44:26 -0800471 ssize_t index = mAudioRecordClients.indexOfKey(portId);
472 if (index < 0) {
473 return INVALID_OPERATION;
474 }
475 client = mAudioRecordClients.valueAt(index);
Eric Laurentfee19762018-01-29 18:44:13 -0800476 }
Eric Laurent7dca8a82018-01-29 18:44:26 -0800477
478 // check calling permissions
Svet Ganov6e641372018-03-02 09:21:30 -0800479 if (!startRecording(client->opPackageName, client->pid, client->uid)) {
Eric Laurent7dca8a82018-01-29 18:44:26 -0800480 ALOGE("%s permission denied: recording not allowed for uid %d pid %d",
481 __func__, client->uid, client->pid);
482 return PERMISSION_DENIED;
483 }
Eric Laurentfee19762018-01-29 18:44:13 -0800484
Eric Laurentdf628922018-12-06 21:45:51 +0000485 Mutex::Autolock _l(mLock);
Eric Laurent4eb58f12018-12-07 16:41:02 -0800486
487 client->active = true;
488 client->startTimeNs = systemTime();
489 updateUidStates_l();
Eric Laurentfee19762018-01-29 18:44:13 -0800490
Eric Laurent10b71232018-04-13 18:14:44 -0700491 status_t status;
492 {
493 AutoCallerClear acc;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800494 status = mAudioPolicyManager->startInput(portId);
Ray Essick84e84a52018-05-03 18:45:07 -0700495
496 }
497
Ray Essickf6a57cd2018-05-22 16:20:54 -0700498 // including successes gets very verbose
499 if (status != NO_ERROR) {
Ray Essick84e84a52018-05-03 18:45:07 -0700500
501 static constexpr char kAudioPolicy[] = "audiopolicy";
502
Ray Essick84e84a52018-05-03 18:45:07 -0700503 static constexpr char kAudioPolicyStatus[] = "android.media.audiopolicy.status";
504 static constexpr char kAudioPolicyRqstSrc[] = "android.media.audiopolicy.rqst.src";
505 static constexpr char kAudioPolicyRqstPkg[] = "android.media.audiopolicy.rqst.pkg";
506 static constexpr char kAudioPolicyRqstSession[] = "android.media.audiopolicy.rqst.session";
Eric Laurent99fcae42018-05-17 16:59:18 -0700507 static constexpr char kAudioPolicyRqstDevice[] =
508 "android.media.audiopolicy.rqst.device";
Ray Essick84e84a52018-05-03 18:45:07 -0700509 static constexpr char kAudioPolicyActiveSrc[] = "android.media.audiopolicy.active.src";
510 static constexpr char kAudioPolicyActivePkg[] = "android.media.audiopolicy.active.pkg";
Eric Laurent99fcae42018-05-17 16:59:18 -0700511 static constexpr char kAudioPolicyActiveSession[] =
512 "android.media.audiopolicy.active.session";
513 static constexpr char kAudioPolicyActiveDevice[] =
514 "android.media.audiopolicy.active.device";
Ray Essick84e84a52018-05-03 18:45:07 -0700515
Ray Essick6a305222019-01-28 20:33:18 -0800516 MediaAnalyticsItem *item = MediaAnalyticsItem::create(kAudioPolicy);
Ray Essick84e84a52018-05-03 18:45:07 -0700517 if (item != NULL) {
518
Ray Essick84e84a52018-05-03 18:45:07 -0700519 item->setInt32(kAudioPolicyStatus, status);
520
Eric Laurent99fcae42018-05-17 16:59:18 -0700521 item->setCString(kAudioPolicyRqstSrc,
Andy Hung9b181952019-02-25 14:53:36 -0800522 toString(client->attributes.source).c_str());
Ray Essick84e84a52018-05-03 18:45:07 -0700523 item->setInt32(kAudioPolicyRqstSession, client->session);
Ray Essick51866952018-05-30 11:22:27 -0700524 if (client->opPackageName.size() != 0) {
525 item->setCString(kAudioPolicyRqstPkg,
526 std::string(String8(client->opPackageName).string()).c_str());
527 } else {
Kevin Rocardfbdfebe2018-06-18 12:30:40 -0700528 item->setCString(kAudioPolicyRqstPkg, std::to_string(client->uid).c_str());
Ray Essick51866952018-05-30 11:22:27 -0700529 }
Eric Laurent99fcae42018-05-17 16:59:18 -0700530 item->setCString(
531 kAudioPolicyRqstDevice, getDeviceTypeStrForPortId(client->deviceId).c_str());
532
Eric Laurent4eb58f12018-12-07 16:41:02 -0800533 int count = mAudioRecordClients.size();
534 for (int i = 0; i < count ; i++) {
535 if (portId == mAudioRecordClients.keyAt(i)) {
536 continue;
537 }
538 sp<AudioRecordClient> other = mAudioRecordClients.valueAt(i);
539 if (other->active) {
540 // keeps the last of the clients marked active
541 item->setCString(kAudioPolicyActiveSrc,
Andy Hung9b181952019-02-25 14:53:36 -0800542 toString(other->attributes.source).c_str());
Eric Laurent4eb58f12018-12-07 16:41:02 -0800543 item->setInt32(kAudioPolicyActiveSession, other->session);
544 if (other->opPackageName.size() != 0) {
545 item->setCString(kAudioPolicyActivePkg,
546 std::string(String8(other->opPackageName).string()).c_str());
547 } else {
548 item->setCString(kAudioPolicyRqstPkg,
549 std::to_string(other->uid).c_str());
Ray Essick84e84a52018-05-03 18:45:07 -0700550 }
Eric Laurent4eb58f12018-12-07 16:41:02 -0800551 item->setCString(kAudioPolicyActiveDevice,
552 getDeviceTypeStrForPortId(other->deviceId).c_str());
Ray Essick84e84a52018-05-03 18:45:07 -0700553 }
554 }
555 item->selfrecord();
556 delete item;
557 item = NULL;
558 }
Eric Laurent4eb58f12018-12-07 16:41:02 -0800559 client->active = false;
560 client->startTimeNs = 0;
561 updateUidStates_l();
Svet Ganov6e641372018-03-02 09:21:30 -0800562 finishRecording(client->opPackageName, client->uid);
Eric Laurentfb66dd92016-01-28 18:32:03 -0800563 }
564
565 return status;
Eric Laurent2d388ec2014-03-07 13:25:54 -0800566}
567
Eric Laurentfee19762018-01-29 18:44:13 -0800568status_t AudioPolicyService::stopInput(audio_port_handle_t portId)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800569{
Eric Laurentdce54a12014-03-10 12:19:46 -0700570 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800571 return NO_INIT;
572 }
Eric Laurent4eb58f12018-12-07 16:41:02 -0800573
Eric Laurent2d388ec2014-03-07 13:25:54 -0800574 Mutex::Autolock _l(mLock);
575
Eric Laurentfee19762018-01-29 18:44:13 -0800576 ssize_t index = mAudioRecordClients.indexOfKey(portId);
577 if (index < 0) {
578 return INVALID_OPERATION;
579 }
580 sp<AudioRecordClient> client = mAudioRecordClients.valueAt(index);
581
Ray Essick84e84a52018-05-03 18:45:07 -0700582 client->active = false;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800583 client->startTimeNs = 0;
584
585 updateUidStates_l();
Ray Essick84e84a52018-05-03 18:45:07 -0700586
Svet Ganov6e641372018-03-02 09:21:30 -0800587 // finish the recording app op
588 finishRecording(client->opPackageName, client->uid);
Eric Laurent10b71232018-04-13 18:14:44 -0700589 AutoCallerClear acc;
Eric Laurent8fc147b2018-07-22 19:13:55 -0700590 return mAudioPolicyManager->stopInput(portId);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800591}
592
Eric Laurentfee19762018-01-29 18:44:13 -0800593void AudioPolicyService::releaseInput(audio_port_handle_t portId)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800594{
Eric Laurentdce54a12014-03-10 12:19:46 -0700595 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800596 return;
597 }
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700598 sp<AudioPolicyEffects>audioPolicyEffects;
Eric Laurentfee19762018-01-29 18:44:13 -0800599 sp<AudioRecordClient> client;
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700600 {
601 Mutex::Autolock _l(mLock);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700602 audioPolicyEffects = mAudioPolicyEffects;
Eric Laurentfee19762018-01-29 18:44:13 -0800603 ssize_t index = mAudioRecordClients.indexOfKey(portId);
604 if (index < 0) {
605 return;
606 }
607 client = mAudioRecordClients.valueAt(index);
Eric Laurent4eb58f12018-12-07 16:41:02 -0800608
609 if (client->active) {
610 ALOGW("%s releasing active client portId %d", __FUNCTION__, portId);
611 client->active = false;
612 client->startTimeNs = 0;
613 updateUidStates_l();
614 }
615
Eric Laurentfee19762018-01-29 18:44:13 -0800616 mAudioRecordClients.removeItem(portId);
617 }
618 if (client == 0) {
619 return;
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700620 }
621 if (audioPolicyEffects != 0) {
622 // release audio processors from the input
Eric Laurentd7fe0862018-07-14 16:48:01 -0700623 status_t status = audioPolicyEffects->releaseInputEffects(client->io, client->session);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700624 if(status != NO_ERROR) {
Eric Laurentd7fe0862018-07-14 16:48:01 -0700625 ALOGW("Failed to release effects on input %d", client->io);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700626 }
Eric Laurent2d388ec2014-03-07 13:25:54 -0800627 }
Eric Laurentf10c7092016-12-06 17:09:56 -0800628 {
629 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700630 AutoCallerClear acc;
Eric Laurent8fc147b2018-07-22 19:13:55 -0700631 mAudioPolicyManager->releaseInput(portId);
Eric Laurentf10c7092016-12-06 17:09:56 -0800632 }
Eric Laurent2d388ec2014-03-07 13:25:54 -0800633}
634
635status_t AudioPolicyService::initStreamVolume(audio_stream_type_t stream,
636 int indexMin,
637 int indexMax)
638{
Eric Laurentdce54a12014-03-10 12:19:46 -0700639 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800640 return NO_INIT;
641 }
642 if (!settingsAllowed()) {
643 return PERMISSION_DENIED;
644 }
Eric Laurent223fd5c2014-11-11 13:43:36 -0800645 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800646 return BAD_VALUE;
647 }
648 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700649 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700650 mAudioPolicyManager->initStreamVolume(stream, indexMin, indexMax);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800651 return NO_ERROR;
652}
653
654status_t AudioPolicyService::setStreamVolumeIndex(audio_stream_type_t stream,
655 int index,
656 audio_devices_t device)
657{
Eric Laurentdce54a12014-03-10 12:19:46 -0700658 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800659 return NO_INIT;
660 }
661 if (!settingsAllowed()) {
662 return PERMISSION_DENIED;
663 }
Eric Laurent223fd5c2014-11-11 13:43:36 -0800664 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800665 return BAD_VALUE;
666 }
667 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700668 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700669 return mAudioPolicyManager->setStreamVolumeIndex(stream,
670 index,
671 device);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800672}
673
674status_t AudioPolicyService::getStreamVolumeIndex(audio_stream_type_t stream,
675 int *index,
676 audio_devices_t device)
677{
Eric Laurentdce54a12014-03-10 12:19:46 -0700678 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800679 return NO_INIT;
680 }
Eric Laurent223fd5c2014-11-11 13:43:36 -0800681 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800682 return BAD_VALUE;
683 }
684 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700685 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700686 return mAudioPolicyManager->getStreamVolumeIndex(stream,
687 index,
688 device);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800689}
690
691uint32_t AudioPolicyService::getStrategyForStream(audio_stream_type_t stream)
692{
Eric Laurent223fd5c2014-11-11 13:43:36 -0800693 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
François Gaffiec005e562018-11-06 15:04:49 +0100694 return PRODUCT_STRATEGY_NONE;
Eric Laurentdea15412014-10-28 15:46:45 -0700695 }
Eric Laurentdce54a12014-03-10 12:19:46 -0700696 if (mAudioPolicyManager == NULL) {
François Gaffiec005e562018-11-06 15:04:49 +0100697 return PRODUCT_STRATEGY_NONE;
Eric Laurent2d388ec2014-03-07 13:25:54 -0800698 }
François Gaffiec005e562018-11-06 15:04:49 +0100699 // DO NOT LOCK, may be called from AudioFlinger with lock held, reaching deadlock
Eric Laurent10b71232018-04-13 18:14:44 -0700700 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700701 return mAudioPolicyManager->getStrategyForStream(stream);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800702}
703
704//audio policy: use audio_device_t appropriately
705
706audio_devices_t AudioPolicyService::getDevicesForStream(audio_stream_type_t stream)
707{
Eric Laurent223fd5c2014-11-11 13:43:36 -0800708 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
Eric Laurentb1322c72014-10-30 14:59:13 -0700709 return AUDIO_DEVICE_NONE;
Eric Laurentdea15412014-10-28 15:46:45 -0700710 }
Eric Laurentdce54a12014-03-10 12:19:46 -0700711 if (mAudioPolicyManager == NULL) {
Eric Laurentb1322c72014-10-30 14:59:13 -0700712 return AUDIO_DEVICE_NONE;
Eric Laurent2d388ec2014-03-07 13:25:54 -0800713 }
Haynes Mathew Georgedfb9f3b2015-10-26 18:22:13 -0700714 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700715 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700716 return mAudioPolicyManager->getDevicesForStream(stream);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800717}
718
719audio_io_handle_t AudioPolicyService::getOutputForEffect(const effect_descriptor_t *desc)
720{
721 // FIXME change return type to status_t, and return NO_INIT here
Eric Laurentdce54a12014-03-10 12:19:46 -0700722 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800723 return 0;
724 }
725 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700726 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700727 return mAudioPolicyManager->getOutputForEffect(desc);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800728}
729
730status_t AudioPolicyService::registerEffect(const effect_descriptor_t *desc,
731 audio_io_handle_t io,
732 uint32_t strategy,
Glenn Kastend848eb42016-03-08 13:42:11 -0800733 audio_session_t session,
Eric Laurent2d388ec2014-03-07 13:25:54 -0800734 int id)
735{
Eric Laurentdce54a12014-03-10 12:19:46 -0700736 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800737 return NO_INIT;
738 }
Haynes Mathew Georgebab7bf42015-10-30 18:02:23 -0700739 Mutex::Autolock _l(mEffectsLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700740 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700741 return mAudioPolicyManager->registerEffect(desc, io, strategy, session, id);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800742}
743
744status_t AudioPolicyService::unregisterEffect(int id)
745{
Eric Laurentdce54a12014-03-10 12:19:46 -0700746 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800747 return NO_INIT;
748 }
Haynes Mathew Georgebab7bf42015-10-30 18:02:23 -0700749 Mutex::Autolock _l(mEffectsLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700750 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700751 return mAudioPolicyManager->unregisterEffect(id);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800752}
753
754status_t AudioPolicyService::setEffectEnabled(int id, bool enabled)
755{
Eric Laurentdce54a12014-03-10 12:19:46 -0700756 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800757 return NO_INIT;
758 }
Haynes Mathew Georgebab7bf42015-10-30 18:02:23 -0700759 Mutex::Autolock _l(mEffectsLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700760 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700761 return mAudioPolicyManager->setEffectEnabled(id, enabled);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800762}
763
764bool AudioPolicyService::isStreamActive(audio_stream_type_t stream, uint32_t inPastMs) const
765{
Eric Laurent223fd5c2014-11-11 13:43:36 -0800766 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
Eric Laurentb1322c72014-10-30 14:59:13 -0700767 return false;
Eric Laurentdea15412014-10-28 15:46:45 -0700768 }
Eric Laurentdce54a12014-03-10 12:19:46 -0700769 if (mAudioPolicyManager == NULL) {
Eric Laurentb1322c72014-10-30 14:59:13 -0700770 return false;
Eric Laurent2d388ec2014-03-07 13:25:54 -0800771 }
772 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700773 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700774 return mAudioPolicyManager->isStreamActive(stream, inPastMs);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800775}
776
777bool AudioPolicyService::isStreamActiveRemotely(audio_stream_type_t stream, uint32_t inPastMs) const
778{
Eric Laurent223fd5c2014-11-11 13:43:36 -0800779 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
Eric Laurentb1322c72014-10-30 14:59:13 -0700780 return false;
Eric Laurentdea15412014-10-28 15:46:45 -0700781 }
Eric Laurentdce54a12014-03-10 12:19:46 -0700782 if (mAudioPolicyManager == NULL) {
Eric Laurentb1322c72014-10-30 14:59:13 -0700783 return false;
Eric Laurent2d388ec2014-03-07 13:25:54 -0800784 }
785 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700786 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700787 return mAudioPolicyManager->isStreamActiveRemotely(stream, inPastMs);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800788}
789
790bool AudioPolicyService::isSourceActive(audio_source_t source) const
791{
Eric Laurentdce54a12014-03-10 12:19:46 -0700792 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800793 return false;
794 }
795 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700796 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700797 return mAudioPolicyManager->isSourceActive(source);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800798}
799
Ari Hausman-Cohen24628312018-08-13 15:01:09 -0700800status_t AudioPolicyService::getAudioPolicyEffects(sp<AudioPolicyEffects>& audioPolicyEffects)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800801{
Eric Laurentdce54a12014-03-10 12:19:46 -0700802 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800803 return NO_INIT;
804 }
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700805 {
806 Mutex::Autolock _l(mLock);
807 audioPolicyEffects = mAudioPolicyEffects;
808 }
809 if (audioPolicyEffects == 0) {
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700810 return NO_INIT;
811 }
Ari Hausman-Cohen24628312018-08-13 15:01:09 -0700812
813 return OK;
814}
815
816status_t AudioPolicyService::queryDefaultPreProcessing(audio_session_t audioSession,
817 effect_descriptor_t *descriptors,
818 uint32_t *count)
819{
820 sp<AudioPolicyEffects>audioPolicyEffects;
821 status_t status = getAudioPolicyEffects(audioPolicyEffects);
822 if (status != OK) {
823 *count = 0;
824 return status;
825 }
Eric Laurentfb66dd92016-01-28 18:32:03 -0800826 return audioPolicyEffects->queryDefaultInputEffects(
827 (audio_session_t)audioSession, descriptors, count);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800828}
829
Ari Hausman-Cohen24628312018-08-13 15:01:09 -0700830status_t AudioPolicyService::addSourceDefaultEffect(const effect_uuid_t *type,
831 const String16& opPackageName,
832 const effect_uuid_t *uuid,
833 int32_t priority,
834 audio_source_t source,
835 audio_unique_id_t* id)
836{
837 sp<AudioPolicyEffects>audioPolicyEffects;
838 status_t status = getAudioPolicyEffects(audioPolicyEffects);
839 if (status != OK) {
840 return status;
841 }
842 if (!modifyDefaultAudioEffectsAllowed()) {
843 return PERMISSION_DENIED;
844 }
845 return audioPolicyEffects->addSourceDefaultEffect(
846 type, opPackageName, uuid, priority, source, id);
847}
848
Ari Hausman-Cohen433722e2018-04-24 14:25:22 -0700849status_t AudioPolicyService::addStreamDefaultEffect(const effect_uuid_t *type,
850 const String16& opPackageName,
851 const effect_uuid_t *uuid,
852 int32_t priority,
853 audio_usage_t usage,
854 audio_unique_id_t* id)
855{
Ari Hausman-Cohen24628312018-08-13 15:01:09 -0700856 sp<AudioPolicyEffects>audioPolicyEffects;
857 status_t status = getAudioPolicyEffects(audioPolicyEffects);
858 if (status != OK) {
859 return status;
Ari Hausman-Cohen433722e2018-04-24 14:25:22 -0700860 }
861 if (!modifyDefaultAudioEffectsAllowed()) {
862 return PERMISSION_DENIED;
863 }
Ari Hausman-Cohen433722e2018-04-24 14:25:22 -0700864 return audioPolicyEffects->addStreamDefaultEffect(
865 type, opPackageName, uuid, priority, usage, id);
866}
867
Ari Hausman-Cohen24628312018-08-13 15:01:09 -0700868status_t AudioPolicyService::removeSourceDefaultEffect(audio_unique_id_t id)
Ari Hausman-Cohen433722e2018-04-24 14:25:22 -0700869{
Ari Hausman-Cohen24628312018-08-13 15:01:09 -0700870 sp<AudioPolicyEffects>audioPolicyEffects;
871 status_t status = getAudioPolicyEffects(audioPolicyEffects);
872 if (status != OK) {
873 return status;
Ari Hausman-Cohen433722e2018-04-24 14:25:22 -0700874 }
875 if (!modifyDefaultAudioEffectsAllowed()) {
876 return PERMISSION_DENIED;
877 }
Ari Hausman-Cohen24628312018-08-13 15:01:09 -0700878 return audioPolicyEffects->removeSourceDefaultEffect(id);
879}
880
881status_t AudioPolicyService::removeStreamDefaultEffect(audio_unique_id_t id)
882{
Ari Hausman-Cohen433722e2018-04-24 14:25:22 -0700883 sp<AudioPolicyEffects>audioPolicyEffects;
Ari Hausman-Cohen24628312018-08-13 15:01:09 -0700884 status_t status = getAudioPolicyEffects(audioPolicyEffects);
885 if (status != OK) {
886 return status;
Ari Hausman-Cohen433722e2018-04-24 14:25:22 -0700887 }
Ari Hausman-Cohen24628312018-08-13 15:01:09 -0700888 if (!modifyDefaultAudioEffectsAllowed()) {
889 return PERMISSION_DENIED;
Ari Hausman-Cohen433722e2018-04-24 14:25:22 -0700890 }
891 return audioPolicyEffects->removeStreamDefaultEffect(id);
892}
893
Eric Laurent2d388ec2014-03-07 13:25:54 -0800894bool AudioPolicyService::isOffloadSupported(const audio_offload_info_t& info)
895{
Eric Laurentdce54a12014-03-10 12:19:46 -0700896 if (mAudioPolicyManager == NULL) {
897 ALOGV("mAudioPolicyManager == NULL");
Eric Laurent2d388ec2014-03-07 13:25:54 -0800898 return false;
899 }
Andy Hung2ddee192015-12-18 17:34:44 -0800900 Mutex::Autolock _l(mLock);
Haynes Mathew Georgebab7bf42015-10-30 18:02:23 -0700901 Mutex::Autolock _le(mEffectsLock); // isOffloadSupported queries for
902 // non-offloadable effects
Eric Laurent10b71232018-04-13 18:14:44 -0700903 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700904 return mAudioPolicyManager->isOffloadSupported(info);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800905}
906
Michael Chana94fbb22018-04-24 14:31:19 +1000907bool AudioPolicyService::isDirectOutputSupported(const audio_config_base_t& config,
908 const audio_attributes_t& attributes) {
909 if (mAudioPolicyManager == NULL) {
910 ALOGV("mAudioPolicyManager == NULL");
911 return false;
912 }
913 Mutex::Autolock _l(mLock);
914 return mAudioPolicyManager->isDirectOutputSupported(config, attributes);
915}
916
917
Eric Laurent6a94d692014-05-20 11:18:06 -0700918status_t AudioPolicyService::listAudioPorts(audio_port_role_t role,
919 audio_port_type_t type,
Eric Laurent203b1a12014-04-01 10:34:16 -0700920 unsigned int *num_ports,
Eric Laurent6a94d692014-05-20 11:18:06 -0700921 struct audio_port *ports,
922 unsigned int *generation)
Eric Laurent203b1a12014-04-01 10:34:16 -0700923{
Eric Laurent6a94d692014-05-20 11:18:06 -0700924 Mutex::Autolock _l(mLock);
925 if (mAudioPolicyManager == NULL) {
926 return NO_INIT;
927 }
Eric Laurent10b71232018-04-13 18:14:44 -0700928 AutoCallerClear acc;
Eric Laurent6a94d692014-05-20 11:18:06 -0700929 return mAudioPolicyManager->listAudioPorts(role, type, num_ports, ports, generation);
Eric Laurent203b1a12014-04-01 10:34:16 -0700930}
931
Eric Laurent6a94d692014-05-20 11:18:06 -0700932status_t AudioPolicyService::getAudioPort(struct audio_port *port)
Eric Laurent203b1a12014-04-01 10:34:16 -0700933{
Eric Laurent6a94d692014-05-20 11:18:06 -0700934 Mutex::Autolock _l(mLock);
935 if (mAudioPolicyManager == NULL) {
936 return NO_INIT;
937 }
Eric Laurent10b71232018-04-13 18:14:44 -0700938 AutoCallerClear acc;
Eric Laurent6a94d692014-05-20 11:18:06 -0700939 return mAudioPolicyManager->getAudioPort(port);
Eric Laurent203b1a12014-04-01 10:34:16 -0700940}
941
Eric Laurent6a94d692014-05-20 11:18:06 -0700942status_t AudioPolicyService::createAudioPatch(const struct audio_patch *patch,
943 audio_patch_handle_t *handle)
Eric Laurent203b1a12014-04-01 10:34:16 -0700944{
Eric Laurent6a94d692014-05-20 11:18:06 -0700945 Mutex::Autolock _l(mLock);
Eric Laurent5284ed52014-05-29 14:37:38 -0700946 if(!modifyAudioRoutingAllowed()) {
947 return PERMISSION_DENIED;
948 }
Eric Laurent6a94d692014-05-20 11:18:06 -0700949 if (mAudioPolicyManager == NULL) {
950 return NO_INIT;
951 }
Eric Laurent10b71232018-04-13 18:14:44 -0700952 AutoCallerClear acc;
Eric Laurent6a94d692014-05-20 11:18:06 -0700953 return mAudioPolicyManager->createAudioPatch(patch, handle,
954 IPCThreadState::self()->getCallingUid());
Eric Laurent203b1a12014-04-01 10:34:16 -0700955}
956
Eric Laurent6a94d692014-05-20 11:18:06 -0700957status_t AudioPolicyService::releaseAudioPatch(audio_patch_handle_t handle)
Eric Laurent203b1a12014-04-01 10:34:16 -0700958{
Eric Laurent6a94d692014-05-20 11:18:06 -0700959 Mutex::Autolock _l(mLock);
Eric Laurent5284ed52014-05-29 14:37:38 -0700960 if(!modifyAudioRoutingAllowed()) {
961 return PERMISSION_DENIED;
962 }
Eric Laurent6a94d692014-05-20 11:18:06 -0700963 if (mAudioPolicyManager == NULL) {
964 return NO_INIT;
965 }
Eric Laurent10b71232018-04-13 18:14:44 -0700966 AutoCallerClear acc;
Eric Laurent6a94d692014-05-20 11:18:06 -0700967 return mAudioPolicyManager->releaseAudioPatch(handle,
968 IPCThreadState::self()->getCallingUid());
Eric Laurent203b1a12014-04-01 10:34:16 -0700969}
970
971status_t AudioPolicyService::listAudioPatches(unsigned int *num_patches,
Eric Laurent6a94d692014-05-20 11:18:06 -0700972 struct audio_patch *patches,
973 unsigned int *generation)
Eric Laurent203b1a12014-04-01 10:34:16 -0700974{
Eric Laurent6a94d692014-05-20 11:18:06 -0700975 Mutex::Autolock _l(mLock);
976 if (mAudioPolicyManager == NULL) {
977 return NO_INIT;
978 }
Eric Laurent10b71232018-04-13 18:14:44 -0700979 AutoCallerClear acc;
Eric Laurent6a94d692014-05-20 11:18:06 -0700980 return mAudioPolicyManager->listAudioPatches(num_patches, patches, generation);
Eric Laurent203b1a12014-04-01 10:34:16 -0700981}
982
Eric Laurent6a94d692014-05-20 11:18:06 -0700983status_t AudioPolicyService::setAudioPortConfig(const struct audio_port_config *config)
Eric Laurent203b1a12014-04-01 10:34:16 -0700984{
Eric Laurent6a94d692014-05-20 11:18:06 -0700985 Mutex::Autolock _l(mLock);
Eric Laurent5284ed52014-05-29 14:37:38 -0700986 if(!modifyAudioRoutingAllowed()) {
987 return PERMISSION_DENIED;
988 }
Eric Laurent6a94d692014-05-20 11:18:06 -0700989 if (mAudioPolicyManager == NULL) {
990 return NO_INIT;
991 }
Eric Laurent10b71232018-04-13 18:14:44 -0700992 AutoCallerClear acc;
Eric Laurent6a94d692014-05-20 11:18:06 -0700993 return mAudioPolicyManager->setAudioPortConfig(config);
Eric Laurent203b1a12014-04-01 10:34:16 -0700994}
Eric Laurent2d388ec2014-03-07 13:25:54 -0800995
Eric Laurentdf3dc7e2014-07-27 18:39:40 -0700996status_t AudioPolicyService::acquireSoundTriggerSession(audio_session_t *session,
997 audio_io_handle_t *ioHandle,
998 audio_devices_t *device)
999{
Andy Hungf759b8c2017-08-15 12:48:54 -07001000 Mutex::Autolock _l(mLock);
Eric Laurentdf3dc7e2014-07-27 18:39:40 -07001001 if (mAudioPolicyManager == NULL) {
1002 return NO_INIT;
1003 }
Eric Laurent10b71232018-04-13 18:14:44 -07001004 AutoCallerClear acc;
Eric Laurentdf3dc7e2014-07-27 18:39:40 -07001005 return mAudioPolicyManager->acquireSoundTriggerSession(session, ioHandle, device);
1006}
1007
1008status_t AudioPolicyService::releaseSoundTriggerSession(audio_session_t session)
1009{
Andy Hungf759b8c2017-08-15 12:48:54 -07001010 Mutex::Autolock _l(mLock);
Eric Laurentdf3dc7e2014-07-27 18:39:40 -07001011 if (mAudioPolicyManager == NULL) {
1012 return NO_INIT;
1013 }
Eric Laurent10b71232018-04-13 18:14:44 -07001014 AutoCallerClear acc;
Eric Laurentdf3dc7e2014-07-27 18:39:40 -07001015 return mAudioPolicyManager->releaseSoundTriggerSession(session);
1016}
1017
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -07001018status_t AudioPolicyService::registerPolicyMixes(const Vector<AudioMix>& mixes, bool registration)
Eric Laurentbaac1832014-12-01 17:52:59 -08001019{
1020 Mutex::Autolock _l(mLock);
1021 if(!modifyAudioRoutingAllowed()) {
1022 return PERMISSION_DENIED;
1023 }
1024 if (mAudioPolicyManager == NULL) {
1025 return NO_INIT;
1026 }
Eric Laurent10b71232018-04-13 18:14:44 -07001027 AutoCallerClear acc;
Eric Laurentbaac1832014-12-01 17:52:59 -08001028 if (registration) {
1029 return mAudioPolicyManager->registerPolicyMixes(mixes);
1030 } else {
1031 return mAudioPolicyManager->unregisterPolicyMixes(mixes);
1032 }
1033}
1034
Jean-Michel Trivibda70da2018-12-19 07:30:15 -08001035status_t AudioPolicyService::setUidDeviceAffinities(uid_t uid,
1036 const Vector<AudioDeviceTypeAddr>& devices) {
1037 Mutex::Autolock _l(mLock);
1038 if(!modifyAudioRoutingAllowed()) {
1039 return PERMISSION_DENIED;
1040 }
1041 if (mAudioPolicyManager == NULL) {
1042 return NO_INIT;
1043 }
1044 AutoCallerClear acc;
1045 return mAudioPolicyManager->setUidDeviceAffinities(uid, devices);
1046}
1047
1048status_t AudioPolicyService::removeUidDeviceAffinities(uid_t uid) {
1049 Mutex::Autolock _l(mLock);
1050 if(!modifyAudioRoutingAllowed()) {
1051 return PERMISSION_DENIED;
1052 }
1053 if (mAudioPolicyManager == NULL) {
1054 return NO_INIT;
1055 }
1056 AutoCallerClear acc;
1057 return mAudioPolicyManager->removeUidDeviceAffinities(uid);
1058}
1059
Eric Laurent554a2772015-04-10 11:29:24 -07001060status_t AudioPolicyService::startAudioSource(const struct audio_port_config *source,
Eric Laurent3e6c7e12018-07-27 17:09:23 -07001061 const audio_attributes_t *attributes,
1062 audio_port_handle_t *portId)
Eric Laurent554a2772015-04-10 11:29:24 -07001063{
1064 Mutex::Autolock _l(mLock);
1065 if (mAudioPolicyManager == NULL) {
1066 return NO_INIT;
1067 }
Eric Laurent10b71232018-04-13 18:14:44 -07001068 AutoCallerClear acc;
Eric Laurent3e6c7e12018-07-27 17:09:23 -07001069 return mAudioPolicyManager->startAudioSource(source, attributes, portId,
Eric Laurentd60560a2015-04-10 11:31:20 -07001070 IPCThreadState::self()->getCallingUid());
Eric Laurent554a2772015-04-10 11:29:24 -07001071}
1072
Eric Laurent3e6c7e12018-07-27 17:09:23 -07001073status_t AudioPolicyService::stopAudioSource(audio_port_handle_t portId)
Eric Laurent554a2772015-04-10 11:29:24 -07001074{
1075 Mutex::Autolock _l(mLock);
1076 if (mAudioPolicyManager == NULL) {
1077 return NO_INIT;
1078 }
Eric Laurent10b71232018-04-13 18:14:44 -07001079 AutoCallerClear acc;
Eric Laurent3e6c7e12018-07-27 17:09:23 -07001080 return mAudioPolicyManager->stopAudioSource(portId);
Eric Laurent554a2772015-04-10 11:29:24 -07001081}
1082
Andy Hung2ddee192015-12-18 17:34:44 -08001083status_t AudioPolicyService::setMasterMono(bool mono)
1084{
1085 if (mAudioPolicyManager == NULL) {
1086 return NO_INIT;
1087 }
1088 if (!settingsAllowed()) {
1089 return PERMISSION_DENIED;
1090 }
1091 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -07001092 AutoCallerClear acc;
Andy Hung2ddee192015-12-18 17:34:44 -08001093 return mAudioPolicyManager->setMasterMono(mono);
1094}
1095
1096status_t AudioPolicyService::getMasterMono(bool *mono)
1097{
1098 if (mAudioPolicyManager == NULL) {
1099 return NO_INIT;
1100 }
1101 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -07001102 AutoCallerClear acc;
Andy Hung2ddee192015-12-18 17:34:44 -08001103 return mAudioPolicyManager->getMasterMono(mono);
1104}
1105
Eric Laurentac9cef52017-06-09 15:46:26 -07001106
1107float AudioPolicyService::getStreamVolumeDB(
1108 audio_stream_type_t stream, int index, audio_devices_t device)
1109{
1110 if (mAudioPolicyManager == NULL) {
1111 return NAN;
1112 }
1113 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -07001114 AutoCallerClear acc;
Eric Laurentac9cef52017-06-09 15:46:26 -07001115 return mAudioPolicyManager->getStreamVolumeDB(stream, index, device);
1116}
1117
jiabin81772902018-04-02 17:52:27 -07001118status_t AudioPolicyService::getSurroundFormats(unsigned int *numSurroundFormats,
1119 audio_format_t *surroundFormats,
1120 bool *surroundFormatsEnabled,
1121 bool reported)
1122{
1123 if (mAudioPolicyManager == NULL) {
1124 return NO_INIT;
1125 }
1126 Mutex::Autolock _l(mLock);
1127 AutoCallerClear acc;
1128 return mAudioPolicyManager->getSurroundFormats(numSurroundFormats, surroundFormats,
1129 surroundFormatsEnabled, reported);
1130}
1131
Arun Mirpuri11029ad2018-12-19 20:45:19 -08001132status_t AudioPolicyService::getHwOffloadEncodingFormatsSupportedForA2DP(
1133 std::vector<audio_format_t> *formats)
1134{
1135 if (mAudioPolicyManager == NULL) {
1136 return NO_INIT;
1137 }
1138 Mutex::Autolock _l(mLock);
1139 AutoCallerClear acc;
1140 return mAudioPolicyManager->getHwOffloadEncodingFormatsSupportedForA2DP(formats);
1141}
1142
jiabin81772902018-04-02 17:52:27 -07001143status_t AudioPolicyService::setSurroundFormatEnabled(audio_format_t audioFormat, bool enabled)
1144{
1145 if (mAudioPolicyManager == NULL) {
1146 return NO_INIT;
1147 }
1148 Mutex::Autolock _l(mLock);
1149 AutoCallerClear acc;
1150 return mAudioPolicyManager->setSurroundFormatEnabled(audioFormat, enabled);
1151}
Eric Laurentac9cef52017-06-09 15:46:26 -07001152
Eric Laurentb78763e2018-10-17 10:08:02 -07001153status_t AudioPolicyService::setAssistantUid(uid_t uid)
1154{
1155 Mutex::Autolock _l(mLock);
1156 mUidPolicy->setAssistantUid(uid);
1157 return NO_ERROR;
1158}
1159
1160status_t AudioPolicyService::setA11yServicesUids(const std::vector<uid_t>& uids)
1161{
1162 Mutex::Autolock _l(mLock);
1163 mUidPolicy->setA11yUids(uids);
1164 return NO_ERROR;
1165}
1166
jiabin6012f912018-11-02 17:06:30 -07001167bool AudioPolicyService::isHapticPlaybackSupported()
1168{
1169 if (mAudioPolicyManager == NULL) {
1170 ALOGW("%s, mAudioPolicyManager == NULL", __func__);
1171 return false;
1172 }
1173 Mutex::Autolock _l(mLock);
1174 AutoCallerClear acc;
1175 return mAudioPolicyManager->isHapticPlaybackSupported();
1176}
1177
François Gaffied0ba9ed2018-11-05 11:50:42 +01001178status_t AudioPolicyService::listAudioProductStrategies(AudioProductStrategyVector &strategies)
1179{
1180 if (mAudioPolicyManager == NULL) {
1181 return NO_INIT;
1182 }
1183 Mutex::Autolock _l(mLock);
1184 return mAudioPolicyManager->listAudioProductStrategies(strategies);
1185}
1186
1187product_strategy_t AudioPolicyService::getProductStrategyFromAudioAttributes(
1188 const AudioAttributes &aa)
1189{
1190 if (mAudioPolicyManager == NULL) {
1191 return PRODUCT_STRATEGY_NONE;
1192 }
1193 Mutex::Autolock _l(mLock);
1194 return mAudioPolicyManager->getProductStrategyFromAudioAttributes(aa);
1195}
Mikhail Naganov1b2a7942017-12-08 10:18:09 -08001196} // namespace android