1 /*
2 **
3 ** Copyright 2009, The Android Open Source Project
4 **
5 ** Licensed under the Apache License, Version 2.0 (the "License");
6 ** you may not use this file except in compliance with the License.
7 ** You may obtain a copy of the License at
8 **
9 ** http://www.apache.org/licenses/LICENSE-2.0
10 **
11 ** Unless required by applicable law or agreed to in writing, software
12 ** distributed under the License is distributed on an "AS IS" BASIS,
13 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 ** See the License for the specific language governing permissions and
15 ** limitations under the License.
16 */
17
18 #define LOG_TAG "IAudioPolicyService"
19 #include <utils/Log.h>
20
21 #include <stdint.h>
22 #include <math.h>
23 #include <sys/types.h>
24
25 #include <binder/IPCThreadState.h>
26 #include <binder/Parcel.h>
27 #include <cutils/multiuser.h>
28 #include <media/AudioEffect.h>
29 #include <media/IAudioPolicyService.h>
30 #include <media/TimeCheck.h>
31 #include <private/android_filesystem_config.h>
32 #include <system/audio.h>
33
34 namespace android {
35
36 enum {
37 SET_DEVICE_CONNECTION_STATE = IBinder::FIRST_CALL_TRANSACTION,
38 GET_DEVICE_CONNECTION_STATE,
39 HANDLE_DEVICE_CONFIG_CHANGE,
40 SET_PHONE_STATE,
41 SET_RINGER_MODE, // reserved, no longer used
42 SET_FORCE_USE,
43 GET_FORCE_USE,
44 GET_OUTPUT,
45 START_OUTPUT,
46 STOP_OUTPUT,
47 RELEASE_OUTPUT,
48 GET_INPUT_FOR_ATTR,
49 START_INPUT,
50 STOP_INPUT,
51 RELEASE_INPUT,
52 INIT_STREAM_VOLUME,
53 SET_STREAM_VOLUME,
54 GET_STREAM_VOLUME,
55 GET_STRATEGY_FOR_STREAM,
56 GET_OUTPUT_FOR_EFFECT,
57 REGISTER_EFFECT,
58 UNREGISTER_EFFECT,
59 IS_STREAM_ACTIVE,
60 IS_SOURCE_ACTIVE,
61 GET_DEVICES_FOR_STREAM,
62 QUERY_DEFAULT_PRE_PROCESSING,
63 SET_EFFECT_ENABLED,
64 IS_STREAM_ACTIVE_REMOTELY,
65 IS_OFFLOAD_SUPPORTED,
66 LIST_AUDIO_PORTS,
67 GET_AUDIO_PORT,
68 CREATE_AUDIO_PATCH,
69 RELEASE_AUDIO_PATCH,
70 LIST_AUDIO_PATCHES,
71 SET_AUDIO_PORT_CONFIG,
72 REGISTER_CLIENT,
73 GET_OUTPUT_FOR_ATTR,
74 ACQUIRE_SOUNDTRIGGER_SESSION,
75 RELEASE_SOUNDTRIGGER_SESSION,
76 GET_PHONE_STATE,
77 REGISTER_POLICY_MIXES,
78 START_AUDIO_SOURCE,
79 STOP_AUDIO_SOURCE,
80 SET_AUDIO_PORT_CALLBACK_ENABLED,
81 SET_MASTER_MONO,
82 GET_MASTER_MONO,
83 GET_STREAM_VOLUME_DB,
84 GET_SURROUND_FORMATS,
85 SET_SURROUND_FORMAT_ENABLED
86 };
87
88 #define MAX_ITEMS_PER_LIST 1024
89
90 class BpAudioPolicyService : public BpInterface<IAudioPolicyService>
91 {
92 public:
BpAudioPolicyService(const sp<IBinder> & impl)93 explicit BpAudioPolicyService(const sp<IBinder>& impl)
94 : BpInterface<IAudioPolicyService>(impl)
95 {
96 }
97
setDeviceConnectionState(audio_devices_t device,audio_policy_dev_state_t state,const char * device_address,const char * device_name)98 virtual status_t setDeviceConnectionState(
99 audio_devices_t device,
100 audio_policy_dev_state_t state,
101 const char *device_address,
102 const char *device_name)
103 {
104 Parcel data, reply;
105 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
106 data.writeInt32(static_cast <uint32_t>(device));
107 data.writeInt32(static_cast <uint32_t>(state));
108 data.writeCString(device_address);
109 data.writeCString(device_name);
110 remote()->transact(SET_DEVICE_CONNECTION_STATE, data, &reply);
111 return static_cast <status_t> (reply.readInt32());
112 }
113
getDeviceConnectionState(audio_devices_t device,const char * device_address)114 virtual audio_policy_dev_state_t getDeviceConnectionState(
115 audio_devices_t device,
116 const char *device_address)
117 {
118 Parcel data, reply;
119 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
120 data.writeInt32(static_cast <uint32_t>(device));
121 data.writeCString(device_address);
122 remote()->transact(GET_DEVICE_CONNECTION_STATE, data, &reply);
123 return static_cast <audio_policy_dev_state_t>(reply.readInt32());
124 }
125
handleDeviceConfigChange(audio_devices_t device,const char * device_address,const char * device_name)126 virtual status_t handleDeviceConfigChange(audio_devices_t device,
127 const char *device_address,
128 const char *device_name)
129 {
130 Parcel data, reply;
131 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
132 data.writeInt32(static_cast <uint32_t>(device));
133 data.writeCString(device_address);
134 data.writeCString(device_name);
135 remote()->transact(HANDLE_DEVICE_CONFIG_CHANGE, data, &reply);
136 return static_cast <status_t> (reply.readInt32());
137 }
138
setPhoneState(audio_mode_t state)139 virtual status_t setPhoneState(audio_mode_t state)
140 {
141 Parcel data, reply;
142 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
143 data.writeInt32(state);
144 remote()->transact(SET_PHONE_STATE, data, &reply);
145 return static_cast <status_t> (reply.readInt32());
146 }
147
setForceUse(audio_policy_force_use_t usage,audio_policy_forced_cfg_t config)148 virtual status_t setForceUse(audio_policy_force_use_t usage, audio_policy_forced_cfg_t config)
149 {
150 Parcel data, reply;
151 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
152 data.writeInt32(static_cast <uint32_t>(usage));
153 data.writeInt32(static_cast <uint32_t>(config));
154 remote()->transact(SET_FORCE_USE, data, &reply);
155 return static_cast <status_t> (reply.readInt32());
156 }
157
getForceUse(audio_policy_force_use_t usage)158 virtual audio_policy_forced_cfg_t getForceUse(audio_policy_force_use_t usage)
159 {
160 Parcel data, reply;
161 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
162 data.writeInt32(static_cast <uint32_t>(usage));
163 remote()->transact(GET_FORCE_USE, data, &reply);
164 return static_cast <audio_policy_forced_cfg_t> (reply.readInt32());
165 }
166
getOutput(audio_stream_type_t stream)167 virtual audio_io_handle_t getOutput(audio_stream_type_t stream)
168 {
169 Parcel data, reply;
170 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
171 data.writeInt32(static_cast <uint32_t>(stream));
172 remote()->transact(GET_OUTPUT, data, &reply);
173 return static_cast <audio_io_handle_t> (reply.readInt32());
174 }
175
getOutputForAttr(const audio_attributes_t * attr,audio_io_handle_t * output,audio_session_t session,audio_stream_type_t * stream,pid_t pid,uid_t uid,const audio_config_t * config,audio_output_flags_t flags,audio_port_handle_t * selectedDeviceId,audio_port_handle_t * portId)176 virtual status_t getOutputForAttr(const audio_attributes_t *attr,
177 audio_io_handle_t *output,
178 audio_session_t session,
179 audio_stream_type_t *stream,
180 pid_t pid,
181 uid_t uid,
182 const audio_config_t *config,
183 audio_output_flags_t flags,
184 audio_port_handle_t *selectedDeviceId,
185 audio_port_handle_t *portId)
186 {
187 Parcel data, reply;
188 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
189 if (attr == NULL) {
190 if (stream == NULL) {
191 ALOGE("getOutputForAttr(): NULL audio attributes and stream type");
192 return BAD_VALUE;
193 }
194 if (*stream == AUDIO_STREAM_DEFAULT) {
195 ALOGE("getOutputForAttr unspecified stream type");
196 return BAD_VALUE;
197 }
198 }
199 if (output == NULL) {
200 ALOGE("getOutputForAttr NULL output - shouldn't happen");
201 return BAD_VALUE;
202 }
203 if (selectedDeviceId == NULL) {
204 ALOGE("getOutputForAttr NULL selectedDeviceId - shouldn't happen");
205 return BAD_VALUE;
206 }
207 if (portId == NULL) {
208 ALOGE("getOutputForAttr NULL portId - shouldn't happen");
209 return BAD_VALUE;
210 }
211 if (attr == NULL) {
212 data.writeInt32(0);
213 } else {
214 data.writeInt32(1);
215 data.write(attr, sizeof(audio_attributes_t));
216 }
217 data.writeInt32(session);
218 if (stream == NULL) {
219 data.writeInt32(0);
220 } else {
221 data.writeInt32(1);
222 data.writeInt32(*stream);
223 }
224 data.writeInt32(pid);
225 data.writeInt32(uid);
226 data.write(config, sizeof(audio_config_t));
227 data.writeInt32(static_cast <uint32_t>(flags));
228 data.writeInt32(*selectedDeviceId);
229 data.writeInt32(*portId);
230 status_t status = remote()->transact(GET_OUTPUT_FOR_ATTR, data, &reply);
231 if (status != NO_ERROR) {
232 return status;
233 }
234 status = (status_t)reply.readInt32();
235 if (status != NO_ERROR) {
236 return status;
237 }
238 *output = (audio_io_handle_t)reply.readInt32();
239 audio_stream_type_t lStream = (audio_stream_type_t)reply.readInt32();
240 if (stream != NULL) {
241 *stream = lStream;
242 }
243 *selectedDeviceId = (audio_port_handle_t)reply.readInt32();
244 *portId = (audio_port_handle_t)reply.readInt32();
245 return status;
246 }
247
startOutput(audio_io_handle_t output,audio_stream_type_t stream,audio_session_t session)248 virtual status_t startOutput(audio_io_handle_t output,
249 audio_stream_type_t stream,
250 audio_session_t session)
251 {
252 Parcel data, reply;
253 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
254 data.writeInt32(output);
255 data.writeInt32((int32_t) stream);
256 data.writeInt32((int32_t) session);
257 remote()->transact(START_OUTPUT, data, &reply);
258 return static_cast <status_t> (reply.readInt32());
259 }
260
stopOutput(audio_io_handle_t output,audio_stream_type_t stream,audio_session_t session)261 virtual status_t stopOutput(audio_io_handle_t output,
262 audio_stream_type_t stream,
263 audio_session_t session)
264 {
265 Parcel data, reply;
266 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
267 data.writeInt32(output);
268 data.writeInt32((int32_t) stream);
269 data.writeInt32((int32_t) session);
270 remote()->transact(STOP_OUTPUT, data, &reply);
271 return static_cast <status_t> (reply.readInt32());
272 }
273
releaseOutput(audio_io_handle_t output,audio_stream_type_t stream,audio_session_t session)274 virtual void releaseOutput(audio_io_handle_t output,
275 audio_stream_type_t stream,
276 audio_session_t session)
277 {
278 Parcel data, reply;
279 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
280 data.writeInt32(output);
281 data.writeInt32((int32_t)stream);
282 data.writeInt32((int32_t)session);
283 remote()->transact(RELEASE_OUTPUT, data, &reply);
284 }
285
getInputForAttr(const audio_attributes_t * attr,audio_io_handle_t * input,audio_session_t session,pid_t pid,uid_t uid,const String16 & opPackageName,const audio_config_base_t * config,audio_input_flags_t flags,audio_port_handle_t * selectedDeviceId,audio_port_handle_t * portId)286 virtual status_t getInputForAttr(const audio_attributes_t *attr,
287 audio_io_handle_t *input,
288 audio_session_t session,
289 pid_t pid,
290 uid_t uid,
291 const String16& opPackageName,
292 const audio_config_base_t *config,
293 audio_input_flags_t flags,
294 audio_port_handle_t *selectedDeviceId,
295 audio_port_handle_t *portId)
296 {
297 Parcel data, reply;
298 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
299 if (attr == NULL) {
300 ALOGE("getInputForAttr NULL attr - shouldn't happen");
301 return BAD_VALUE;
302 }
303 if (input == NULL) {
304 ALOGE("getInputForAttr NULL input - shouldn't happen");
305 return BAD_VALUE;
306 }
307 if (selectedDeviceId == NULL) {
308 ALOGE("getInputForAttr NULL selectedDeviceId - shouldn't happen");
309 return BAD_VALUE;
310 }
311 if (portId == NULL) {
312 ALOGE("getInputForAttr NULL portId - shouldn't happen");
313 return BAD_VALUE;
314 }
315 data.write(attr, sizeof(audio_attributes_t));
316 data.writeInt32(*input);
317 data.writeInt32(session);
318 data.writeInt32(pid);
319 data.writeInt32(uid);
320 data.writeString16(opPackageName);
321 data.write(config, sizeof(audio_config_base_t));
322 data.writeInt32(flags);
323 data.writeInt32(*selectedDeviceId);
324 data.writeInt32(*portId);
325 status_t status = remote()->transact(GET_INPUT_FOR_ATTR, data, &reply);
326 if (status != NO_ERROR) {
327 return status;
328 }
329 status = reply.readInt32();
330 if (status != NO_ERROR) {
331 return status;
332 }
333 *input = (audio_io_handle_t)reply.readInt32();
334 *selectedDeviceId = (audio_port_handle_t)reply.readInt32();
335 *portId = (audio_port_handle_t)reply.readInt32();
336 return NO_ERROR;
337 }
338
startInput(audio_port_handle_t portId,bool * silenced)339 virtual status_t startInput(audio_port_handle_t portId,
340 bool *silenced)
341 {
342 Parcel data, reply;
343 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
344 data.writeInt32(portId);
345 data.writeInt32(*silenced ? 1 : 0);
346 remote()->transact(START_INPUT, data, &reply);
347 status_t status = static_cast <status_t> (reply.readInt32());
348 *silenced = reply.readInt32() == 1;
349 return status;
350 }
351
stopInput(audio_port_handle_t portId)352 virtual status_t stopInput(audio_port_handle_t portId)
353 {
354 Parcel data, reply;
355 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
356 data.writeInt32(portId);
357 remote()->transact(STOP_INPUT, data, &reply);
358 return static_cast <status_t> (reply.readInt32());
359 }
360
releaseInput(audio_port_handle_t portId)361 virtual void releaseInput(audio_port_handle_t portId)
362 {
363 Parcel data, reply;
364 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
365 data.writeInt32(portId);
366 remote()->transact(RELEASE_INPUT, data, &reply);
367 }
368
initStreamVolume(audio_stream_type_t stream,int indexMin,int indexMax)369 virtual status_t initStreamVolume(audio_stream_type_t stream,
370 int indexMin,
371 int indexMax)
372 {
373 Parcel data, reply;
374 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
375 data.writeInt32(static_cast <uint32_t>(stream));
376 data.writeInt32(indexMin);
377 data.writeInt32(indexMax);
378 remote()->transact(INIT_STREAM_VOLUME, data, &reply);
379 return static_cast <status_t> (reply.readInt32());
380 }
381
setStreamVolumeIndex(audio_stream_type_t stream,int index,audio_devices_t device)382 virtual status_t setStreamVolumeIndex(audio_stream_type_t stream,
383 int index,
384 audio_devices_t device)
385 {
386 Parcel data, reply;
387 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
388 data.writeInt32(static_cast <uint32_t>(stream));
389 data.writeInt32(index);
390 data.writeInt32(static_cast <uint32_t>(device));
391 remote()->transact(SET_STREAM_VOLUME, data, &reply);
392 return static_cast <status_t> (reply.readInt32());
393 }
394
getStreamVolumeIndex(audio_stream_type_t stream,int * index,audio_devices_t device)395 virtual status_t getStreamVolumeIndex(audio_stream_type_t stream,
396 int *index,
397 audio_devices_t device)
398 {
399 Parcel data, reply;
400 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
401 data.writeInt32(static_cast <uint32_t>(stream));
402 data.writeInt32(static_cast <uint32_t>(device));
403
404 remote()->transact(GET_STREAM_VOLUME, data, &reply);
405 int lIndex = reply.readInt32();
406 if (index) *index = lIndex;
407 return static_cast <status_t> (reply.readInt32());
408 }
409
getStrategyForStream(audio_stream_type_t stream)410 virtual uint32_t getStrategyForStream(audio_stream_type_t stream)
411 {
412 Parcel data, reply;
413 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
414 data.writeInt32(static_cast <uint32_t>(stream));
415 remote()->transact(GET_STRATEGY_FOR_STREAM, data, &reply);
416 return reply.readInt32();
417 }
418
getDevicesForStream(audio_stream_type_t stream)419 virtual audio_devices_t getDevicesForStream(audio_stream_type_t stream)
420 {
421 Parcel data, reply;
422 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
423 data.writeInt32(static_cast <uint32_t>(stream));
424 remote()->transact(GET_DEVICES_FOR_STREAM, data, &reply);
425 return (audio_devices_t) reply.readInt32();
426 }
427
getOutputForEffect(const effect_descriptor_t * desc)428 virtual audio_io_handle_t getOutputForEffect(const effect_descriptor_t *desc)
429 {
430 Parcel data, reply;
431 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
432 data.write(desc, sizeof(effect_descriptor_t));
433 remote()->transact(GET_OUTPUT_FOR_EFFECT, data, &reply);
434 return static_cast <audio_io_handle_t> (reply.readInt32());
435 }
436
registerEffect(const effect_descriptor_t * desc,audio_io_handle_t io,uint32_t strategy,audio_session_t session,int id)437 virtual status_t registerEffect(const effect_descriptor_t *desc,
438 audio_io_handle_t io,
439 uint32_t strategy,
440 audio_session_t session,
441 int id)
442 {
443 Parcel data, reply;
444 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
445 data.write(desc, sizeof(effect_descriptor_t));
446 data.writeInt32(io);
447 data.writeInt32(strategy);
448 data.writeInt32(session);
449 data.writeInt32(id);
450 remote()->transact(REGISTER_EFFECT, data, &reply);
451 return static_cast <status_t> (reply.readInt32());
452 }
453
unregisterEffect(int id)454 virtual status_t unregisterEffect(int id)
455 {
456 Parcel data, reply;
457 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
458 data.writeInt32(id);
459 remote()->transact(UNREGISTER_EFFECT, data, &reply);
460 return static_cast <status_t> (reply.readInt32());
461 }
462
setEffectEnabled(int id,bool enabled)463 virtual status_t setEffectEnabled(int id, bool enabled)
464 {
465 Parcel data, reply;
466 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
467 data.writeInt32(id);
468 data.writeInt32(enabled);
469 remote()->transact(SET_EFFECT_ENABLED, data, &reply);
470 return static_cast <status_t> (reply.readInt32());
471 }
472
isStreamActive(audio_stream_type_t stream,uint32_t inPastMs) const473 virtual bool isStreamActive(audio_stream_type_t stream, uint32_t inPastMs) const
474 {
475 Parcel data, reply;
476 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
477 data.writeInt32((int32_t) stream);
478 data.writeInt32(inPastMs);
479 remote()->transact(IS_STREAM_ACTIVE, data, &reply);
480 return reply.readInt32();
481 }
482
isStreamActiveRemotely(audio_stream_type_t stream,uint32_t inPastMs) const483 virtual bool isStreamActiveRemotely(audio_stream_type_t stream, uint32_t inPastMs) const
484 {
485 Parcel data, reply;
486 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
487 data.writeInt32((int32_t) stream);
488 data.writeInt32(inPastMs);
489 remote()->transact(IS_STREAM_ACTIVE_REMOTELY, data, &reply);
490 return reply.readInt32();
491 }
492
isSourceActive(audio_source_t source) const493 virtual bool isSourceActive(audio_source_t source) const
494 {
495 Parcel data, reply;
496 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
497 data.writeInt32((int32_t) source);
498 remote()->transact(IS_SOURCE_ACTIVE, data, &reply);
499 return reply.readInt32();
500 }
501
queryDefaultPreProcessing(audio_session_t audioSession,effect_descriptor_t * descriptors,uint32_t * count)502 virtual status_t queryDefaultPreProcessing(audio_session_t audioSession,
503 effect_descriptor_t *descriptors,
504 uint32_t *count)
505 {
506 if (descriptors == NULL || count == NULL) {
507 return BAD_VALUE;
508 }
509 Parcel data, reply;
510 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
511 data.writeInt32(audioSession);
512 data.writeInt32(*count);
513 status_t status = remote()->transact(QUERY_DEFAULT_PRE_PROCESSING, data, &reply);
514 if (status != NO_ERROR) {
515 return status;
516 }
517 status = static_cast <status_t> (reply.readInt32());
518 uint32_t retCount = reply.readInt32();
519 if (retCount != 0) {
520 uint32_t numDesc = (retCount < *count) ? retCount : *count;
521 reply.read(descriptors, sizeof(effect_descriptor_t) * numDesc);
522 }
523 *count = retCount;
524 return status;
525 }
526
isOffloadSupported(const audio_offload_info_t & info)527 virtual bool isOffloadSupported(const audio_offload_info_t& info)
528 {
529 Parcel data, reply;
530 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
531 data.write(&info, sizeof(audio_offload_info_t));
532 remote()->transact(IS_OFFLOAD_SUPPORTED, data, &reply);
533 return reply.readInt32();
534 }
535
listAudioPorts(audio_port_role_t role,audio_port_type_t type,unsigned int * num_ports,struct audio_port * ports,unsigned int * generation)536 virtual status_t listAudioPorts(audio_port_role_t role,
537 audio_port_type_t type,
538 unsigned int *num_ports,
539 struct audio_port *ports,
540 unsigned int *generation)
541 {
542 if (num_ports == NULL || (*num_ports != 0 && ports == NULL) ||
543 generation == NULL) {
544 return BAD_VALUE;
545 }
546 Parcel data, reply;
547 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
548 unsigned int numPortsReq = (ports == NULL) ? 0 : *num_ports;
549 data.writeInt32(role);
550 data.writeInt32(type);
551 data.writeInt32(numPortsReq);
552 status_t status = remote()->transact(LIST_AUDIO_PORTS, data, &reply);
553 if (status == NO_ERROR) {
554 status = (status_t)reply.readInt32();
555 *num_ports = (unsigned int)reply.readInt32();
556 }
557 if (status == NO_ERROR) {
558 if (numPortsReq > *num_ports) {
559 numPortsReq = *num_ports;
560 }
561 if (numPortsReq > 0) {
562 reply.read(ports, numPortsReq * sizeof(struct audio_port));
563 }
564 *generation = reply.readInt32();
565 }
566 return status;
567 }
568
getAudioPort(struct audio_port * port)569 virtual status_t getAudioPort(struct audio_port *port)
570 {
571 if (port == NULL) {
572 return BAD_VALUE;
573 }
574 Parcel data, reply;
575 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
576 data.write(port, sizeof(struct audio_port));
577 status_t status = remote()->transact(GET_AUDIO_PORT, data, &reply);
578 if (status != NO_ERROR ||
579 (status = (status_t)reply.readInt32()) != NO_ERROR) {
580 return status;
581 }
582 reply.read(port, sizeof(struct audio_port));
583 return status;
584 }
585
createAudioPatch(const struct audio_patch * patch,audio_patch_handle_t * handle)586 virtual status_t createAudioPatch(const struct audio_patch *patch,
587 audio_patch_handle_t *handle)
588 {
589 if (patch == NULL || handle == NULL) {
590 return BAD_VALUE;
591 }
592 Parcel data, reply;
593 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
594 data.write(patch, sizeof(struct audio_patch));
595 data.write(handle, sizeof(audio_patch_handle_t));
596 status_t status = remote()->transact(CREATE_AUDIO_PATCH, data, &reply);
597 if (status != NO_ERROR ||
598 (status = (status_t)reply.readInt32()) != NO_ERROR) {
599 return status;
600 }
601 reply.read(handle, sizeof(audio_patch_handle_t));
602 return status;
603 }
604
releaseAudioPatch(audio_patch_handle_t handle)605 virtual status_t releaseAudioPatch(audio_patch_handle_t handle)
606 {
607 Parcel data, reply;
608 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
609 data.write(&handle, sizeof(audio_patch_handle_t));
610 status_t status = remote()->transact(RELEASE_AUDIO_PATCH, data, &reply);
611 if (status != NO_ERROR) {
612 status = (status_t)reply.readInt32();
613 }
614 return status;
615 }
616
listAudioPatches(unsigned int * num_patches,struct audio_patch * patches,unsigned int * generation)617 virtual status_t listAudioPatches(unsigned int *num_patches,
618 struct audio_patch *patches,
619 unsigned int *generation)
620 {
621 if (num_patches == NULL || (*num_patches != 0 && patches == NULL) ||
622 generation == NULL) {
623 return BAD_VALUE;
624 }
625 Parcel data, reply;
626 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
627 unsigned int numPatchesReq = (patches == NULL) ? 0 : *num_patches;
628 data.writeInt32(numPatchesReq);
629 status_t status = remote()->transact(LIST_AUDIO_PATCHES, data, &reply);
630 if (status == NO_ERROR) {
631 status = (status_t)reply.readInt32();
632 *num_patches = (unsigned int)reply.readInt32();
633 }
634 if (status == NO_ERROR) {
635 if (numPatchesReq > *num_patches) {
636 numPatchesReq = *num_patches;
637 }
638 if (numPatchesReq > 0) {
639 reply.read(patches, numPatchesReq * sizeof(struct audio_patch));
640 }
641 *generation = reply.readInt32();
642 }
643 return status;
644 }
645
setAudioPortConfig(const struct audio_port_config * config)646 virtual status_t setAudioPortConfig(const struct audio_port_config *config)
647 {
648 if (config == NULL) {
649 return BAD_VALUE;
650 }
651 Parcel data, reply;
652 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
653 data.write(config, sizeof(struct audio_port_config));
654 status_t status = remote()->transact(SET_AUDIO_PORT_CONFIG, data, &reply);
655 if (status != NO_ERROR) {
656 status = (status_t)reply.readInt32();
657 }
658 return status;
659 }
660
registerClient(const sp<IAudioPolicyServiceClient> & client)661 virtual void registerClient(const sp<IAudioPolicyServiceClient>& client)
662 {
663 Parcel data, reply;
664 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
665 data.writeStrongBinder(IInterface::asBinder(client));
666 remote()->transact(REGISTER_CLIENT, data, &reply);
667 }
668
setAudioPortCallbacksEnabled(bool enabled)669 virtual void setAudioPortCallbacksEnabled(bool enabled)
670 {
671 Parcel data, reply;
672 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
673 data.writeInt32(enabled ? 1 : 0);
674 remote()->transact(SET_AUDIO_PORT_CALLBACK_ENABLED, data, &reply);
675 }
676
acquireSoundTriggerSession(audio_session_t * session,audio_io_handle_t * ioHandle,audio_devices_t * device)677 virtual status_t acquireSoundTriggerSession(audio_session_t *session,
678 audio_io_handle_t *ioHandle,
679 audio_devices_t *device)
680 {
681 if (session == NULL || ioHandle == NULL || device == NULL) {
682 return BAD_VALUE;
683 }
684 Parcel data, reply;
685 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
686 status_t status = remote()->transact(ACQUIRE_SOUNDTRIGGER_SESSION, data, &reply);
687 if (status != NO_ERROR) {
688 return status;
689 }
690 status = (status_t)reply.readInt32();
691 if (status == NO_ERROR) {
692 *session = (audio_session_t)reply.readInt32();
693 *ioHandle = (audio_io_handle_t)reply.readInt32();
694 *device = (audio_devices_t)reply.readInt32();
695 }
696 return status;
697 }
698
releaseSoundTriggerSession(audio_session_t session)699 virtual status_t releaseSoundTriggerSession(audio_session_t session)
700 {
701 Parcel data, reply;
702 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
703 data.writeInt32(session);
704 status_t status = remote()->transact(RELEASE_SOUNDTRIGGER_SESSION, data, &reply);
705 if (status != NO_ERROR) {
706 return status;
707 }
708 return (status_t)reply.readInt32();
709 }
710
getPhoneState()711 virtual audio_mode_t getPhoneState()
712 {
713 Parcel data, reply;
714 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
715 status_t status = remote()->transact(GET_PHONE_STATE, data, &reply);
716 if (status != NO_ERROR) {
717 return AUDIO_MODE_INVALID;
718 }
719 return (audio_mode_t)reply.readInt32();
720 }
721
registerPolicyMixes(const Vector<AudioMix> & mixes,bool registration)722 virtual status_t registerPolicyMixes(const Vector<AudioMix>& mixes, bool registration)
723 {
724 Parcel data, reply;
725 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
726 data.writeInt32(registration ? 1 : 0);
727 size_t size = mixes.size();
728 if (size > MAX_MIXES_PER_POLICY) {
729 size = MAX_MIXES_PER_POLICY;
730 }
731 size_t sizePosition = data.dataPosition();
732 data.writeInt32(size);
733 size_t finalSize = size;
734 for (size_t i = 0; i < size; i++) {
735 size_t position = data.dataPosition();
736 if (mixes[i].writeToParcel(&data) != NO_ERROR) {
737 data.setDataPosition(position);
738 finalSize--;
739 }
740 }
741 if (size != finalSize) {
742 size_t position = data.dataPosition();
743 data.setDataPosition(sizePosition);
744 data.writeInt32(finalSize);
745 data.setDataPosition(position);
746 }
747 status_t status = remote()->transact(REGISTER_POLICY_MIXES, data, &reply);
748 if (status == NO_ERROR) {
749 status = (status_t)reply.readInt32();
750 }
751 return status;
752 }
753
startAudioSource(const struct audio_port_config * source,const audio_attributes_t * attributes,audio_patch_handle_t * handle)754 virtual status_t startAudioSource(const struct audio_port_config *source,
755 const audio_attributes_t *attributes,
756 audio_patch_handle_t *handle)
757 {
758 Parcel data, reply;
759 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
760 if (source == NULL || attributes == NULL || handle == NULL) {
761 return BAD_VALUE;
762 }
763 data.write(source, sizeof(struct audio_port_config));
764 data.write(attributes, sizeof(audio_attributes_t));
765 status_t status = remote()->transact(START_AUDIO_SOURCE, data, &reply);
766 if (status != NO_ERROR) {
767 return status;
768 }
769 status = (status_t)reply.readInt32();
770 if (status != NO_ERROR) {
771 return status;
772 }
773 *handle = (audio_patch_handle_t)reply.readInt32();
774 return status;
775 }
776
stopAudioSource(audio_patch_handle_t handle)777 virtual status_t stopAudioSource(audio_patch_handle_t handle)
778 {
779 Parcel data, reply;
780 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
781 data.writeInt32(handle);
782 status_t status = remote()->transact(STOP_AUDIO_SOURCE, data, &reply);
783 if (status != NO_ERROR) {
784 return status;
785 }
786 status = (status_t)reply.readInt32();
787 return status;
788 }
789
setMasterMono(bool mono)790 virtual status_t setMasterMono(bool mono)
791 {
792 Parcel data, reply;
793 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
794 data.writeInt32(static_cast<int32_t>(mono));
795 status_t status = remote()->transact(SET_MASTER_MONO, data, &reply);
796 if (status != NO_ERROR) {
797 return status;
798 }
799 return static_cast<status_t>(reply.readInt32());
800 }
801
getMasterMono(bool * mono)802 virtual status_t getMasterMono(bool *mono)
803 {
804 if (mono == nullptr) {
805 return BAD_VALUE;
806 }
807 Parcel data, reply;
808 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
809
810 status_t status = remote()->transact(GET_MASTER_MONO, data, &reply);
811 if (status != NO_ERROR) {
812 return status;
813 }
814 status = static_cast<status_t>(reply.readInt32());
815 if (status == NO_ERROR) {
816 *mono = static_cast<bool>(reply.readInt32());
817 }
818 return status;
819 }
820
getStreamVolumeDB(audio_stream_type_t stream,int index,audio_devices_t device)821 virtual float getStreamVolumeDB(audio_stream_type_t stream, int index, audio_devices_t device)
822 {
823 Parcel data, reply;
824 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
825 data.writeInt32(static_cast <int32_t>(stream));
826 data.writeInt32(static_cast <int32_t>(index));
827 data.writeUint32(static_cast <uint32_t>(device));
828 status_t status = remote()->transact(GET_STREAM_VOLUME_DB, data, &reply);
829 if (status != NO_ERROR) {
830 return NAN;
831 }
832 return reply.readFloat();
833 }
834
getSurroundFormats(unsigned int * numSurroundFormats,audio_format_t * surroundFormats,bool * surroundFormatsEnabled,bool reported)835 virtual status_t getSurroundFormats(unsigned int *numSurroundFormats,
836 audio_format_t *surroundFormats,
837 bool *surroundFormatsEnabled,
838 bool reported)
839 {
840 if (numSurroundFormats == NULL || (*numSurroundFormats != 0 &&
841 (surroundFormats == NULL || surroundFormatsEnabled == NULL))) {
842 return BAD_VALUE;
843 }
844 Parcel data, reply;
845 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
846 unsigned int numSurroundFormatsReq = *numSurroundFormats;
847 data.writeUint32(numSurroundFormatsReq);
848 data.writeBool(reported);
849 status_t status = remote()->transact(GET_SURROUND_FORMATS, data, &reply);
850 if (status == NO_ERROR && (status = (status_t)reply.readInt32()) == NO_ERROR) {
851 *numSurroundFormats = reply.readUint32();
852 }
853 if (status == NO_ERROR) {
854 if (numSurroundFormatsReq > *numSurroundFormats) {
855 numSurroundFormatsReq = *numSurroundFormats;
856 }
857 if (numSurroundFormatsReq > 0) {
858 status = reply.read(surroundFormats,
859 numSurroundFormatsReq * sizeof(audio_format_t));
860 if (status != NO_ERROR) {
861 return status;
862 }
863 status = reply.read(surroundFormatsEnabled,
864 numSurroundFormatsReq * sizeof(bool));
865 }
866 }
867 return status;
868 }
869
setSurroundFormatEnabled(audio_format_t audioFormat,bool enabled)870 virtual status_t setSurroundFormatEnabled(audio_format_t audioFormat, bool enabled)
871 {
872 Parcel data, reply;
873 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
874 data.writeInt32(audioFormat);
875 data.writeBool(enabled);
876 status_t status = remote()->transact(SET_SURROUND_FORMAT_ENABLED, data, &reply);
877 if (status != NO_ERROR) {
878 return status;
879 }
880 return reply.readInt32();
881 }
882 };
883
884 IMPLEMENT_META_INTERFACE(AudioPolicyService, "android.media.IAudioPolicyService");
885
886 // ----------------------------------------------------------------------
887
onTransact(uint32_t code,const Parcel & data,Parcel * reply,uint32_t flags)888 status_t BnAudioPolicyService::onTransact(
889 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
890 {
891 // make sure transactions reserved to AudioFlinger do not come from other processes
892 switch (code) {
893 case START_OUTPUT:
894 case STOP_OUTPUT:
895 case RELEASE_OUTPUT:
896 case GET_INPUT_FOR_ATTR:
897 case START_INPUT:
898 case STOP_INPUT:
899 case RELEASE_INPUT:
900 case GET_STRATEGY_FOR_STREAM:
901 case GET_OUTPUT_FOR_EFFECT:
902 case REGISTER_EFFECT:
903 case UNREGISTER_EFFECT:
904 case SET_EFFECT_ENABLED:
905 case GET_OUTPUT_FOR_ATTR:
906 case ACQUIRE_SOUNDTRIGGER_SESSION:
907 case RELEASE_SOUNDTRIGGER_SESSION:
908 ALOGW("%s: transaction %d received from PID %d",
909 __func__, code, IPCThreadState::self()->getCallingPid());
910 // return status only for non void methods
911 switch (code) {
912 case RELEASE_OUTPUT:
913 case RELEASE_INPUT:
914 break;
915 default:
916 reply->writeInt32(static_cast<int32_t> (INVALID_OPERATION));
917 break;
918 }
919 return OK;
920 default:
921 break;
922 }
923
924 // make sure the following transactions come from system components
925 switch (code) {
926 case SET_DEVICE_CONNECTION_STATE:
927 case HANDLE_DEVICE_CONFIG_CHANGE:
928 case SET_PHONE_STATE:
929 //FIXME: Allow SET_FORCE_USE calls from system apps until a better use case routing API is available
930 // case SET_FORCE_USE:
931 case INIT_STREAM_VOLUME:
932 case SET_STREAM_VOLUME:
933 case REGISTER_POLICY_MIXES:
934 case SET_MASTER_MONO:
935 case START_AUDIO_SOURCE:
936 case STOP_AUDIO_SOURCE:
937 case GET_SURROUND_FORMATS:
938 case SET_SURROUND_FORMAT_ENABLED: {
939 if (multiuser_get_app_id(IPCThreadState::self()->getCallingUid()) >= AID_APP_START) {
940 ALOGW("%s: transaction %d received from PID %d unauthorized UID %d",
941 __func__, code, IPCThreadState::self()->getCallingPid(),
942 IPCThreadState::self()->getCallingUid());
943 reply->writeInt32(static_cast<int32_t> (INVALID_OPERATION));
944 return OK;
945 }
946 } break;
947 default:
948 break;
949 }
950
951 TimeCheck check("IAudioPolicyService");
952
953 switch (code) {
954 case SET_DEVICE_CONNECTION_STATE: {
955 CHECK_INTERFACE(IAudioPolicyService, data, reply);
956 audio_devices_t device =
957 static_cast <audio_devices_t>(data.readInt32());
958 audio_policy_dev_state_t state =
959 static_cast <audio_policy_dev_state_t>(data.readInt32());
960 const char *device_address = data.readCString();
961 const char *device_name = data.readCString();
962 if (device_address == nullptr || device_name == nullptr) {
963 ALOGE("Bad Binder transaction: SET_DEVICE_CONNECTION_STATE for device %u", device);
964 reply->writeInt32(static_cast<int32_t> (BAD_VALUE));
965 } else {
966 reply->writeInt32(static_cast<uint32_t> (setDeviceConnectionState(device,
967 state,
968 device_address,
969 device_name)));
970 }
971 return NO_ERROR;
972 } break;
973
974 case GET_DEVICE_CONNECTION_STATE: {
975 CHECK_INTERFACE(IAudioPolicyService, data, reply);
976 audio_devices_t device =
977 static_cast<audio_devices_t> (data.readInt32());
978 const char *device_address = data.readCString();
979 if (device_address == nullptr) {
980 ALOGE("Bad Binder transaction: GET_DEVICE_CONNECTION_STATE for device %u", device);
981 reply->writeInt32(static_cast<int32_t> (AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE));
982 } else {
983 reply->writeInt32(static_cast<uint32_t> (getDeviceConnectionState(device,
984 device_address)));
985 }
986 return NO_ERROR;
987 } break;
988
989 case HANDLE_DEVICE_CONFIG_CHANGE: {
990 CHECK_INTERFACE(IAudioPolicyService, data, reply);
991 audio_devices_t device =
992 static_cast <audio_devices_t>(data.readInt32());
993 const char *device_address = data.readCString();
994 const char *device_name = data.readCString();
995 if (device_address == nullptr || device_name == nullptr) {
996 ALOGE("Bad Binder transaction: HANDLE_DEVICE_CONFIG_CHANGE for device %u", device);
997 reply->writeInt32(static_cast<int32_t> (BAD_VALUE));
998 } else {
999 reply->writeInt32(static_cast<uint32_t> (handleDeviceConfigChange(device,
1000 device_address,
1001 device_name)));
1002 }
1003 return NO_ERROR;
1004 } break;
1005
1006 case SET_PHONE_STATE: {
1007 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1008 reply->writeInt32(static_cast <uint32_t>(setPhoneState(
1009 (audio_mode_t) data.readInt32())));
1010 return NO_ERROR;
1011 } break;
1012
1013 case SET_FORCE_USE: {
1014 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1015 audio_policy_force_use_t usage = static_cast <audio_policy_force_use_t>(
1016 data.readInt32());
1017 audio_policy_forced_cfg_t config =
1018 static_cast <audio_policy_forced_cfg_t>(data.readInt32());
1019 reply->writeInt32(static_cast <uint32_t>(setForceUse(usage, config)));
1020 return NO_ERROR;
1021 } break;
1022
1023 case GET_FORCE_USE: {
1024 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1025 audio_policy_force_use_t usage = static_cast <audio_policy_force_use_t>(
1026 data.readInt32());
1027 reply->writeInt32(static_cast <uint32_t>(getForceUse(usage)));
1028 return NO_ERROR;
1029 } break;
1030
1031 case GET_OUTPUT: {
1032 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1033 audio_stream_type_t stream =
1034 static_cast <audio_stream_type_t>(data.readInt32());
1035 audio_io_handle_t output = getOutput(stream);
1036 reply->writeInt32(static_cast <int>(output));
1037 return NO_ERROR;
1038 } break;
1039
1040 case GET_OUTPUT_FOR_ATTR: {
1041 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1042 audio_attributes_t attr = {};
1043 bool hasAttributes = data.readInt32() != 0;
1044 if (hasAttributes) {
1045 data.read(&attr, sizeof(audio_attributes_t));
1046 sanetizeAudioAttributes(&attr);
1047 }
1048 audio_session_t session = (audio_session_t)data.readInt32();
1049 audio_stream_type_t stream = AUDIO_STREAM_DEFAULT;
1050 bool hasStream = data.readInt32() != 0;
1051 if (hasStream) {
1052 stream = (audio_stream_type_t)data.readInt32();
1053 }
1054 pid_t pid = (pid_t)data.readInt32();
1055 uid_t uid = (uid_t)data.readInt32();
1056 audio_config_t config;
1057 memset(&config, 0, sizeof(audio_config_t));
1058 data.read(&config, sizeof(audio_config_t));
1059 audio_output_flags_t flags =
1060 static_cast <audio_output_flags_t>(data.readInt32());
1061 audio_port_handle_t selectedDeviceId = data.readInt32();
1062 audio_port_handle_t portId = (audio_port_handle_t)data.readInt32();
1063 audio_io_handle_t output = 0;
1064 status_t status = getOutputForAttr(hasAttributes ? &attr : NULL,
1065 &output, session, &stream, pid, uid,
1066 &config,
1067 flags, &selectedDeviceId, &portId);
1068 reply->writeInt32(status);
1069 reply->writeInt32(output);
1070 reply->writeInt32(stream);
1071 reply->writeInt32(selectedDeviceId);
1072 reply->writeInt32(portId);
1073 return NO_ERROR;
1074 } break;
1075
1076 case START_OUTPUT: {
1077 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1078 audio_io_handle_t output = static_cast <audio_io_handle_t>(data.readInt32());
1079 audio_stream_type_t stream =
1080 static_cast <audio_stream_type_t>(data.readInt32());
1081 audio_session_t session = (audio_session_t)data.readInt32();
1082 reply->writeInt32(static_cast <uint32_t>(startOutput(output,
1083 stream,
1084 session)));
1085 return NO_ERROR;
1086 } break;
1087
1088 case STOP_OUTPUT: {
1089 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1090 audio_io_handle_t output = static_cast <audio_io_handle_t>(data.readInt32());
1091 audio_stream_type_t stream =
1092 static_cast <audio_stream_type_t>(data.readInt32());
1093 audio_session_t session = (audio_session_t)data.readInt32();
1094 reply->writeInt32(static_cast <uint32_t>(stopOutput(output,
1095 stream,
1096 session)));
1097 return NO_ERROR;
1098 } break;
1099
1100 case RELEASE_OUTPUT: {
1101 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1102 audio_io_handle_t output = static_cast <audio_io_handle_t>(data.readInt32());
1103 audio_stream_type_t stream = (audio_stream_type_t)data.readInt32();
1104 audio_session_t session = (audio_session_t)data.readInt32();
1105 releaseOutput(output, stream, session);
1106 return NO_ERROR;
1107 } break;
1108
1109 case GET_INPUT_FOR_ATTR: {
1110 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1111 audio_attributes_t attr = {};
1112 data.read(&attr, sizeof(audio_attributes_t));
1113 sanetizeAudioAttributes(&attr);
1114 audio_io_handle_t input = (audio_io_handle_t)data.readInt32();
1115 audio_session_t session = (audio_session_t)data.readInt32();
1116 pid_t pid = (pid_t)data.readInt32();
1117 uid_t uid = (uid_t)data.readInt32();
1118 const String16 opPackageName = data.readString16();
1119 audio_config_base_t config;
1120 memset(&config, 0, sizeof(audio_config_base_t));
1121 data.read(&config, sizeof(audio_config_base_t));
1122 audio_input_flags_t flags = (audio_input_flags_t) data.readInt32();
1123 audio_port_handle_t selectedDeviceId = (audio_port_handle_t) data.readInt32();
1124 audio_port_handle_t portId = (audio_port_handle_t)data.readInt32();
1125 status_t status = getInputForAttr(&attr, &input, session, pid, uid,
1126 opPackageName, &config,
1127 flags, &selectedDeviceId, &portId);
1128 reply->writeInt32(status);
1129 if (status == NO_ERROR) {
1130 reply->writeInt32(input);
1131 reply->writeInt32(selectedDeviceId);
1132 reply->writeInt32(portId);
1133 }
1134 return NO_ERROR;
1135 } break;
1136
1137 case START_INPUT: {
1138 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1139 audio_port_handle_t portId = static_cast <audio_port_handle_t>(data.readInt32());
1140 bool silenced = data.readInt32() == 1;
1141 status_t status = startInput(portId, &silenced);
1142 reply->writeInt32(static_cast <uint32_t>(status));
1143 reply->writeInt32(silenced ? 1 : 0);
1144 return NO_ERROR;
1145 } break;
1146
1147 case STOP_INPUT: {
1148 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1149 audio_port_handle_t portId = static_cast <audio_port_handle_t>(data.readInt32());
1150 reply->writeInt32(static_cast <uint32_t>(stopInput(portId)));
1151 return NO_ERROR;
1152 } break;
1153
1154 case RELEASE_INPUT: {
1155 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1156 audio_port_handle_t portId = static_cast <audio_port_handle_t>(data.readInt32());
1157 releaseInput(portId);
1158 return NO_ERROR;
1159 } break;
1160
1161 case INIT_STREAM_VOLUME: {
1162 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1163 audio_stream_type_t stream =
1164 static_cast <audio_stream_type_t>(data.readInt32());
1165 int indexMin = data.readInt32();
1166 int indexMax = data.readInt32();
1167 reply->writeInt32(static_cast <uint32_t>(initStreamVolume(stream, indexMin,indexMax)));
1168 return NO_ERROR;
1169 } break;
1170
1171 case SET_STREAM_VOLUME: {
1172 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1173 audio_stream_type_t stream =
1174 static_cast <audio_stream_type_t>(data.readInt32());
1175 int index = data.readInt32();
1176 audio_devices_t device = static_cast <audio_devices_t>(data.readInt32());
1177 reply->writeInt32(static_cast <uint32_t>(setStreamVolumeIndex(stream,
1178 index,
1179 device)));
1180 return NO_ERROR;
1181 } break;
1182
1183 case GET_STREAM_VOLUME: {
1184 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1185 audio_stream_type_t stream =
1186 static_cast <audio_stream_type_t>(data.readInt32());
1187 audio_devices_t device = static_cast <audio_devices_t>(data.readInt32());
1188 int index = 0;
1189 status_t status = getStreamVolumeIndex(stream, &index, device);
1190 reply->writeInt32(index);
1191 reply->writeInt32(static_cast <uint32_t>(status));
1192 return NO_ERROR;
1193 } break;
1194
1195 case GET_STRATEGY_FOR_STREAM: {
1196 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1197 audio_stream_type_t stream =
1198 static_cast <audio_stream_type_t>(data.readInt32());
1199 reply->writeInt32(getStrategyForStream(stream));
1200 return NO_ERROR;
1201 } break;
1202
1203 case GET_DEVICES_FOR_STREAM: {
1204 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1205 audio_stream_type_t stream =
1206 static_cast <audio_stream_type_t>(data.readInt32());
1207 reply->writeInt32(static_cast <int>(getDevicesForStream(stream)));
1208 return NO_ERROR;
1209 } break;
1210
1211 case GET_OUTPUT_FOR_EFFECT: {
1212 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1213 effect_descriptor_t desc = {};
1214 if (data.read(&desc, sizeof(desc)) != NO_ERROR) {
1215 android_errorWriteLog(0x534e4554, "73126106");
1216 }
1217 (void)sanitizeEffectDescriptor(&desc);
1218 audio_io_handle_t output = getOutputForEffect(&desc);
1219 reply->writeInt32(static_cast <int>(output));
1220 return NO_ERROR;
1221 } break;
1222
1223 case REGISTER_EFFECT: {
1224 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1225 effect_descriptor_t desc = {};
1226 if (data.read(&desc, sizeof(desc)) != NO_ERROR) {
1227 android_errorWriteLog(0x534e4554, "73126106");
1228 }
1229 (void)sanitizeEffectDescriptor(&desc);
1230 audio_io_handle_t io = data.readInt32();
1231 uint32_t strategy = data.readInt32();
1232 audio_session_t session = (audio_session_t) data.readInt32();
1233 int id = data.readInt32();
1234 reply->writeInt32(static_cast <int32_t>(registerEffect(&desc,
1235 io,
1236 strategy,
1237 session,
1238 id)));
1239 return NO_ERROR;
1240 } break;
1241
1242 case UNREGISTER_EFFECT: {
1243 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1244 int id = data.readInt32();
1245 reply->writeInt32(static_cast <int32_t>(unregisterEffect(id)));
1246 return NO_ERROR;
1247 } break;
1248
1249 case SET_EFFECT_ENABLED: {
1250 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1251 int id = data.readInt32();
1252 bool enabled = static_cast <bool>(data.readInt32());
1253 reply->writeInt32(static_cast <int32_t>(setEffectEnabled(id, enabled)));
1254 return NO_ERROR;
1255 } break;
1256
1257 case IS_STREAM_ACTIVE: {
1258 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1259 audio_stream_type_t stream = (audio_stream_type_t) data.readInt32();
1260 uint32_t inPastMs = (uint32_t)data.readInt32();
1261 reply->writeInt32( isStreamActive(stream, inPastMs) );
1262 return NO_ERROR;
1263 } break;
1264
1265 case IS_STREAM_ACTIVE_REMOTELY: {
1266 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1267 audio_stream_type_t stream = (audio_stream_type_t) data.readInt32();
1268 uint32_t inPastMs = (uint32_t)data.readInt32();
1269 reply->writeInt32( isStreamActiveRemotely(stream, inPastMs) );
1270 return NO_ERROR;
1271 } break;
1272
1273 case IS_SOURCE_ACTIVE: {
1274 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1275 audio_source_t source = (audio_source_t) data.readInt32();
1276 reply->writeInt32( isSourceActive(source));
1277 return NO_ERROR;
1278 }
1279
1280 case QUERY_DEFAULT_PRE_PROCESSING: {
1281 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1282 audio_session_t audioSession = (audio_session_t) data.readInt32();
1283 uint32_t count = data.readInt32();
1284 if (count > AudioEffect::kMaxPreProcessing) {
1285 count = AudioEffect::kMaxPreProcessing;
1286 }
1287 uint32_t retCount = count;
1288 effect_descriptor_t *descriptors = new effect_descriptor_t[count]{};
1289 status_t status = queryDefaultPreProcessing(audioSession, descriptors, &retCount);
1290 reply->writeInt32(status);
1291 if (status != NO_ERROR && status != NO_MEMORY) {
1292 retCount = 0;
1293 }
1294 reply->writeInt32(retCount);
1295 if (retCount != 0) {
1296 if (retCount < count) {
1297 count = retCount;
1298 }
1299 reply->write(descriptors, sizeof(effect_descriptor_t) * count);
1300 }
1301 delete[] descriptors;
1302 return status;
1303 }
1304
1305 case IS_OFFLOAD_SUPPORTED: {
1306 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1307 audio_offload_info_t info = {};
1308 data.read(&info, sizeof(audio_offload_info_t));
1309 bool isSupported = isOffloadSupported(info);
1310 reply->writeInt32(isSupported);
1311 return NO_ERROR;
1312 }
1313
1314 case LIST_AUDIO_PORTS: {
1315 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1316 audio_port_role_t role = (audio_port_role_t)data.readInt32();
1317 audio_port_type_t type = (audio_port_type_t)data.readInt32();
1318 unsigned int numPortsReq = data.readInt32();
1319 if (numPortsReq > MAX_ITEMS_PER_LIST) {
1320 numPortsReq = MAX_ITEMS_PER_LIST;
1321 }
1322 unsigned int numPorts = numPortsReq;
1323 struct audio_port *ports =
1324 (struct audio_port *)calloc(numPortsReq, sizeof(struct audio_port));
1325 if (ports == NULL) {
1326 reply->writeInt32(NO_MEMORY);
1327 reply->writeInt32(0);
1328 return NO_ERROR;
1329 }
1330 unsigned int generation;
1331 status_t status = listAudioPorts(role, type, &numPorts, ports, &generation);
1332 reply->writeInt32(status);
1333 reply->writeInt32(numPorts);
1334
1335 if (status == NO_ERROR) {
1336 if (numPortsReq > numPorts) {
1337 numPortsReq = numPorts;
1338 }
1339 reply->write(ports, numPortsReq * sizeof(struct audio_port));
1340 reply->writeInt32(generation);
1341 }
1342 free(ports);
1343 return NO_ERROR;
1344 }
1345
1346 case GET_AUDIO_PORT: {
1347 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1348 struct audio_port port = {};
1349 if (data.read(&port, sizeof(struct audio_port)) != NO_ERROR) {
1350 ALOGE("b/23912202");
1351 }
1352 status_t status = getAudioPort(&port);
1353 reply->writeInt32(status);
1354 if (status == NO_ERROR) {
1355 reply->write(&port, sizeof(struct audio_port));
1356 }
1357 return NO_ERROR;
1358 }
1359
1360 case CREATE_AUDIO_PATCH: {
1361 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1362 struct audio_patch patch = {};
1363 data.read(&patch, sizeof(struct audio_patch));
1364 audio_patch_handle_t handle = AUDIO_PATCH_HANDLE_NONE;
1365 if (data.read(&handle, sizeof(audio_patch_handle_t)) != NO_ERROR) {
1366 ALOGE("b/23912202");
1367 }
1368 status_t status = createAudioPatch(&patch, &handle);
1369 reply->writeInt32(status);
1370 if (status == NO_ERROR) {
1371 reply->write(&handle, sizeof(audio_patch_handle_t));
1372 }
1373 return NO_ERROR;
1374 }
1375
1376 case RELEASE_AUDIO_PATCH: {
1377 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1378 audio_patch_handle_t handle = AUDIO_PATCH_HANDLE_NONE;
1379 data.read(&handle, sizeof(audio_patch_handle_t));
1380 status_t status = releaseAudioPatch(handle);
1381 reply->writeInt32(status);
1382 return NO_ERROR;
1383 }
1384
1385 case LIST_AUDIO_PATCHES: {
1386 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1387 unsigned int numPatchesReq = data.readInt32();
1388 if (numPatchesReq > MAX_ITEMS_PER_LIST) {
1389 numPatchesReq = MAX_ITEMS_PER_LIST;
1390 }
1391 unsigned int numPatches = numPatchesReq;
1392 struct audio_patch *patches =
1393 (struct audio_patch *)calloc(numPatchesReq,
1394 sizeof(struct audio_patch));
1395 if (patches == NULL) {
1396 reply->writeInt32(NO_MEMORY);
1397 reply->writeInt32(0);
1398 return NO_ERROR;
1399 }
1400 unsigned int generation;
1401 status_t status = listAudioPatches(&numPatches, patches, &generation);
1402 reply->writeInt32(status);
1403 reply->writeInt32(numPatches);
1404 if (status == NO_ERROR) {
1405 if (numPatchesReq > numPatches) {
1406 numPatchesReq = numPatches;
1407 }
1408 reply->write(patches, numPatchesReq * sizeof(struct audio_patch));
1409 reply->writeInt32(generation);
1410 }
1411 free(patches);
1412 return NO_ERROR;
1413 }
1414
1415 case SET_AUDIO_PORT_CONFIG: {
1416 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1417 struct audio_port_config config = {};
1418 data.read(&config, sizeof(struct audio_port_config));
1419 (void)sanitizeAudioPortConfig(&config);
1420 status_t status = setAudioPortConfig(&config);
1421 reply->writeInt32(status);
1422 return NO_ERROR;
1423 }
1424
1425 case REGISTER_CLIENT: {
1426 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1427 sp<IAudioPolicyServiceClient> client = interface_cast<IAudioPolicyServiceClient>(
1428 data.readStrongBinder());
1429 registerClient(client);
1430 return NO_ERROR;
1431 } break;
1432
1433 case SET_AUDIO_PORT_CALLBACK_ENABLED: {
1434 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1435 setAudioPortCallbacksEnabled(data.readInt32() == 1);
1436 return NO_ERROR;
1437 } break;
1438
1439 case ACQUIRE_SOUNDTRIGGER_SESSION: {
1440 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1441 sp<IAudioPolicyServiceClient> client = interface_cast<IAudioPolicyServiceClient>(
1442 data.readStrongBinder());
1443 audio_session_t session = AUDIO_SESSION_NONE;
1444 audio_io_handle_t ioHandle = AUDIO_IO_HANDLE_NONE;
1445 audio_devices_t device = AUDIO_DEVICE_NONE;
1446 status_t status = acquireSoundTriggerSession(&session, &ioHandle, &device);
1447 reply->writeInt32(status);
1448 if (status == NO_ERROR) {
1449 reply->writeInt32(session);
1450 reply->writeInt32(ioHandle);
1451 reply->writeInt32(device);
1452 }
1453 return NO_ERROR;
1454 } break;
1455
1456 case RELEASE_SOUNDTRIGGER_SESSION: {
1457 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1458 sp<IAudioPolicyServiceClient> client = interface_cast<IAudioPolicyServiceClient>(
1459 data.readStrongBinder());
1460 audio_session_t session = (audio_session_t)data.readInt32();
1461 status_t status = releaseSoundTriggerSession(session);
1462 reply->writeInt32(status);
1463 return NO_ERROR;
1464 } break;
1465
1466 case GET_PHONE_STATE: {
1467 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1468 reply->writeInt32((int32_t)getPhoneState());
1469 return NO_ERROR;
1470 } break;
1471
1472 case REGISTER_POLICY_MIXES: {
1473 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1474 bool registration = data.readInt32() == 1;
1475 Vector<AudioMix> mixes;
1476 size_t size = (size_t)data.readInt32();
1477 if (size > MAX_MIXES_PER_POLICY) {
1478 size = MAX_MIXES_PER_POLICY;
1479 }
1480 for (size_t i = 0; i < size; i++) {
1481 AudioMix mix;
1482 if (mix.readFromParcel((Parcel*)&data) == NO_ERROR) {
1483 mixes.add(mix);
1484 }
1485 }
1486 status_t status = registerPolicyMixes(mixes, registration);
1487 reply->writeInt32(status);
1488 return NO_ERROR;
1489 } break;
1490
1491 case START_AUDIO_SOURCE: {
1492 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1493 struct audio_port_config source = {};
1494 data.read(&source, sizeof(struct audio_port_config));
1495 (void)sanitizeAudioPortConfig(&source);
1496 audio_attributes_t attributes = {};
1497 data.read(&attributes, sizeof(audio_attributes_t));
1498 sanetizeAudioAttributes(&attributes);
1499 audio_patch_handle_t handle = AUDIO_PATCH_HANDLE_NONE;
1500 status_t status = startAudioSource(&source, &attributes, &handle);
1501 reply->writeInt32(status);
1502 reply->writeInt32(handle);
1503 return NO_ERROR;
1504 } break;
1505
1506 case STOP_AUDIO_SOURCE: {
1507 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1508 audio_patch_handle_t handle = (audio_patch_handle_t) data.readInt32();
1509 status_t status = stopAudioSource(handle);
1510 reply->writeInt32(status);
1511 return NO_ERROR;
1512 } break;
1513
1514 case SET_MASTER_MONO: {
1515 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1516 bool mono = static_cast<bool>(data.readInt32());
1517 status_t status = setMasterMono(mono);
1518 reply->writeInt32(status);
1519 return NO_ERROR;
1520 } break;
1521
1522 case GET_MASTER_MONO: {
1523 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1524 bool mono;
1525 status_t status = getMasterMono(&mono);
1526 reply->writeInt32(status);
1527 if (status == NO_ERROR) {
1528 reply->writeInt32(static_cast<int32_t>(mono));
1529 }
1530 return NO_ERROR;
1531 } break;
1532
1533 case GET_STREAM_VOLUME_DB: {
1534 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1535 audio_stream_type_t stream =
1536 static_cast <audio_stream_type_t>(data.readInt32());
1537 int index = static_cast <int>(data.readInt32());
1538 audio_devices_t device =
1539 static_cast <audio_devices_t>(data.readUint32());
1540 reply->writeFloat(getStreamVolumeDB(stream, index, device));
1541 return NO_ERROR;
1542 }
1543
1544 case GET_SURROUND_FORMATS: {
1545 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1546 unsigned int numSurroundFormatsReq = data.readUint32();
1547 if (numSurroundFormatsReq > MAX_ITEMS_PER_LIST) {
1548 numSurroundFormatsReq = MAX_ITEMS_PER_LIST;
1549 }
1550 bool reported = data.readBool();
1551 unsigned int numSurroundFormats = numSurroundFormatsReq;
1552 audio_format_t *surroundFormats = (audio_format_t *)calloc(
1553 numSurroundFormats, sizeof(audio_format_t));
1554 bool *surroundFormatsEnabled = (bool *)calloc(numSurroundFormats, sizeof(bool));
1555 if (numSurroundFormatsReq > 0 &&
1556 (surroundFormats == NULL || surroundFormatsEnabled == NULL)) {
1557 free(surroundFormats);
1558 free(surroundFormatsEnabled);
1559 reply->writeInt32(NO_MEMORY);
1560 return NO_ERROR;
1561 }
1562 status_t status = getSurroundFormats(
1563 &numSurroundFormats, surroundFormats, surroundFormatsEnabled, reported);
1564 reply->writeInt32(status);
1565
1566 if (status == NO_ERROR) {
1567 reply->writeUint32(numSurroundFormats);
1568 if (numSurroundFormatsReq > numSurroundFormats) {
1569 numSurroundFormatsReq = numSurroundFormats;
1570 }
1571 reply->write(surroundFormats, numSurroundFormatsReq * sizeof(audio_format_t));
1572 reply->write(surroundFormatsEnabled, numSurroundFormatsReq * sizeof(bool));
1573 }
1574 free(surroundFormats);
1575 free(surroundFormatsEnabled);
1576 return NO_ERROR;
1577 }
1578
1579 case SET_SURROUND_FORMAT_ENABLED: {
1580 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1581 audio_format_t audioFormat = (audio_format_t) data.readInt32();
1582 bool enabled = data.readBool();
1583 status_t status = setSurroundFormatEnabled(audioFormat, enabled);
1584 reply->writeInt32(status);
1585 return NO_ERROR;
1586 }
1587
1588 default:
1589 return BBinder::onTransact(code, data, reply, flags);
1590 }
1591 }
1592
1593 /** returns true if string overflow was prevented by zero termination */
1594 template <size_t size>
preventStringOverflow(char (& s)[size])1595 static bool preventStringOverflow(char (&s)[size]) {
1596 if (strnlen(s, size) < size) return false;
1597 s[size - 1] = '\0';
1598 return true;
1599 }
1600
sanetizeAudioAttributes(audio_attributes_t * attr)1601 void BnAudioPolicyService::sanetizeAudioAttributes(audio_attributes_t* attr)
1602 {
1603 const size_t tagsMaxSize = AUDIO_ATTRIBUTES_TAGS_MAX_SIZE;
1604 if (strnlen(attr->tags, tagsMaxSize) >= tagsMaxSize) {
1605 android_errorWriteLog(0x534e4554, "68953950"); // SafetyNet logging
1606 }
1607 attr->tags[tagsMaxSize - 1] = '\0';
1608 }
1609
1610 /** returns BAD_VALUE if sanitization was required. */
sanitizeEffectDescriptor(effect_descriptor_t * desc)1611 status_t BnAudioPolicyService::sanitizeEffectDescriptor(effect_descriptor_t* desc)
1612 {
1613 if (preventStringOverflow(desc->name)
1614 | /* always */ preventStringOverflow(desc->implementor)) {
1615 android_errorWriteLog(0x534e4554, "73126106"); // SafetyNet logging
1616 return BAD_VALUE;
1617 }
1618 return NO_ERROR;
1619 }
1620
1621 /** returns BAD_VALUE if sanitization was required. */
sanitizeAudioPortConfig(struct audio_port_config * config)1622 status_t BnAudioPolicyService::sanitizeAudioPortConfig(struct audio_port_config* config)
1623 {
1624 if (config->type == AUDIO_PORT_TYPE_DEVICE &&
1625 preventStringOverflow(config->ext.device.address)) {
1626 return BAD_VALUE;
1627 }
1628 return NO_ERROR;
1629 }
1630
1631 // ----------------------------------------------------------------------------
1632
1633 } // namespace android
1634