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 <media/AudioEffect.h>
28 #include <media/IAudioPolicyService.h>
29 #include <media/TimeCheck.h>
30 #include <mediautils/ServiceUtilities.h>
31 #include <system/audio.h>
32
33 namespace android {
34
35 enum {
36 SET_DEVICE_CONNECTION_STATE = IBinder::FIRST_CALL_TRANSACTION,
37 GET_DEVICE_CONNECTION_STATE,
38 HANDLE_DEVICE_CONFIG_CHANGE,
39 SET_PHONE_STATE,
40 SET_RINGER_MODE, // reserved, no longer used
41 SET_FORCE_USE,
42 GET_FORCE_USE,
43 GET_OUTPUT,
44 START_OUTPUT,
45 STOP_OUTPUT,
46 RELEASE_OUTPUT,
47 GET_INPUT_FOR_ATTR,
48 START_INPUT,
49 STOP_INPUT,
50 RELEASE_INPUT,
51 INIT_STREAM_VOLUME,
52 SET_STREAM_VOLUME,
53 GET_STREAM_VOLUME,
54 SET_VOLUME_ATTRIBUTES,
55 GET_VOLUME_ATTRIBUTES,
56 GET_MIN_VOLUME_FOR_ATTRIBUTES,
57 GET_MAX_VOLUME_FOR_ATTRIBUTES,
58 GET_STRATEGY_FOR_STREAM,
59 GET_OUTPUT_FOR_EFFECT,
60 REGISTER_EFFECT,
61 UNREGISTER_EFFECT,
62 IS_STREAM_ACTIVE,
63 IS_SOURCE_ACTIVE,
64 GET_DEVICES_FOR_STREAM,
65 QUERY_DEFAULT_PRE_PROCESSING,
66 SET_EFFECT_ENABLED,
67 IS_STREAM_ACTIVE_REMOTELY,
68 IS_OFFLOAD_SUPPORTED,
69 IS_DIRECT_OUTPUT_SUPPORTED,
70 LIST_AUDIO_PORTS,
71 GET_AUDIO_PORT,
72 CREATE_AUDIO_PATCH,
73 RELEASE_AUDIO_PATCH,
74 LIST_AUDIO_PATCHES,
75 SET_AUDIO_PORT_CONFIG,
76 REGISTER_CLIENT,
77 GET_OUTPUT_FOR_ATTR,
78 ACQUIRE_SOUNDTRIGGER_SESSION,
79 RELEASE_SOUNDTRIGGER_SESSION,
80 GET_PHONE_STATE,
81 REGISTER_POLICY_MIXES,
82 START_AUDIO_SOURCE,
83 STOP_AUDIO_SOURCE,
84 SET_AUDIO_PORT_CALLBACK_ENABLED,
85 SET_AUDIO_VOLUME_GROUP_CALLBACK_ENABLED,
86 SET_MASTER_MONO,
87 GET_MASTER_MONO,
88 GET_STREAM_VOLUME_DB,
89 GET_SURROUND_FORMATS,
90 SET_SURROUND_FORMAT_ENABLED,
91 ADD_STREAM_DEFAULT_EFFECT,
92 REMOVE_STREAM_DEFAULT_EFFECT,
93 ADD_SOURCE_DEFAULT_EFFECT,
94 REMOVE_SOURCE_DEFAULT_EFFECT,
95 SET_ASSISTANT_UID,
96 SET_A11Y_SERVICES_UIDS,
97 IS_HAPTIC_PLAYBACK_SUPPORTED,
98 SET_UID_DEVICE_AFFINITY,
99 REMOVE_UID_DEVICE_AFFINITY,
100 GET_OFFLOAD_FORMATS_A2DP,
101 LIST_AUDIO_PRODUCT_STRATEGIES,
102 GET_STRATEGY_FOR_ATTRIBUTES,
103 LIST_AUDIO_VOLUME_GROUPS,
104 GET_VOLUME_GROUP_FOR_ATTRIBUTES,
105 SET_ALLOWED_CAPTURE_POLICY,
106 MOVE_EFFECTS_TO_IO,
107 SET_RTT_ENABLED
108 };
109
110 #define MAX_ITEMS_PER_LIST 1024
111
112 class BpAudioPolicyService : public BpInterface<IAudioPolicyService>
113 {
114 public:
BpAudioPolicyService(const sp<IBinder> & impl)115 explicit BpAudioPolicyService(const sp<IBinder>& impl)
116 : BpInterface<IAudioPolicyService>(impl)
117 {
118 }
119
setDeviceConnectionState(audio_devices_t device,audio_policy_dev_state_t state,const char * device_address,const char * device_name,audio_format_t encodedFormat)120 virtual status_t setDeviceConnectionState(
121 audio_devices_t device,
122 audio_policy_dev_state_t state,
123 const char *device_address,
124 const char *device_name,
125 audio_format_t encodedFormat)
126 {
127 Parcel data, reply;
128 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
129 data.writeInt32(static_cast <uint32_t>(device));
130 data.writeInt32(static_cast <uint32_t>(state));
131 data.writeCString(device_address);
132 data.writeCString(device_name);
133 data.writeInt32(static_cast <uint32_t>(encodedFormat));
134 remote()->transact(SET_DEVICE_CONNECTION_STATE, data, &reply);
135 return static_cast <status_t> (reply.readInt32());
136 }
137
getDeviceConnectionState(audio_devices_t device,const char * device_address)138 virtual audio_policy_dev_state_t getDeviceConnectionState(
139 audio_devices_t device,
140 const char *device_address)
141 {
142 Parcel data, reply;
143 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
144 data.writeInt32(static_cast <uint32_t>(device));
145 data.writeCString(device_address);
146 remote()->transact(GET_DEVICE_CONNECTION_STATE, data, &reply);
147 return static_cast <audio_policy_dev_state_t>(reply.readInt32());
148 }
149
handleDeviceConfigChange(audio_devices_t device,const char * device_address,const char * device_name,audio_format_t encodedFormat)150 virtual status_t handleDeviceConfigChange(audio_devices_t device,
151 const char *device_address,
152 const char *device_name,
153 audio_format_t encodedFormat)
154 {
155 Parcel data, reply;
156 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
157 data.writeInt32(static_cast <uint32_t>(device));
158 data.writeCString(device_address);
159 data.writeCString(device_name);
160 data.writeInt32(static_cast <uint32_t>(encodedFormat));
161 remote()->transact(HANDLE_DEVICE_CONFIG_CHANGE, data, &reply);
162 return static_cast <status_t> (reply.readInt32());
163 }
164
setPhoneState(audio_mode_t state)165 virtual status_t setPhoneState(audio_mode_t state)
166 {
167 Parcel data, reply;
168 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
169 data.writeInt32(state);
170 remote()->transact(SET_PHONE_STATE, data, &reply);
171 return static_cast <status_t> (reply.readInt32());
172 }
173
setForceUse(audio_policy_force_use_t usage,audio_policy_forced_cfg_t config)174 virtual status_t setForceUse(audio_policy_force_use_t usage, audio_policy_forced_cfg_t config)
175 {
176 Parcel data, reply;
177 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
178 data.writeInt32(static_cast <uint32_t>(usage));
179 data.writeInt32(static_cast <uint32_t>(config));
180 remote()->transact(SET_FORCE_USE, data, &reply);
181 return static_cast <status_t> (reply.readInt32());
182 }
183
getForceUse(audio_policy_force_use_t usage)184 virtual audio_policy_forced_cfg_t getForceUse(audio_policy_force_use_t usage)
185 {
186 Parcel data, reply;
187 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
188 data.writeInt32(static_cast <uint32_t>(usage));
189 remote()->transact(GET_FORCE_USE, data, &reply);
190 return static_cast <audio_policy_forced_cfg_t> (reply.readInt32());
191 }
192
getOutput(audio_stream_type_t stream)193 virtual audio_io_handle_t getOutput(audio_stream_type_t stream)
194 {
195 Parcel data, reply;
196 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
197 data.writeInt32(static_cast <uint32_t>(stream));
198 remote()->transact(GET_OUTPUT, data, &reply);
199 return static_cast <audio_io_handle_t> (reply.readInt32());
200 }
201
getOutputForAttr(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,std::vector<audio_io_handle_t> * secondaryOutputs)202 status_t getOutputForAttr(audio_attributes_t *attr,
203 audio_io_handle_t *output,
204 audio_session_t session,
205 audio_stream_type_t *stream,
206 pid_t pid,
207 uid_t uid,
208 const audio_config_t *config,
209 audio_output_flags_t flags,
210 audio_port_handle_t *selectedDeviceId,
211 audio_port_handle_t *portId,
212 std::vector<audio_io_handle_t> *secondaryOutputs) override
213 {
214 Parcel data, reply;
215 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
216 if (attr == nullptr) {
217 ALOGE("%s NULL audio attributes", __func__);
218 return BAD_VALUE;
219 }
220 if (output == nullptr) {
221 ALOGE("%s NULL output - shouldn't happen", __func__);
222 return BAD_VALUE;
223 }
224 if (selectedDeviceId == nullptr) {
225 ALOGE("%s NULL selectedDeviceId - shouldn't happen", __func__);
226 return BAD_VALUE;
227 }
228 if (portId == nullptr) {
229 ALOGE("%s NULL portId - shouldn't happen", __func__);
230 return BAD_VALUE;
231 }
232 if (secondaryOutputs == nullptr) {
233 ALOGE("%s NULL secondaryOutputs - shouldn't happen", __func__);
234 return BAD_VALUE;
235 }
236 data.write(attr, sizeof(audio_attributes_t));
237 data.writeInt32(session);
238 if (stream == NULL) {
239 data.writeInt32(0);
240 } else {
241 data.writeInt32(1);
242 data.writeInt32(*stream);
243 }
244 data.writeInt32(pid);
245 data.writeInt32(uid);
246 data.write(config, sizeof(audio_config_t));
247 data.writeInt32(static_cast <uint32_t>(flags));
248 data.writeInt32(*selectedDeviceId);
249 data.writeInt32(*portId);
250 status_t status = remote()->transact(GET_OUTPUT_FOR_ATTR, data, &reply);
251 if (status != NO_ERROR) {
252 return status;
253 }
254 status = (status_t)reply.readInt32();
255 if (status != NO_ERROR) {
256 return status;
257 }
258 status = (status_t)reply.read(&attr, sizeof(audio_attributes_t));
259 if (status != NO_ERROR) {
260 return status;
261 }
262 *output = (audio_io_handle_t)reply.readInt32();
263 audio_stream_type_t lStream = (audio_stream_type_t)reply.readInt32();
264 if (stream != NULL) {
265 *stream = lStream;
266 }
267 *selectedDeviceId = (audio_port_handle_t)reply.readInt32();
268 *portId = (audio_port_handle_t)reply.readInt32();
269 secondaryOutputs->resize(reply.readInt32());
270 return reply.read(secondaryOutputs->data(),
271 secondaryOutputs->size() * sizeof(audio_io_handle_t));
272 }
273
startOutput(audio_port_handle_t portId)274 virtual status_t startOutput(audio_port_handle_t portId)
275 {
276 Parcel data, reply;
277 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
278 data.writeInt32((int32_t)portId);
279 remote()->transact(START_OUTPUT, data, &reply);
280 return static_cast <status_t> (reply.readInt32());
281 }
282
stopOutput(audio_port_handle_t portId)283 virtual status_t stopOutput(audio_port_handle_t portId)
284 {
285 Parcel data, reply;
286 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
287 data.writeInt32((int32_t)portId);
288 remote()->transact(STOP_OUTPUT, data, &reply);
289 return static_cast <status_t> (reply.readInt32());
290 }
291
releaseOutput(audio_port_handle_t portId)292 virtual void releaseOutput(audio_port_handle_t portId)
293 {
294 Parcel data, reply;
295 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
296 data.writeInt32((int32_t)portId);
297 remote()->transact(RELEASE_OUTPUT, data, &reply);
298 }
299
getInputForAttr(const audio_attributes_t * attr,audio_io_handle_t * input,audio_unique_id_t riid,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)300 virtual status_t getInputForAttr(const audio_attributes_t *attr,
301 audio_io_handle_t *input,
302 audio_unique_id_t riid,
303 audio_session_t session,
304 pid_t pid,
305 uid_t uid,
306 const String16& opPackageName,
307 const audio_config_base_t *config,
308 audio_input_flags_t flags,
309 audio_port_handle_t *selectedDeviceId,
310 audio_port_handle_t *portId)
311 {
312 Parcel data, reply;
313 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
314 if (attr == NULL) {
315 ALOGE("getInputForAttr NULL attr - shouldn't happen");
316 return BAD_VALUE;
317 }
318 if (input == NULL) {
319 ALOGE("getInputForAttr NULL input - shouldn't happen");
320 return BAD_VALUE;
321 }
322 if (selectedDeviceId == NULL) {
323 ALOGE("getInputForAttr NULL selectedDeviceId - shouldn't happen");
324 return BAD_VALUE;
325 }
326 if (portId == NULL) {
327 ALOGE("getInputForAttr NULL portId - shouldn't happen");
328 return BAD_VALUE;
329 }
330 data.write(attr, sizeof(audio_attributes_t));
331 data.writeInt32(*input);
332 data.writeInt32(riid);
333 data.writeInt32(session);
334 data.writeInt32(pid);
335 data.writeInt32(uid);
336 data.writeString16(opPackageName);
337 data.write(config, sizeof(audio_config_base_t));
338 data.writeInt32(flags);
339 data.writeInt32(*selectedDeviceId);
340 data.writeInt32(*portId);
341 status_t status = remote()->transact(GET_INPUT_FOR_ATTR, data, &reply);
342 if (status != NO_ERROR) {
343 return status;
344 }
345 status = reply.readInt32();
346 if (status != NO_ERROR) {
347 return status;
348 }
349 *input = (audio_io_handle_t)reply.readInt32();
350 *selectedDeviceId = (audio_port_handle_t)reply.readInt32();
351 *portId = (audio_port_handle_t)reply.readInt32();
352 return NO_ERROR;
353 }
354
startInput(audio_port_handle_t portId)355 virtual status_t startInput(audio_port_handle_t portId)
356 {
357 Parcel data, reply;
358 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
359 data.writeInt32(portId);
360 remote()->transact(START_INPUT, data, &reply);
361 status_t status = static_cast <status_t> (reply.readInt32());
362 return status;
363 }
364
stopInput(audio_port_handle_t portId)365 virtual status_t stopInput(audio_port_handle_t portId)
366 {
367 Parcel data, reply;
368 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
369 data.writeInt32(portId);
370 remote()->transact(STOP_INPUT, data, &reply);
371 return static_cast <status_t> (reply.readInt32());
372 }
373
releaseInput(audio_port_handle_t portId)374 virtual void releaseInput(audio_port_handle_t portId)
375 {
376 Parcel data, reply;
377 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
378 data.writeInt32(portId);
379 remote()->transact(RELEASE_INPUT, data, &reply);
380 }
381
initStreamVolume(audio_stream_type_t stream,int indexMin,int indexMax)382 virtual status_t initStreamVolume(audio_stream_type_t stream,
383 int indexMin,
384 int indexMax)
385 {
386 Parcel data, reply;
387 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
388 data.writeInt32(static_cast <uint32_t>(stream));
389 data.writeInt32(indexMin);
390 data.writeInt32(indexMax);
391 remote()->transact(INIT_STREAM_VOLUME, data, &reply);
392 return static_cast <status_t> (reply.readInt32());
393 }
394
setStreamVolumeIndex(audio_stream_type_t stream,int index,audio_devices_t device)395 virtual status_t setStreamVolumeIndex(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(index);
403 data.writeInt32(static_cast <uint32_t>(device));
404 remote()->transact(SET_STREAM_VOLUME, data, &reply);
405 return static_cast <status_t> (reply.readInt32());
406 }
407
getStreamVolumeIndex(audio_stream_type_t stream,int * index,audio_devices_t device)408 virtual status_t getStreamVolumeIndex(audio_stream_type_t stream,
409 int *index,
410 audio_devices_t device)
411 {
412 Parcel data, reply;
413 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
414 data.writeInt32(static_cast <uint32_t>(stream));
415 data.writeInt32(static_cast <uint32_t>(device));
416
417 remote()->transact(GET_STREAM_VOLUME, data, &reply);
418 int lIndex = reply.readInt32();
419 if (index) *index = lIndex;
420 return static_cast <status_t> (reply.readInt32());
421 }
422
setVolumeIndexForAttributes(const audio_attributes_t & attr,int index,audio_devices_t device)423 virtual status_t setVolumeIndexForAttributes(const audio_attributes_t &attr, int index,
424 audio_devices_t device)
425 {
426 Parcel data, reply;
427 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
428 data.write(&attr, sizeof(audio_attributes_t));
429 data.writeInt32(index);
430 data.writeInt32(static_cast <uint32_t>(device));
431 status_t status = remote()->transact(SET_VOLUME_ATTRIBUTES, data, &reply);
432 if (status != NO_ERROR) {
433 return status;
434 }
435 return static_cast <status_t> (reply.readInt32());
436 }
getVolumeIndexForAttributes(const audio_attributes_t & attr,int & index,audio_devices_t device)437 virtual status_t getVolumeIndexForAttributes(const audio_attributes_t &attr, int &index,
438 audio_devices_t device)
439 {
440 Parcel data, reply;
441 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
442 data.write(&attr, sizeof(audio_attributes_t));
443 data.writeInt32(static_cast <uint32_t>(device));
444 status_t status = remote()->transact(GET_VOLUME_ATTRIBUTES, data, &reply);
445 if (status != NO_ERROR) {
446 return status;
447 }
448 status = static_cast <status_t> (reply.readInt32());
449 if (status != NO_ERROR) {
450 return status;
451 }
452 index = reply.readInt32();
453 return NO_ERROR;
454 }
getMinVolumeIndexForAttributes(const audio_attributes_t & attr,int & index)455 virtual status_t getMinVolumeIndexForAttributes(const audio_attributes_t &attr, int &index)
456 {
457 Parcel data, reply;
458 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
459 data.write(&attr, sizeof(audio_attributes_t));
460 status_t status = remote()->transact(GET_MIN_VOLUME_FOR_ATTRIBUTES, data, &reply);
461 if (status != NO_ERROR) {
462 return status;
463 }
464 status = static_cast <status_t> (reply.readInt32());
465 if (status != NO_ERROR) {
466 return status;
467 }
468 index = reply.readInt32();
469 return NO_ERROR;
470 }
getMaxVolumeIndexForAttributes(const audio_attributes_t & attr,int & index)471 virtual status_t getMaxVolumeIndexForAttributes(const audio_attributes_t &attr, int &index)
472 {
473 Parcel data, reply;
474 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
475 data.write(&attr, sizeof(audio_attributes_t));
476 status_t status = remote()->transact(GET_MAX_VOLUME_FOR_ATTRIBUTES, data, &reply);
477 if (status != NO_ERROR) {
478 return status;
479 }
480 status = static_cast <status_t> (reply.readInt32());
481 if (status != NO_ERROR) {
482 return status;
483 }
484 index = reply.readInt32();
485 return NO_ERROR;
486 }
getStrategyForStream(audio_stream_type_t stream)487 virtual uint32_t getStrategyForStream(audio_stream_type_t stream)
488 {
489 Parcel data, reply;
490 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
491 data.writeInt32(static_cast <uint32_t>(stream));
492 remote()->transact(GET_STRATEGY_FOR_STREAM, data, &reply);
493 return reply.readUint32();
494 }
495
getDevicesForStream(audio_stream_type_t stream)496 virtual audio_devices_t getDevicesForStream(audio_stream_type_t stream)
497 {
498 Parcel data, reply;
499 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
500 data.writeInt32(static_cast <uint32_t>(stream));
501 remote()->transact(GET_DEVICES_FOR_STREAM, data, &reply);
502 return (audio_devices_t) reply.readInt32();
503 }
504
getOutputForEffect(const effect_descriptor_t * desc)505 virtual audio_io_handle_t getOutputForEffect(const effect_descriptor_t *desc)
506 {
507 Parcel data, reply;
508 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
509 data.write(desc, sizeof(effect_descriptor_t));
510 remote()->transact(GET_OUTPUT_FOR_EFFECT, data, &reply);
511 return static_cast <audio_io_handle_t> (reply.readInt32());
512 }
513
registerEffect(const effect_descriptor_t * desc,audio_io_handle_t io,uint32_t strategy,audio_session_t session,int id)514 virtual status_t registerEffect(const effect_descriptor_t *desc,
515 audio_io_handle_t io,
516 uint32_t strategy,
517 audio_session_t session,
518 int id)
519 {
520 Parcel data, reply;
521 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
522 data.write(desc, sizeof(effect_descriptor_t));
523 data.writeInt32(io);
524 data.writeInt32(strategy);
525 data.writeInt32(session);
526 data.writeInt32(id);
527 remote()->transact(REGISTER_EFFECT, data, &reply);
528 return static_cast <status_t> (reply.readInt32());
529 }
530
unregisterEffect(int id)531 virtual status_t unregisterEffect(int id)
532 {
533 Parcel data, reply;
534 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
535 data.writeInt32(id);
536 remote()->transact(UNREGISTER_EFFECT, data, &reply);
537 return static_cast <status_t> (reply.readInt32());
538 }
539
setEffectEnabled(int id,bool enabled)540 virtual status_t setEffectEnabled(int id, bool enabled)
541 {
542 Parcel data, reply;
543 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
544 data.writeInt32(id);
545 data.writeInt32(enabled);
546 remote()->transact(SET_EFFECT_ENABLED, data, &reply);
547 return static_cast <status_t> (reply.readInt32());
548 }
549
moveEffectsToIo(const std::vector<int> & ids,audio_io_handle_t io)550 status_t moveEffectsToIo(const std::vector<int>& ids, audio_io_handle_t io) override
551 {
552 Parcel data, reply;
553 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
554 data.writeInt32(ids.size());
555 for (auto id : ids) {
556 data.writeInt32(id);
557 }
558 data.writeInt32(io);
559 status_t status = remote()->transact(MOVE_EFFECTS_TO_IO, data, &reply);
560 if (status != NO_ERROR) {
561 return status;
562 }
563 return static_cast <status_t> (reply.readInt32());
564 }
565
isStreamActive(audio_stream_type_t stream,uint32_t inPastMs) const566 virtual bool isStreamActive(audio_stream_type_t stream, uint32_t inPastMs) const
567 {
568 Parcel data, reply;
569 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
570 data.writeInt32((int32_t) stream);
571 data.writeInt32(inPastMs);
572 remote()->transact(IS_STREAM_ACTIVE, data, &reply);
573 return reply.readInt32();
574 }
575
isStreamActiveRemotely(audio_stream_type_t stream,uint32_t inPastMs) const576 virtual bool isStreamActiveRemotely(audio_stream_type_t stream, uint32_t inPastMs) const
577 {
578 Parcel data, reply;
579 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
580 data.writeInt32((int32_t) stream);
581 data.writeInt32(inPastMs);
582 remote()->transact(IS_STREAM_ACTIVE_REMOTELY, data, &reply);
583 return reply.readInt32();
584 }
585
isSourceActive(audio_source_t source) const586 virtual bool isSourceActive(audio_source_t source) const
587 {
588 Parcel data, reply;
589 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
590 data.writeInt32((int32_t) source);
591 remote()->transact(IS_SOURCE_ACTIVE, data, &reply);
592 return reply.readInt32();
593 }
594
queryDefaultPreProcessing(audio_session_t audioSession,effect_descriptor_t * descriptors,uint32_t * count)595 virtual status_t queryDefaultPreProcessing(audio_session_t audioSession,
596 effect_descriptor_t *descriptors,
597 uint32_t *count)
598 {
599 if (descriptors == NULL || count == NULL) {
600 return BAD_VALUE;
601 }
602 Parcel data, reply;
603 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
604 data.writeInt32(audioSession);
605 data.writeInt32(*count);
606 status_t status = remote()->transact(QUERY_DEFAULT_PRE_PROCESSING, data, &reply);
607 if (status != NO_ERROR) {
608 return status;
609 }
610 status = static_cast <status_t> (reply.readInt32());
611 uint32_t retCount = reply.readInt32();
612 if (retCount != 0) {
613 uint32_t numDesc = (retCount < *count) ? retCount : *count;
614 reply.read(descriptors, sizeof(effect_descriptor_t) * numDesc);
615 }
616 *count = retCount;
617 return status;
618 }
619
setAllowedCapturePolicy(uid_t uid,audio_flags_mask_t flags)620 status_t setAllowedCapturePolicy(uid_t uid, audio_flags_mask_t flags) override {
621 Parcel data, reply;
622 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
623 data.writeInt32(uid);
624 data.writeInt32(flags);
625 remote()->transact(SET_ALLOWED_CAPTURE_POLICY, data, &reply);
626 return reply.readInt32();
627 }
628
isOffloadSupported(const audio_offload_info_t & info)629 virtual bool isOffloadSupported(const audio_offload_info_t& info)
630 {
631 Parcel data, reply;
632 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
633 data.write(&info, sizeof(audio_offload_info_t));
634 remote()->transact(IS_OFFLOAD_SUPPORTED, data, &reply);
635 return reply.readInt32();
636 }
637
isDirectOutputSupported(const audio_config_base_t & config,const audio_attributes_t & attributes)638 virtual bool isDirectOutputSupported(const audio_config_base_t& config,
639 const audio_attributes_t& attributes) {
640 Parcel data, reply;
641 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
642 data.write(&config, sizeof(audio_config_base_t));
643 data.write(&attributes, sizeof(audio_attributes_t));
644 status_t status = remote()->transact(IS_DIRECT_OUTPUT_SUPPORTED, data, &reply);
645 return status == NO_ERROR ? static_cast<bool>(reply.readInt32()) : false;
646 }
647
listAudioPorts(audio_port_role_t role,audio_port_type_t type,unsigned int * num_ports,struct audio_port * ports,unsigned int * generation)648 virtual status_t listAudioPorts(audio_port_role_t role,
649 audio_port_type_t type,
650 unsigned int *num_ports,
651 struct audio_port *ports,
652 unsigned int *generation)
653 {
654 if (num_ports == NULL || (*num_ports != 0 && ports == NULL) ||
655 generation == NULL) {
656 return BAD_VALUE;
657 }
658 Parcel data, reply;
659 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
660 unsigned int numPortsReq = (ports == NULL) ? 0 : *num_ports;
661 data.writeInt32(role);
662 data.writeInt32(type);
663 data.writeInt32(numPortsReq);
664 status_t status = remote()->transact(LIST_AUDIO_PORTS, data, &reply);
665 if (status == NO_ERROR) {
666 status = (status_t)reply.readInt32();
667 *num_ports = (unsigned int)reply.readInt32();
668 }
669 if (status == NO_ERROR) {
670 if (numPortsReq > *num_ports) {
671 numPortsReq = *num_ports;
672 }
673 if (numPortsReq > 0) {
674 reply.read(ports, numPortsReq * sizeof(struct audio_port));
675 }
676 *generation = reply.readInt32();
677 }
678 return status;
679 }
680
getAudioPort(struct audio_port * port)681 virtual status_t getAudioPort(struct audio_port *port)
682 {
683 if (port == NULL) {
684 return BAD_VALUE;
685 }
686 Parcel data, reply;
687 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
688 data.write(port, sizeof(struct audio_port));
689 status_t status = remote()->transact(GET_AUDIO_PORT, data, &reply);
690 if (status != NO_ERROR ||
691 (status = (status_t)reply.readInt32()) != NO_ERROR) {
692 return status;
693 }
694 reply.read(port, sizeof(struct audio_port));
695 return status;
696 }
697
createAudioPatch(const struct audio_patch * patch,audio_patch_handle_t * handle)698 virtual status_t createAudioPatch(const struct audio_patch *patch,
699 audio_patch_handle_t *handle)
700 {
701 if (patch == NULL || handle == NULL) {
702 return BAD_VALUE;
703 }
704 Parcel data, reply;
705 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
706 data.write(patch, sizeof(struct audio_patch));
707 data.write(handle, sizeof(audio_patch_handle_t));
708 status_t status = remote()->transact(CREATE_AUDIO_PATCH, data, &reply);
709 if (status != NO_ERROR ||
710 (status = (status_t)reply.readInt32()) != NO_ERROR) {
711 return status;
712 }
713 reply.read(handle, sizeof(audio_patch_handle_t));
714 return status;
715 }
716
releaseAudioPatch(audio_patch_handle_t handle)717 virtual status_t releaseAudioPatch(audio_patch_handle_t handle)
718 {
719 Parcel data, reply;
720 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
721 data.write(&handle, sizeof(audio_patch_handle_t));
722 status_t status = remote()->transact(RELEASE_AUDIO_PATCH, data, &reply);
723 if (status != NO_ERROR) {
724 status = (status_t)reply.readInt32();
725 }
726 return status;
727 }
728
listAudioPatches(unsigned int * num_patches,struct audio_patch * patches,unsigned int * generation)729 virtual status_t listAudioPatches(unsigned int *num_patches,
730 struct audio_patch *patches,
731 unsigned int *generation)
732 {
733 if (num_patches == NULL || (*num_patches != 0 && patches == NULL) ||
734 generation == NULL) {
735 return BAD_VALUE;
736 }
737 Parcel data, reply;
738 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
739 unsigned int numPatchesReq = (patches == NULL) ? 0 : *num_patches;
740 data.writeInt32(numPatchesReq);
741 status_t status = remote()->transact(LIST_AUDIO_PATCHES, data, &reply);
742 if (status == NO_ERROR) {
743 status = (status_t)reply.readInt32();
744 *num_patches = (unsigned int)reply.readInt32();
745 }
746 if (status == NO_ERROR) {
747 if (numPatchesReq > *num_patches) {
748 numPatchesReq = *num_patches;
749 }
750 if (numPatchesReq > 0) {
751 reply.read(patches, numPatchesReq * sizeof(struct audio_patch));
752 }
753 *generation = reply.readInt32();
754 }
755 return status;
756 }
757
setAudioPortConfig(const struct audio_port_config * config)758 virtual status_t setAudioPortConfig(const struct audio_port_config *config)
759 {
760 if (config == NULL) {
761 return BAD_VALUE;
762 }
763 Parcel data, reply;
764 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
765 data.write(config, sizeof(struct audio_port_config));
766 status_t status = remote()->transact(SET_AUDIO_PORT_CONFIG, data, &reply);
767 if (status != NO_ERROR) {
768 status = (status_t)reply.readInt32();
769 }
770 return status;
771 }
772
registerClient(const sp<IAudioPolicyServiceClient> & client)773 virtual void registerClient(const sp<IAudioPolicyServiceClient>& client)
774 {
775 Parcel data, reply;
776 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
777 data.writeStrongBinder(IInterface::asBinder(client));
778 remote()->transact(REGISTER_CLIENT, data, &reply);
779 }
780
setAudioPortCallbacksEnabled(bool enabled)781 virtual void setAudioPortCallbacksEnabled(bool enabled)
782 {
783 Parcel data, reply;
784 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
785 data.writeInt32(enabled ? 1 : 0);
786 remote()->transact(SET_AUDIO_PORT_CALLBACK_ENABLED, data, &reply);
787 }
788
setAudioVolumeGroupCallbacksEnabled(bool enabled)789 virtual void setAudioVolumeGroupCallbacksEnabled(bool enabled)
790 {
791 Parcel data, reply;
792 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
793 data.writeInt32(enabled ? 1 : 0);
794 remote()->transact(SET_AUDIO_VOLUME_GROUP_CALLBACK_ENABLED, data, &reply);
795 }
796
acquireSoundTriggerSession(audio_session_t * session,audio_io_handle_t * ioHandle,audio_devices_t * device)797 virtual status_t acquireSoundTriggerSession(audio_session_t *session,
798 audio_io_handle_t *ioHandle,
799 audio_devices_t *device)
800 {
801 if (session == NULL || ioHandle == NULL || device == NULL) {
802 return BAD_VALUE;
803 }
804 Parcel data, reply;
805 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
806 status_t status = remote()->transact(ACQUIRE_SOUNDTRIGGER_SESSION, data, &reply);
807 if (status != NO_ERROR) {
808 return status;
809 }
810 status = (status_t)reply.readInt32();
811 if (status == NO_ERROR) {
812 *session = (audio_session_t)reply.readInt32();
813 *ioHandle = (audio_io_handle_t)reply.readInt32();
814 *device = (audio_devices_t)reply.readInt32();
815 }
816 return status;
817 }
818
releaseSoundTriggerSession(audio_session_t session)819 virtual status_t releaseSoundTriggerSession(audio_session_t session)
820 {
821 Parcel data, reply;
822 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
823 data.writeInt32(session);
824 status_t status = remote()->transact(RELEASE_SOUNDTRIGGER_SESSION, data, &reply);
825 if (status != NO_ERROR) {
826 return status;
827 }
828 return (status_t)reply.readInt32();
829 }
830
getPhoneState()831 virtual audio_mode_t getPhoneState()
832 {
833 Parcel data, reply;
834 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
835 status_t status = remote()->transact(GET_PHONE_STATE, data, &reply);
836 if (status != NO_ERROR) {
837 return AUDIO_MODE_INVALID;
838 }
839 return (audio_mode_t)reply.readInt32();
840 }
841
registerPolicyMixes(const Vector<AudioMix> & mixes,bool registration)842 virtual status_t registerPolicyMixes(const Vector<AudioMix>& mixes, bool registration)
843 {
844 Parcel data, reply;
845 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
846 data.writeInt32(registration ? 1 : 0);
847 size_t size = mixes.size();
848 if (size > MAX_MIXES_PER_POLICY) {
849 size = MAX_MIXES_PER_POLICY;
850 }
851 size_t sizePosition = data.dataPosition();
852 data.writeInt32(size);
853 size_t finalSize = size;
854 for (size_t i = 0; i < size; i++) {
855 size_t position = data.dataPosition();
856 if (mixes[i].writeToParcel(&data) != NO_ERROR) {
857 data.setDataPosition(position);
858 finalSize--;
859 }
860 }
861 if (size != finalSize) {
862 size_t position = data.dataPosition();
863 data.setDataPosition(sizePosition);
864 data.writeInt32(finalSize);
865 data.setDataPosition(position);
866 }
867 status_t status = remote()->transact(REGISTER_POLICY_MIXES, data, &reply);
868 if (status == NO_ERROR) {
869 status = (status_t)reply.readInt32();
870 }
871 return status;
872 }
873
startAudioSource(const struct audio_port_config * source,const audio_attributes_t * attributes,audio_port_handle_t * portId)874 virtual status_t startAudioSource(const struct audio_port_config *source,
875 const audio_attributes_t *attributes,
876 audio_port_handle_t *portId)
877 {
878 Parcel data, reply;
879 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
880 if (source == NULL || attributes == NULL || portId == NULL) {
881 return BAD_VALUE;
882 }
883 data.write(source, sizeof(struct audio_port_config));
884 data.write(attributes, sizeof(audio_attributes_t));
885 status_t status = remote()->transact(START_AUDIO_SOURCE, data, &reply);
886 if (status != NO_ERROR) {
887 return status;
888 }
889 status = (status_t)reply.readInt32();
890 if (status != NO_ERROR) {
891 return status;
892 }
893 *portId = (audio_port_handle_t)reply.readInt32();
894 return status;
895 }
896
stopAudioSource(audio_port_handle_t portId)897 virtual status_t stopAudioSource(audio_port_handle_t portId)
898 {
899 Parcel data, reply;
900 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
901 data.writeInt32(portId);
902 status_t status = remote()->transact(STOP_AUDIO_SOURCE, data, &reply);
903 if (status != NO_ERROR) {
904 return status;
905 }
906 status = (status_t)reply.readInt32();
907 return status;
908 }
909
setMasterMono(bool mono)910 virtual status_t setMasterMono(bool mono)
911 {
912 Parcel data, reply;
913 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
914 data.writeInt32(static_cast<int32_t>(mono));
915 status_t status = remote()->transact(SET_MASTER_MONO, data, &reply);
916 if (status != NO_ERROR) {
917 return status;
918 }
919 return static_cast<status_t>(reply.readInt32());
920 }
921
getMasterMono(bool * mono)922 virtual status_t getMasterMono(bool *mono)
923 {
924 if (mono == nullptr) {
925 return BAD_VALUE;
926 }
927 Parcel data, reply;
928 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
929
930 status_t status = remote()->transact(GET_MASTER_MONO, data, &reply);
931 if (status != NO_ERROR) {
932 return status;
933 }
934 status = static_cast<status_t>(reply.readInt32());
935 if (status == NO_ERROR) {
936 *mono = static_cast<bool>(reply.readInt32());
937 }
938 return status;
939 }
940
getStreamVolumeDB(audio_stream_type_t stream,int index,audio_devices_t device)941 virtual float getStreamVolumeDB(audio_stream_type_t stream, int index, audio_devices_t device)
942 {
943 Parcel data, reply;
944 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
945 data.writeInt32(static_cast <int32_t>(stream));
946 data.writeInt32(static_cast <int32_t>(index));
947 data.writeUint32(static_cast <uint32_t>(device));
948 status_t status = remote()->transact(GET_STREAM_VOLUME_DB, data, &reply);
949 if (status != NO_ERROR) {
950 return NAN;
951 }
952 return reply.readFloat();
953 }
954
getSurroundFormats(unsigned int * numSurroundFormats,audio_format_t * surroundFormats,bool * surroundFormatsEnabled,bool reported)955 virtual status_t getSurroundFormats(unsigned int *numSurroundFormats,
956 audio_format_t *surroundFormats,
957 bool *surroundFormatsEnabled,
958 bool reported)
959 {
960 if (numSurroundFormats == NULL || (*numSurroundFormats != 0 &&
961 (surroundFormats == NULL || surroundFormatsEnabled == NULL))) {
962 return BAD_VALUE;
963 }
964 Parcel data, reply;
965 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
966 unsigned int numSurroundFormatsReq = *numSurroundFormats;
967 data.writeUint32(numSurroundFormatsReq);
968 data.writeBool(reported);
969 status_t status = remote()->transact(GET_SURROUND_FORMATS, data, &reply);
970 if (status == NO_ERROR && (status = (status_t)reply.readInt32()) == NO_ERROR) {
971 *numSurroundFormats = reply.readUint32();
972 }
973 if (status == NO_ERROR) {
974 if (numSurroundFormatsReq > *numSurroundFormats) {
975 numSurroundFormatsReq = *numSurroundFormats;
976 }
977 if (numSurroundFormatsReq > 0) {
978 status = reply.read(surroundFormats,
979 numSurroundFormatsReq * sizeof(audio_format_t));
980 if (status != NO_ERROR) {
981 return status;
982 }
983 status = reply.read(surroundFormatsEnabled,
984 numSurroundFormatsReq * sizeof(bool));
985 }
986 }
987 return status;
988 }
989
setSurroundFormatEnabled(audio_format_t audioFormat,bool enabled)990 virtual status_t setSurroundFormatEnabled(audio_format_t audioFormat, bool enabled)
991 {
992 Parcel data, reply;
993 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
994 data.writeInt32(audioFormat);
995 data.writeBool(enabled);
996 status_t status = remote()->transact(SET_SURROUND_FORMAT_ENABLED, data, &reply);
997 if (status != NO_ERROR) {
998 return status;
999 }
1000 return reply.readInt32();
1001 }
1002
getHwOffloadEncodingFormatsSupportedForA2DP(std::vector<audio_format_t> * formats)1003 virtual status_t getHwOffloadEncodingFormatsSupportedForA2DP(
1004 std::vector<audio_format_t> *formats)
1005 {
1006 if (formats == NULL) {
1007 return BAD_VALUE;
1008 }
1009
1010 Parcel data, reply;
1011 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
1012 status_t status = remote()->transact(GET_OFFLOAD_FORMATS_A2DP, data, &reply);
1013 if (status != NO_ERROR || (status = (status_t)reply.readInt32()) != NO_ERROR) {
1014 return status;
1015 }
1016
1017 size_t list_size = reply.readUint32();
1018
1019 for (size_t i = 0; i < list_size; i++) {
1020 formats->push_back(static_cast<audio_format_t>(reply.readInt32()));
1021 }
1022 return NO_ERROR;
1023 }
1024
1025
addStreamDefaultEffect(const effect_uuid_t * type,const String16 & opPackageName,const effect_uuid_t * uuid,int32_t priority,audio_usage_t usage,audio_unique_id_t * id)1026 virtual status_t addStreamDefaultEffect(const effect_uuid_t *type,
1027 const String16& opPackageName,
1028 const effect_uuid_t *uuid,
1029 int32_t priority,
1030 audio_usage_t usage,
1031 audio_unique_id_t* id)
1032 {
1033 Parcel data, reply;
1034 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
1035 data.write(type, sizeof(effect_uuid_t));
1036 data.writeString16(opPackageName);
1037 data.write(uuid, sizeof(effect_uuid_t));
1038 data.writeInt32(priority);
1039 data.writeInt32((int32_t) usage);
1040 status_t status = remote()->transact(ADD_STREAM_DEFAULT_EFFECT, data, &reply);
1041 if (status != NO_ERROR) {
1042 return status;
1043 }
1044 status = static_cast <status_t> (reply.readInt32());
1045 *id = reply.readInt32();
1046 return status;
1047 }
1048
removeStreamDefaultEffect(audio_unique_id_t id)1049 virtual status_t removeStreamDefaultEffect(audio_unique_id_t id)
1050 {
1051 Parcel data, reply;
1052 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
1053 data.writeInt32(id);
1054 status_t status = remote()->transact(REMOVE_STREAM_DEFAULT_EFFECT, data, &reply);
1055 if (status != NO_ERROR) {
1056 return status;
1057 }
1058 return static_cast <status_t> (reply.readInt32());
1059 }
1060
addSourceDefaultEffect(const effect_uuid_t * type,const String16 & opPackageName,const effect_uuid_t * uuid,int32_t priority,audio_source_t source,audio_unique_id_t * id)1061 virtual status_t addSourceDefaultEffect(const effect_uuid_t *type,
1062 const String16& opPackageName,
1063 const effect_uuid_t *uuid,
1064 int32_t priority,
1065 audio_source_t source,
1066 audio_unique_id_t* id)
1067 {
1068 Parcel data, reply;
1069 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
1070 data.write(type, sizeof(effect_uuid_t));
1071 data.writeString16(opPackageName);
1072 data.write(uuid, sizeof(effect_uuid_t));
1073 data.writeInt32(priority);
1074 data.writeInt32((int32_t) source);
1075 status_t status = remote()->transact(ADD_SOURCE_DEFAULT_EFFECT, data, &reply);
1076 if (status != NO_ERROR) {
1077 return status;
1078 }
1079 status = static_cast <status_t> (reply.readInt32());
1080 *id = reply.readInt32();
1081 return status;
1082 }
1083
removeSourceDefaultEffect(audio_unique_id_t id)1084 virtual status_t removeSourceDefaultEffect(audio_unique_id_t id)
1085 {
1086 Parcel data, reply;
1087 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
1088 data.writeInt32(id);
1089 status_t status = remote()->transact(REMOVE_SOURCE_DEFAULT_EFFECT, data, &reply);
1090 if (status != NO_ERROR) {
1091 return status;
1092 }
1093 return static_cast <status_t> (reply.readInt32());
1094 }
1095
setAssistantUid(uid_t uid)1096 virtual status_t setAssistantUid(uid_t uid)
1097 {
1098 Parcel data, reply;
1099 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
1100 data.writeInt32(uid);
1101 status_t status = remote()->transact(SET_ASSISTANT_UID, data, &reply);
1102 if (status != NO_ERROR) {
1103 return status;
1104 }
1105 return static_cast <status_t> (reply.readInt32());
1106 }
1107
setA11yServicesUids(const std::vector<uid_t> & uids)1108 virtual status_t setA11yServicesUids(const std::vector<uid_t>& uids)
1109 {
1110 Parcel data, reply;
1111 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
1112 data.writeInt32(uids.size());
1113 for (auto uid : uids) {
1114 data.writeInt32(uid);
1115 }
1116 status_t status = remote()->transact(SET_A11Y_SERVICES_UIDS, data, &reply);
1117 if (status != NO_ERROR) {
1118 return status;
1119 }
1120 return static_cast <status_t> (reply.readInt32());
1121 }
1122
isHapticPlaybackSupported()1123 virtual bool isHapticPlaybackSupported()
1124 {
1125 Parcel data, reply;
1126 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
1127 status_t status = remote()->transact(IS_HAPTIC_PLAYBACK_SUPPORTED, data, &reply);
1128 if (status != NO_ERROR) {
1129 return false;
1130 }
1131 return reply.readBool();
1132 }
1133
setUidDeviceAffinities(uid_t uid,const Vector<AudioDeviceTypeAddr> & devices)1134 virtual status_t setUidDeviceAffinities(uid_t uid, const Vector<AudioDeviceTypeAddr>& devices)
1135 {
1136 Parcel data, reply;
1137 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
1138
1139 data.writeInt32((int32_t) uid);
1140 size_t size = devices.size();
1141 size_t sizePosition = data.dataPosition();
1142 data.writeInt32((int32_t) size);
1143 size_t finalSize = size;
1144 for (size_t i = 0; i < size; i++) {
1145 size_t position = data.dataPosition();
1146 if (devices[i].writeToParcel(&data) != NO_ERROR) {
1147 data.setDataPosition(position);
1148 finalSize--;
1149 }
1150 }
1151 if (size != finalSize) {
1152 size_t position = data.dataPosition();
1153 data.setDataPosition(sizePosition);
1154 data.writeInt32(finalSize);
1155 data.setDataPosition(position);
1156 }
1157
1158 status_t status = remote()->transact(SET_UID_DEVICE_AFFINITY, data, &reply);
1159 if (status == NO_ERROR) {
1160 status = (status_t)reply.readInt32();
1161 }
1162 return status;
1163 }
1164
removeUidDeviceAffinities(uid_t uid)1165 virtual status_t removeUidDeviceAffinities(uid_t uid) {
1166 Parcel data, reply;
1167 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
1168
1169 data.writeInt32((int32_t) uid);
1170
1171 status_t status =
1172 remote()->transact(REMOVE_UID_DEVICE_AFFINITY, data, &reply);
1173 if (status == NO_ERROR) {
1174 status = (status_t) reply.readInt32();
1175 }
1176 return status;
1177 }
1178
listAudioProductStrategies(AudioProductStrategyVector & strategies)1179 virtual status_t listAudioProductStrategies(AudioProductStrategyVector &strategies)
1180 {
1181 Parcel data, reply;
1182 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
1183
1184 status_t status = remote()->transact(LIST_AUDIO_PRODUCT_STRATEGIES, data, &reply);
1185 if (status != NO_ERROR) {
1186 ALOGE("%s: permission denied", __func__);
1187 return status;
1188 }
1189 status = static_cast<status_t>(reply.readInt32());
1190 if (status != NO_ERROR) {
1191 return status;
1192 }
1193 uint32_t numStrategies = static_cast<uint32_t>(reply.readInt32());
1194 for (size_t i = 0; i < numStrategies; i++) {
1195 AudioProductStrategy strategy;
1196 status = strategy.readFromParcel(&reply);
1197 if (status != NO_ERROR) {
1198 ALOGE("%s: failed to read strategies", __FUNCTION__);
1199 strategies.clear();
1200 return status;
1201 }
1202 strategies.push_back(strategy);
1203 }
1204 return NO_ERROR;
1205 }
1206
getProductStrategyFromAudioAttributes(const AudioAttributes & aa,product_strategy_t & productStrategy)1207 virtual status_t getProductStrategyFromAudioAttributes(const AudioAttributes &aa,
1208 product_strategy_t &productStrategy)
1209 {
1210 Parcel data, reply;
1211 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
1212 status_t status = aa.writeToParcel(&data);
1213 if (status != NO_ERROR) {
1214 return status;
1215 }
1216 status = remote()->transact(GET_STRATEGY_FOR_ATTRIBUTES, data, &reply);
1217 if (status != NO_ERROR) {
1218 return status;
1219 }
1220 status = static_cast<status_t>(reply.readInt32());
1221 if (status != NO_ERROR) {
1222 return status;
1223 }
1224 productStrategy = static_cast<product_strategy_t>(reply.readInt32());
1225 return NO_ERROR;
1226 }
1227
listAudioVolumeGroups(AudioVolumeGroupVector & groups)1228 virtual status_t listAudioVolumeGroups(AudioVolumeGroupVector &groups)
1229 {
1230 Parcel data, reply;
1231 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
1232
1233 status_t status = remote()->transact(LIST_AUDIO_VOLUME_GROUPS, data, &reply);
1234 if (status != NO_ERROR) {
1235 return status;
1236 }
1237 status = static_cast<status_t>(reply.readInt32());
1238 if (status != NO_ERROR) {
1239 return status;
1240 }
1241 uint32_t numGroups = static_cast<uint32_t>(reply.readInt32());
1242 for (size_t i = 0; i < numGroups; i++) {
1243 AudioVolumeGroup group;
1244 status = group.readFromParcel(&reply);
1245 if (status != NO_ERROR) {
1246 ALOGE("%s: failed to read volume groups", __FUNCTION__);
1247 groups.clear();
1248 return status;
1249 }
1250 groups.push_back(group);
1251 }
1252 return NO_ERROR;
1253 }
1254
getVolumeGroupFromAudioAttributes(const AudioAttributes & aa,volume_group_t & volumeGroup)1255 virtual status_t getVolumeGroupFromAudioAttributes(const AudioAttributes &aa,
1256 volume_group_t &volumeGroup)
1257 {
1258 Parcel data, reply;
1259 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
1260 status_t status = aa.writeToParcel(&data);
1261 if (status != NO_ERROR) {
1262 return status;
1263 }
1264 status = remote()->transact(GET_VOLUME_GROUP_FOR_ATTRIBUTES, data, &reply);
1265 if (status != NO_ERROR) {
1266 return status;
1267 }
1268 status = static_cast<status_t>(reply.readInt32());
1269 if (status != NO_ERROR) {
1270 return status;
1271 }
1272 volumeGroup = static_cast<volume_group_t>(reply.readInt32());
1273 return NO_ERROR;
1274 }
1275
setRttEnabled(bool enabled)1276 virtual status_t setRttEnabled(bool enabled)
1277 {
1278 Parcel data, reply;
1279 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
1280 data.writeInt32(static_cast<int32_t>(enabled));
1281 status_t status = remote()->transact(SET_RTT_ENABLED, data, &reply);
1282 if (status != NO_ERROR) {
1283 return status;
1284 }
1285 return static_cast<status_t>(reply.readInt32());
1286 }
1287 };
1288
1289 IMPLEMENT_META_INTERFACE(AudioPolicyService, "android.media.IAudioPolicyService");
1290
1291 // ----------------------------------------------------------------------
1292
onTransact(uint32_t code,const Parcel & data,Parcel * reply,uint32_t flags)1293 status_t BnAudioPolicyService::onTransact(
1294 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
1295 {
1296 // make sure transactions reserved to AudioFlinger do not come from other processes
1297 switch (code) {
1298 case START_OUTPUT:
1299 case STOP_OUTPUT:
1300 case RELEASE_OUTPUT:
1301 case GET_INPUT_FOR_ATTR:
1302 case START_INPUT:
1303 case STOP_INPUT:
1304 case RELEASE_INPUT:
1305 case GET_OUTPUT_FOR_EFFECT:
1306 case REGISTER_EFFECT:
1307 case UNREGISTER_EFFECT:
1308 case SET_EFFECT_ENABLED:
1309 case GET_OUTPUT_FOR_ATTR:
1310 case ACQUIRE_SOUNDTRIGGER_SESSION:
1311 case RELEASE_SOUNDTRIGGER_SESSION:
1312 case MOVE_EFFECTS_TO_IO:
1313 ALOGW("%s: transaction %d received from PID %d",
1314 __func__, code, IPCThreadState::self()->getCallingPid());
1315 // return status only for non void methods
1316 switch (code) {
1317 case RELEASE_OUTPUT:
1318 case RELEASE_INPUT:
1319 break;
1320 default:
1321 reply->writeInt32(static_cast<int32_t> (INVALID_OPERATION));
1322 break;
1323 }
1324 return OK;
1325 default:
1326 break;
1327 }
1328
1329 // make sure the following transactions come from system components
1330 switch (code) {
1331 case SET_DEVICE_CONNECTION_STATE:
1332 case HANDLE_DEVICE_CONFIG_CHANGE:
1333 case SET_PHONE_STATE:
1334 //FIXME: Allow SET_FORCE_USE calls from system apps until a better use case routing API is available
1335 // case SET_FORCE_USE:
1336 case INIT_STREAM_VOLUME:
1337 case SET_STREAM_VOLUME:
1338 case REGISTER_POLICY_MIXES:
1339 case SET_MASTER_MONO:
1340 case GET_SURROUND_FORMATS:
1341 case SET_SURROUND_FORMAT_ENABLED:
1342 case SET_ASSISTANT_UID:
1343 case SET_A11Y_SERVICES_UIDS:
1344 case SET_UID_DEVICE_AFFINITY:
1345 case REMOVE_UID_DEVICE_AFFINITY:
1346 case GET_OFFLOAD_FORMATS_A2DP:
1347 case LIST_AUDIO_VOLUME_GROUPS:
1348 case GET_VOLUME_GROUP_FOR_ATTRIBUTES:
1349 case SET_RTT_ENABLED: {
1350 if (!isServiceUid(IPCThreadState::self()->getCallingUid())) {
1351 ALOGW("%s: transaction %d received from PID %d unauthorized UID %d",
1352 __func__, code, IPCThreadState::self()->getCallingPid(),
1353 IPCThreadState::self()->getCallingUid());
1354 reply->writeInt32(static_cast<int32_t> (INVALID_OPERATION));
1355 return OK;
1356 }
1357 } break;
1358 default:
1359 break;
1360 }
1361
1362 std::string tag("IAudioPolicyService command " + std::to_string(code));
1363 TimeCheck check(tag.c_str());
1364
1365 switch (code) {
1366 case SET_DEVICE_CONNECTION_STATE: {
1367 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1368 audio_devices_t device =
1369 static_cast <audio_devices_t>(data.readInt32());
1370 audio_policy_dev_state_t state =
1371 static_cast <audio_policy_dev_state_t>(data.readInt32());
1372 const char *device_address = data.readCString();
1373 const char *device_name = data.readCString();
1374 audio_format_t codecFormat = static_cast <audio_format_t>(data.readInt32());
1375 if (device_address == nullptr || device_name == nullptr) {
1376 ALOGE("Bad Binder transaction: SET_DEVICE_CONNECTION_STATE for device %u", device);
1377 reply->writeInt32(static_cast<int32_t> (BAD_VALUE));
1378 } else {
1379 reply->writeInt32(static_cast<uint32_t> (setDeviceConnectionState(device,
1380 state,
1381 device_address,
1382 device_name,
1383 codecFormat)));
1384 }
1385 return NO_ERROR;
1386 } break;
1387
1388 case GET_DEVICE_CONNECTION_STATE: {
1389 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1390 audio_devices_t device =
1391 static_cast<audio_devices_t> (data.readInt32());
1392 const char *device_address = data.readCString();
1393 if (device_address == nullptr) {
1394 ALOGE("Bad Binder transaction: GET_DEVICE_CONNECTION_STATE for device %u", device);
1395 reply->writeInt32(static_cast<int32_t> (AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE));
1396 } else {
1397 reply->writeInt32(static_cast<uint32_t> (getDeviceConnectionState(device,
1398 device_address)));
1399 }
1400 return NO_ERROR;
1401 } break;
1402
1403 case HANDLE_DEVICE_CONFIG_CHANGE: {
1404 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1405 audio_devices_t device =
1406 static_cast <audio_devices_t>(data.readInt32());
1407 const char *device_address = data.readCString();
1408 const char *device_name = data.readCString();
1409 audio_format_t codecFormat =
1410 static_cast <audio_format_t>(data.readInt32());
1411 if (device_address == nullptr || device_name == nullptr) {
1412 ALOGE("Bad Binder transaction: HANDLE_DEVICE_CONFIG_CHANGE for device %u", device);
1413 reply->writeInt32(static_cast<int32_t> (BAD_VALUE));
1414 } else {
1415 reply->writeInt32(static_cast<uint32_t> (handleDeviceConfigChange(device,
1416 device_address,
1417 device_name,
1418 codecFormat)));
1419 }
1420 return NO_ERROR;
1421 } break;
1422
1423 case SET_PHONE_STATE: {
1424 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1425 reply->writeInt32(static_cast <uint32_t>(setPhoneState(
1426 (audio_mode_t) data.readInt32())));
1427 return NO_ERROR;
1428 } break;
1429
1430 case SET_FORCE_USE: {
1431 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1432 audio_policy_force_use_t usage = static_cast <audio_policy_force_use_t>(
1433 data.readInt32());
1434 audio_policy_forced_cfg_t config =
1435 static_cast <audio_policy_forced_cfg_t>(data.readInt32());
1436 reply->writeInt32(static_cast <uint32_t>(setForceUse(usage, config)));
1437 return NO_ERROR;
1438 } break;
1439
1440 case GET_FORCE_USE: {
1441 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1442 audio_policy_force_use_t usage = static_cast <audio_policy_force_use_t>(
1443 data.readInt32());
1444 reply->writeInt32(static_cast <uint32_t>(getForceUse(usage)));
1445 return NO_ERROR;
1446 } break;
1447
1448 case GET_OUTPUT: {
1449 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1450 audio_stream_type_t stream =
1451 static_cast <audio_stream_type_t>(data.readInt32());
1452 audio_io_handle_t output = getOutput(stream);
1453 reply->writeInt32(static_cast <int>(output));
1454 return NO_ERROR;
1455 } break;
1456
1457 case GET_OUTPUT_FOR_ATTR: {
1458 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1459 audio_attributes_t attr = AUDIO_ATTRIBUTES_INITIALIZER;
1460 status_t status = data.read(&attr, sizeof(audio_attributes_t));
1461 if (status != NO_ERROR) {
1462 return status;
1463 }
1464 sanetizeAudioAttributes(&attr);
1465 audio_session_t session = (audio_session_t)data.readInt32();
1466 audio_stream_type_t stream = AUDIO_STREAM_DEFAULT;
1467 bool hasStream = data.readInt32() != 0;
1468 if (hasStream) {
1469 stream = (audio_stream_type_t)data.readInt32();
1470 }
1471 pid_t pid = (pid_t)data.readInt32();
1472 uid_t uid = (uid_t)data.readInt32();
1473 audio_config_t config;
1474 memset(&config, 0, sizeof(audio_config_t));
1475 data.read(&config, sizeof(audio_config_t));
1476 audio_output_flags_t flags =
1477 static_cast <audio_output_flags_t>(data.readInt32());
1478 audio_port_handle_t selectedDeviceId = data.readInt32();
1479 audio_port_handle_t portId = (audio_port_handle_t)data.readInt32();
1480 audio_io_handle_t output = 0;
1481 std::vector<audio_io_handle_t> secondaryOutputs;
1482 status = getOutputForAttr(&attr,
1483 &output, session, &stream, pid, uid,
1484 &config,
1485 flags, &selectedDeviceId, &portId, &secondaryOutputs);
1486 reply->writeInt32(status);
1487 status = reply->write(&attr, sizeof(audio_attributes_t));
1488 if (status != NO_ERROR) {
1489 return status;
1490 }
1491 reply->writeInt32(output);
1492 reply->writeInt32(stream);
1493 reply->writeInt32(selectedDeviceId);
1494 reply->writeInt32(portId);
1495 reply->writeInt32(secondaryOutputs.size());
1496 return reply->write(secondaryOutputs.data(),
1497 secondaryOutputs.size() * sizeof(audio_io_handle_t));
1498 } break;
1499
1500 case START_OUTPUT: {
1501 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1502 const audio_port_handle_t portId = static_cast <audio_port_handle_t>(data.readInt32());
1503 reply->writeInt32(static_cast <uint32_t>(startOutput(portId)));
1504 return NO_ERROR;
1505 } break;
1506
1507 case STOP_OUTPUT: {
1508 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1509 const audio_port_handle_t portId = static_cast <audio_port_handle_t>(data.readInt32());
1510 reply->writeInt32(static_cast <uint32_t>(stopOutput(portId)));
1511 return NO_ERROR;
1512 } break;
1513
1514 case RELEASE_OUTPUT: {
1515 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1516 const audio_port_handle_t portId = static_cast <audio_port_handle_t>(data.readInt32());
1517 releaseOutput(portId);
1518 return NO_ERROR;
1519 } break;
1520
1521 case GET_INPUT_FOR_ATTR: {
1522 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1523 audio_attributes_t attr = {};
1524 data.read(&attr, sizeof(audio_attributes_t));
1525 sanetizeAudioAttributes(&attr);
1526 audio_io_handle_t input = (audio_io_handle_t)data.readInt32();
1527 audio_unique_id_t riid = (audio_unique_id_t)data.readInt32();
1528 audio_session_t session = (audio_session_t)data.readInt32();
1529 pid_t pid = (pid_t)data.readInt32();
1530 uid_t uid = (uid_t)data.readInt32();
1531 const String16 opPackageName = data.readString16();
1532 audio_config_base_t config;
1533 memset(&config, 0, sizeof(audio_config_base_t));
1534 data.read(&config, sizeof(audio_config_base_t));
1535 audio_input_flags_t flags = (audio_input_flags_t) data.readInt32();
1536 audio_port_handle_t selectedDeviceId = (audio_port_handle_t) data.readInt32();
1537 audio_port_handle_t portId = (audio_port_handle_t)data.readInt32();
1538 status_t status = getInputForAttr(&attr, &input, riid, session, pid, uid,
1539 opPackageName, &config,
1540 flags, &selectedDeviceId, &portId);
1541 reply->writeInt32(status);
1542 if (status == NO_ERROR) {
1543 reply->writeInt32(input);
1544 reply->writeInt32(selectedDeviceId);
1545 reply->writeInt32(portId);
1546 }
1547 return NO_ERROR;
1548 } break;
1549
1550 case START_INPUT: {
1551 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1552 audio_port_handle_t portId = static_cast <audio_port_handle_t>(data.readInt32());
1553 status_t status = startInput(portId);
1554 reply->writeInt32(static_cast <uint32_t>(status));
1555 return NO_ERROR;
1556 } break;
1557
1558 case STOP_INPUT: {
1559 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1560 audio_port_handle_t portId = static_cast <audio_port_handle_t>(data.readInt32());
1561 reply->writeInt32(static_cast <uint32_t>(stopInput(portId)));
1562 return NO_ERROR;
1563 } break;
1564
1565 case RELEASE_INPUT: {
1566 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1567 audio_port_handle_t portId = static_cast <audio_port_handle_t>(data.readInt32());
1568 releaseInput(portId);
1569 return NO_ERROR;
1570 } break;
1571
1572 case INIT_STREAM_VOLUME: {
1573 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1574 audio_stream_type_t stream =
1575 static_cast <audio_stream_type_t>(data.readInt32());
1576 int indexMin = data.readInt32();
1577 int indexMax = data.readInt32();
1578 reply->writeInt32(static_cast <uint32_t>(initStreamVolume(stream, indexMin,indexMax)));
1579 return NO_ERROR;
1580 } break;
1581
1582 case SET_STREAM_VOLUME: {
1583 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1584 audio_stream_type_t stream =
1585 static_cast <audio_stream_type_t>(data.readInt32());
1586 int index = data.readInt32();
1587 audio_devices_t device = static_cast <audio_devices_t>(data.readInt32());
1588 reply->writeInt32(static_cast <uint32_t>(setStreamVolumeIndex(stream,
1589 index,
1590 device)));
1591 return NO_ERROR;
1592 } break;
1593
1594 case GET_STREAM_VOLUME: {
1595 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1596 audio_stream_type_t stream =
1597 static_cast <audio_stream_type_t>(data.readInt32());
1598 audio_devices_t device = static_cast <audio_devices_t>(data.readInt32());
1599 int index = 0;
1600 status_t status = getStreamVolumeIndex(stream, &index, device);
1601 reply->writeInt32(index);
1602 reply->writeInt32(static_cast <uint32_t>(status));
1603 return NO_ERROR;
1604 } break;
1605
1606 case GET_STRATEGY_FOR_STREAM: {
1607 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1608 audio_stream_type_t stream =
1609 static_cast <audio_stream_type_t>(data.readInt32());
1610 reply->writeUint32(getStrategyForStream(stream));
1611 return NO_ERROR;
1612 } break;
1613
1614 case SET_VOLUME_ATTRIBUTES: {
1615 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1616 audio_attributes_t attributes = {};
1617 status_t status = data.read(&attributes, sizeof(audio_attributes_t));
1618 if (status != NO_ERROR) {
1619 return status;
1620 }
1621 int index = data.readInt32();
1622 audio_devices_t device = static_cast <audio_devices_t>(data.readInt32());
1623
1624 reply->writeInt32(static_cast <uint32_t>(setVolumeIndexForAttributes(attributes,
1625 index, device)));
1626 return NO_ERROR;
1627 } break;
1628
1629 case GET_VOLUME_ATTRIBUTES: {
1630 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1631 audio_attributes_t attributes = {};
1632 status_t status = data.read(&attributes, sizeof(audio_attributes_t));
1633 if (status != NO_ERROR) {
1634 return status;
1635 }
1636 audio_devices_t device = static_cast <audio_devices_t>(data.readInt32());
1637
1638 int index = 0;
1639 status = getVolumeIndexForAttributes(attributes, index, device);
1640 reply->writeInt32(static_cast <uint32_t>(status));
1641 if (status == NO_ERROR) {
1642 reply->writeInt32(index);
1643 }
1644 return NO_ERROR;
1645 } break;
1646
1647 case GET_MIN_VOLUME_FOR_ATTRIBUTES: {
1648 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1649 audio_attributes_t attributes = {};
1650 status_t status = data.read(&attributes, sizeof(audio_attributes_t));
1651 if (status != NO_ERROR) {
1652 return status;
1653 }
1654
1655 int index = 0;
1656 status = getMinVolumeIndexForAttributes(attributes, index);
1657 reply->writeInt32(static_cast <uint32_t>(status));
1658 if (status == NO_ERROR) {
1659 reply->writeInt32(index);
1660 }
1661 return NO_ERROR;
1662 } break;
1663
1664 case GET_MAX_VOLUME_FOR_ATTRIBUTES: {
1665 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1666 audio_attributes_t attributes = {};
1667 status_t status = data.read(&attributes, sizeof(audio_attributes_t));
1668 if (status != NO_ERROR) {
1669 return status;
1670 }
1671
1672 int index = 0;
1673 status = getMaxVolumeIndexForAttributes(attributes, index);
1674 reply->writeInt32(static_cast <uint32_t>(status));
1675 if (status == NO_ERROR) {
1676 reply->writeInt32(index);
1677 }
1678 return NO_ERROR;
1679 } break;
1680
1681 case GET_DEVICES_FOR_STREAM: {
1682 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1683 audio_stream_type_t stream =
1684 static_cast <audio_stream_type_t>(data.readInt32());
1685 reply->writeInt32(static_cast <int>(getDevicesForStream(stream)));
1686 return NO_ERROR;
1687 } break;
1688
1689 case GET_OUTPUT_FOR_EFFECT: {
1690 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1691 effect_descriptor_t desc = {};
1692 if (data.read(&desc, sizeof(desc)) != NO_ERROR) {
1693 android_errorWriteLog(0x534e4554, "73126106");
1694 }
1695 (void)sanitizeEffectDescriptor(&desc);
1696 audio_io_handle_t output = getOutputForEffect(&desc);
1697 reply->writeInt32(static_cast <int>(output));
1698 return NO_ERROR;
1699 } break;
1700
1701 case REGISTER_EFFECT: {
1702 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1703 effect_descriptor_t desc = {};
1704 if (data.read(&desc, sizeof(desc)) != NO_ERROR) {
1705 android_errorWriteLog(0x534e4554, "73126106");
1706 }
1707 (void)sanitizeEffectDescriptor(&desc);
1708 audio_io_handle_t io = data.readInt32();
1709 uint32_t strategy = data.readInt32();
1710 audio_session_t session = (audio_session_t) data.readInt32();
1711 int id = data.readInt32();
1712 reply->writeInt32(static_cast <int32_t>(registerEffect(&desc,
1713 io,
1714 strategy,
1715 session,
1716 id)));
1717 return NO_ERROR;
1718 } break;
1719
1720 case UNREGISTER_EFFECT: {
1721 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1722 int id = data.readInt32();
1723 reply->writeInt32(static_cast <int32_t>(unregisterEffect(id)));
1724 return NO_ERROR;
1725 } break;
1726
1727 case SET_EFFECT_ENABLED: {
1728 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1729 int id = data.readInt32();
1730 bool enabled = static_cast <bool>(data.readInt32());
1731 reply->writeInt32(static_cast <int32_t>(setEffectEnabled(id, enabled)));
1732 return NO_ERROR;
1733 } break;
1734
1735 case MOVE_EFFECTS_TO_IO: {
1736 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1737 std::vector<int> ids;
1738 int32_t size;
1739 status_t status = data.readInt32(&size);
1740 if (status != NO_ERROR) {
1741 return status;
1742 }
1743 if (size > MAX_ITEMS_PER_LIST) {
1744 return BAD_VALUE;
1745 }
1746 for (int32_t i = 0; i < size; i++) {
1747 int id;
1748 status = data.readInt32(&id);
1749 if (status != NO_ERROR) {
1750 return status;
1751 }
1752 ids.push_back(id);
1753 }
1754
1755 audio_io_handle_t io = data.readInt32();
1756 reply->writeInt32(static_cast <int32_t>(moveEffectsToIo(ids, io)));
1757 return NO_ERROR;
1758 } break;
1759
1760 case IS_STREAM_ACTIVE: {
1761 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1762 audio_stream_type_t stream = (audio_stream_type_t) data.readInt32();
1763 uint32_t inPastMs = (uint32_t)data.readInt32();
1764 reply->writeInt32( isStreamActive(stream, inPastMs) );
1765 return NO_ERROR;
1766 } break;
1767
1768 case IS_STREAM_ACTIVE_REMOTELY: {
1769 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1770 audio_stream_type_t stream = (audio_stream_type_t) data.readInt32();
1771 uint32_t inPastMs = (uint32_t)data.readInt32();
1772 reply->writeInt32( isStreamActiveRemotely(stream, inPastMs) );
1773 return NO_ERROR;
1774 } break;
1775
1776 case IS_SOURCE_ACTIVE: {
1777 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1778 audio_source_t source = (audio_source_t) data.readInt32();
1779 reply->writeInt32( isSourceActive(source));
1780 return NO_ERROR;
1781 }
1782
1783 case QUERY_DEFAULT_PRE_PROCESSING: {
1784 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1785 audio_session_t audioSession = (audio_session_t) data.readInt32();
1786 uint32_t count = data.readInt32();
1787 if (count > AudioEffect::kMaxPreProcessing) {
1788 count = AudioEffect::kMaxPreProcessing;
1789 }
1790 uint32_t retCount = count;
1791 effect_descriptor_t *descriptors = new effect_descriptor_t[count]{};
1792 status_t status = queryDefaultPreProcessing(audioSession, descriptors, &retCount);
1793 reply->writeInt32(status);
1794 if (status != NO_ERROR && status != NO_MEMORY) {
1795 retCount = 0;
1796 }
1797 reply->writeInt32(retCount);
1798 if (retCount != 0) {
1799 if (retCount < count) {
1800 count = retCount;
1801 }
1802 reply->write(descriptors, sizeof(effect_descriptor_t) * count);
1803 }
1804 delete[] descriptors;
1805 return status;
1806 }
1807
1808 case IS_OFFLOAD_SUPPORTED: {
1809 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1810 audio_offload_info_t info = {};
1811 data.read(&info, sizeof(audio_offload_info_t));
1812 bool isSupported = isOffloadSupported(info);
1813 reply->writeInt32(isSupported);
1814 return NO_ERROR;
1815 }
1816
1817 case IS_DIRECT_OUTPUT_SUPPORTED: {
1818 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1819 audio_config_base_t config = {};
1820 audio_attributes_t attributes = {};
1821 status_t status = data.read(&config, sizeof(audio_config_base_t));
1822 if (status != NO_ERROR) return status;
1823 status = data.read(&attributes, sizeof(audio_attributes_t));
1824 if (status != NO_ERROR) return status;
1825 reply->writeInt32(isDirectOutputSupported(config, attributes));
1826 return NO_ERROR;
1827 }
1828
1829 case LIST_AUDIO_PORTS: {
1830 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1831 audio_port_role_t role = (audio_port_role_t)data.readInt32();
1832 audio_port_type_t type = (audio_port_type_t)data.readInt32();
1833 unsigned int numPortsReq = data.readInt32();
1834 if (numPortsReq > MAX_ITEMS_PER_LIST) {
1835 numPortsReq = MAX_ITEMS_PER_LIST;
1836 }
1837 unsigned int numPorts = numPortsReq;
1838 struct audio_port *ports =
1839 (struct audio_port *)calloc(numPortsReq, sizeof(struct audio_port));
1840 if (ports == NULL) {
1841 reply->writeInt32(NO_MEMORY);
1842 reply->writeInt32(0);
1843 return NO_ERROR;
1844 }
1845 unsigned int generation;
1846 status_t status = listAudioPorts(role, type, &numPorts, ports, &generation);
1847 reply->writeInt32(status);
1848 reply->writeInt32(numPorts);
1849
1850 if (status == NO_ERROR) {
1851 if (numPortsReq > numPorts) {
1852 numPortsReq = numPorts;
1853 }
1854 reply->write(ports, numPortsReq * sizeof(struct audio_port));
1855 reply->writeInt32(generation);
1856 }
1857 free(ports);
1858 return NO_ERROR;
1859 }
1860
1861 case GET_AUDIO_PORT: {
1862 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1863 struct audio_port port = {};
1864 if (data.read(&port, sizeof(struct audio_port)) != NO_ERROR) {
1865 ALOGE("b/23912202");
1866 }
1867 status_t status = getAudioPort(&port);
1868 reply->writeInt32(status);
1869 if (status == NO_ERROR) {
1870 reply->write(&port, sizeof(struct audio_port));
1871 }
1872 return NO_ERROR;
1873 }
1874
1875 case CREATE_AUDIO_PATCH: {
1876 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1877 struct audio_patch patch = {};
1878 data.read(&patch, sizeof(struct audio_patch));
1879 audio_patch_handle_t handle = AUDIO_PATCH_HANDLE_NONE;
1880 if (data.read(&handle, sizeof(audio_patch_handle_t)) != NO_ERROR) {
1881 ALOGE("b/23912202");
1882 }
1883 status_t status = createAudioPatch(&patch, &handle);
1884 reply->writeInt32(status);
1885 if (status == NO_ERROR) {
1886 reply->write(&handle, sizeof(audio_patch_handle_t));
1887 }
1888 return NO_ERROR;
1889 }
1890
1891 case RELEASE_AUDIO_PATCH: {
1892 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1893 audio_patch_handle_t handle = AUDIO_PATCH_HANDLE_NONE;
1894 data.read(&handle, sizeof(audio_patch_handle_t));
1895 status_t status = releaseAudioPatch(handle);
1896 reply->writeInt32(status);
1897 return NO_ERROR;
1898 }
1899
1900 case LIST_AUDIO_PATCHES: {
1901 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1902 unsigned int numPatchesReq = data.readInt32();
1903 if (numPatchesReq > MAX_ITEMS_PER_LIST) {
1904 numPatchesReq = MAX_ITEMS_PER_LIST;
1905 }
1906 unsigned int numPatches = numPatchesReq;
1907 struct audio_patch *patches =
1908 (struct audio_patch *)calloc(numPatchesReq,
1909 sizeof(struct audio_patch));
1910 if (patches == NULL) {
1911 reply->writeInt32(NO_MEMORY);
1912 reply->writeInt32(0);
1913 return NO_ERROR;
1914 }
1915 unsigned int generation;
1916 status_t status = listAudioPatches(&numPatches, patches, &generation);
1917 reply->writeInt32(status);
1918 reply->writeInt32(numPatches);
1919 if (status == NO_ERROR) {
1920 if (numPatchesReq > numPatches) {
1921 numPatchesReq = numPatches;
1922 }
1923 reply->write(patches, numPatchesReq * sizeof(struct audio_patch));
1924 reply->writeInt32(generation);
1925 }
1926 free(patches);
1927 return NO_ERROR;
1928 }
1929
1930 case SET_AUDIO_PORT_CONFIG: {
1931 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1932 struct audio_port_config config = {};
1933 data.read(&config, sizeof(struct audio_port_config));
1934 (void)sanitizeAudioPortConfig(&config);
1935 status_t status = setAudioPortConfig(&config);
1936 reply->writeInt32(status);
1937 return NO_ERROR;
1938 }
1939
1940 case REGISTER_CLIENT: {
1941 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1942 sp<IAudioPolicyServiceClient> client = interface_cast<IAudioPolicyServiceClient>(
1943 data.readStrongBinder());
1944 registerClient(client);
1945 return NO_ERROR;
1946 } break;
1947
1948 case SET_AUDIO_PORT_CALLBACK_ENABLED: {
1949 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1950 setAudioPortCallbacksEnabled(data.readInt32() == 1);
1951 return NO_ERROR;
1952 } break;
1953
1954 case SET_AUDIO_VOLUME_GROUP_CALLBACK_ENABLED: {
1955 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1956 setAudioVolumeGroupCallbacksEnabled(data.readInt32() == 1);
1957 return NO_ERROR;
1958 } break;
1959
1960 case ACQUIRE_SOUNDTRIGGER_SESSION: {
1961 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1962 sp<IAudioPolicyServiceClient> client = interface_cast<IAudioPolicyServiceClient>(
1963 data.readStrongBinder());
1964 audio_session_t session = AUDIO_SESSION_NONE;
1965 audio_io_handle_t ioHandle = AUDIO_IO_HANDLE_NONE;
1966 audio_devices_t device = AUDIO_DEVICE_NONE;
1967 status_t status = acquireSoundTriggerSession(&session, &ioHandle, &device);
1968 reply->writeInt32(status);
1969 if (status == NO_ERROR) {
1970 reply->writeInt32(session);
1971 reply->writeInt32(ioHandle);
1972 reply->writeInt32(device);
1973 }
1974 return NO_ERROR;
1975 } break;
1976
1977 case RELEASE_SOUNDTRIGGER_SESSION: {
1978 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1979 sp<IAudioPolicyServiceClient> client = interface_cast<IAudioPolicyServiceClient>(
1980 data.readStrongBinder());
1981 audio_session_t session = (audio_session_t)data.readInt32();
1982 status_t status = releaseSoundTriggerSession(session);
1983 reply->writeInt32(status);
1984 return NO_ERROR;
1985 } break;
1986
1987 case GET_PHONE_STATE: {
1988 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1989 reply->writeInt32((int32_t)getPhoneState());
1990 return NO_ERROR;
1991 } break;
1992
1993 case REGISTER_POLICY_MIXES: {
1994 CHECK_INTERFACE(IAudioPolicyService, data, reply);
1995 bool registration = data.readInt32() == 1;
1996 Vector<AudioMix> mixes;
1997 size_t size = (size_t)data.readInt32();
1998 if (size > MAX_MIXES_PER_POLICY) {
1999 size = MAX_MIXES_PER_POLICY;
2000 }
2001 for (size_t i = 0; i < size; i++) {
2002 AudioMix mix;
2003 if (mix.readFromParcel((Parcel*)&data) == NO_ERROR) {
2004 mixes.add(mix);
2005 }
2006 }
2007 status_t status = registerPolicyMixes(mixes, registration);
2008 reply->writeInt32(status);
2009 return NO_ERROR;
2010 } break;
2011
2012 case START_AUDIO_SOURCE: {
2013 CHECK_INTERFACE(IAudioPolicyService, data, reply);
2014 struct audio_port_config source = {};
2015 data.read(&source, sizeof(struct audio_port_config));
2016 (void)sanitizeAudioPortConfig(&source);
2017 audio_attributes_t attributes = {};
2018 data.read(&attributes, sizeof(audio_attributes_t));
2019 sanetizeAudioAttributes(&attributes);
2020 audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE;
2021 status_t status = startAudioSource(&source, &attributes, &portId);
2022 reply->writeInt32(status);
2023 reply->writeInt32(portId);
2024 return NO_ERROR;
2025 } break;
2026
2027 case STOP_AUDIO_SOURCE: {
2028 CHECK_INTERFACE(IAudioPolicyService, data, reply);
2029 audio_port_handle_t portId = (audio_port_handle_t) data.readInt32();
2030 status_t status = stopAudioSource(portId);
2031 reply->writeInt32(status);
2032 return NO_ERROR;
2033 } break;
2034
2035 case SET_MASTER_MONO: {
2036 CHECK_INTERFACE(IAudioPolicyService, data, reply);
2037 bool mono = static_cast<bool>(data.readInt32());
2038 status_t status = setMasterMono(mono);
2039 reply->writeInt32(status);
2040 return NO_ERROR;
2041 } break;
2042
2043 case GET_MASTER_MONO: {
2044 CHECK_INTERFACE(IAudioPolicyService, data, reply);
2045 bool mono;
2046 status_t status = getMasterMono(&mono);
2047 reply->writeInt32(status);
2048 if (status == NO_ERROR) {
2049 reply->writeInt32(static_cast<int32_t>(mono));
2050 }
2051 return NO_ERROR;
2052 } break;
2053
2054 case GET_STREAM_VOLUME_DB: {
2055 CHECK_INTERFACE(IAudioPolicyService, data, reply);
2056 audio_stream_type_t stream =
2057 static_cast <audio_stream_type_t>(data.readInt32());
2058 int index = static_cast <int>(data.readInt32());
2059 audio_devices_t device =
2060 static_cast <audio_devices_t>(data.readUint32());
2061 reply->writeFloat(getStreamVolumeDB(stream, index, device));
2062 return NO_ERROR;
2063 }
2064
2065 case GET_SURROUND_FORMATS: {
2066 CHECK_INTERFACE(IAudioPolicyService, data, reply);
2067 unsigned int numSurroundFormatsReq = data.readUint32();
2068 if (numSurroundFormatsReq > MAX_ITEMS_PER_LIST) {
2069 numSurroundFormatsReq = MAX_ITEMS_PER_LIST;
2070 }
2071 bool reported = data.readBool();
2072 unsigned int numSurroundFormats = numSurroundFormatsReq;
2073 audio_format_t *surroundFormats = (audio_format_t *)calloc(
2074 numSurroundFormats, sizeof(audio_format_t));
2075 bool *surroundFormatsEnabled = (bool *)calloc(numSurroundFormats, sizeof(bool));
2076 if (numSurroundFormatsReq > 0 &&
2077 (surroundFormats == NULL || surroundFormatsEnabled == NULL)) {
2078 free(surroundFormats);
2079 free(surroundFormatsEnabled);
2080 reply->writeInt32(NO_MEMORY);
2081 return NO_ERROR;
2082 }
2083 status_t status = getSurroundFormats(
2084 &numSurroundFormats, surroundFormats, surroundFormatsEnabled, reported);
2085 reply->writeInt32(status);
2086
2087 if (status == NO_ERROR) {
2088 reply->writeUint32(numSurroundFormats);
2089 if (numSurroundFormatsReq > numSurroundFormats) {
2090 numSurroundFormatsReq = numSurroundFormats;
2091 }
2092 reply->write(surroundFormats, numSurroundFormatsReq * sizeof(audio_format_t));
2093 reply->write(surroundFormatsEnabled, numSurroundFormatsReq * sizeof(bool));
2094 }
2095 free(surroundFormats);
2096 free(surroundFormatsEnabled);
2097 return NO_ERROR;
2098 }
2099
2100 case SET_SURROUND_FORMAT_ENABLED: {
2101 CHECK_INTERFACE(IAudioPolicyService, data, reply);
2102 audio_format_t audioFormat = (audio_format_t) data.readInt32();
2103 bool enabled = data.readBool();
2104 status_t status = setSurroundFormatEnabled(audioFormat, enabled);
2105 reply->writeInt32(status);
2106 return NO_ERROR;
2107 }
2108
2109 case GET_OFFLOAD_FORMATS_A2DP: {
2110 CHECK_INTERFACE(IAudioPolicyService, data, reply);
2111 std::vector<audio_format_t> encodingFormats;
2112 status_t status = getHwOffloadEncodingFormatsSupportedForA2DP(&encodingFormats);
2113 reply->writeInt32(status);
2114 if (status != NO_ERROR) {
2115 return NO_ERROR;
2116 }
2117 reply->writeUint32(static_cast<uint32_t>(encodingFormats.size()));
2118 for (size_t i = 0; i < encodingFormats.size(); i++)
2119 reply->writeInt32(static_cast<int32_t>(encodingFormats[i]));
2120 return NO_ERROR;
2121 }
2122
2123
2124 case ADD_STREAM_DEFAULT_EFFECT: {
2125 CHECK_INTERFACE(IAudioPolicyService, data, reply);
2126 effect_uuid_t type;
2127 status_t status = data.read(&type, sizeof(effect_uuid_t));
2128 if (status != NO_ERROR) {
2129 return status;
2130 }
2131 String16 opPackageName;
2132 status = data.readString16(&opPackageName);
2133 if (status != NO_ERROR) {
2134 return status;
2135 }
2136 effect_uuid_t uuid;
2137 status = data.read(&uuid, sizeof(effect_uuid_t));
2138 if (status != NO_ERROR) {
2139 return status;
2140 }
2141 int32_t priority = data.readInt32();
2142 audio_usage_t usage = (audio_usage_t) data.readInt32();
2143 audio_unique_id_t id = 0;
2144 reply->writeInt32(static_cast <int32_t>(addStreamDefaultEffect(&type,
2145 opPackageName,
2146 &uuid,
2147 priority,
2148 usage,
2149 &id)));
2150 reply->writeInt32(id);
2151 return NO_ERROR;
2152 }
2153
2154 case REMOVE_STREAM_DEFAULT_EFFECT: {
2155 CHECK_INTERFACE(IAudioPolicyService, data, reply);
2156 audio_unique_id_t id = static_cast<audio_unique_id_t>(data.readInt32());
2157 reply->writeInt32(static_cast <int32_t>(removeStreamDefaultEffect(id)));
2158 return NO_ERROR;
2159 }
2160
2161 case ADD_SOURCE_DEFAULT_EFFECT: {
2162 CHECK_INTERFACE(IAudioPolicyService, data, reply);
2163 effect_uuid_t type;
2164 status_t status = data.read(&type, sizeof(effect_uuid_t));
2165 if (status != NO_ERROR) {
2166 return status;
2167 }
2168 String16 opPackageName;
2169 status = data.readString16(&opPackageName);
2170 if (status != NO_ERROR) {
2171 return status;
2172 }
2173 effect_uuid_t uuid;
2174 status = data.read(&uuid, sizeof(effect_uuid_t));
2175 if (status != NO_ERROR) {
2176 return status;
2177 }
2178 int32_t priority = data.readInt32();
2179 audio_source_t source = (audio_source_t) data.readInt32();
2180 audio_unique_id_t id = 0;
2181 reply->writeInt32(static_cast <int32_t>(addSourceDefaultEffect(&type,
2182 opPackageName,
2183 &uuid,
2184 priority,
2185 source,
2186 &id)));
2187 reply->writeInt32(id);
2188 return NO_ERROR;
2189 }
2190
2191 case REMOVE_SOURCE_DEFAULT_EFFECT: {
2192 CHECK_INTERFACE(IAudioPolicyService, data, reply);
2193 audio_unique_id_t id = static_cast<audio_unique_id_t>(data.readInt32());
2194 reply->writeInt32(static_cast <int32_t>(removeSourceDefaultEffect(id)));
2195 return NO_ERROR;
2196 }
2197
2198 case SET_ASSISTANT_UID: {
2199 CHECK_INTERFACE(IAudioPolicyService, data, reply);
2200 int32_t uid;
2201 status_t status = data.readInt32(&uid);
2202 if (status != NO_ERROR) {
2203 return status;
2204 }
2205 status = setAssistantUid(uid);
2206 reply->writeInt32(static_cast <int32_t>(status));
2207 return NO_ERROR;
2208 }
2209
2210 case SET_A11Y_SERVICES_UIDS: {
2211 CHECK_INTERFACE(IAudioPolicyService, data, reply);
2212 std::vector<uid_t> uids;
2213 int32_t size;
2214 status_t status = data.readInt32(&size);
2215 if (status != NO_ERROR) {
2216 return status;
2217 }
2218 if (size > MAX_ITEMS_PER_LIST) {
2219 size = MAX_ITEMS_PER_LIST;
2220 }
2221 for (int32_t i = 0; i < size; i++) {
2222 int32_t uid;
2223 status = data.readInt32(&uid);
2224 if (status != NO_ERROR) {
2225 return status;
2226 }
2227 uids.push_back(uid);
2228 }
2229 status = setA11yServicesUids(uids);
2230 reply->writeInt32(static_cast <int32_t>(status));
2231 return NO_ERROR;
2232 }
2233
2234 case IS_HAPTIC_PLAYBACK_SUPPORTED: {
2235 CHECK_INTERFACE(IAudioPolicyService, data, reply);
2236 bool isSupported = isHapticPlaybackSupported();
2237 reply->writeBool(isSupported);
2238 return NO_ERROR;
2239 }
2240
2241 case SET_UID_DEVICE_AFFINITY: {
2242 CHECK_INTERFACE(IAudioPolicyService, data, reply);
2243 const uid_t uid = (uid_t) data.readInt32();
2244 Vector<AudioDeviceTypeAddr> devices;
2245 size_t size = (size_t)data.readInt32();
2246 for (size_t i = 0; i < size; i++) {
2247 AudioDeviceTypeAddr device;
2248 if (device.readFromParcel((Parcel*)&data) == NO_ERROR) {
2249 devices.add(device);
2250 }
2251 }
2252 status_t status = setUidDeviceAffinities(uid, devices);
2253 reply->writeInt32(status);
2254 return NO_ERROR;
2255 }
2256
2257 case REMOVE_UID_DEVICE_AFFINITY: {
2258 CHECK_INTERFACE(IAudioPolicyService, data, reply);
2259 const uid_t uid = (uid_t) data.readInt32();
2260 status_t status = removeUidDeviceAffinities(uid);
2261 reply->writeInt32(status);
2262 return NO_ERROR;
2263 }
2264
2265 case LIST_AUDIO_PRODUCT_STRATEGIES: {
2266 CHECK_INTERFACE(IAudioPolicyService, data, reply);
2267 AudioProductStrategyVector strategies;
2268 status_t status = listAudioProductStrategies(strategies);
2269 reply->writeInt32(status);
2270 if (status != NO_ERROR) {
2271 return NO_ERROR;
2272 }
2273 size_t size = strategies.size();
2274 size_t sizePosition = reply->dataPosition();
2275 reply->writeInt32(size);
2276 size_t finalSize = size;
2277 for (size_t i = 0; i < size; i++) {
2278 size_t position = reply->dataPosition();
2279 if (strategies[i].writeToParcel(reply) != NO_ERROR) {
2280 reply->setDataPosition(position);
2281 finalSize--;
2282 }
2283 }
2284 if (size != finalSize) {
2285 size_t position = reply->dataPosition();
2286 reply->setDataPosition(sizePosition);
2287 reply->writeInt32(finalSize);
2288 reply->setDataPosition(position);
2289 }
2290 return NO_ERROR;
2291 }
2292
2293 case GET_STRATEGY_FOR_ATTRIBUTES: {
2294 CHECK_INTERFACE(IAudioPolicyService, data, reply);
2295 AudioAttributes attributes;
2296 status_t status = attributes.readFromParcel(&data);
2297 if (status != NO_ERROR) {
2298 return status;
2299 }
2300 product_strategy_t strategy;
2301 status = getProductStrategyFromAudioAttributes(attributes, strategy);
2302 reply->writeInt32(status);
2303 if (status != NO_ERROR) {
2304 return NO_ERROR;
2305 }
2306 reply->writeUint32(static_cast<int>(strategy));
2307 return NO_ERROR;
2308 }
2309
2310 case LIST_AUDIO_VOLUME_GROUPS: {
2311 CHECK_INTERFACE(IAudioPolicyService, data, reply);
2312 AudioVolumeGroupVector groups;
2313 status_t status = listAudioVolumeGroups(groups);
2314 reply->writeInt32(status);
2315 if (status != NO_ERROR) {
2316 return NO_ERROR;
2317 }
2318 size_t size = groups.size();
2319 size_t sizePosition = reply->dataPosition();
2320 reply->writeInt32(size);
2321 size_t finalSize = size;
2322 for (size_t i = 0; i < size; i++) {
2323 size_t position = reply->dataPosition();
2324 if (groups[i].writeToParcel(reply) != NO_ERROR) {
2325 reply->setDataPosition(position);
2326 finalSize--;
2327 }
2328 }
2329 if (size != finalSize) {
2330 size_t position = reply->dataPosition();
2331 reply->setDataPosition(sizePosition);
2332 reply->writeInt32(finalSize);
2333 reply->setDataPosition(position);
2334 }
2335 return NO_ERROR;
2336 }
2337
2338 case GET_VOLUME_GROUP_FOR_ATTRIBUTES: {
2339 CHECK_INTERFACE(IAudioPolicyService, data, reply);
2340 AudioAttributes attributes;
2341 status_t status = attributes.readFromParcel(&data);
2342 if (status != NO_ERROR) {
2343 return status;
2344 }
2345 volume_group_t group;
2346 status = getVolumeGroupFromAudioAttributes(attributes, group);
2347 reply->writeInt32(status);
2348 if (status != NO_ERROR) {
2349 return NO_ERROR;
2350 }
2351 reply->writeUint32(static_cast<int>(group));
2352 return NO_ERROR;
2353 }
2354
2355 case SET_ALLOWED_CAPTURE_POLICY: {
2356 CHECK_INTERFACE(IAudioPolicyService, data, reply);
2357 uid_t uid = data.readInt32();
2358 audio_flags_mask_t flags = data.readInt32();
2359 status_t status = setAllowedCapturePolicy(uid, flags);
2360 reply->writeInt32(status);
2361 return NO_ERROR;
2362 }
2363
2364 case SET_RTT_ENABLED: {
2365 CHECK_INTERFACE(IAudioPolicyService, data, reply);
2366 bool enabled = static_cast<bool>(data.readInt32());
2367 status_t status = setRttEnabled(enabled);
2368 reply->writeInt32(status);
2369 return NO_ERROR;
2370 }
2371
2372 default:
2373 return BBinder::onTransact(code, data, reply, flags);
2374 }
2375 }
2376
2377 /** returns true if string overflow was prevented by zero termination */
2378 template <size_t size>
preventStringOverflow(char (& s)[size])2379 static bool preventStringOverflow(char (&s)[size]) {
2380 if (strnlen(s, size) < size) return false;
2381 s[size - 1] = '\0';
2382 return true;
2383 }
2384
sanetizeAudioAttributes(audio_attributes_t * attr)2385 void BnAudioPolicyService::sanetizeAudioAttributes(audio_attributes_t* attr)
2386 {
2387 const size_t tagsMaxSize = AUDIO_ATTRIBUTES_TAGS_MAX_SIZE;
2388 if (strnlen(attr->tags, tagsMaxSize) >= tagsMaxSize) {
2389 android_errorWriteLog(0x534e4554, "68953950"); // SafetyNet logging
2390 }
2391 attr->tags[tagsMaxSize - 1] = '\0';
2392 }
2393
2394 /** returns BAD_VALUE if sanitization was required. */
sanitizeEffectDescriptor(effect_descriptor_t * desc)2395 status_t BnAudioPolicyService::sanitizeEffectDescriptor(effect_descriptor_t* desc)
2396 {
2397 if (preventStringOverflow(desc->name)
2398 | /* always */ preventStringOverflow(desc->implementor)) {
2399 android_errorWriteLog(0x534e4554, "73126106"); // SafetyNet logging
2400 return BAD_VALUE;
2401 }
2402 return NO_ERROR;
2403 }
2404
2405 /** returns BAD_VALUE if sanitization was required. */
sanitizeAudioPortConfig(struct audio_port_config * config)2406 status_t BnAudioPolicyService::sanitizeAudioPortConfig(struct audio_port_config* config)
2407 {
2408 if (config->type == AUDIO_PORT_TYPE_DEVICE &&
2409 preventStringOverflow(config->ext.device.address)) {
2410 return BAD_VALUE;
2411 }
2412 return NO_ERROR;
2413 }
2414
2415 // ----------------------------------------------------------------------------
2416
2417 } // namespace android
2418