blob: 8b64d5be6ac2779b81adecc436ef0cbaa5e79dcb [file] [log] [blame]
Eric Laurent2d388ec2014-03-07 13:25:54 -08001/*
2 * Copyright (C) 2009 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
Eric Laurentdce54a12014-03-10 12:19:46 -070017#define LOG_TAG "AudioPolicyIntefaceImpl"
Eric Laurent2d388ec2014-03-07 13:25:54 -080018//#define LOG_NDEBUG 0
19
20#include <utils/Log.h>
21#include "AudioPolicyService.h"
22#include "ServiceUtilities.h"
23
Eric Laurent2d388ec2014-03-07 13:25:54 -080024namespace android {
25
26
27// ----------------------------------------------------------------------------
28
29status_t AudioPolicyService::setDeviceConnectionState(audio_devices_t device,
30 audio_policy_dev_state_t state,
31 const char *device_address)
32{
Eric Laurentdce54a12014-03-10 12:19:46 -070033 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -080034 return NO_INIT;
35 }
36 if (!settingsAllowed()) {
37 return PERMISSION_DENIED;
38 }
39 if (!audio_is_output_device(device) && !audio_is_input_device(device)) {
40 return BAD_VALUE;
41 }
42 if (state != AUDIO_POLICY_DEVICE_STATE_AVAILABLE &&
43 state != AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE) {
44 return BAD_VALUE;
45 }
46
47 ALOGV("setDeviceConnectionState()");
48 Mutex::Autolock _l(mLock);
Eric Laurentdce54a12014-03-10 12:19:46 -070049 return mAudioPolicyManager->setDeviceConnectionState(device,
Eric Laurent2d388ec2014-03-07 13:25:54 -080050 state, device_address);
51}
52
53audio_policy_dev_state_t AudioPolicyService::getDeviceConnectionState(
54 audio_devices_t device,
55 const char *device_address)
56{
Eric Laurentdce54a12014-03-10 12:19:46 -070057 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -080058 return AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE;
59 }
Eric Laurentdce54a12014-03-10 12:19:46 -070060 return mAudioPolicyManager->getDeviceConnectionState(device,
Eric Laurent2d388ec2014-03-07 13:25:54 -080061 device_address);
62}
63
64status_t AudioPolicyService::setPhoneState(audio_mode_t state)
65{
Eric Laurentdce54a12014-03-10 12:19:46 -070066 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -080067 return NO_INIT;
68 }
69 if (!settingsAllowed()) {
70 return PERMISSION_DENIED;
71 }
72 if (uint32_t(state) >= AUDIO_MODE_CNT) {
73 return BAD_VALUE;
74 }
75
76 ALOGV("setPhoneState()");
77
78 // TODO: check if it is more appropriate to do it in platform specific policy manager
79 AudioSystem::setMode(state);
80
81 Mutex::Autolock _l(mLock);
Eric Laurentdce54a12014-03-10 12:19:46 -070082 mAudioPolicyManager->setPhoneState(state);
Eric Laurentbb6c9a02014-09-25 14:11:47 -070083 mPhoneState = state;
Eric Laurent2d388ec2014-03-07 13:25:54 -080084 return NO_ERROR;
85}
86
Eric Laurentbb6c9a02014-09-25 14:11:47 -070087audio_mode_t AudioPolicyService::getPhoneState()
88{
89 Mutex::Autolock _l(mLock);
90 return mPhoneState;
91}
92
Eric Laurent2d388ec2014-03-07 13:25:54 -080093status_t AudioPolicyService::setForceUse(audio_policy_force_use_t usage,
94 audio_policy_forced_cfg_t config)
95{
Eric Laurentdce54a12014-03-10 12:19:46 -070096 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -080097 return NO_INIT;
98 }
99 if (!settingsAllowed()) {
100 return PERMISSION_DENIED;
101 }
102 if (usage < 0 || usage >= AUDIO_POLICY_FORCE_USE_CNT) {
103 return BAD_VALUE;
104 }
105 if (config < 0 || config >= AUDIO_POLICY_FORCE_CFG_CNT) {
106 return BAD_VALUE;
107 }
108 ALOGV("setForceUse()");
109 Mutex::Autolock _l(mLock);
Eric Laurentdce54a12014-03-10 12:19:46 -0700110 mAudioPolicyManager->setForceUse(usage, config);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800111 return NO_ERROR;
112}
113
114audio_policy_forced_cfg_t AudioPolicyService::getForceUse(audio_policy_force_use_t usage)
115{
Eric Laurentdce54a12014-03-10 12:19:46 -0700116 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800117 return AUDIO_POLICY_FORCE_NONE;
118 }
119 if (usage < 0 || usage >= AUDIO_POLICY_FORCE_USE_CNT) {
120 return AUDIO_POLICY_FORCE_NONE;
121 }
Eric Laurentdce54a12014-03-10 12:19:46 -0700122 return mAudioPolicyManager->getForceUse(usage);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800123}
124
125audio_io_handle_t AudioPolicyService::getOutput(audio_stream_type_t stream,
126 uint32_t samplingRate,
127 audio_format_t format,
128 audio_channel_mask_t channelMask,
129 audio_output_flags_t flags,
130 const audio_offload_info_t *offloadInfo)
131{
Eric Laurent223fd5c2014-11-11 13:43:36 -0800132 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
Eric Laurentb1322c72014-10-30 14:59:13 -0700133 return AUDIO_IO_HANDLE_NONE;
Eric Laurentdea15412014-10-28 15:46:45 -0700134 }
Eric Laurentdce54a12014-03-10 12:19:46 -0700135 if (mAudioPolicyManager == NULL) {
Eric Laurentb1322c72014-10-30 14:59:13 -0700136 return AUDIO_IO_HANDLE_NONE;
Eric Laurent2d388ec2014-03-07 13:25:54 -0800137 }
138 ALOGV("getOutput()");
139 Mutex::Autolock _l(mLock);
Eric Laurentdce54a12014-03-10 12:19:46 -0700140 return mAudioPolicyManager->getOutput(stream, samplingRate,
Eric Laurent2d388ec2014-03-07 13:25:54 -0800141 format, channelMask, flags, offloadInfo);
142}
143
Eric Laurente83b55d2014-11-14 10:06:21 -0800144status_t AudioPolicyService::getOutputForAttr(const audio_attributes_t *attr,
145 audio_io_handle_t *output,
146 audio_session_t session,
147 audio_stream_type_t *stream,
148 uint32_t samplingRate,
149 audio_format_t format,
150 audio_channel_mask_t channelMask,
151 audio_output_flags_t flags,
152 const audio_offload_info_t *offloadInfo)
Jean-Michel Trivi5bd3f382014-06-13 16:06:54 -0700153{
154 if (mAudioPolicyManager == NULL) {
Eric Laurente83b55d2014-11-14 10:06:21 -0800155 return NO_INIT;
Jean-Michel Trivi5bd3f382014-06-13 16:06:54 -0700156 }
157 ALOGV("getOutput()");
158 Mutex::Autolock _l(mLock);
Eric Laurente83b55d2014-11-14 10:06:21 -0800159 return mAudioPolicyManager->getOutputForAttr(attr, output, session, stream, samplingRate,
Jean-Michel Trivi5bd3f382014-06-13 16:06:54 -0700160 format, channelMask, flags, offloadInfo);
161}
162
Eric Laurent2d388ec2014-03-07 13:25:54 -0800163status_t AudioPolicyService::startOutput(audio_io_handle_t output,
164 audio_stream_type_t stream,
Eric Laurente83b55d2014-11-14 10:06:21 -0800165 audio_session_t session)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800166{
Eric Laurentdea15412014-10-28 15:46:45 -0700167 if (uint32_t(stream) >= AUDIO_STREAM_CNT) {
168 return BAD_VALUE;
169 }
Eric Laurentdce54a12014-03-10 12:19:46 -0700170 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800171 return NO_INIT;
172 }
173 ALOGV("startOutput()");
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700174 sp<AudioPolicyEffects>audioPolicyEffects;
175 {
176 Mutex::Autolock _l(mLock);
177 audioPolicyEffects = mAudioPolicyEffects;
bryant_liuba2b4392014-06-11 16:49:30 +0800178 }
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700179 if (audioPolicyEffects != 0) {
180 // create audio processors according to stream
181 status_t status = audioPolicyEffects->addOutputSessionEffects(output, stream, session);
182 if (status != NO_ERROR && status != ALREADY_EXISTS) {
183 ALOGW("Failed to add effects on session %d", session);
184 }
185 }
186 Mutex::Autolock _l(mLock);
Eric Laurentdce54a12014-03-10 12:19:46 -0700187 return mAudioPolicyManager->startOutput(output, stream, session);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800188}
189
190status_t AudioPolicyService::stopOutput(audio_io_handle_t output,
191 audio_stream_type_t stream,
Eric Laurente83b55d2014-11-14 10:06:21 -0800192 audio_session_t session)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800193{
Eric Laurentdea15412014-10-28 15:46:45 -0700194 if (uint32_t(stream) >= AUDIO_STREAM_CNT) {
195 return BAD_VALUE;
196 }
Eric Laurentdce54a12014-03-10 12:19:46 -0700197 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800198 return NO_INIT;
199 }
200 ALOGV("stopOutput()");
201 mOutputCommandThread->stopOutputCommand(output, stream, session);
202 return NO_ERROR;
203}
204
205status_t AudioPolicyService::doStopOutput(audio_io_handle_t output,
206 audio_stream_type_t stream,
Eric Laurente83b55d2014-11-14 10:06:21 -0800207 audio_session_t session)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800208{
209 ALOGV("doStopOutput from tid %d", gettid());
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700210 sp<AudioPolicyEffects>audioPolicyEffects;
211 {
212 Mutex::Autolock _l(mLock);
213 audioPolicyEffects = mAudioPolicyEffects;
bryant_liuba2b4392014-06-11 16:49:30 +0800214 }
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700215 if (audioPolicyEffects != 0) {
216 // release audio processors from the stream
217 status_t status = audioPolicyEffects->releaseOutputSessionEffects(output, stream, session);
218 if (status != NO_ERROR && status != ALREADY_EXISTS) {
219 ALOGW("Failed to release effects on session %d", session);
220 }
221 }
222 Mutex::Autolock _l(mLock);
Eric Laurentdce54a12014-03-10 12:19:46 -0700223 return mAudioPolicyManager->stopOutput(output, stream, session);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800224}
225
Eric Laurente83b55d2014-11-14 10:06:21 -0800226void AudioPolicyService::releaseOutput(audio_io_handle_t output,
227 audio_stream_type_t stream,
228 audio_session_t session)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800229{
Eric Laurentdce54a12014-03-10 12:19:46 -0700230 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800231 return;
232 }
233 ALOGV("releaseOutput()");
Eric Laurente83b55d2014-11-14 10:06:21 -0800234 mOutputCommandThread->releaseOutputCommand(output, stream, session);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800235}
236
Eric Laurente83b55d2014-11-14 10:06:21 -0800237void AudioPolicyService::doReleaseOutput(audio_io_handle_t output,
238 audio_stream_type_t stream,
239 audio_session_t session)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800240{
241 ALOGV("doReleaseOutput from tid %d", gettid());
242 Mutex::Autolock _l(mLock);
Eric Laurente83b55d2014-11-14 10:06:21 -0800243 mAudioPolicyManager->releaseOutput(output, stream, session);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800244}
245
246audio_io_handle_t AudioPolicyService::getInput(audio_source_t inputSource,
247 uint32_t samplingRate,
248 audio_format_t format,
249 audio_channel_mask_t channelMask,
Eric Laurente83b55d2014-11-14 10:06:21 -0800250 audio_session_t audioSession,
Glenn Kasten6a8ab052014-07-24 14:08:35 -0700251 audio_input_flags_t flags)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800252{
Eric Laurentdce54a12014-03-10 12:19:46 -0700253 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800254 return 0;
255 }
256 // already checked by client, but double-check in case the client wrapper is bypassed
Hochi Huangf53eaf42014-10-09 11:36:22 +0800257 if (inputSource >= AUDIO_SOURCE_CNT && inputSource != AUDIO_SOURCE_HOTWORD &&
258 inputSource != AUDIO_SOURCE_FM_TUNER) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800259 return 0;
260 }
261
Hochi Huangf53eaf42014-10-09 11:36:22 +0800262 if (((inputSource == AUDIO_SOURCE_HOTWORD) && !captureHotwordAllowed()) ||
263 ((inputSource == AUDIO_SOURCE_FM_TUNER) && !captureFmTunerAllowed())) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800264 return 0;
265 }
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700266 audio_io_handle_t input;
267 sp<AudioPolicyEffects>audioPolicyEffects;
268 {
269 Mutex::Autolock _l(mLock);
270 // the audio_in_acoustics_t parameter is ignored by get_input()
271 input = mAudioPolicyManager->getInput(inputSource, samplingRate,
272 format, channelMask,
Eric Laurente83b55d2014-11-14 10:06:21 -0800273 audioSession, flags);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700274 audioPolicyEffects = mAudioPolicyEffects;
275 }
Eric Laurent2d388ec2014-03-07 13:25:54 -0800276 if (input == 0) {
277 return input;
278 }
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700279 if (audioPolicyEffects != 0) {
280 // create audio pre processors according to input source
281 status_t status = audioPolicyEffects->addInputEffects(input, inputSource, audioSession);
282 if (status != NO_ERROR && status != ALREADY_EXISTS) {
283 ALOGW("Failed to add effects on input %d", input);
284 }
Eric Laurent2d388ec2014-03-07 13:25:54 -0800285 }
Eric Laurent2d388ec2014-03-07 13:25:54 -0800286 return input;
287}
288
Eric Laurent4dc68062014-07-28 17:26:49 -0700289status_t AudioPolicyService::startInput(audio_io_handle_t input,
290 audio_session_t session)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800291{
Eric Laurentdce54a12014-03-10 12:19:46 -0700292 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800293 return NO_INIT;
294 }
295 Mutex::Autolock _l(mLock);
296
Eric Laurent4dc68062014-07-28 17:26:49 -0700297 return mAudioPolicyManager->startInput(input, session);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800298}
299
Eric Laurent4dc68062014-07-28 17:26:49 -0700300status_t AudioPolicyService::stopInput(audio_io_handle_t input,
301 audio_session_t session)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800302{
Eric Laurentdce54a12014-03-10 12:19:46 -0700303 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800304 return NO_INIT;
305 }
306 Mutex::Autolock _l(mLock);
307
Eric Laurent4dc68062014-07-28 17:26:49 -0700308 return mAudioPolicyManager->stopInput(input, session);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800309}
310
Eric Laurent4dc68062014-07-28 17:26:49 -0700311void AudioPolicyService::releaseInput(audio_io_handle_t input,
312 audio_session_t session)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800313{
Eric Laurentdce54a12014-03-10 12:19:46 -0700314 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800315 return;
316 }
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700317 sp<AudioPolicyEffects>audioPolicyEffects;
318 {
319 Mutex::Autolock _l(mLock);
320 mAudioPolicyManager->releaseInput(input, session);
321 audioPolicyEffects = mAudioPolicyEffects;
322 }
323 if (audioPolicyEffects != 0) {
324 // release audio processors from the input
325 status_t status = audioPolicyEffects->releaseInputEffects(input);
326 if(status != NO_ERROR) {
327 ALOGW("Failed to release effects on input %d", input);
328 }
Eric Laurent2d388ec2014-03-07 13:25:54 -0800329 }
Eric Laurent2d388ec2014-03-07 13:25:54 -0800330}
331
332status_t AudioPolicyService::initStreamVolume(audio_stream_type_t stream,
333 int indexMin,
334 int indexMax)
335{
Eric Laurentdce54a12014-03-10 12:19:46 -0700336 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800337 return NO_INIT;
338 }
339 if (!settingsAllowed()) {
340 return PERMISSION_DENIED;
341 }
Eric Laurent223fd5c2014-11-11 13:43:36 -0800342 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800343 return BAD_VALUE;
344 }
345 Mutex::Autolock _l(mLock);
Eric Laurentdce54a12014-03-10 12:19:46 -0700346 mAudioPolicyManager->initStreamVolume(stream, indexMin, indexMax);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800347 return NO_ERROR;
348}
349
350status_t AudioPolicyService::setStreamVolumeIndex(audio_stream_type_t stream,
351 int index,
352 audio_devices_t device)
353{
Eric Laurentdce54a12014-03-10 12:19:46 -0700354 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800355 return NO_INIT;
356 }
357 if (!settingsAllowed()) {
358 return PERMISSION_DENIED;
359 }
Eric Laurent223fd5c2014-11-11 13:43:36 -0800360 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800361 return BAD_VALUE;
362 }
363 Mutex::Autolock _l(mLock);
Eric Laurentdce54a12014-03-10 12:19:46 -0700364 return mAudioPolicyManager->setStreamVolumeIndex(stream,
365 index,
366 device);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800367}
368
369status_t AudioPolicyService::getStreamVolumeIndex(audio_stream_type_t stream,
370 int *index,
371 audio_devices_t device)
372{
Eric Laurentdce54a12014-03-10 12:19:46 -0700373 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800374 return NO_INIT;
375 }
Eric Laurent223fd5c2014-11-11 13:43:36 -0800376 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800377 return BAD_VALUE;
378 }
379 Mutex::Autolock _l(mLock);
Eric Laurentdce54a12014-03-10 12:19:46 -0700380 return mAudioPolicyManager->getStreamVolumeIndex(stream,
381 index,
382 device);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800383}
384
385uint32_t AudioPolicyService::getStrategyForStream(audio_stream_type_t stream)
386{
Eric Laurent223fd5c2014-11-11 13:43:36 -0800387 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
Eric Laurentb1322c72014-10-30 14:59:13 -0700388 return 0;
Eric Laurentdea15412014-10-28 15:46:45 -0700389 }
Eric Laurentdce54a12014-03-10 12:19:46 -0700390 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800391 return 0;
392 }
Eric Laurentdce54a12014-03-10 12:19:46 -0700393 return mAudioPolicyManager->getStrategyForStream(stream);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800394}
395
396//audio policy: use audio_device_t appropriately
397
398audio_devices_t AudioPolicyService::getDevicesForStream(audio_stream_type_t stream)
399{
Eric Laurent223fd5c2014-11-11 13:43:36 -0800400 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
Eric Laurentb1322c72014-10-30 14:59:13 -0700401 return AUDIO_DEVICE_NONE;
Eric Laurentdea15412014-10-28 15:46:45 -0700402 }
Eric Laurentdce54a12014-03-10 12:19:46 -0700403 if (mAudioPolicyManager == NULL) {
Eric Laurentb1322c72014-10-30 14:59:13 -0700404 return AUDIO_DEVICE_NONE;
Eric Laurent2d388ec2014-03-07 13:25:54 -0800405 }
Eric Laurentdce54a12014-03-10 12:19:46 -0700406 return mAudioPolicyManager->getDevicesForStream(stream);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800407}
408
409audio_io_handle_t AudioPolicyService::getOutputForEffect(const effect_descriptor_t *desc)
410{
411 // FIXME change return type to status_t, and return NO_INIT here
Eric Laurentdce54a12014-03-10 12:19:46 -0700412 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800413 return 0;
414 }
415 Mutex::Autolock _l(mLock);
Eric Laurentdce54a12014-03-10 12:19:46 -0700416 return mAudioPolicyManager->getOutputForEffect(desc);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800417}
418
419status_t AudioPolicyService::registerEffect(const effect_descriptor_t *desc,
420 audio_io_handle_t io,
421 uint32_t strategy,
422 int session,
423 int id)
424{
Eric Laurentdce54a12014-03-10 12:19:46 -0700425 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800426 return NO_INIT;
427 }
Eric Laurentdce54a12014-03-10 12:19:46 -0700428 return mAudioPolicyManager->registerEffect(desc, io, strategy, session, id);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800429}
430
431status_t AudioPolicyService::unregisterEffect(int id)
432{
Eric Laurentdce54a12014-03-10 12:19:46 -0700433 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800434 return NO_INIT;
435 }
Eric Laurentdce54a12014-03-10 12:19:46 -0700436 return mAudioPolicyManager->unregisterEffect(id);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800437}
438
439status_t AudioPolicyService::setEffectEnabled(int id, bool enabled)
440{
Eric Laurentdce54a12014-03-10 12:19:46 -0700441 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800442 return NO_INIT;
443 }
Eric Laurentdce54a12014-03-10 12:19:46 -0700444 return mAudioPolicyManager->setEffectEnabled(id, enabled);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800445}
446
447bool AudioPolicyService::isStreamActive(audio_stream_type_t stream, uint32_t inPastMs) const
448{
Eric Laurent223fd5c2014-11-11 13:43:36 -0800449 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
Eric Laurentb1322c72014-10-30 14:59:13 -0700450 return false;
Eric Laurentdea15412014-10-28 15:46:45 -0700451 }
Eric Laurentdce54a12014-03-10 12:19:46 -0700452 if (mAudioPolicyManager == NULL) {
Eric Laurentb1322c72014-10-30 14:59:13 -0700453 return false;
Eric Laurent2d388ec2014-03-07 13:25:54 -0800454 }
455 Mutex::Autolock _l(mLock);
Eric Laurentdce54a12014-03-10 12:19:46 -0700456 return mAudioPolicyManager->isStreamActive(stream, inPastMs);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800457}
458
459bool AudioPolicyService::isStreamActiveRemotely(audio_stream_type_t stream, uint32_t inPastMs) const
460{
Eric Laurent223fd5c2014-11-11 13:43:36 -0800461 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
Eric Laurentb1322c72014-10-30 14:59:13 -0700462 return false;
Eric Laurentdea15412014-10-28 15:46:45 -0700463 }
Eric Laurentdce54a12014-03-10 12:19:46 -0700464 if (mAudioPolicyManager == NULL) {
Eric Laurentb1322c72014-10-30 14:59:13 -0700465 return false;
Eric Laurent2d388ec2014-03-07 13:25:54 -0800466 }
467 Mutex::Autolock _l(mLock);
Eric Laurentdce54a12014-03-10 12:19:46 -0700468 return mAudioPolicyManager->isStreamActiveRemotely(stream, inPastMs);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800469}
470
471bool AudioPolicyService::isSourceActive(audio_source_t source) const
472{
Eric Laurentdce54a12014-03-10 12:19:46 -0700473 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800474 return false;
475 }
476 Mutex::Autolock _l(mLock);
Eric Laurentdce54a12014-03-10 12:19:46 -0700477 return mAudioPolicyManager->isSourceActive(source);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800478}
479
480status_t AudioPolicyService::queryDefaultPreProcessing(int audioSession,
481 effect_descriptor_t *descriptors,
482 uint32_t *count)
483{
Eric Laurentdce54a12014-03-10 12:19:46 -0700484 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -0800485 *count = 0;
486 return NO_INIT;
487 }
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700488 sp<AudioPolicyEffects>audioPolicyEffects;
489 {
490 Mutex::Autolock _l(mLock);
491 audioPolicyEffects = mAudioPolicyEffects;
492 }
493 if (audioPolicyEffects == 0) {
494 *count = 0;
495 return NO_INIT;
496 }
497 return audioPolicyEffects->queryDefaultInputEffects(audioSession, descriptors, count);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800498}
499
500bool AudioPolicyService::isOffloadSupported(const audio_offload_info_t& info)
501{
Eric Laurentdce54a12014-03-10 12:19:46 -0700502 if (mAudioPolicyManager == NULL) {
503 ALOGV("mAudioPolicyManager == NULL");
Eric Laurent2d388ec2014-03-07 13:25:54 -0800504 return false;
505 }
506
Eric Laurentdce54a12014-03-10 12:19:46 -0700507 return mAudioPolicyManager->isOffloadSupported(info);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800508}
509
Eric Laurent6a94d692014-05-20 11:18:06 -0700510status_t AudioPolicyService::listAudioPorts(audio_port_role_t role,
511 audio_port_type_t type,
Eric Laurent203b1a12014-04-01 10:34:16 -0700512 unsigned int *num_ports,
Eric Laurent6a94d692014-05-20 11:18:06 -0700513 struct audio_port *ports,
514 unsigned int *generation)
Eric Laurent203b1a12014-04-01 10:34:16 -0700515{
Eric Laurent6a94d692014-05-20 11:18:06 -0700516 Mutex::Autolock _l(mLock);
Eric Laurent5284ed52014-05-29 14:37:38 -0700517 if(!modifyAudioRoutingAllowed()) {
518 return PERMISSION_DENIED;
519 }
Eric Laurent6a94d692014-05-20 11:18:06 -0700520 if (mAudioPolicyManager == NULL) {
521 return NO_INIT;
522 }
523
524 return mAudioPolicyManager->listAudioPorts(role, type, num_ports, ports, generation);
Eric Laurent203b1a12014-04-01 10:34:16 -0700525}
526
Eric Laurent6a94d692014-05-20 11:18:06 -0700527status_t AudioPolicyService::getAudioPort(struct audio_port *port)
Eric Laurent203b1a12014-04-01 10:34:16 -0700528{
Eric Laurent6a94d692014-05-20 11:18:06 -0700529 Mutex::Autolock _l(mLock);
Eric Laurent5284ed52014-05-29 14:37:38 -0700530 if(!modifyAudioRoutingAllowed()) {
531 return PERMISSION_DENIED;
532 }
Eric Laurent6a94d692014-05-20 11:18:06 -0700533 if (mAudioPolicyManager == NULL) {
534 return NO_INIT;
535 }
536
537 return mAudioPolicyManager->getAudioPort(port);
Eric Laurent203b1a12014-04-01 10:34:16 -0700538}
539
Eric Laurent6a94d692014-05-20 11:18:06 -0700540status_t AudioPolicyService::createAudioPatch(const struct audio_patch *patch,
541 audio_patch_handle_t *handle)
Eric Laurent203b1a12014-04-01 10:34:16 -0700542{
Eric Laurent6a94d692014-05-20 11:18:06 -0700543 Mutex::Autolock _l(mLock);
Eric Laurent5284ed52014-05-29 14:37:38 -0700544 if(!modifyAudioRoutingAllowed()) {
545 return PERMISSION_DENIED;
546 }
Eric Laurent6a94d692014-05-20 11:18:06 -0700547 if (mAudioPolicyManager == NULL) {
548 return NO_INIT;
549 }
550 return mAudioPolicyManager->createAudioPatch(patch, handle,
551 IPCThreadState::self()->getCallingUid());
Eric Laurent203b1a12014-04-01 10:34:16 -0700552}
553
Eric Laurent6a94d692014-05-20 11:18:06 -0700554status_t AudioPolicyService::releaseAudioPatch(audio_patch_handle_t handle)
Eric Laurent203b1a12014-04-01 10:34:16 -0700555{
Eric Laurent6a94d692014-05-20 11:18:06 -0700556 Mutex::Autolock _l(mLock);
Eric Laurent5284ed52014-05-29 14:37:38 -0700557 if(!modifyAudioRoutingAllowed()) {
558 return PERMISSION_DENIED;
559 }
Eric Laurent6a94d692014-05-20 11:18:06 -0700560 if (mAudioPolicyManager == NULL) {
561 return NO_INIT;
562 }
563
564 return mAudioPolicyManager->releaseAudioPatch(handle,
565 IPCThreadState::self()->getCallingUid());
Eric Laurent203b1a12014-04-01 10:34:16 -0700566}
567
568status_t AudioPolicyService::listAudioPatches(unsigned int *num_patches,
Eric Laurent6a94d692014-05-20 11:18:06 -0700569 struct audio_patch *patches,
570 unsigned int *generation)
Eric Laurent203b1a12014-04-01 10:34:16 -0700571{
Eric Laurent6a94d692014-05-20 11:18:06 -0700572 Mutex::Autolock _l(mLock);
Eric Laurent5284ed52014-05-29 14:37:38 -0700573 if(!modifyAudioRoutingAllowed()) {
574 return PERMISSION_DENIED;
575 }
Eric Laurent6a94d692014-05-20 11:18:06 -0700576 if (mAudioPolicyManager == NULL) {
577 return NO_INIT;
578 }
579
580 return mAudioPolicyManager->listAudioPatches(num_patches, patches, generation);
Eric Laurent203b1a12014-04-01 10:34:16 -0700581}
582
Eric Laurent6a94d692014-05-20 11:18:06 -0700583status_t AudioPolicyService::setAudioPortConfig(const struct audio_port_config *config)
Eric Laurent203b1a12014-04-01 10:34:16 -0700584{
Eric Laurent6a94d692014-05-20 11:18:06 -0700585 Mutex::Autolock _l(mLock);
Eric Laurent5284ed52014-05-29 14:37:38 -0700586 if(!modifyAudioRoutingAllowed()) {
587 return PERMISSION_DENIED;
588 }
Eric Laurent6a94d692014-05-20 11:18:06 -0700589 if (mAudioPolicyManager == NULL) {
590 return NO_INIT;
591 }
592
593 return mAudioPolicyManager->setAudioPortConfig(config);
Eric Laurent203b1a12014-04-01 10:34:16 -0700594}
Eric Laurent2d388ec2014-03-07 13:25:54 -0800595
Eric Laurentdf3dc7e2014-07-27 18:39:40 -0700596status_t AudioPolicyService::acquireSoundTriggerSession(audio_session_t *session,
597 audio_io_handle_t *ioHandle,
598 audio_devices_t *device)
599{
600 if (mAudioPolicyManager == NULL) {
601 return NO_INIT;
602 }
603
604 return mAudioPolicyManager->acquireSoundTriggerSession(session, ioHandle, device);
605}
606
607status_t AudioPolicyService::releaseSoundTriggerSession(audio_session_t session)
608{
609 if (mAudioPolicyManager == NULL) {
610 return NO_INIT;
611 }
612
613 return mAudioPolicyManager->releaseSoundTriggerSession(session);
614}
615
Eric Laurent2d388ec2014-03-07 13:25:54 -0800616}; // namespace android