IAudioPolicyService.cpp revision baac183f3808d7b68f184647a97bd381620415fe
15821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)/* 25821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)** 35821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)** Copyright 2009, The Android Open Source Project 45821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)** 55821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)** Licensed under the Apache License, Version 2.0 (the "License"); 65821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)** you may not use this file except in compliance with the License. 75821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)** You may obtain a copy of the License at 85821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)** 95821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)** http://www.apache.org/licenses/LICENSE-2.0 105821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)** 115821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)** Unless required by applicable law or agreed to in writing, software 125821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)** distributed under the License is distributed on an "AS IS" BASIS, 135821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 145821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)** See the License for the specific language governing permissions and 152a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)** limitations under the License. 165821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)*/ 175821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 185821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#define LOG_TAG "IAudioPolicyService" 195821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include <utils/Log.h> 205821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 215821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include <stdint.h> 225821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include <sys/types.h> 235821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 245821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include <binder/Parcel.h> 255821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 265821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include <media/AudioEffect.h> 275821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include <media/IAudioPolicyService.h> 285821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 295821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include <system/audio.h> 305821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 315821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)namespace android { 325821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 335821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)enum { 345821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SET_DEVICE_CONNECTION_STATE = IBinder::FIRST_CALL_TRANSACTION, 355821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) GET_DEVICE_CONNECTION_STATE, 365821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SET_PHONE_STATE, 375821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SET_RINGER_MODE, // reserved, no longer used 385821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SET_FORCE_USE, 395821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) GET_FORCE_USE, 405821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) GET_OUTPUT, 415821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) START_OUTPUT, 425821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) STOP_OUTPUT, 435821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) RELEASE_OUTPUT, 445821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) GET_INPUT_FOR_ATTR, 455821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) START_INPUT, 465821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) STOP_INPUT, 475821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) RELEASE_INPUT, 485821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) INIT_STREAM_VOLUME, 495821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SET_STREAM_VOLUME, 505821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) GET_STREAM_VOLUME, 515821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) GET_STRATEGY_FOR_STREAM, 525821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) GET_OUTPUT_FOR_EFFECT, 535821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) REGISTER_EFFECT, 545821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) UNREGISTER_EFFECT, 555821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) IS_STREAM_ACTIVE, 565821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) IS_SOURCE_ACTIVE, 575821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) GET_DEVICES_FOR_STREAM, 585821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) QUERY_DEFAULT_PRE_PROCESSING, 595821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SET_EFFECT_ENABLED, 605821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) IS_STREAM_ACTIVE_REMOTELY, 615821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) IS_OFFLOAD_SUPPORTED, 625821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) LIST_AUDIO_PORTS, 635821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) GET_AUDIO_PORT, 645821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CREATE_AUDIO_PATCH, 655821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) RELEASE_AUDIO_PATCH, 665821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) LIST_AUDIO_PATCHES, 675821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SET_AUDIO_PORT_CONFIG, 685821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) REGISTER_CLIENT, 695821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) GET_OUTPUT_FOR_ATTR, 705821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ACQUIRE_SOUNDTRIGGER_SESSION, 715821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) RELEASE_SOUNDTRIGGER_SESSION, 725821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) GET_PHONE_STATE, 735821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) REGISTER_POLICY_MIXES, 745821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)}; 755821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 765821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)class BpAudioPolicyService : public BpInterface<IAudioPolicyService> 775821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles){ 785821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)public: 795821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) BpAudioPolicyService(const sp<IBinder>& impl) 805821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) : BpInterface<IAudioPolicyService>(impl) 815821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) { 825821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 835821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 845821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) virtual status_t setDeviceConnectionState( 855821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) audio_devices_t device, 865821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) audio_policy_dev_state_t state, 875821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const char *device_address) 885821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) { 895821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) Parcel data, reply; 905821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 915821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) data.writeInt32(static_cast <uint32_t>(device)); 925821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) data.writeInt32(static_cast <uint32_t>(state)); 935821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) data.writeCString(device_address); 945821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) remote()->transact(SET_DEVICE_CONNECTION_STATE, data, &reply); 955821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return static_cast <status_t> (reply.readInt32()); 965821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 975821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 985821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) virtual audio_policy_dev_state_t getDeviceConnectionState( 995821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) audio_devices_t device, 1005821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const char *device_address) 1015821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) { 1025821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) Parcel data, reply; 1035821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 1045821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) data.writeInt32(static_cast <uint32_t>(device)); 1055821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) data.writeCString(device_address); 1065821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) remote()->transact(GET_DEVICE_CONNECTION_STATE, data, &reply); 1075821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return static_cast <audio_policy_dev_state_t>(reply.readInt32()); 1085821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 1095821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1105821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) virtual status_t setPhoneState(audio_mode_t state) 1115821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) { 1125821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) Parcel data, reply; 1135821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 1145821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) data.writeInt32(state); 1155821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) remote()->transact(SET_PHONE_STATE, data, &reply); 1165821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return static_cast <status_t> (reply.readInt32()); 1175821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 1185821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1195821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) virtual status_t setForceUse(audio_policy_force_use_t usage, audio_policy_forced_cfg_t config) 1205821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) { 1215821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) Parcel data, reply; 1225821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 1235821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) data.writeInt32(static_cast <uint32_t>(usage)); 1245821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) data.writeInt32(static_cast <uint32_t>(config)); 1255821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) remote()->transact(SET_FORCE_USE, data, &reply); 1265821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return static_cast <status_t> (reply.readInt32()); 1275821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 1285821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1295821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) virtual audio_policy_forced_cfg_t getForceUse(audio_policy_force_use_t usage) 1305821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) { 1315821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) Parcel data, reply; 1325821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 1335821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) data.writeInt32(static_cast <uint32_t>(usage)); 1345821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) remote()->transact(GET_FORCE_USE, data, &reply); 1355821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return static_cast <audio_policy_forced_cfg_t> (reply.readInt32()); 1365821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 1375821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1385821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) virtual audio_io_handle_t getOutput( 1395821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) audio_stream_type_t stream, 1405821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) uint32_t samplingRate, 1415821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) audio_format_t format, 1425821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) audio_channel_mask_t channelMask, 1435821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) audio_output_flags_t flags, 1445821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const audio_offload_info_t *offloadInfo) 1455821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) { 1465821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) Parcel data, reply; 1475821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 1485821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) data.writeInt32(static_cast <uint32_t>(stream)); 1495821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) data.writeInt32(samplingRate); 1505821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) data.writeInt32(static_cast <uint32_t>(format)); 1515821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) data.writeInt32(channelMask); 1525821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) data.writeInt32(static_cast <uint32_t>(flags)); 1535821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // hasOffloadInfo 1545821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (offloadInfo == NULL) { 1555821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) data.writeInt32(0); 1565821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } else { 1575821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) data.writeInt32(1); 1585821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) data.write(offloadInfo, sizeof(audio_offload_info_t)); 1595821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 1605821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) remote()->transact(GET_OUTPUT, data, &reply); 1615821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return static_cast <audio_io_handle_t> (reply.readInt32()); 1625821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 1635821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1645821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) virtual status_t getOutputForAttr(const audio_attributes_t *attr, 1655821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) audio_io_handle_t *output, 1665821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) audio_session_t session, 1675821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) audio_stream_type_t *stream, 1685821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) uint32_t samplingRate, 1695821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) audio_format_t format, 1705821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) audio_channel_mask_t channelMask, 1715821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) audio_output_flags_t flags, 1725821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const audio_offload_info_t *offloadInfo) 1735821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) { 1745821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) Parcel data, reply; 1755821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 1765821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (attr == NULL) { 1775821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (stream == NULL) { 1785821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ALOGE("getOutputForAttr(): NULL audio attributes and stream type"); 1795821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return BAD_VALUE; 1805821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 1815821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (*stream == AUDIO_STREAM_DEFAULT) { 1825821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ALOGE("getOutputForAttr unspecified stream type"); 1835821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return BAD_VALUE; 1845821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 1855821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 1865821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (output == NULL) { 1875821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ALOGE("getOutputForAttr NULL output - shouldn't happen"); 1885821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return BAD_VALUE; 1895821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 1905821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (attr == NULL) { 1915821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) data.writeInt32(0); 1925821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } else { 1935821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) data.writeInt32(1); 1945821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) data.write(attr, sizeof(audio_attributes_t)); 1955821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 1965821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) data.writeInt32(session); 1975821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (stream == NULL) { 1985821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) data.writeInt32(0); 1995821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } else { 2005821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) data.writeInt32(1); 2015821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) data.writeInt32(*stream); 2025821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 2035821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) data.writeInt32(samplingRate); 2045821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) data.writeInt32(static_cast <uint32_t>(format)); 2055821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) data.writeInt32(channelMask); 2065821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) data.writeInt32(static_cast <uint32_t>(flags)); 2075821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // hasOffloadInfo 2085821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (offloadInfo == NULL) { 2095821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) data.writeInt32(0); 2105821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } else { 2115821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) data.writeInt32(1); 2125821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) data.write(offloadInfo, sizeof(audio_offload_info_t)); 2135821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 2145821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) status_t status = remote()->transact(GET_OUTPUT_FOR_ATTR, data, &reply); 2155821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (status != NO_ERROR) { 2165821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return status; 2175821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 2185821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) status = (status_t)reply.readInt32(); 2195821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (status != NO_ERROR) { 2205821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return status; 2215821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 2225821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) *output = (audio_io_handle_t)reply.readInt32(); 2235821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (stream != NULL) { 2245821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) *stream = (audio_stream_type_t)reply.readInt32(); 2255821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 2265821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return status; 2275821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 2285821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 2295821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) virtual status_t startOutput(audio_io_handle_t output, 2305821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) audio_stream_type_t stream, 2315821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) audio_session_t session) 2325821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) { 2335821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) Parcel data, reply; 2345821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 2355821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) data.writeInt32(output); 2365821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) data.writeInt32((int32_t) stream); 2375821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) data.writeInt32((int32_t)session); 2385821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) remote()->transact(START_OUTPUT, data, &reply); 2395821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return static_cast <status_t> (reply.readInt32()); 2405821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 2415821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 2425821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) virtual status_t stopOutput(audio_io_handle_t output, 2435821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) audio_stream_type_t stream, 2445821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) audio_session_t session) 2455821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) { 2465821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) Parcel data, reply; 2475821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 2485821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) data.writeInt32(output); 2495821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) data.writeInt32((int32_t) stream); 2505821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) data.writeInt32((int32_t)session); 2515821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) remote()->transact(STOP_OUTPUT, data, &reply); 2525821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return static_cast <status_t> (reply.readInt32()); 2535821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 2545821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 2555821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) virtual void releaseOutput(audio_io_handle_t output, 2565821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) audio_stream_type_t stream, 2575821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) audio_session_t session) 2585821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) { 2595821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) Parcel data, reply; 2605821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 2615821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) data.writeInt32(output); 2625821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) data.writeInt32((int32_t)stream); 2635821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) data.writeInt32((int32_t)session); 2645821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) remote()->transact(RELEASE_OUTPUT, data, &reply); 2655821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 2665821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 2675821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) virtual status_t getInputForAttr(const audio_attributes_t *attr, 2685821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) audio_io_handle_t *input, 2695821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) audio_session_t session, 2702a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) uint32_t samplingRate, 2712a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) audio_format_t format, 2722a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) audio_channel_mask_t channelMask, 2732a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) audio_input_flags_t flags) 2742a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) { 2752a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) Parcel data, reply; 2762a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 2775821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (attr == NULL) { 2785821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ALOGE("getInputForAttr NULL attr - shouldn't happen"); 2795821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return BAD_VALUE; 2802a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 2815821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (input == NULL) { 2822a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) ALOGE("getInputForAttr NULL input - shouldn't happen"); 2835821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return BAD_VALUE; 2842a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 2855821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) data.write(attr, sizeof(audio_attributes_t)); 2862a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) data.writeInt32(session); 2875821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) data.writeInt32(samplingRate); 2882a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) data.writeInt32(static_cast <uint32_t>(format)); 2892a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) data.writeInt32(channelMask); 2902a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) data.writeInt32(flags); 2912a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) status_t status = remote()->transact(GET_INPUT_FOR_ATTR, data, &reply); 2922a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (status != NO_ERROR) { 2932a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return status; 2942a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 2952a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) status = reply.readInt32(); 2962a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (status != NO_ERROR) { 2975821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return status; 2985821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 2992a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) *input = (audio_io_handle_t)reply.readInt32(); 3005821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return NO_ERROR; 3015821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 3025821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 3035821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) virtual status_t startInput(audio_io_handle_t input, 3045821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) audio_session_t session) 3055821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) { 3065821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) Parcel data, reply; 3075821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 3085821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) data.writeInt32(input); 3095821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) data.writeInt32(session); 3105821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) remote()->transact(START_INPUT, data, &reply); 3115821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return static_cast <status_t> (reply.readInt32()); 3125821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 3135821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 3145821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) virtual status_t stopInput(audio_io_handle_t input, 3155821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) audio_session_t session) 3165821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) { 3175821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) Parcel data, reply; 3185821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 3195821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) data.writeInt32(input); 3205821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) data.writeInt32(session); 3215821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) remote()->transact(STOP_INPUT, data, &reply); 3225821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return static_cast <status_t> (reply.readInt32()); 3235821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 3245821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 3255821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) virtual void releaseInput(audio_io_handle_t input, 3265821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) audio_session_t session) 327 { 328 Parcel data, reply; 329 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 330 data.writeInt32(input); 331 data.writeInt32(session); 332 remote()->transact(RELEASE_INPUT, data, &reply); 333 } 334 335 virtual status_t initStreamVolume(audio_stream_type_t stream, 336 int indexMin, 337 int indexMax) 338 { 339 Parcel data, reply; 340 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 341 data.writeInt32(static_cast <uint32_t>(stream)); 342 data.writeInt32(indexMin); 343 data.writeInt32(indexMax); 344 remote()->transact(INIT_STREAM_VOLUME, data, &reply); 345 return static_cast <status_t> (reply.readInt32()); 346 } 347 348 virtual status_t setStreamVolumeIndex(audio_stream_type_t stream, 349 int index, 350 audio_devices_t device) 351 { 352 Parcel data, reply; 353 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 354 data.writeInt32(static_cast <uint32_t>(stream)); 355 data.writeInt32(index); 356 data.writeInt32(static_cast <uint32_t>(device)); 357 remote()->transact(SET_STREAM_VOLUME, data, &reply); 358 return static_cast <status_t> (reply.readInt32()); 359 } 360 361 virtual status_t getStreamVolumeIndex(audio_stream_type_t stream, 362 int *index, 363 audio_devices_t device) 364 { 365 Parcel data, reply; 366 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 367 data.writeInt32(static_cast <uint32_t>(stream)); 368 data.writeInt32(static_cast <uint32_t>(device)); 369 370 remote()->transact(GET_STREAM_VOLUME, data, &reply); 371 int lIndex = reply.readInt32(); 372 if (index) *index = lIndex; 373 return static_cast <status_t> (reply.readInt32()); 374 } 375 376 virtual uint32_t getStrategyForStream(audio_stream_type_t stream) 377 { 378 Parcel data, reply; 379 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 380 data.writeInt32(static_cast <uint32_t>(stream)); 381 remote()->transact(GET_STRATEGY_FOR_STREAM, data, &reply); 382 return reply.readInt32(); 383 } 384 385 virtual audio_devices_t getDevicesForStream(audio_stream_type_t stream) 386 { 387 Parcel data, reply; 388 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 389 data.writeInt32(static_cast <uint32_t>(stream)); 390 remote()->transact(GET_DEVICES_FOR_STREAM, data, &reply); 391 return (audio_devices_t) reply.readInt32(); 392 } 393 394 virtual audio_io_handle_t getOutputForEffect(const effect_descriptor_t *desc) 395 { 396 Parcel data, reply; 397 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 398 data.write(desc, sizeof(effect_descriptor_t)); 399 remote()->transact(GET_OUTPUT_FOR_EFFECT, data, &reply); 400 return static_cast <audio_io_handle_t> (reply.readInt32()); 401 } 402 403 virtual status_t registerEffect(const effect_descriptor_t *desc, 404 audio_io_handle_t io, 405 uint32_t strategy, 406 int session, 407 int id) 408 { 409 Parcel data, reply; 410 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 411 data.write(desc, sizeof(effect_descriptor_t)); 412 data.writeInt32(io); 413 data.writeInt32(strategy); 414 data.writeInt32(session); 415 data.writeInt32(id); 416 remote()->transact(REGISTER_EFFECT, data, &reply); 417 return static_cast <status_t> (reply.readInt32()); 418 } 419 420 virtual status_t unregisterEffect(int id) 421 { 422 Parcel data, reply; 423 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 424 data.writeInt32(id); 425 remote()->transact(UNREGISTER_EFFECT, data, &reply); 426 return static_cast <status_t> (reply.readInt32()); 427 } 428 429 virtual status_t setEffectEnabled(int id, bool enabled) 430 { 431 Parcel data, reply; 432 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 433 data.writeInt32(id); 434 data.writeInt32(enabled); 435 remote()->transact(SET_EFFECT_ENABLED, data, &reply); 436 return static_cast <status_t> (reply.readInt32()); 437 } 438 439 virtual bool isStreamActive(audio_stream_type_t stream, uint32_t inPastMs) const 440 { 441 Parcel data, reply; 442 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 443 data.writeInt32((int32_t) stream); 444 data.writeInt32(inPastMs); 445 remote()->transact(IS_STREAM_ACTIVE, data, &reply); 446 return reply.readInt32(); 447 } 448 449 virtual bool isStreamActiveRemotely(audio_stream_type_t stream, uint32_t inPastMs) const 450 { 451 Parcel data, reply; 452 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 453 data.writeInt32((int32_t) stream); 454 data.writeInt32(inPastMs); 455 remote()->transact(IS_STREAM_ACTIVE_REMOTELY, data, &reply); 456 return reply.readInt32(); 457 } 458 459 virtual bool isSourceActive(audio_source_t source) const 460 { 461 Parcel data, reply; 462 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 463 data.writeInt32((int32_t) source); 464 remote()->transact(IS_SOURCE_ACTIVE, data, &reply); 465 return reply.readInt32(); 466 } 467 468 virtual status_t queryDefaultPreProcessing(int audioSession, 469 effect_descriptor_t *descriptors, 470 uint32_t *count) 471 { 472 if (descriptors == NULL || count == NULL) { 473 return BAD_VALUE; 474 } 475 Parcel data, reply; 476 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 477 data.writeInt32(audioSession); 478 data.writeInt32(*count); 479 status_t status = remote()->transact(QUERY_DEFAULT_PRE_PROCESSING, data, &reply); 480 if (status != NO_ERROR) { 481 return status; 482 } 483 status = static_cast <status_t> (reply.readInt32()); 484 uint32_t retCount = reply.readInt32(); 485 if (retCount != 0) { 486 uint32_t numDesc = (retCount < *count) ? retCount : *count; 487 reply.read(descriptors, sizeof(effect_descriptor_t) * numDesc); 488 } 489 *count = retCount; 490 return status; 491 } 492 493 virtual bool isOffloadSupported(const audio_offload_info_t& info) 494 { 495 Parcel data, reply; 496 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 497 data.write(&info, sizeof(audio_offload_info_t)); 498 remote()->transact(IS_OFFLOAD_SUPPORTED, data, &reply); 499 return reply.readInt32(); 500 } 501 502 virtual status_t listAudioPorts(audio_port_role_t role, 503 audio_port_type_t type, 504 unsigned int *num_ports, 505 struct audio_port *ports, 506 unsigned int *generation) 507 { 508 if (num_ports == NULL || (*num_ports != 0 && ports == NULL) || 509 generation == NULL) { 510 return BAD_VALUE; 511 } 512 Parcel data, reply; 513 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 514 unsigned int numPortsReq = (ports == NULL) ? 0 : *num_ports; 515 data.writeInt32(role); 516 data.writeInt32(type); 517 data.writeInt32(numPortsReq); 518 status_t status = remote()->transact(LIST_AUDIO_PORTS, data, &reply); 519 if (status == NO_ERROR) { 520 status = (status_t)reply.readInt32(); 521 *num_ports = (unsigned int)reply.readInt32(); 522 } 523 if (status == NO_ERROR) { 524 if (numPortsReq > *num_ports) { 525 numPortsReq = *num_ports; 526 } 527 if (numPortsReq > 0) { 528 reply.read(ports, numPortsReq * sizeof(struct audio_port)); 529 } 530 *generation = reply.readInt32(); 531 } 532 return status; 533 } 534 535 virtual status_t getAudioPort(struct audio_port *port) 536 { 537 if (port == NULL) { 538 return BAD_VALUE; 539 } 540 Parcel data, reply; 541 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 542 data.write(port, sizeof(struct audio_port)); 543 status_t status = remote()->transact(GET_AUDIO_PORT, data, &reply); 544 if (status != NO_ERROR || 545 (status = (status_t)reply.readInt32()) != NO_ERROR) { 546 return status; 547 } 548 reply.read(port, sizeof(struct audio_port)); 549 return status; 550 } 551 552 virtual status_t createAudioPatch(const struct audio_patch *patch, 553 audio_patch_handle_t *handle) 554 { 555 if (patch == NULL || handle == NULL) { 556 return BAD_VALUE; 557 } 558 Parcel data, reply; 559 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 560 data.write(patch, sizeof(struct audio_patch)); 561 data.write(handle, sizeof(audio_patch_handle_t)); 562 status_t status = remote()->transact(CREATE_AUDIO_PATCH, data, &reply); 563 if (status != NO_ERROR || 564 (status = (status_t)reply.readInt32()) != NO_ERROR) { 565 return status; 566 } 567 reply.read(handle, sizeof(audio_patch_handle_t)); 568 return status; 569 } 570 571 virtual status_t releaseAudioPatch(audio_patch_handle_t handle) 572 { 573 Parcel data, reply; 574 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 575 data.write(&handle, sizeof(audio_patch_handle_t)); 576 status_t status = remote()->transact(RELEASE_AUDIO_PATCH, data, &reply); 577 if (status != NO_ERROR) { 578 status = (status_t)reply.readInt32(); 579 } 580 return status; 581 } 582 583 virtual status_t listAudioPatches(unsigned int *num_patches, 584 struct audio_patch *patches, 585 unsigned int *generation) 586 { 587 if (num_patches == NULL || (*num_patches != 0 && patches == NULL) || 588 generation == NULL) { 589 return BAD_VALUE; 590 } 591 Parcel data, reply; 592 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 593 unsigned int numPatchesReq = (patches == NULL) ? 0 : *num_patches; 594 data.writeInt32(numPatchesReq); 595 status_t status = remote()->transact(LIST_AUDIO_PATCHES, data, &reply); 596 if (status == NO_ERROR) { 597 status = (status_t)reply.readInt32(); 598 *num_patches = (unsigned int)reply.readInt32(); 599 } 600 if (status == NO_ERROR) { 601 if (numPatchesReq > *num_patches) { 602 numPatchesReq = *num_patches; 603 } 604 if (numPatchesReq > 0) { 605 reply.read(patches, numPatchesReq * sizeof(struct audio_patch)); 606 } 607 *generation = reply.readInt32(); 608 } 609 return status; 610 } 611 612 virtual status_t setAudioPortConfig(const struct audio_port_config *config) 613 { 614 if (config == NULL) { 615 return BAD_VALUE; 616 } 617 Parcel data, reply; 618 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 619 data.write(config, sizeof(struct audio_port_config)); 620 status_t status = remote()->transact(SET_AUDIO_PORT_CONFIG, data, &reply); 621 if (status != NO_ERROR) { 622 status = (status_t)reply.readInt32(); 623 } 624 return status; 625 } 626 627 virtual void registerClient(const sp<IAudioPolicyServiceClient>& client) 628 { 629 Parcel data, reply; 630 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 631 data.writeStrongBinder(client->asBinder()); 632 remote()->transact(REGISTER_CLIENT, data, &reply); 633 } 634 635 virtual status_t acquireSoundTriggerSession(audio_session_t *session, 636 audio_io_handle_t *ioHandle, 637 audio_devices_t *device) 638 { 639 if (session == NULL || ioHandle == NULL || device == NULL) { 640 return BAD_VALUE; 641 } 642 Parcel data, reply; 643 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 644 status_t status = remote()->transact(ACQUIRE_SOUNDTRIGGER_SESSION, data, &reply); 645 if (status != NO_ERROR) { 646 return status; 647 } 648 status = (status_t)reply.readInt32(); 649 if (status == NO_ERROR) { 650 *session = (audio_session_t)reply.readInt32(); 651 *ioHandle = (audio_io_handle_t)reply.readInt32(); 652 *device = (audio_devices_t)reply.readInt32(); 653 } 654 return status; 655 } 656 657 virtual status_t releaseSoundTriggerSession(audio_session_t session) 658 { 659 Parcel data, reply; 660 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 661 data.writeInt32(session); 662 status_t status = remote()->transact(RELEASE_SOUNDTRIGGER_SESSION, data, &reply); 663 if (status != NO_ERROR) { 664 return status; 665 } 666 return (status_t)reply.readInt32(); 667 } 668 669 virtual audio_mode_t getPhoneState() 670 { 671 Parcel data, reply; 672 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 673 status_t status = remote()->transact(GET_PHONE_STATE, data, &reply); 674 if (status != NO_ERROR) { 675 return AUDIO_MODE_INVALID; 676 } 677 return (audio_mode_t)reply.readInt32(); 678 } 679 680 virtual status_t registerPolicyMixes(Vector<AudioMix> mixes, bool registration) 681 { 682 Parcel data, reply; 683 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 684 data.writeInt32(registration ? 1 : 0); 685 size_t size = mixes.size(); 686 if (size > MAX_MIXES_PER_POLICY) { 687 size = MAX_MIXES_PER_POLICY; 688 } 689 size_t sizePosition = data.dataPosition(); 690 data.writeInt32(size); 691 size_t finalSize = size; 692 for (size_t i = 0; i < size; i++) { 693 size_t position = data.dataPosition(); 694 if (mixes[i].writeToParcel(&data) != NO_ERROR) { 695 data.setDataPosition(position); 696 finalSize--; 697 } 698 } 699 if (size != finalSize) { 700 size_t position = data.dataPosition(); 701 data.setDataPosition(sizePosition); 702 data.writeInt32(finalSize); 703 data.setDataPosition(position); 704 } 705 status_t status = remote()->transact(REGISTER_POLICY_MIXES, data, &reply); 706 if (status == NO_ERROR) { 707 status = (status_t)reply.readInt32(); 708 } 709 return status; 710 } 711}; 712 713IMPLEMENT_META_INTERFACE(AudioPolicyService, "android.media.IAudioPolicyService"); 714 715// ---------------------------------------------------------------------- 716 717 718status_t BnAudioPolicyService::onTransact( 719 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) 720{ 721 switch (code) { 722 case SET_DEVICE_CONNECTION_STATE: { 723 CHECK_INTERFACE(IAudioPolicyService, data, reply); 724 audio_devices_t device = 725 static_cast <audio_devices_t>(data.readInt32()); 726 audio_policy_dev_state_t state = 727 static_cast <audio_policy_dev_state_t>(data.readInt32()); 728 const char *device_address = data.readCString(); 729 reply->writeInt32(static_cast<uint32_t> (setDeviceConnectionState(device, 730 state, 731 device_address))); 732 return NO_ERROR; 733 } break; 734 735 case GET_DEVICE_CONNECTION_STATE: { 736 CHECK_INTERFACE(IAudioPolicyService, data, reply); 737 audio_devices_t device = 738 static_cast<audio_devices_t> (data.readInt32()); 739 const char *device_address = data.readCString(); 740 reply->writeInt32(static_cast<uint32_t> (getDeviceConnectionState(device, 741 device_address))); 742 return NO_ERROR; 743 } break; 744 745 case SET_PHONE_STATE: { 746 CHECK_INTERFACE(IAudioPolicyService, data, reply); 747 reply->writeInt32(static_cast <uint32_t>(setPhoneState( 748 (audio_mode_t) data.readInt32()))); 749 return NO_ERROR; 750 } break; 751 752 case SET_FORCE_USE: { 753 CHECK_INTERFACE(IAudioPolicyService, data, reply); 754 audio_policy_force_use_t usage = static_cast <audio_policy_force_use_t>( 755 data.readInt32()); 756 audio_policy_forced_cfg_t config = 757 static_cast <audio_policy_forced_cfg_t>(data.readInt32()); 758 reply->writeInt32(static_cast <uint32_t>(setForceUse(usage, config))); 759 return NO_ERROR; 760 } break; 761 762 case GET_FORCE_USE: { 763 CHECK_INTERFACE(IAudioPolicyService, data, reply); 764 audio_policy_force_use_t usage = static_cast <audio_policy_force_use_t>( 765 data.readInt32()); 766 reply->writeInt32(static_cast <uint32_t>(getForceUse(usage))); 767 return NO_ERROR; 768 } break; 769 770 case GET_OUTPUT: { 771 CHECK_INTERFACE(IAudioPolicyService, data, reply); 772 audio_stream_type_t stream = 773 static_cast <audio_stream_type_t>(data.readInt32()); 774 uint32_t samplingRate = data.readInt32(); 775 audio_format_t format = (audio_format_t) data.readInt32(); 776 audio_channel_mask_t channelMask = data.readInt32(); 777 audio_output_flags_t flags = 778 static_cast <audio_output_flags_t>(data.readInt32()); 779 bool hasOffloadInfo = data.readInt32() != 0; 780 audio_offload_info_t offloadInfo; 781 if (hasOffloadInfo) { 782 data.read(&offloadInfo, sizeof(audio_offload_info_t)); 783 } 784 audio_io_handle_t output = getOutput(stream, 785 samplingRate, 786 format, 787 channelMask, 788 flags, 789 hasOffloadInfo ? &offloadInfo : NULL); 790 reply->writeInt32(static_cast <int>(output)); 791 return NO_ERROR; 792 } break; 793 794 case GET_OUTPUT_FOR_ATTR: { 795 CHECK_INTERFACE(IAudioPolicyService, data, reply); 796 audio_attributes_t attr; 797 bool hasAttributes = data.readInt32() != 0; 798 if (hasAttributes) { 799 data.read(&attr, sizeof(audio_attributes_t)); 800 } 801 audio_session_t session = (audio_session_t)data.readInt32(); 802 audio_stream_type_t stream = AUDIO_STREAM_DEFAULT; 803 bool hasStream = data.readInt32() != 0; 804 if (hasStream) { 805 stream = (audio_stream_type_t)data.readInt32(); 806 } 807 uint32_t samplingRate = data.readInt32(); 808 audio_format_t format = (audio_format_t) data.readInt32(); 809 audio_channel_mask_t channelMask = data.readInt32(); 810 audio_output_flags_t flags = 811 static_cast <audio_output_flags_t>(data.readInt32()); 812 bool hasOffloadInfo = data.readInt32() != 0; 813 audio_offload_info_t offloadInfo; 814 if (hasOffloadInfo) { 815 data.read(&offloadInfo, sizeof(audio_offload_info_t)); 816 } 817 audio_io_handle_t output; 818 status_t status = getOutputForAttr(hasAttributes ? &attr : NULL, 819 &output, session, &stream, 820 samplingRate, format, channelMask, 821 flags, hasOffloadInfo ? &offloadInfo : NULL); 822 reply->writeInt32(status); 823 reply->writeInt32(output); 824 reply->writeInt32(stream); 825 return NO_ERROR; 826 } break; 827 828 case START_OUTPUT: { 829 CHECK_INTERFACE(IAudioPolicyService, data, reply); 830 audio_io_handle_t output = static_cast <audio_io_handle_t>(data.readInt32()); 831 audio_stream_type_t stream = 832 static_cast <audio_stream_type_t>(data.readInt32()); 833 audio_session_t session = (audio_session_t)data.readInt32(); 834 reply->writeInt32(static_cast <uint32_t>(startOutput(output, 835 stream, 836 session))); 837 return NO_ERROR; 838 } break; 839 840 case STOP_OUTPUT: { 841 CHECK_INTERFACE(IAudioPolicyService, data, reply); 842 audio_io_handle_t output = static_cast <audio_io_handle_t>(data.readInt32()); 843 audio_stream_type_t stream = 844 static_cast <audio_stream_type_t>(data.readInt32()); 845 audio_session_t session = (audio_session_t)data.readInt32(); 846 reply->writeInt32(static_cast <uint32_t>(stopOutput(output, 847 stream, 848 session))); 849 return NO_ERROR; 850 } break; 851 852 case RELEASE_OUTPUT: { 853 CHECK_INTERFACE(IAudioPolicyService, data, reply); 854 audio_io_handle_t output = static_cast <audio_io_handle_t>(data.readInt32()); 855 audio_stream_type_t stream = (audio_stream_type_t)data.readInt32(); 856 audio_session_t session = (audio_session_t)data.readInt32(); 857 releaseOutput(output, stream, session); 858 return NO_ERROR; 859 } break; 860 861 case GET_INPUT_FOR_ATTR: { 862 CHECK_INTERFACE(IAudioPolicyService, data, reply); 863 audio_attributes_t attr; 864 data.read(&attr, sizeof(audio_attributes_t)); 865 audio_session_t session = (audio_session_t)data.readInt32(); 866 uint32_t samplingRate = data.readInt32(); 867 audio_format_t format = (audio_format_t) data.readInt32(); 868 audio_channel_mask_t channelMask = data.readInt32(); 869 audio_input_flags_t flags = (audio_input_flags_t) data.readInt32(); 870 audio_io_handle_t input; 871 status_t status = getInputForAttr(&attr, &input, session, 872 samplingRate, format, channelMask, 873 flags); 874 reply->writeInt32(status); 875 if (status == NO_ERROR) { 876 reply->writeInt32(input); 877 } 878 return NO_ERROR; 879 } break; 880 881 case START_INPUT: { 882 CHECK_INTERFACE(IAudioPolicyService, data, reply); 883 audio_io_handle_t input = static_cast <audio_io_handle_t>(data.readInt32()); 884 audio_session_t session = static_cast <audio_session_t>(data.readInt32()); 885 reply->writeInt32(static_cast <uint32_t>(startInput(input, session))); 886 return NO_ERROR; 887 } break; 888 889 case STOP_INPUT: { 890 CHECK_INTERFACE(IAudioPolicyService, data, reply); 891 audio_io_handle_t input = static_cast <audio_io_handle_t>(data.readInt32()); 892 audio_session_t session = static_cast <audio_session_t>(data.readInt32()); 893 reply->writeInt32(static_cast <uint32_t>(stopInput(input, session))); 894 return NO_ERROR; 895 } break; 896 897 case RELEASE_INPUT: { 898 CHECK_INTERFACE(IAudioPolicyService, data, reply); 899 audio_io_handle_t input = static_cast <audio_io_handle_t>(data.readInt32()); 900 audio_session_t session = static_cast <audio_session_t>(data.readInt32()); 901 releaseInput(input, session); 902 return NO_ERROR; 903 } break; 904 905 case INIT_STREAM_VOLUME: { 906 CHECK_INTERFACE(IAudioPolicyService, data, reply); 907 audio_stream_type_t stream = 908 static_cast <audio_stream_type_t>(data.readInt32()); 909 int indexMin = data.readInt32(); 910 int indexMax = data.readInt32(); 911 reply->writeInt32(static_cast <uint32_t>(initStreamVolume(stream, indexMin,indexMax))); 912 return NO_ERROR; 913 } break; 914 915 case SET_STREAM_VOLUME: { 916 CHECK_INTERFACE(IAudioPolicyService, data, reply); 917 audio_stream_type_t stream = 918 static_cast <audio_stream_type_t>(data.readInt32()); 919 int index = data.readInt32(); 920 audio_devices_t device = static_cast <audio_devices_t>(data.readInt32()); 921 reply->writeInt32(static_cast <uint32_t>(setStreamVolumeIndex(stream, 922 index, 923 device))); 924 return NO_ERROR; 925 } break; 926 927 case GET_STREAM_VOLUME: { 928 CHECK_INTERFACE(IAudioPolicyService, data, reply); 929 audio_stream_type_t stream = 930 static_cast <audio_stream_type_t>(data.readInt32()); 931 audio_devices_t device = static_cast <audio_devices_t>(data.readInt32()); 932 int index; 933 status_t status = getStreamVolumeIndex(stream, &index, device); 934 reply->writeInt32(index); 935 reply->writeInt32(static_cast <uint32_t>(status)); 936 return NO_ERROR; 937 } break; 938 939 case GET_STRATEGY_FOR_STREAM: { 940 CHECK_INTERFACE(IAudioPolicyService, data, reply); 941 audio_stream_type_t stream = 942 static_cast <audio_stream_type_t>(data.readInt32()); 943 reply->writeInt32(getStrategyForStream(stream)); 944 return NO_ERROR; 945 } break; 946 947 case GET_DEVICES_FOR_STREAM: { 948 CHECK_INTERFACE(IAudioPolicyService, data, reply); 949 audio_stream_type_t stream = 950 static_cast <audio_stream_type_t>(data.readInt32()); 951 reply->writeInt32(static_cast <int>(getDevicesForStream(stream))); 952 return NO_ERROR; 953 } break; 954 955 case GET_OUTPUT_FOR_EFFECT: { 956 CHECK_INTERFACE(IAudioPolicyService, data, reply); 957 effect_descriptor_t desc; 958 data.read(&desc, sizeof(effect_descriptor_t)); 959 audio_io_handle_t output = getOutputForEffect(&desc); 960 reply->writeInt32(static_cast <int>(output)); 961 return NO_ERROR; 962 } break; 963 964 case REGISTER_EFFECT: { 965 CHECK_INTERFACE(IAudioPolicyService, data, reply); 966 effect_descriptor_t desc; 967 data.read(&desc, sizeof(effect_descriptor_t)); 968 audio_io_handle_t io = data.readInt32(); 969 uint32_t strategy = data.readInt32(); 970 int session = data.readInt32(); 971 int id = data.readInt32(); 972 reply->writeInt32(static_cast <int32_t>(registerEffect(&desc, 973 io, 974 strategy, 975 session, 976 id))); 977 return NO_ERROR; 978 } break; 979 980 case UNREGISTER_EFFECT: { 981 CHECK_INTERFACE(IAudioPolicyService, data, reply); 982 int id = data.readInt32(); 983 reply->writeInt32(static_cast <int32_t>(unregisterEffect(id))); 984 return NO_ERROR; 985 } break; 986 987 case SET_EFFECT_ENABLED: { 988 CHECK_INTERFACE(IAudioPolicyService, data, reply); 989 int id = data.readInt32(); 990 bool enabled = static_cast <bool>(data.readInt32()); 991 reply->writeInt32(static_cast <int32_t>(setEffectEnabled(id, enabled))); 992 return NO_ERROR; 993 } break; 994 995 case IS_STREAM_ACTIVE: { 996 CHECK_INTERFACE(IAudioPolicyService, data, reply); 997 audio_stream_type_t stream = (audio_stream_type_t) data.readInt32(); 998 uint32_t inPastMs = (uint32_t)data.readInt32(); 999 reply->writeInt32( isStreamActive(stream, inPastMs) ); 1000 return NO_ERROR; 1001 } break; 1002 1003 case IS_STREAM_ACTIVE_REMOTELY: { 1004 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1005 audio_stream_type_t stream = (audio_stream_type_t) data.readInt32(); 1006 uint32_t inPastMs = (uint32_t)data.readInt32(); 1007 reply->writeInt32( isStreamActiveRemotely(stream, inPastMs) ); 1008 return NO_ERROR; 1009 } break; 1010 1011 case IS_SOURCE_ACTIVE: { 1012 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1013 audio_source_t source = (audio_source_t) data.readInt32(); 1014 reply->writeInt32( isSourceActive(source)); 1015 return NO_ERROR; 1016 } 1017 1018 case QUERY_DEFAULT_PRE_PROCESSING: { 1019 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1020 int audioSession = data.readInt32(); 1021 uint32_t count = data.readInt32(); 1022 if (count > AudioEffect::kMaxPreProcessing) { 1023 count = AudioEffect::kMaxPreProcessing; 1024 } 1025 uint32_t retCount = count; 1026 effect_descriptor_t *descriptors = new effect_descriptor_t[count]; 1027 status_t status = queryDefaultPreProcessing(audioSession, descriptors, &retCount); 1028 reply->writeInt32(status); 1029 if (status != NO_ERROR && status != NO_MEMORY) { 1030 retCount = 0; 1031 } 1032 reply->writeInt32(retCount); 1033 if (retCount != 0) { 1034 if (retCount < count) { 1035 count = retCount; 1036 } 1037 reply->write(descriptors, sizeof(effect_descriptor_t) * count); 1038 } 1039 delete[] descriptors; 1040 return status; 1041 } 1042 1043 case IS_OFFLOAD_SUPPORTED: { 1044 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1045 audio_offload_info_t info; 1046 data.read(&info, sizeof(audio_offload_info_t)); 1047 bool isSupported = isOffloadSupported(info); 1048 reply->writeInt32(isSupported); 1049 return NO_ERROR; 1050 } 1051 1052 case LIST_AUDIO_PORTS: { 1053 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1054 audio_port_role_t role = (audio_port_role_t)data.readInt32(); 1055 audio_port_type_t type = (audio_port_type_t)data.readInt32(); 1056 unsigned int numPortsReq = data.readInt32(); 1057 unsigned int numPorts = numPortsReq; 1058 unsigned int generation; 1059 struct audio_port *ports = 1060 (struct audio_port *)calloc(numPortsReq, sizeof(struct audio_port)); 1061 status_t status = listAudioPorts(role, type, &numPorts, ports, &generation); 1062 reply->writeInt32(status); 1063 reply->writeInt32(numPorts); 1064 1065 if (status == NO_ERROR) { 1066 if (numPortsReq > numPorts) { 1067 numPortsReq = numPorts; 1068 } 1069 reply->write(ports, numPortsReq * sizeof(struct audio_port)); 1070 reply->writeInt32(generation); 1071 } 1072 free(ports); 1073 return NO_ERROR; 1074 } 1075 1076 case GET_AUDIO_PORT: { 1077 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1078 struct audio_port port; 1079 data.read(&port, sizeof(struct audio_port)); 1080 status_t status = getAudioPort(&port); 1081 reply->writeInt32(status); 1082 if (status == NO_ERROR) { 1083 reply->write(&port, sizeof(struct audio_port)); 1084 } 1085 return NO_ERROR; 1086 } 1087 1088 case CREATE_AUDIO_PATCH: { 1089 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1090 struct audio_patch patch; 1091 data.read(&patch, sizeof(struct audio_patch)); 1092 audio_patch_handle_t handle; 1093 data.read(&handle, sizeof(audio_patch_handle_t)); 1094 status_t status = createAudioPatch(&patch, &handle); 1095 reply->writeInt32(status); 1096 if (status == NO_ERROR) { 1097 reply->write(&handle, sizeof(audio_patch_handle_t)); 1098 } 1099 return NO_ERROR; 1100 } 1101 1102 case RELEASE_AUDIO_PATCH: { 1103 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1104 audio_patch_handle_t handle; 1105 data.read(&handle, sizeof(audio_patch_handle_t)); 1106 status_t status = releaseAudioPatch(handle); 1107 reply->writeInt32(status); 1108 return NO_ERROR; 1109 } 1110 1111 case LIST_AUDIO_PATCHES: { 1112 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1113 unsigned int numPatchesReq = data.readInt32(); 1114 unsigned int numPatches = numPatchesReq; 1115 unsigned int generation; 1116 struct audio_patch *patches = 1117 (struct audio_patch *)calloc(numPatchesReq, 1118 sizeof(struct audio_patch)); 1119 status_t status = listAudioPatches(&numPatches, patches, &generation); 1120 reply->writeInt32(status); 1121 reply->writeInt32(numPatches); 1122 if (status == NO_ERROR) { 1123 if (numPatchesReq > numPatches) { 1124 numPatchesReq = numPatches; 1125 } 1126 reply->write(patches, numPatchesReq * sizeof(struct audio_patch)); 1127 reply->writeInt32(generation); 1128 } 1129 free(patches); 1130 return NO_ERROR; 1131 } 1132 1133 case SET_AUDIO_PORT_CONFIG: { 1134 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1135 struct audio_port_config config; 1136 data.read(&config, sizeof(struct audio_port_config)); 1137 status_t status = setAudioPortConfig(&config); 1138 reply->writeInt32(status); 1139 return NO_ERROR; 1140 } 1141 1142 case REGISTER_CLIENT: { 1143 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1144 sp<IAudioPolicyServiceClient> client = interface_cast<IAudioPolicyServiceClient>( 1145 data.readStrongBinder()); 1146 registerClient(client); 1147 return NO_ERROR; 1148 } break; 1149 1150 case ACQUIRE_SOUNDTRIGGER_SESSION: { 1151 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1152 sp<IAudioPolicyServiceClient> client = interface_cast<IAudioPolicyServiceClient>( 1153 data.readStrongBinder()); 1154 audio_session_t session; 1155 audio_io_handle_t ioHandle; 1156 audio_devices_t device; 1157 status_t status = acquireSoundTriggerSession(&session, &ioHandle, &device); 1158 reply->writeInt32(status); 1159 if (status == NO_ERROR) { 1160 reply->writeInt32(session); 1161 reply->writeInt32(ioHandle); 1162 reply->writeInt32(device); 1163 } 1164 return NO_ERROR; 1165 } break; 1166 1167 case RELEASE_SOUNDTRIGGER_SESSION: { 1168 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1169 sp<IAudioPolicyServiceClient> client = interface_cast<IAudioPolicyServiceClient>( 1170 data.readStrongBinder()); 1171 audio_session_t session = (audio_session_t)data.readInt32(); 1172 status_t status = releaseSoundTriggerSession(session); 1173 reply->writeInt32(status); 1174 return NO_ERROR; 1175 } break; 1176 1177 case GET_PHONE_STATE: { 1178 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1179 reply->writeInt32((int32_t)getPhoneState()); 1180 return NO_ERROR; 1181 } break; 1182 1183 case REGISTER_POLICY_MIXES: { 1184 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1185 bool registration = data.readInt32() == 1; 1186 Vector<AudioMix> mixes; 1187 size_t size = (size_t)data.readInt32(); 1188 if (size > MAX_MIXES_PER_POLICY) { 1189 size = MAX_MIXES_PER_POLICY; 1190 } 1191 for (size_t i = 0; i < size; i++) { 1192 AudioMix mix; 1193 if (mix.readFromParcel((Parcel*)&data) == NO_ERROR) { 1194 mixes.add(mix); 1195 } 1196 } 1197 status_t status = registerPolicyMixes(mixes, registration); 1198 reply->writeInt32(status); 1199 return NO_ERROR; 1200 } break; 1201 1202 default: 1203 return BBinder::onTransact(code, data, reply, flags); 1204 } 1205} 1206 1207// ---------------------------------------------------------------------------- 1208 1209}; // namespace android 1210