blob: 63cb18757e258cd1b34c666bf5284989e4ed1b5f [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/AudioPolicyHelper.h>
23#include <media/MediaAnalyticsItem.h>
24#include <mediautils/ServiceUtilities.h>
25#include <utils/Log.h>
Eric Laurent2d388ec2014-03-07 13:25:54 -080026
Eric Laurent2d388ec2014-03-07 13:25:54 -080027namespace android {
28
29
30// ----------------------------------------------------------------------------
31
32status_t AudioPolicyService::setDeviceConnectionState(audio_devices_t device,
33 audio_policy_dev_state_t state,
Paul McLeane743a472015-01-28 11:07:31 -080034 const char *device_address,
Aniket Kumar Lata4e464702019-01-10 23:38:46 -080035 const char *device_name,
36 audio_format_t encodedFormat)
Eric Laurent2d388ec2014-03-07 13:25:54 -080037{
Eric Laurentdce54a12014-03-10 12:19:46 -070038 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -080039 return NO_INIT;
40 }
41 if (!settingsAllowed()) {
42 return PERMISSION_DENIED;
43 }
Eric Laurent2d388ec2014-03-07 13:25:54 -080044 if (state != AUDIO_POLICY_DEVICE_STATE_AVAILABLE &&
45 state != AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE) {
46 return BAD_VALUE;
47 }
48
49 ALOGV("setDeviceConnectionState()");
50 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -070051 AutoCallerClear acc;
Paul McLeane743a472015-01-28 11:07:31 -080052 return mAudioPolicyManager->setDeviceConnectionState(device, state,
Aniket Kumar Lata4e464702019-01-10 23:38:46 -080053 device_address, device_name, encodedFormat);
Eric Laurent2d388ec2014-03-07 13:25:54 -080054}
55
56audio_policy_dev_state_t AudioPolicyService::getDeviceConnectionState(
57 audio_devices_t device,
58 const char *device_address)
59{
Eric Laurentdce54a12014-03-10 12:19:46 -070060 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -080061 return AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE;
62 }
Eric Laurent10b71232018-04-13 18:14:44 -070063 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -070064 return mAudioPolicyManager->getDeviceConnectionState(device,
Eric Laurent2d388ec2014-03-07 13:25:54 -080065 device_address);
66}
67
Pavlin Radoslavovf862bc62016-12-26 18:57:22 -080068status_t AudioPolicyService::handleDeviceConfigChange(audio_devices_t device,
69 const char *device_address,
Aniket Kumar Lata4e464702019-01-10 23:38:46 -080070 const char *device_name,
71 audio_format_t encodedFormat)
Pavlin Radoslavovf862bc62016-12-26 18:57:22 -080072{
73 if (mAudioPolicyManager == NULL) {
74 return NO_INIT;
75 }
76 if (!settingsAllowed()) {
77 return PERMISSION_DENIED;
78 }
Pavlin Radoslavovf862bc62016-12-26 18:57:22 -080079
80 ALOGV("handleDeviceConfigChange()");
81 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -070082 AutoCallerClear acc;
Pavlin Radoslavovf862bc62016-12-26 18:57:22 -080083 return mAudioPolicyManager->handleDeviceConfigChange(device, device_address,
Aniket Kumar Lata4e464702019-01-10 23:38:46 -080084 device_name, encodedFormat);
Pavlin Radoslavovf862bc62016-12-26 18:57:22 -080085}
86
Eric Laurent2d388ec2014-03-07 13:25:54 -080087status_t AudioPolicyService::setPhoneState(audio_mode_t state)
88{
Eric Laurentdce54a12014-03-10 12:19:46 -070089 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -080090 return NO_INIT;
91 }
92 if (!settingsAllowed()) {
93 return PERMISSION_DENIED;
94 }
95 if (uint32_t(state) >= AUDIO_MODE_CNT) {
96 return BAD_VALUE;
97 }
98
99 ALOGV("setPhoneState()");
100
Eric Laurentbeb07fe2015-09-16 15:49:30 -0700101 // acquire lock before calling setMode() so that setMode() + setPhoneState() are an atomic
102 // operation from policy manager standpoint (no other operation (e.g track start or stop)
103 // can be interleaved).
104 Mutex::Autolock _l(mLock);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800105 // TODO: check if it is more appropriate to do it in platform specific policy manager
106 AudioSystem::setMode(state);
107
Eric Laurent10b71232018-04-13 18:14:44 -0700108 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700109 mAudioPolicyManager->setPhoneState(state);
Eric Laurentbb6c9a02014-09-25 14:11:47 -0700110 mPhoneState = state;
Eric Laurent2d388ec2014-03-07 13:25:54 -0800111 return NO_ERROR;
112}
113
Eric Laurentbb6c9a02014-09-25 14:11:47 -0700114audio_mode_t AudioPolicyService::getPhoneState()
115{
116 Mutex::Autolock _l(mLock);
117 return mPhoneState;
118}
119
Eric Laurent2d388ec2014-03-07 13:25:54 -0800120status_t AudioPolicyService::setForceUse(audio_policy_force_use_t usage,
121 audio_policy_forced_cfg_t config)
122{
Eric Laurentdce54a12014-03-10 12:19:46 -0700123 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800124 return NO_INIT;
125 }
Eric Laurente17378d2018-05-09 14:43:01 -0700126
127 if (!modifyAudioRoutingAllowed()) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800128 return PERMISSION_DENIED;
129 }
Eric Laurente17378d2018-05-09 14:43:01 -0700130
Eric Laurent2d388ec2014-03-07 13:25:54 -0800131 if (usage < 0 || usage >= AUDIO_POLICY_FORCE_USE_CNT) {
132 return BAD_VALUE;
133 }
134 if (config < 0 || config >= AUDIO_POLICY_FORCE_CFG_CNT) {
135 return BAD_VALUE;
136 }
137 ALOGV("setForceUse()");
138 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700139 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700140 mAudioPolicyManager->setForceUse(usage, config);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800141 return NO_ERROR;
142}
143
144audio_policy_forced_cfg_t AudioPolicyService::getForceUse(audio_policy_force_use_t usage)
145{
Eric Laurentdce54a12014-03-10 12:19:46 -0700146 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800147 return AUDIO_POLICY_FORCE_NONE;
148 }
149 if (usage < 0 || usage >= AUDIO_POLICY_FORCE_USE_CNT) {
150 return AUDIO_POLICY_FORCE_NONE;
151 }
Eric Laurent10b71232018-04-13 18:14:44 -0700152 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700153 return mAudioPolicyManager->getForceUse(usage);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800154}
155
Eric Laurentf4e63452017-11-06 19:31:46 +0000156audio_io_handle_t AudioPolicyService::getOutput(audio_stream_type_t stream)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800157{
Eric Laurent223fd5c2014-11-11 13:43:36 -0800158 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
Eric Laurentb1322c72014-10-30 14:59:13 -0700159 return AUDIO_IO_HANDLE_NONE;
Eric Laurentdea15412014-10-28 15:46:45 -0700160 }
Eric Laurentdce54a12014-03-10 12:19:46 -0700161 if (mAudioPolicyManager == NULL) {
Eric Laurentb1322c72014-10-30 14:59:13 -0700162 return AUDIO_IO_HANDLE_NONE;
Eric Laurent2d388ec2014-03-07 13:25:54 -0800163 }
164 ALOGV("getOutput()");
165 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700166 AutoCallerClear acc;
Eric Laurentf4e63452017-11-06 19:31:46 +0000167 return mAudioPolicyManager->getOutput(stream);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800168}
169
Eric Laurente83b55d2014-11-14 10:06:21 -0800170status_t AudioPolicyService::getOutputForAttr(const audio_attributes_t *attr,
171 audio_io_handle_t *output,
172 audio_session_t session,
173 audio_stream_type_t *stream,
Nadav Bar766fb022018-01-07 12:18:03 +0200174 pid_t pid,
Eric Laurent8c7e6da2015-04-21 17:37:00 -0700175 uid_t uid,
Eric Laurent20b9ef02016-12-05 11:03:16 -0800176 const audio_config_t *config,
Eric Laurente83b55d2014-11-14 10:06:21 -0800177 audio_output_flags_t flags,
Eric Laurent9ae8c592017-06-22 17:17:09 -0700178 audio_port_handle_t *selectedDeviceId,
Eric Laurent20b9ef02016-12-05 11:03:16 -0800179 audio_port_handle_t *portId)
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,
Nadav Bar766fb022018-01-07 12:18:03 +0200197 &flags, selectedDeviceId, portId);
198
199 // FIXME: Introduce a way to check for the the telephony device before opening the output
200 if ((result == NO_ERROR) &&
201 (flags & AUDIO_OUTPUT_FLAG_INCALL_MUSIC) &&
202 !modifyPhoneStateAllowed(pid, uid)) {
203 // If the app tries to play music through the telephony device and doesn't have permission
204 // the fallback to the default output device.
Eric Laurent8fc147b2018-07-22 19:13:55 -0700205 mAudioPolicyManager->releaseOutput(*portId);
Nadav Bar766fb022018-01-07 12:18:03 +0200206 flags = originalFlags;
207 *selectedDeviceId = AUDIO_PORT_HANDLE_NONE;
208 *portId = AUDIO_PORT_HANDLE_NONE;
209 result = mAudioPolicyManager->getOutputForAttr(attr, output, session, stream, uid,
210 config,
211 &flags, selectedDeviceId, portId);
212 }
Eric Laurentd7fe0862018-07-14 16:48:01 -0700213
214 if (result == NO_ERROR) {
215 sp <AudioPlaybackClient> client =
216 new AudioPlaybackClient(*attr, *output, uid, pid, session, *selectedDeviceId, *stream);
217 mAudioPlaybackClients.add(*portId, client);
218 }
Nadav Bar766fb022018-01-07 12:18:03 +0200219 return result;
Jean-Michel Trivi5bd3f382014-06-13 16:06:54 -0700220}
221
Eric Laurentd7fe0862018-07-14 16:48:01 -0700222status_t AudioPolicyService::startOutput(audio_port_handle_t portId)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800223{
Eric Laurentdce54a12014-03-10 12:19:46 -0700224 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800225 return NO_INIT;
226 }
227 ALOGV("startOutput()");
Eric Laurentd7fe0862018-07-14 16:48:01 -0700228 sp<AudioPlaybackClient> client;
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700229 sp<AudioPolicyEffects>audioPolicyEffects;
230 {
231 Mutex::Autolock _l(mLock);
Eric Laurentd7fe0862018-07-14 16:48:01 -0700232 const ssize_t index = mAudioPlaybackClients.indexOfKey(portId);
233 if (index < 0) {
234 ALOGE("%s AudioTrack client not found for portId %d", __FUNCTION__, portId);
235 return INVALID_OPERATION;
236 }
237 client = mAudioPlaybackClients.valueAt(index);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700238 audioPolicyEffects = mAudioPolicyEffects;
bryant_liuba2b4392014-06-11 16:49:30 +0800239 }
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700240 if (audioPolicyEffects != 0) {
241 // create audio processors according to stream
Eric Laurentd7fe0862018-07-14 16:48:01 -0700242 status_t status = audioPolicyEffects->addOutputSessionEffects(
243 client->io, client->stream, client->session);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700244 if (status != NO_ERROR && status != ALREADY_EXISTS) {
Eric Laurentd7fe0862018-07-14 16:48:01 -0700245 ALOGW("Failed to add effects on session %d", client->session);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700246 }
247 }
248 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700249 AutoCallerClear acc;
Eric Laurent8fc147b2018-07-22 19:13:55 -0700250 status_t status = mAudioPolicyManager->startOutput(portId);
Eric Laurentd7fe0862018-07-14 16:48:01 -0700251 if (status == NO_ERROR) {
252 client->active = true;
253 }
254 return status;
Eric Laurent2d388ec2014-03-07 13:25:54 -0800255}
256
Eric Laurentd7fe0862018-07-14 16:48:01 -0700257status_t AudioPolicyService::stopOutput(audio_port_handle_t portId)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800258{
Eric Laurentdce54a12014-03-10 12:19:46 -0700259 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800260 return NO_INIT;
261 }
262 ALOGV("stopOutput()");
Eric Laurentd7fe0862018-07-14 16:48:01 -0700263 mOutputCommandThread->stopOutputCommand(portId);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800264 return NO_ERROR;
265}
266
Eric Laurentd7fe0862018-07-14 16:48:01 -0700267status_t AudioPolicyService::doStopOutput(audio_port_handle_t portId)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800268{
Eric Laurentd7fe0862018-07-14 16:48:01 -0700269 ALOGV("doStopOutput");
270 sp<AudioPlaybackClient> client;
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700271 sp<AudioPolicyEffects>audioPolicyEffects;
272 {
273 Mutex::Autolock _l(mLock);
Eric Laurentd7fe0862018-07-14 16:48:01 -0700274
275 const ssize_t index = mAudioPlaybackClients.indexOfKey(portId);
276 if (index < 0) {
277 ALOGE("%s AudioTrack client not found for portId %d", __FUNCTION__, portId);
278 return INVALID_OPERATION;
279 }
280 client = mAudioPlaybackClients.valueAt(index);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700281 audioPolicyEffects = mAudioPolicyEffects;
bryant_liuba2b4392014-06-11 16:49:30 +0800282 }
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700283 if (audioPolicyEffects != 0) {
284 // release audio processors from the stream
Eric Laurentd7fe0862018-07-14 16:48:01 -0700285 status_t status = audioPolicyEffects->releaseOutputSessionEffects(
286 client->io, client->stream, client->session);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700287 if (status != NO_ERROR && status != ALREADY_EXISTS) {
Eric Laurentd7fe0862018-07-14 16:48:01 -0700288 ALOGW("Failed to release effects on session %d", client->session);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700289 }
290 }
291 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700292 AutoCallerClear acc;
Eric Laurent8fc147b2018-07-22 19:13:55 -0700293 status_t status = mAudioPolicyManager->stopOutput(portId);
Eric Laurentd7fe0862018-07-14 16:48:01 -0700294 if (status == NO_ERROR) {
295 client->active = false;
296 }
297 return status;
Eric Laurent2d388ec2014-03-07 13:25:54 -0800298}
299
Eric Laurentd7fe0862018-07-14 16:48:01 -0700300void AudioPolicyService::releaseOutput(audio_port_handle_t portId)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800301{
Eric Laurentdce54a12014-03-10 12:19:46 -0700302 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800303 return;
304 }
305 ALOGV("releaseOutput()");
Eric Laurentd7fe0862018-07-14 16:48:01 -0700306 mOutputCommandThread->releaseOutputCommand(portId);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800307}
308
Eric Laurentd7fe0862018-07-14 16:48:01 -0700309void AudioPolicyService::doReleaseOutput(audio_port_handle_t portId)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800310{
311 ALOGV("doReleaseOutput from tid %d", gettid());
312 Mutex::Autolock _l(mLock);
Eric Laurentd7fe0862018-07-14 16:48:01 -0700313 const ssize_t index = mAudioPlaybackClients.indexOfKey(portId);
314 if (index < 0) {
315 ALOGE("%s AudioTrack client not found for portId %d", __FUNCTION__, portId);
316 return;
317 }
318 sp<AudioPlaybackClient> client = mAudioPlaybackClients.valueAt(index);
319 mAudioRecordClients.removeItem(portId);
320
Eric Laurent10b71232018-04-13 18:14:44 -0700321 // called from internal thread: no need to clear caller identity
Eric Laurent8fc147b2018-07-22 19:13:55 -0700322 mAudioPolicyManager->releaseOutput(portId);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800323}
324
Eric Laurentcaf7f482014-11-25 17:50:47 -0800325status_t AudioPolicyService::getInputForAttr(const audio_attributes_t *attr,
326 audio_io_handle_t *input,
327 audio_session_t session,
Eric Laurentb2379ba2016-05-23 17:42:12 -0700328 pid_t pid,
Eric Laurent8c7e6da2015-04-21 17:37:00 -0700329 uid_t uid,
Eric Laurentfee19762018-01-29 18:44:13 -0800330 const String16& opPackageName,
Eric Laurent20b9ef02016-12-05 11:03:16 -0800331 const audio_config_base_t *config,
Paul McLean466dc8e2015-04-17 13:15:36 -0600332 audio_input_flags_t flags,
Eric Laurent9ae8c592017-06-22 17:17:09 -0700333 audio_port_handle_t *selectedDeviceId,
Eric Laurent20b9ef02016-12-05 11:03:16 -0800334 audio_port_handle_t *portId)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800335{
Eric Laurentdce54a12014-03-10 12:19:46 -0700336 if (mAudioPolicyManager == NULL) {
Eric Laurentcaf7f482014-11-25 17:50:47 -0800337 return NO_INIT;
Eric Laurent2d388ec2014-03-07 13:25:54 -0800338 }
Eric Laurent7dca8a82018-01-29 18:44:26 -0800339
Eric Laurent2d388ec2014-03-07 13:25:54 -0800340 // already checked by client, but double-check in case the client wrapper is bypassed
Eric Laurentae4b6ec2019-01-15 18:34:38 -0800341 if ((attr->source < AUDIO_SOURCE_DEFAULT)
342 || (attr->source >= AUDIO_SOURCE_CNT
343 && attr->source != AUDIO_SOURCE_HOTWORD
344 && attr->source != AUDIO_SOURCE_FM_TUNER
345 && attr->source != AUDIO_SOURCE_ECHO_REFERENCE)) {
Eric Laurentcaf7f482014-11-25 17:50:47 -0800346 return BAD_VALUE;
Eric Laurent2d388ec2014-03-07 13:25:54 -0800347 }
348
Eric Laurentb2379ba2016-05-23 17:42:12 -0700349 bool updatePid = (pid == -1);
Marco Nelissendcb346b2015-09-09 10:47:29 -0700350 const uid_t callingUid = IPCThreadState::self()->getCallingUid();
Andy Hung4ef19fa2018-05-15 19:35:29 -0700351 if (!isAudioServerOrMediaServerUid(callingUid)) {
Eric Laurent9f39f8d2016-05-25 12:34:48 -0700352 ALOGW_IF(uid != (uid_t)-1 && uid != callingUid,
Marco Nelissendcb346b2015-09-09 10:47:29 -0700353 "%s uid %d tried to pass itself off as %d", __FUNCTION__, callingUid, uid);
354 uid = callingUid;
Eric Laurentb2379ba2016-05-23 17:42:12 -0700355 updatePid = true;
356 }
357
358 if (updatePid) {
359 const pid_t callingPid = IPCThreadState::self()->getCallingPid();
Eric Laurent9f39f8d2016-05-25 12:34:48 -0700360 ALOGW_IF(pid != (pid_t)-1 && pid != callingPid,
Eric Laurentb2379ba2016-05-23 17:42:12 -0700361 "%s uid %d pid %d tried to pass itself off as pid %d",
362 __func__, callingUid, callingPid, pid);
363 pid = callingPid;
Eric Laurent8c7e6da2015-04-21 17:37:00 -0700364 }
365
Eric Laurent7dca8a82018-01-29 18:44:26 -0800366 // check calling permissions
367 if (!recordingAllowed(opPackageName, pid, uid)) {
368 ALOGE("%s permission denied: recording not allowed for uid %d pid %d",
369 __func__, uid, pid);
370 return PERMISSION_DENIED;
371 }
372
Nadav Bar744be482018-05-08 13:26:21 +0300373 if ((attr->source == AUDIO_SOURCE_VOICE_UPLINK ||
374 attr->source == AUDIO_SOURCE_VOICE_DOWNLINK ||
Eric Laurentae4b6ec2019-01-15 18:34:38 -0800375 attr->source == AUDIO_SOURCE_VOICE_CALL ||
376 attr->source == AUDIO_SOURCE_ECHO_REFERENCE) &&
Nadav Bar744be482018-05-08 13:26:21 +0300377 !captureAudioOutputAllowed(pid, uid)) {
378 return PERMISSION_DENIED;
379 }
380
Eric Laurent7504b9e2017-08-15 18:17:26 -0700381 if ((attr->source == AUDIO_SOURCE_HOTWORD) && !captureHotwordAllowed(pid, uid)) {
382 return BAD_VALUE;
383 }
384
385 sp<AudioPolicyEffects>audioPolicyEffects;
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700386 {
Eric Laurent7504b9e2017-08-15 18:17:26 -0700387 status_t status;
388 AudioPolicyInterface::input_type_t inputType;
389
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700390 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700391 {
392 AutoCallerClear acc;
393 // the audio_in_acoustics_t parameter is ignored by get_input()
394 status = mAudioPolicyManager->getInputForAttr(attr, input, session, uid,
395 config,
396 flags, selectedDeviceId,
397 &inputType, portId);
398 }
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700399 audioPolicyEffects = mAudioPolicyEffects;
Jean-Michel Trivi97bb33f2014-12-12 16:23:43 -0800400
401 if (status == NO_ERROR) {
402 // enforce permission (if any) required for each type of input
403 switch (inputType) {
404 case AudioPolicyInterface::API_INPUT_LEGACY:
405 break;
Eric Laurent82db2692015-08-07 13:59:42 -0700406 case AudioPolicyInterface::API_INPUT_TELEPHONY_RX:
407 // FIXME: use the same permission as for remote submix for now.
Jean-Michel Trivi97bb33f2014-12-12 16:23:43 -0800408 case AudioPolicyInterface::API_INPUT_MIX_CAPTURE:
Eric Laurentb2379ba2016-05-23 17:42:12 -0700409 if (!captureAudioOutputAllowed(pid, uid)) {
Jean-Michel Trivi97bb33f2014-12-12 16:23:43 -0800410 ALOGE("getInputForAttr() permission denied: capture not allowed");
411 status = PERMISSION_DENIED;
412 }
413 break;
414 case AudioPolicyInterface::API_INPUT_MIX_EXT_POLICY_REROUTE:
415 if (!modifyAudioRoutingAllowed()) {
416 ALOGE("getInputForAttr() permission denied: modify audio routing not allowed");
417 status = PERMISSION_DENIED;
418 }
419 break;
420 case AudioPolicyInterface::API_INPUT_INVALID:
421 default:
422 LOG_ALWAYS_FATAL("getInputForAttr() encountered an invalid input type %d",
423 (int)inputType);
424 }
425 }
426
427 if (status != NO_ERROR) {
428 if (status == PERMISSION_DENIED) {
Eric Laurent10b71232018-04-13 18:14:44 -0700429 AutoCallerClear acc;
Eric Laurent8fc147b2018-07-22 19:13:55 -0700430 mAudioPolicyManager->releaseInput(*portId);
Jean-Michel Trivi97bb33f2014-12-12 16:23:43 -0800431 }
432 return status;
433 }
Eric Laurentfee19762018-01-29 18:44:13 -0800434
Eric Laurentd7fe0862018-07-14 16:48:01 -0700435 sp<AudioRecordClient> client = new AudioRecordClient(*attr, *input, uid, pid, session,
436 *selectedDeviceId, opPackageName);
Eric Laurentfee19762018-01-29 18:44:13 -0800437 mAudioRecordClients.add(*portId, client);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700438 }
Jean-Michel Trivi97bb33f2014-12-12 16:23:43 -0800439
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700440 if (audioPolicyEffects != 0) {
441 // create audio pre processors according to input source
Eric Laurentcaf7f482014-11-25 17:50:47 -0800442 status_t status = audioPolicyEffects->addInputEffects(*input, attr->source, session);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700443 if (status != NO_ERROR && status != ALREADY_EXISTS) {
Eric Laurentcaf7f482014-11-25 17:50:47 -0800444 ALOGW("Failed to add effects on input %d", *input);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700445 }
Eric Laurent2d388ec2014-03-07 13:25:54 -0800446 }
Eric Laurentcaf7f482014-11-25 17:50:47 -0800447 return NO_ERROR;
Eric Laurent2d388ec2014-03-07 13:25:54 -0800448}
449
Ray Essick84e84a52018-05-03 18:45:07 -0700450// this is replicated from frameworks/av/media/libaudioclient/AudioRecord.cpp
451// XXX -- figure out how to put it into a common, shared location
452
453static std::string audioSourceString(audio_source_t value) {
454 std::string source;
455 if (SourceTypeConverter::toString(value, source)) {
456 return source;
457 }
458 char rawbuffer[16]; // room for "%d"
459 snprintf(rawbuffer, sizeof(rawbuffer), "%d", value);
460 return rawbuffer;
461}
462
Eric Laurent99fcae42018-05-17 16:59:18 -0700463std::string AudioPolicyService::getDeviceTypeStrForPortId(audio_port_handle_t portId) {
464 std::string typeStr;
465 struct audio_port port = {};
466 port.id = portId;
467 status_t status = mAudioPolicyManager->getAudioPort(&port);
468 if (status == NO_ERROR && port.type == AUDIO_PORT_TYPE_DEVICE) {
469 deviceToString(port.ext.device.type, typeStr);
470 }
471 return typeStr;
472}
473
Eric Laurent4eb58f12018-12-07 16:41:02 -0800474status_t AudioPolicyService::startInput(audio_port_handle_t portId)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800475{
Eric Laurentdce54a12014-03-10 12:19:46 -0700476 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800477 return NO_INIT;
478 }
Eric Laurent7dca8a82018-01-29 18:44:26 -0800479 sp<AudioRecordClient> client;
480 {
481 Mutex::Autolock _l(mLock);
Svet Ganovf4ddfef2018-01-16 07:37:58 -0800482
Eric Laurent7dca8a82018-01-29 18:44:26 -0800483 ssize_t index = mAudioRecordClients.indexOfKey(portId);
484 if (index < 0) {
485 return INVALID_OPERATION;
486 }
487 client = mAudioRecordClients.valueAt(index);
Eric Laurentfee19762018-01-29 18:44:13 -0800488 }
Eric Laurent7dca8a82018-01-29 18:44:26 -0800489
490 // check calling permissions
Svet Ganov6e641372018-03-02 09:21:30 -0800491 if (!startRecording(client->opPackageName, client->pid, client->uid)) {
Eric Laurent7dca8a82018-01-29 18:44:26 -0800492 ALOGE("%s permission denied: recording not allowed for uid %d pid %d",
493 __func__, client->uid, client->pid);
494 return PERMISSION_DENIED;
495 }
Eric Laurentfee19762018-01-29 18:44:13 -0800496
Eric Laurentdf628922018-12-06 21:45:51 +0000497 Mutex::Autolock _l(mLock);
Eric Laurent4eb58f12018-12-07 16:41:02 -0800498
499 client->active = true;
500 client->startTimeNs = systemTime();
501 updateUidStates_l();
Eric Laurentfee19762018-01-29 18:44:13 -0800502
Eric Laurent10b71232018-04-13 18:14:44 -0700503 status_t status;
504 {
505 AutoCallerClear acc;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800506 status = mAudioPolicyManager->startInput(portId);
Ray Essick84e84a52018-05-03 18:45:07 -0700507
508 }
509
Ray Essickf6a57cd2018-05-22 16:20:54 -0700510 // including successes gets very verbose
511 if (status != NO_ERROR) {
Ray Essick84e84a52018-05-03 18:45:07 -0700512
513 static constexpr char kAudioPolicy[] = "audiopolicy";
514
Ray Essick84e84a52018-05-03 18:45:07 -0700515 static constexpr char kAudioPolicyStatus[] = "android.media.audiopolicy.status";
516 static constexpr char kAudioPolicyRqstSrc[] = "android.media.audiopolicy.rqst.src";
517 static constexpr char kAudioPolicyRqstPkg[] = "android.media.audiopolicy.rqst.pkg";
518 static constexpr char kAudioPolicyRqstSession[] = "android.media.audiopolicy.rqst.session";
Eric Laurent99fcae42018-05-17 16:59:18 -0700519 static constexpr char kAudioPolicyRqstDevice[] =
520 "android.media.audiopolicy.rqst.device";
Ray Essick84e84a52018-05-03 18:45:07 -0700521 static constexpr char kAudioPolicyActiveSrc[] = "android.media.audiopolicy.active.src";
522 static constexpr char kAudioPolicyActivePkg[] = "android.media.audiopolicy.active.pkg";
Eric Laurent99fcae42018-05-17 16:59:18 -0700523 static constexpr char kAudioPolicyActiveSession[] =
524 "android.media.audiopolicy.active.session";
525 static constexpr char kAudioPolicyActiveDevice[] =
526 "android.media.audiopolicy.active.device";
Ray Essick84e84a52018-05-03 18:45:07 -0700527
Ray Essick6a305222019-01-28 20:33:18 -0800528 MediaAnalyticsItem *item = MediaAnalyticsItem::create(kAudioPolicy);
Ray Essick84e84a52018-05-03 18:45:07 -0700529 if (item != NULL) {
530
Ray Essick84e84a52018-05-03 18:45:07 -0700531 item->setInt32(kAudioPolicyStatus, status);
532
Eric Laurent99fcae42018-05-17 16:59:18 -0700533 item->setCString(kAudioPolicyRqstSrc,
534 audioSourceString(client->attributes.source).c_str());
Ray Essick84e84a52018-05-03 18:45:07 -0700535 item->setInt32(kAudioPolicyRqstSession, client->session);
Ray Essick51866952018-05-30 11:22:27 -0700536 if (client->opPackageName.size() != 0) {
537 item->setCString(kAudioPolicyRqstPkg,
538 std::string(String8(client->opPackageName).string()).c_str());
539 } else {
Kevin Rocardfbdfebe2018-06-18 12:30:40 -0700540 item->setCString(kAudioPolicyRqstPkg, std::to_string(client->uid).c_str());
Ray Essick51866952018-05-30 11:22:27 -0700541 }
Eric Laurent99fcae42018-05-17 16:59:18 -0700542 item->setCString(
543 kAudioPolicyRqstDevice, getDeviceTypeStrForPortId(client->deviceId).c_str());
544
Eric Laurent4eb58f12018-12-07 16:41:02 -0800545 int count = mAudioRecordClients.size();
546 for (int i = 0; i < count ; i++) {
547 if (portId == mAudioRecordClients.keyAt(i)) {
548 continue;
549 }
550 sp<AudioRecordClient> other = mAudioRecordClients.valueAt(i);
551 if (other->active) {
552 // keeps the last of the clients marked active
553 item->setCString(kAudioPolicyActiveSrc,
554 audioSourceString(other->attributes.source).c_str());
555 item->setInt32(kAudioPolicyActiveSession, other->session);
556 if (other->opPackageName.size() != 0) {
557 item->setCString(kAudioPolicyActivePkg,
558 std::string(String8(other->opPackageName).string()).c_str());
559 } else {
560 item->setCString(kAudioPolicyRqstPkg,
561 std::to_string(other->uid).c_str());
Ray Essick84e84a52018-05-03 18:45:07 -0700562 }
Eric Laurent4eb58f12018-12-07 16:41:02 -0800563 item->setCString(kAudioPolicyActiveDevice,
564 getDeviceTypeStrForPortId(other->deviceId).c_str());
Ray Essick84e84a52018-05-03 18:45:07 -0700565 }
566 }
567 item->selfrecord();
568 delete item;
569 item = NULL;
570 }
Eric Laurent4eb58f12018-12-07 16:41:02 -0800571 client->active = false;
572 client->startTimeNs = 0;
573 updateUidStates_l();
Svet Ganov6e641372018-03-02 09:21:30 -0800574 finishRecording(client->opPackageName, client->uid);
Eric Laurentfb66dd92016-01-28 18:32:03 -0800575 }
576
577 return status;
Eric Laurent2d388ec2014-03-07 13:25:54 -0800578}
579
Eric Laurentfee19762018-01-29 18:44:13 -0800580status_t AudioPolicyService::stopInput(audio_port_handle_t portId)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800581{
Eric Laurentdce54a12014-03-10 12:19:46 -0700582 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800583 return NO_INIT;
584 }
Eric Laurent4eb58f12018-12-07 16:41:02 -0800585
Eric Laurent2d388ec2014-03-07 13:25:54 -0800586 Mutex::Autolock _l(mLock);
587
Eric Laurentfee19762018-01-29 18:44:13 -0800588 ssize_t index = mAudioRecordClients.indexOfKey(portId);
589 if (index < 0) {
590 return INVALID_OPERATION;
591 }
592 sp<AudioRecordClient> client = mAudioRecordClients.valueAt(index);
593
Ray Essick84e84a52018-05-03 18:45:07 -0700594 client->active = false;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800595 client->startTimeNs = 0;
596
597 updateUidStates_l();
Ray Essick84e84a52018-05-03 18:45:07 -0700598
Svet Ganov6e641372018-03-02 09:21:30 -0800599 // finish the recording app op
600 finishRecording(client->opPackageName, client->uid);
Eric Laurent10b71232018-04-13 18:14:44 -0700601 AutoCallerClear acc;
Eric Laurent8fc147b2018-07-22 19:13:55 -0700602 return mAudioPolicyManager->stopInput(portId);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800603}
604
Eric Laurentfee19762018-01-29 18:44:13 -0800605void AudioPolicyService::releaseInput(audio_port_handle_t portId)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800606{
Eric Laurentdce54a12014-03-10 12:19:46 -0700607 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800608 return;
609 }
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700610 sp<AudioPolicyEffects>audioPolicyEffects;
Eric Laurentfee19762018-01-29 18:44:13 -0800611 sp<AudioRecordClient> client;
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700612 {
613 Mutex::Autolock _l(mLock);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700614 audioPolicyEffects = mAudioPolicyEffects;
Eric Laurentfee19762018-01-29 18:44:13 -0800615 ssize_t index = mAudioRecordClients.indexOfKey(portId);
616 if (index < 0) {
617 return;
618 }
619 client = mAudioRecordClients.valueAt(index);
Eric Laurent4eb58f12018-12-07 16:41:02 -0800620
621 if (client->active) {
622 ALOGW("%s releasing active client portId %d", __FUNCTION__, portId);
623 client->active = false;
624 client->startTimeNs = 0;
625 updateUidStates_l();
626 }
627
Eric Laurentfee19762018-01-29 18:44:13 -0800628 mAudioRecordClients.removeItem(portId);
629 }
630 if (client == 0) {
631 return;
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700632 }
633 if (audioPolicyEffects != 0) {
634 // release audio processors from the input
Eric Laurentd7fe0862018-07-14 16:48:01 -0700635 status_t status = audioPolicyEffects->releaseInputEffects(client->io, client->session);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700636 if(status != NO_ERROR) {
Eric Laurentd7fe0862018-07-14 16:48:01 -0700637 ALOGW("Failed to release effects on input %d", client->io);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700638 }
Eric Laurent2d388ec2014-03-07 13:25:54 -0800639 }
Eric Laurentf10c7092016-12-06 17:09:56 -0800640 {
641 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700642 AutoCallerClear acc;
Eric Laurent8fc147b2018-07-22 19:13:55 -0700643 mAudioPolicyManager->releaseInput(portId);
Eric Laurentf10c7092016-12-06 17:09:56 -0800644 }
Eric Laurent2d388ec2014-03-07 13:25:54 -0800645}
646
647status_t AudioPolicyService::initStreamVolume(audio_stream_type_t stream,
648 int indexMin,
649 int indexMax)
650{
Eric Laurentdce54a12014-03-10 12:19:46 -0700651 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800652 return NO_INIT;
653 }
654 if (!settingsAllowed()) {
655 return PERMISSION_DENIED;
656 }
Eric Laurent223fd5c2014-11-11 13:43:36 -0800657 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800658 return BAD_VALUE;
659 }
660 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700661 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700662 mAudioPolicyManager->initStreamVolume(stream, indexMin, indexMax);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800663 return NO_ERROR;
664}
665
666status_t AudioPolicyService::setStreamVolumeIndex(audio_stream_type_t stream,
667 int index,
668 audio_devices_t device)
669{
Eric Laurentdce54a12014-03-10 12:19:46 -0700670 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800671 return NO_INIT;
672 }
673 if (!settingsAllowed()) {
674 return PERMISSION_DENIED;
675 }
Eric Laurent223fd5c2014-11-11 13:43:36 -0800676 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800677 return BAD_VALUE;
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->setStreamVolumeIndex(stream,
682 index,
683 device);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800684}
685
686status_t AudioPolicyService::getStreamVolumeIndex(audio_stream_type_t stream,
687 int *index,
688 audio_devices_t device)
689{
Eric Laurentdce54a12014-03-10 12:19:46 -0700690 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800691 return NO_INIT;
692 }
Eric Laurent223fd5c2014-11-11 13:43:36 -0800693 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800694 return BAD_VALUE;
695 }
696 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700697 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700698 return mAudioPolicyManager->getStreamVolumeIndex(stream,
699 index,
700 device);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800701}
702
703uint32_t AudioPolicyService::getStrategyForStream(audio_stream_type_t stream)
704{
Eric Laurent223fd5c2014-11-11 13:43:36 -0800705 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
François Gaffiec005e562018-11-06 15:04:49 +0100706 return PRODUCT_STRATEGY_NONE;
Eric Laurentdea15412014-10-28 15:46:45 -0700707 }
Eric Laurentdce54a12014-03-10 12:19:46 -0700708 if (mAudioPolicyManager == NULL) {
François Gaffiec005e562018-11-06 15:04:49 +0100709 return PRODUCT_STRATEGY_NONE;
Eric Laurent2d388ec2014-03-07 13:25:54 -0800710 }
François Gaffiec005e562018-11-06 15:04:49 +0100711 // DO NOT LOCK, may be called from AudioFlinger with lock held, reaching deadlock
Eric Laurent10b71232018-04-13 18:14:44 -0700712 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700713 return mAudioPolicyManager->getStrategyForStream(stream);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800714}
715
716//audio policy: use audio_device_t appropriately
717
718audio_devices_t AudioPolicyService::getDevicesForStream(audio_stream_type_t stream)
719{
Eric Laurent223fd5c2014-11-11 13:43:36 -0800720 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
Eric Laurentb1322c72014-10-30 14:59:13 -0700721 return AUDIO_DEVICE_NONE;
Eric Laurentdea15412014-10-28 15:46:45 -0700722 }
Eric Laurentdce54a12014-03-10 12:19:46 -0700723 if (mAudioPolicyManager == NULL) {
Eric Laurentb1322c72014-10-30 14:59:13 -0700724 return AUDIO_DEVICE_NONE;
Eric Laurent2d388ec2014-03-07 13:25:54 -0800725 }
Haynes Mathew Georgedfb9f3b2015-10-26 18:22:13 -0700726 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700727 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700728 return mAudioPolicyManager->getDevicesForStream(stream);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800729}
730
731audio_io_handle_t AudioPolicyService::getOutputForEffect(const effect_descriptor_t *desc)
732{
733 // FIXME change return type to status_t, and return NO_INIT here
Eric Laurentdce54a12014-03-10 12:19:46 -0700734 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800735 return 0;
736 }
737 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700738 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700739 return mAudioPolicyManager->getOutputForEffect(desc);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800740}
741
742status_t AudioPolicyService::registerEffect(const effect_descriptor_t *desc,
743 audio_io_handle_t io,
744 uint32_t strategy,
Glenn Kastend848eb42016-03-08 13:42:11 -0800745 audio_session_t session,
Eric Laurent2d388ec2014-03-07 13:25:54 -0800746 int id)
747{
Eric Laurentdce54a12014-03-10 12:19:46 -0700748 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800749 return NO_INIT;
750 }
Haynes Mathew Georgebab7bf42015-10-30 18:02:23 -0700751 Mutex::Autolock _l(mEffectsLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700752 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700753 return mAudioPolicyManager->registerEffect(desc, io, strategy, session, id);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800754}
755
756status_t AudioPolicyService::unregisterEffect(int id)
757{
Eric Laurentdce54a12014-03-10 12:19:46 -0700758 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800759 return NO_INIT;
760 }
Haynes Mathew Georgebab7bf42015-10-30 18:02:23 -0700761 Mutex::Autolock _l(mEffectsLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700762 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700763 return mAudioPolicyManager->unregisterEffect(id);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800764}
765
766status_t AudioPolicyService::setEffectEnabled(int id, bool enabled)
767{
Eric Laurentdce54a12014-03-10 12:19:46 -0700768 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800769 return NO_INIT;
770 }
Haynes Mathew Georgebab7bf42015-10-30 18:02:23 -0700771 Mutex::Autolock _l(mEffectsLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700772 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700773 return mAudioPolicyManager->setEffectEnabled(id, enabled);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800774}
775
776bool AudioPolicyService::isStreamActive(audio_stream_type_t stream, uint32_t inPastMs) const
777{
Eric Laurent223fd5c2014-11-11 13:43:36 -0800778 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
Eric Laurentb1322c72014-10-30 14:59:13 -0700779 return false;
Eric Laurentdea15412014-10-28 15:46:45 -0700780 }
Eric Laurentdce54a12014-03-10 12:19:46 -0700781 if (mAudioPolicyManager == NULL) {
Eric Laurentb1322c72014-10-30 14:59:13 -0700782 return false;
Eric Laurent2d388ec2014-03-07 13:25:54 -0800783 }
784 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700785 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700786 return mAudioPolicyManager->isStreamActive(stream, inPastMs);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800787}
788
789bool AudioPolicyService::isStreamActiveRemotely(audio_stream_type_t stream, uint32_t inPastMs) const
790{
Eric Laurent223fd5c2014-11-11 13:43:36 -0800791 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
Eric Laurentb1322c72014-10-30 14:59:13 -0700792 return false;
Eric Laurentdea15412014-10-28 15:46:45 -0700793 }
Eric Laurentdce54a12014-03-10 12:19:46 -0700794 if (mAudioPolicyManager == NULL) {
Eric Laurentb1322c72014-10-30 14:59:13 -0700795 return false;
Eric Laurent2d388ec2014-03-07 13:25:54 -0800796 }
797 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700798 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700799 return mAudioPolicyManager->isStreamActiveRemotely(stream, inPastMs);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800800}
801
802bool AudioPolicyService::isSourceActive(audio_source_t source) const
803{
Eric Laurentdce54a12014-03-10 12:19:46 -0700804 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800805 return false;
806 }
807 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -0700808 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700809 return mAudioPolicyManager->isSourceActive(source);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800810}
811
Ari Hausman-Cohen24628312018-08-13 15:01:09 -0700812status_t AudioPolicyService::getAudioPolicyEffects(sp<AudioPolicyEffects>& audioPolicyEffects)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800813{
Eric Laurentdce54a12014-03-10 12:19:46 -0700814 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800815 return NO_INIT;
816 }
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700817 {
818 Mutex::Autolock _l(mLock);
819 audioPolicyEffects = mAudioPolicyEffects;
820 }
821 if (audioPolicyEffects == 0) {
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700822 return NO_INIT;
823 }
Ari Hausman-Cohen24628312018-08-13 15:01:09 -0700824
825 return OK;
826}
827
828status_t AudioPolicyService::queryDefaultPreProcessing(audio_session_t audioSession,
829 effect_descriptor_t *descriptors,
830 uint32_t *count)
831{
832 sp<AudioPolicyEffects>audioPolicyEffects;
833 status_t status = getAudioPolicyEffects(audioPolicyEffects);
834 if (status != OK) {
835 *count = 0;
836 return status;
837 }
Eric Laurentfb66dd92016-01-28 18:32:03 -0800838 return audioPolicyEffects->queryDefaultInputEffects(
839 (audio_session_t)audioSession, descriptors, count);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800840}
841
Ari Hausman-Cohen24628312018-08-13 15:01:09 -0700842status_t AudioPolicyService::addSourceDefaultEffect(const effect_uuid_t *type,
843 const String16& opPackageName,
844 const effect_uuid_t *uuid,
845 int32_t priority,
846 audio_source_t source,
847 audio_unique_id_t* id)
848{
849 sp<AudioPolicyEffects>audioPolicyEffects;
850 status_t status = getAudioPolicyEffects(audioPolicyEffects);
851 if (status != OK) {
852 return status;
853 }
854 if (!modifyDefaultAudioEffectsAllowed()) {
855 return PERMISSION_DENIED;
856 }
857 return audioPolicyEffects->addSourceDefaultEffect(
858 type, opPackageName, uuid, priority, source, id);
859}
860
Ari Hausman-Cohen433722e2018-04-24 14:25:22 -0700861status_t AudioPolicyService::addStreamDefaultEffect(const effect_uuid_t *type,
862 const String16& opPackageName,
863 const effect_uuid_t *uuid,
864 int32_t priority,
865 audio_usage_t usage,
866 audio_unique_id_t* id)
867{
Ari Hausman-Cohen24628312018-08-13 15:01:09 -0700868 sp<AudioPolicyEffects>audioPolicyEffects;
869 status_t status = getAudioPolicyEffects(audioPolicyEffects);
870 if (status != OK) {
871 return status;
Ari Hausman-Cohen433722e2018-04-24 14:25:22 -0700872 }
873 if (!modifyDefaultAudioEffectsAllowed()) {
874 return PERMISSION_DENIED;
875 }
Ari Hausman-Cohen433722e2018-04-24 14:25:22 -0700876 return audioPolicyEffects->addStreamDefaultEffect(
877 type, opPackageName, uuid, priority, usage, id);
878}
879
Ari Hausman-Cohen24628312018-08-13 15:01:09 -0700880status_t AudioPolicyService::removeSourceDefaultEffect(audio_unique_id_t id)
Ari Hausman-Cohen433722e2018-04-24 14:25:22 -0700881{
Ari Hausman-Cohen24628312018-08-13 15:01:09 -0700882 sp<AudioPolicyEffects>audioPolicyEffects;
883 status_t status = getAudioPolicyEffects(audioPolicyEffects);
884 if (status != OK) {
885 return status;
Ari Hausman-Cohen433722e2018-04-24 14:25:22 -0700886 }
887 if (!modifyDefaultAudioEffectsAllowed()) {
888 return PERMISSION_DENIED;
889 }
Ari Hausman-Cohen24628312018-08-13 15:01:09 -0700890 return audioPolicyEffects->removeSourceDefaultEffect(id);
891}
892
893status_t AudioPolicyService::removeStreamDefaultEffect(audio_unique_id_t id)
894{
Ari Hausman-Cohen433722e2018-04-24 14:25:22 -0700895 sp<AudioPolicyEffects>audioPolicyEffects;
Ari Hausman-Cohen24628312018-08-13 15:01:09 -0700896 status_t status = getAudioPolicyEffects(audioPolicyEffects);
897 if (status != OK) {
898 return status;
Ari Hausman-Cohen433722e2018-04-24 14:25:22 -0700899 }
Ari Hausman-Cohen24628312018-08-13 15:01:09 -0700900 if (!modifyDefaultAudioEffectsAllowed()) {
901 return PERMISSION_DENIED;
Ari Hausman-Cohen433722e2018-04-24 14:25:22 -0700902 }
903 return audioPolicyEffects->removeStreamDefaultEffect(id);
904}
905
Eric Laurent2d388ec2014-03-07 13:25:54 -0800906bool AudioPolicyService::isOffloadSupported(const audio_offload_info_t& info)
907{
Eric Laurentdce54a12014-03-10 12:19:46 -0700908 if (mAudioPolicyManager == NULL) {
909 ALOGV("mAudioPolicyManager == NULL");
Eric Laurent2d388ec2014-03-07 13:25:54 -0800910 return false;
911 }
Andy Hung2ddee192015-12-18 17:34:44 -0800912 Mutex::Autolock _l(mLock);
Haynes Mathew Georgebab7bf42015-10-30 18:02:23 -0700913 Mutex::Autolock _le(mEffectsLock); // isOffloadSupported queries for
914 // non-offloadable effects
Eric Laurent10b71232018-04-13 18:14:44 -0700915 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700916 return mAudioPolicyManager->isOffloadSupported(info);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800917}
918
Michael Chana94fbb22018-04-24 14:31:19 +1000919bool AudioPolicyService::isDirectOutputSupported(const audio_config_base_t& config,
920 const audio_attributes_t& attributes) {
921 if (mAudioPolicyManager == NULL) {
922 ALOGV("mAudioPolicyManager == NULL");
923 return false;
924 }
925 Mutex::Autolock _l(mLock);
926 return mAudioPolicyManager->isDirectOutputSupported(config, attributes);
927}
928
929
Eric Laurent6a94d692014-05-20 11:18:06 -0700930status_t AudioPolicyService::listAudioPorts(audio_port_role_t role,
931 audio_port_type_t type,
Eric Laurent203b1a12014-04-01 10:34:16 -0700932 unsigned int *num_ports,
Eric Laurent6a94d692014-05-20 11:18:06 -0700933 struct audio_port *ports,
934 unsigned int *generation)
Eric Laurent203b1a12014-04-01 10:34:16 -0700935{
Eric Laurent6a94d692014-05-20 11:18:06 -0700936 Mutex::Autolock _l(mLock);
937 if (mAudioPolicyManager == NULL) {
938 return NO_INIT;
939 }
Eric Laurent10b71232018-04-13 18:14:44 -0700940 AutoCallerClear acc;
Eric Laurent6a94d692014-05-20 11:18:06 -0700941 return mAudioPolicyManager->listAudioPorts(role, type, num_ports, ports, generation);
Eric Laurent203b1a12014-04-01 10:34:16 -0700942}
943
Eric Laurent6a94d692014-05-20 11:18:06 -0700944status_t AudioPolicyService::getAudioPort(struct audio_port *port)
Eric Laurent203b1a12014-04-01 10:34:16 -0700945{
Eric Laurent6a94d692014-05-20 11:18:06 -0700946 Mutex::Autolock _l(mLock);
947 if (mAudioPolicyManager == NULL) {
948 return NO_INIT;
949 }
Eric Laurent10b71232018-04-13 18:14:44 -0700950 AutoCallerClear acc;
Eric Laurent6a94d692014-05-20 11:18:06 -0700951 return mAudioPolicyManager->getAudioPort(port);
Eric Laurent203b1a12014-04-01 10:34:16 -0700952}
953
Eric Laurent6a94d692014-05-20 11:18:06 -0700954status_t AudioPolicyService::createAudioPatch(const struct audio_patch *patch,
955 audio_patch_handle_t *handle)
Eric Laurent203b1a12014-04-01 10:34:16 -0700956{
Eric Laurent6a94d692014-05-20 11:18:06 -0700957 Mutex::Autolock _l(mLock);
Eric Laurent5284ed52014-05-29 14:37:38 -0700958 if(!modifyAudioRoutingAllowed()) {
959 return PERMISSION_DENIED;
960 }
Eric Laurent6a94d692014-05-20 11:18:06 -0700961 if (mAudioPolicyManager == NULL) {
962 return NO_INIT;
963 }
Eric Laurent10b71232018-04-13 18:14:44 -0700964 AutoCallerClear acc;
Eric Laurent6a94d692014-05-20 11:18:06 -0700965 return mAudioPolicyManager->createAudioPatch(patch, handle,
966 IPCThreadState::self()->getCallingUid());
Eric Laurent203b1a12014-04-01 10:34:16 -0700967}
968
Eric Laurent6a94d692014-05-20 11:18:06 -0700969status_t AudioPolicyService::releaseAudioPatch(audio_patch_handle_t handle)
Eric Laurent203b1a12014-04-01 10:34:16 -0700970{
Eric Laurent6a94d692014-05-20 11:18:06 -0700971 Mutex::Autolock _l(mLock);
Eric Laurent5284ed52014-05-29 14:37:38 -0700972 if(!modifyAudioRoutingAllowed()) {
973 return PERMISSION_DENIED;
974 }
Eric Laurent6a94d692014-05-20 11:18:06 -0700975 if (mAudioPolicyManager == NULL) {
976 return NO_INIT;
977 }
Eric Laurent10b71232018-04-13 18:14:44 -0700978 AutoCallerClear acc;
Eric Laurent6a94d692014-05-20 11:18:06 -0700979 return mAudioPolicyManager->releaseAudioPatch(handle,
980 IPCThreadState::self()->getCallingUid());
Eric Laurent203b1a12014-04-01 10:34:16 -0700981}
982
983status_t AudioPolicyService::listAudioPatches(unsigned int *num_patches,
Eric Laurent6a94d692014-05-20 11:18:06 -0700984 struct audio_patch *patches,
985 unsigned int *generation)
Eric Laurent203b1a12014-04-01 10:34:16 -0700986{
Eric Laurent6a94d692014-05-20 11:18:06 -0700987 Mutex::Autolock _l(mLock);
988 if (mAudioPolicyManager == NULL) {
989 return NO_INIT;
990 }
Eric Laurent10b71232018-04-13 18:14:44 -0700991 AutoCallerClear acc;
Eric Laurent6a94d692014-05-20 11:18:06 -0700992 return mAudioPolicyManager->listAudioPatches(num_patches, patches, generation);
Eric Laurent203b1a12014-04-01 10:34:16 -0700993}
994
Eric Laurent6a94d692014-05-20 11:18:06 -0700995status_t AudioPolicyService::setAudioPortConfig(const struct audio_port_config *config)
Eric Laurent203b1a12014-04-01 10:34:16 -0700996{
Eric Laurent6a94d692014-05-20 11:18:06 -0700997 Mutex::Autolock _l(mLock);
Eric Laurent5284ed52014-05-29 14:37:38 -0700998 if(!modifyAudioRoutingAllowed()) {
999 return PERMISSION_DENIED;
1000 }
Eric Laurent6a94d692014-05-20 11:18:06 -07001001 if (mAudioPolicyManager == NULL) {
1002 return NO_INIT;
1003 }
Eric Laurent10b71232018-04-13 18:14:44 -07001004 AutoCallerClear acc;
Eric Laurent6a94d692014-05-20 11:18:06 -07001005 return mAudioPolicyManager->setAudioPortConfig(config);
Eric Laurent203b1a12014-04-01 10:34:16 -07001006}
Eric Laurent2d388ec2014-03-07 13:25:54 -08001007
Eric Laurentdf3dc7e2014-07-27 18:39:40 -07001008status_t AudioPolicyService::acquireSoundTriggerSession(audio_session_t *session,
1009 audio_io_handle_t *ioHandle,
1010 audio_devices_t *device)
1011{
Andy Hungf759b8c2017-08-15 12:48:54 -07001012 Mutex::Autolock _l(mLock);
Eric Laurentdf3dc7e2014-07-27 18:39:40 -07001013 if (mAudioPolicyManager == NULL) {
1014 return NO_INIT;
1015 }
Eric Laurent10b71232018-04-13 18:14:44 -07001016 AutoCallerClear acc;
Eric Laurentdf3dc7e2014-07-27 18:39:40 -07001017 return mAudioPolicyManager->acquireSoundTriggerSession(session, ioHandle, device);
1018}
1019
1020status_t AudioPolicyService::releaseSoundTriggerSession(audio_session_t session)
1021{
Andy Hungf759b8c2017-08-15 12:48:54 -07001022 Mutex::Autolock _l(mLock);
Eric Laurentdf3dc7e2014-07-27 18:39:40 -07001023 if (mAudioPolicyManager == NULL) {
1024 return NO_INIT;
1025 }
Eric Laurent10b71232018-04-13 18:14:44 -07001026 AutoCallerClear acc;
Eric Laurentdf3dc7e2014-07-27 18:39:40 -07001027 return mAudioPolicyManager->releaseSoundTriggerSession(session);
1028}
1029
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -07001030status_t AudioPolicyService::registerPolicyMixes(const Vector<AudioMix>& mixes, bool registration)
Eric Laurentbaac1832014-12-01 17:52:59 -08001031{
1032 Mutex::Autolock _l(mLock);
1033 if(!modifyAudioRoutingAllowed()) {
1034 return PERMISSION_DENIED;
1035 }
1036 if (mAudioPolicyManager == NULL) {
1037 return NO_INIT;
1038 }
Eric Laurent10b71232018-04-13 18:14:44 -07001039 AutoCallerClear acc;
Eric Laurentbaac1832014-12-01 17:52:59 -08001040 if (registration) {
1041 return mAudioPolicyManager->registerPolicyMixes(mixes);
1042 } else {
1043 return mAudioPolicyManager->unregisterPolicyMixes(mixes);
1044 }
1045}
1046
Jean-Michel Trivibda70da2018-12-19 07:30:15 -08001047status_t AudioPolicyService::setUidDeviceAffinities(uid_t uid,
1048 const Vector<AudioDeviceTypeAddr>& devices) {
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->setUidDeviceAffinities(uid, devices);
1058}
1059
1060status_t AudioPolicyService::removeUidDeviceAffinities(uid_t uid) {
1061 Mutex::Autolock _l(mLock);
1062 if(!modifyAudioRoutingAllowed()) {
1063 return PERMISSION_DENIED;
1064 }
1065 if (mAudioPolicyManager == NULL) {
1066 return NO_INIT;
1067 }
1068 AutoCallerClear acc;
1069 return mAudioPolicyManager->removeUidDeviceAffinities(uid);
1070}
1071
Eric Laurent554a2772015-04-10 11:29:24 -07001072status_t AudioPolicyService::startAudioSource(const struct audio_port_config *source,
Eric Laurent3e6c7e12018-07-27 17:09:23 -07001073 const audio_attributes_t *attributes,
1074 audio_port_handle_t *portId)
Eric Laurent554a2772015-04-10 11:29:24 -07001075{
1076 Mutex::Autolock _l(mLock);
1077 if (mAudioPolicyManager == NULL) {
1078 return NO_INIT;
1079 }
Eric Laurent10b71232018-04-13 18:14:44 -07001080 AutoCallerClear acc;
Eric Laurent3e6c7e12018-07-27 17:09:23 -07001081 return mAudioPolicyManager->startAudioSource(source, attributes, portId,
Eric Laurentd60560a2015-04-10 11:31:20 -07001082 IPCThreadState::self()->getCallingUid());
Eric Laurent554a2772015-04-10 11:29:24 -07001083}
1084
Eric Laurent3e6c7e12018-07-27 17:09:23 -07001085status_t AudioPolicyService::stopAudioSource(audio_port_handle_t portId)
Eric Laurent554a2772015-04-10 11:29:24 -07001086{
1087 Mutex::Autolock _l(mLock);
1088 if (mAudioPolicyManager == NULL) {
1089 return NO_INIT;
1090 }
Eric Laurent10b71232018-04-13 18:14:44 -07001091 AutoCallerClear acc;
Eric Laurent3e6c7e12018-07-27 17:09:23 -07001092 return mAudioPolicyManager->stopAudioSource(portId);
Eric Laurent554a2772015-04-10 11:29:24 -07001093}
1094
Andy Hung2ddee192015-12-18 17:34:44 -08001095status_t AudioPolicyService::setMasterMono(bool mono)
1096{
1097 if (mAudioPolicyManager == NULL) {
1098 return NO_INIT;
1099 }
1100 if (!settingsAllowed()) {
1101 return PERMISSION_DENIED;
1102 }
1103 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -07001104 AutoCallerClear acc;
Andy Hung2ddee192015-12-18 17:34:44 -08001105 return mAudioPolicyManager->setMasterMono(mono);
1106}
1107
1108status_t AudioPolicyService::getMasterMono(bool *mono)
1109{
1110 if (mAudioPolicyManager == NULL) {
1111 return NO_INIT;
1112 }
1113 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -07001114 AutoCallerClear acc;
Andy Hung2ddee192015-12-18 17:34:44 -08001115 return mAudioPolicyManager->getMasterMono(mono);
1116}
1117
Eric Laurentac9cef52017-06-09 15:46:26 -07001118
1119float AudioPolicyService::getStreamVolumeDB(
1120 audio_stream_type_t stream, int index, audio_devices_t device)
1121{
1122 if (mAudioPolicyManager == NULL) {
1123 return NAN;
1124 }
1125 Mutex::Autolock _l(mLock);
Eric Laurent10b71232018-04-13 18:14:44 -07001126 AutoCallerClear acc;
Eric Laurentac9cef52017-06-09 15:46:26 -07001127 return mAudioPolicyManager->getStreamVolumeDB(stream, index, device);
1128}
1129
jiabin81772902018-04-02 17:52:27 -07001130status_t AudioPolicyService::getSurroundFormats(unsigned int *numSurroundFormats,
1131 audio_format_t *surroundFormats,
1132 bool *surroundFormatsEnabled,
1133 bool reported)
1134{
1135 if (mAudioPolicyManager == NULL) {
1136 return NO_INIT;
1137 }
1138 Mutex::Autolock _l(mLock);
1139 AutoCallerClear acc;
1140 return mAudioPolicyManager->getSurroundFormats(numSurroundFormats, surroundFormats,
1141 surroundFormatsEnabled, reported);
1142}
1143
Arun Mirpuri11029ad2018-12-19 20:45:19 -08001144status_t AudioPolicyService::getHwOffloadEncodingFormatsSupportedForA2DP(
1145 std::vector<audio_format_t> *formats)
1146{
1147 if (mAudioPolicyManager == NULL) {
1148 return NO_INIT;
1149 }
1150 Mutex::Autolock _l(mLock);
1151 AutoCallerClear acc;
1152 return mAudioPolicyManager->getHwOffloadEncodingFormatsSupportedForA2DP(formats);
1153}
1154
jiabin81772902018-04-02 17:52:27 -07001155status_t AudioPolicyService::setSurroundFormatEnabled(audio_format_t audioFormat, bool enabled)
1156{
1157 if (mAudioPolicyManager == NULL) {
1158 return NO_INIT;
1159 }
1160 Mutex::Autolock _l(mLock);
1161 AutoCallerClear acc;
1162 return mAudioPolicyManager->setSurroundFormatEnabled(audioFormat, enabled);
1163}
Eric Laurentac9cef52017-06-09 15:46:26 -07001164
Eric Laurentb78763e2018-10-17 10:08:02 -07001165status_t AudioPolicyService::setAssistantUid(uid_t uid)
1166{
1167 Mutex::Autolock _l(mLock);
1168 mUidPolicy->setAssistantUid(uid);
1169 return NO_ERROR;
1170}
1171
1172status_t AudioPolicyService::setA11yServicesUids(const std::vector<uid_t>& uids)
1173{
1174 Mutex::Autolock _l(mLock);
1175 mUidPolicy->setA11yUids(uids);
1176 return NO_ERROR;
1177}
1178
jiabin6012f912018-11-02 17:06:30 -07001179bool AudioPolicyService::isHapticPlaybackSupported()
1180{
1181 if (mAudioPolicyManager == NULL) {
1182 ALOGW("%s, mAudioPolicyManager == NULL", __func__);
1183 return false;
1184 }
1185 Mutex::Autolock _l(mLock);
1186 AutoCallerClear acc;
1187 return mAudioPolicyManager->isHapticPlaybackSupported();
1188}
1189
François Gaffied0ba9ed2018-11-05 11:50:42 +01001190status_t AudioPolicyService::listAudioProductStrategies(AudioProductStrategyVector &strategies)
1191{
1192 if (mAudioPolicyManager == NULL) {
1193 return NO_INIT;
1194 }
1195 Mutex::Autolock _l(mLock);
1196 return mAudioPolicyManager->listAudioProductStrategies(strategies);
1197}
1198
1199product_strategy_t AudioPolicyService::getProductStrategyFromAudioAttributes(
1200 const AudioAttributes &aa)
1201{
1202 if (mAudioPolicyManager == NULL) {
1203 return PRODUCT_STRATEGY_NONE;
1204 }
1205 Mutex::Autolock _l(mLock);
1206 return mAudioPolicyManager->getProductStrategyFromAudioAttributes(aa);
1207}
Mikhail Naganov1b2a7942017-12-08 10:18:09 -08001208} // namespace android