• Home
  • History
  • Annotate
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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