1 /* 2 * Copyright (C) 2007 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #ifndef ANDROID_IAUDIOFLINGER_H 18 #define ANDROID_IAUDIOFLINGER_H 19 20 #include <stdint.h> 21 #include <sys/types.h> 22 #include <unistd.h> 23 24 #include <utils/RefBase.h> 25 #include <utils/Errors.h> 26 #include <binder/IInterface.h> 27 #include <media/AidlConversion.h> 28 #include <media/AudioClient.h> 29 #include <media/AudioCommonTypes.h> 30 #include <media/DeviceDescriptorBase.h> 31 #include <system/audio.h> 32 #include <system/audio_effect.h> 33 #include <system/audio_policy.h> 34 #include <utils/String8.h> 35 #include <map> 36 #include <string> 37 #include <vector> 38 39 #include <android/content/AttributionSourceState.h> 40 #include <android/media/AudioVibratorInfo.h> 41 #include <android/media/BnAudioFlingerService.h> 42 #include <android/media/BpAudioFlingerService.h> 43 #include <android/media/audio/common/AudioMMapPolicyInfo.h> 44 #include <android/media/audio/common/AudioMMapPolicyType.h> 45 #include "android/media/CreateEffectRequest.h" 46 #include "android/media/CreateEffectResponse.h" 47 #include "android/media/CreateRecordRequest.h" 48 #include "android/media/CreateRecordResponse.h" 49 #include "android/media/CreateTrackRequest.h" 50 #include "android/media/CreateTrackResponse.h" 51 #include "android/media/IAudioRecord.h" 52 #include "android/media/IAudioFlingerClient.h" 53 #include "android/media/IAudioTrack.h" 54 #include "android/media/IAudioTrackCallback.h" 55 #include "android/media/IEffect.h" 56 #include "android/media/IEffectClient.h" 57 #include "android/media/ISoundDose.h" 58 #include "android/media/ISoundDoseCallback.h" 59 #include "android/media/OpenInputRequest.h" 60 #include "android/media/OpenInputResponse.h" 61 #include "android/media/OpenOutputRequest.h" 62 #include "android/media/OpenOutputResponse.h" 63 #include "android/media/TrackSecondaryOutputInfo.h" 64 65 namespace android { 66 67 // ---------------------------------------------------------------------------- 68 69 class IAudioFlinger : public virtual RefBase { 70 public: 71 static constexpr char DEFAULT_SERVICE_NAME[] = "media.audio_flinger"; 72 73 virtual ~IAudioFlinger() = default; 74 75 /* CreateTrackInput contains all input arguments sent by AudioTrack to AudioFlinger 76 * when calling createTrack() including arguments that will be updated by AudioFlinger 77 * and returned in CreateTrackOutput object 78 */ 79 class CreateTrackInput { 80 public: 81 /* input */ 82 audio_attributes_t attr; 83 audio_config_t config; 84 AudioClient clientInfo; 85 sp<IMemory> sharedBuffer; 86 uint32_t notificationsPerBuffer; 87 float speed; 88 sp<media::IAudioTrackCallback> audioTrackCallback; 89 90 /* input/output */ 91 audio_output_flags_t flags; 92 size_t frameCount; 93 size_t notificationFrameCount; 94 audio_port_handle_t selectedDeviceId; 95 audio_session_t sessionId; 96 97 ConversionResult<media::CreateTrackRequest> toAidl() const; 98 static ConversionResult<CreateTrackInput> fromAidl(const media::CreateTrackRequest& aidl); 99 }; 100 101 /* CreateTrackOutput contains all output arguments returned by AudioFlinger to AudioTrack 102 * when calling createTrack() including arguments that were passed as I/O for update by 103 * CreateTrackInput. 104 */ 105 class CreateTrackOutput { 106 public: 107 /* input/output */ 108 audio_output_flags_t flags; 109 size_t frameCount; 110 size_t notificationFrameCount; 111 audio_port_handle_t selectedDeviceId; 112 audio_session_t sessionId; 113 114 /* output */ 115 uint32_t sampleRate; 116 audio_stream_type_t streamType; 117 size_t afFrameCount; 118 uint32_t afSampleRate; 119 uint32_t afLatencyMs; 120 audio_channel_mask_t afChannelMask; 121 audio_format_t afFormat; 122 audio_io_handle_t outputId; 123 audio_port_handle_t portId; 124 sp<media::IAudioTrack> audioTrack; 125 126 ConversionResult<media::CreateTrackResponse> toAidl() const; 127 static ConversionResult<CreateTrackOutput> fromAidl(const media::CreateTrackResponse& aidl); 128 }; 129 130 /* CreateRecordInput contains all input arguments sent by AudioRecord to AudioFlinger 131 * when calling createRecord() including arguments that will be updated by AudioFlinger 132 * and returned in CreateRecordOutput object 133 */ 134 class CreateRecordInput { 135 public: 136 /* input */ 137 audio_attributes_t attr; 138 audio_config_base_t config; 139 AudioClient clientInfo; 140 audio_unique_id_t riid; 141 int32_t maxSharedAudioHistoryMs; 142 143 /* input/output */ 144 audio_input_flags_t flags; 145 size_t frameCount; 146 size_t notificationFrameCount; 147 audio_port_handle_t selectedDeviceId; 148 audio_session_t sessionId; 149 150 ConversionResult<media::CreateRecordRequest> toAidl() const; 151 static ConversionResult<CreateRecordInput> fromAidl(const media::CreateRecordRequest& aidl); 152 }; 153 154 /* CreateRecordOutput contains all output arguments returned by AudioFlinger to AudioRecord 155 * when calling createRecord() including arguments that were passed as I/O for update by 156 * CreateRecordInput. 157 */ 158 class CreateRecordOutput { 159 public: 160 /* input/output */ 161 audio_input_flags_t flags; 162 size_t frameCount; 163 size_t notificationFrameCount; 164 audio_port_handle_t selectedDeviceId; 165 audio_session_t sessionId; 166 167 /* output */ 168 uint32_t sampleRate; 169 audio_io_handle_t inputId; 170 sp<IMemory> cblk; 171 sp<IMemory> buffers; 172 audio_port_handle_t portId; 173 sp<media::IAudioRecord> audioRecord; 174 audio_config_base_t serverConfig; 175 audio_config_base_t halConfig; 176 177 ConversionResult<media::CreateRecordResponse> toAidl() const; 178 static ConversionResult<CreateRecordOutput> 179 fromAidl(const media::CreateRecordResponse& aidl); 180 }; 181 182 /* create an audio track and registers it with AudioFlinger. 183 * The audioTrack field will be null if the track cannot be created and the status will reflect 184 * failure. 185 */ 186 virtual status_t createTrack(const media::CreateTrackRequest& input, 187 media::CreateTrackResponse& output) = 0; 188 189 /* create an audio record and registers it with AudioFlinger. 190 * The audioRecord field will be null if the track cannot be created and the status will reflect 191 * failure. 192 */ 193 virtual status_t createRecord(const media::CreateRecordRequest& input, 194 media::CreateRecordResponse& output) = 0; 195 196 // FIXME Surprisingly, format/latency don't work for input handles 197 198 /* query the audio hardware state. This state never changes, 199 * and therefore can be cached. 200 */ 201 virtual uint32_t sampleRate(audio_io_handle_t ioHandle) const = 0; 202 203 // reserved; formerly channelCount() 204 205 virtual audio_format_t format(audio_io_handle_t output) const = 0; 206 virtual size_t frameCount(audio_io_handle_t ioHandle) const = 0; 207 208 // return estimated latency in milliseconds 209 virtual uint32_t latency(audio_io_handle_t output) const = 0; 210 211 /* set/get the audio hardware state. This will probably be used by 212 * the preference panel, mostly. 213 */ 214 virtual status_t setMasterVolume(float value) = 0; 215 virtual status_t setMasterMute(bool muted) = 0; 216 217 virtual float masterVolume() const = 0; 218 virtual bool masterMute() const = 0; 219 220 virtual status_t setMasterBalance(float balance) = 0; 221 virtual status_t getMasterBalance(float *balance) const = 0; 222 223 /* set/get stream type state. This will probably be used by 224 * the preference panel, mostly. 225 */ 226 virtual status_t setStreamVolume(audio_stream_type_t stream, float value, 227 audio_io_handle_t output) = 0; 228 virtual status_t setStreamMute(audio_stream_type_t stream, bool muted) = 0; 229 230 virtual float streamVolume(audio_stream_type_t stream, 231 audio_io_handle_t output) const = 0; 232 virtual bool streamMute(audio_stream_type_t stream) const = 0; 233 234 // set audio mode 235 virtual status_t setMode(audio_mode_t mode) = 0; 236 237 // mic mute/state 238 virtual status_t setMicMute(bool state) = 0; 239 virtual bool getMicMute() const = 0; 240 virtual void setRecordSilenced(audio_port_handle_t portId, bool silenced) = 0; 241 242 virtual status_t setParameters(audio_io_handle_t ioHandle, 243 const String8& keyValuePairs) = 0; 244 virtual String8 getParameters(audio_io_handle_t ioHandle, const String8& keys) 245 const = 0; 246 247 // Register an object to receive audio input/output change and track notifications. 248 // For a given calling pid, AudioFlinger disregards any registrations after the first. 249 // Thus the IAudioFlingerClient must be a singleton per process. 250 virtual void registerClient(const sp<media::IAudioFlingerClient>& client) = 0; 251 252 // retrieve the audio recording buffer size in bytes 253 // FIXME This API assumes a route, and so should be deprecated. 254 virtual size_t getInputBufferSize(uint32_t sampleRate, audio_format_t format, 255 audio_channel_mask_t channelMask) const = 0; 256 257 virtual status_t openOutput(const media::OpenOutputRequest& request, 258 media::OpenOutputResponse* response) = 0; 259 virtual audio_io_handle_t openDuplicateOutput(audio_io_handle_t output1, 260 audio_io_handle_t output2) = 0; 261 virtual status_t closeOutput(audio_io_handle_t output) = 0; 262 virtual status_t suspendOutput(audio_io_handle_t output) = 0; 263 virtual status_t restoreOutput(audio_io_handle_t output) = 0; 264 265 virtual status_t openInput(const media::OpenInputRequest& request, 266 media::OpenInputResponse* response) = 0; 267 268 virtual status_t closeInput(audio_io_handle_t input) = 0; 269 270 virtual status_t setVoiceVolume(float volume) = 0; 271 272 virtual status_t getRenderPosition(uint32_t *halFrames, uint32_t *dspFrames, 273 audio_io_handle_t output) const = 0; 274 275 virtual uint32_t getInputFramesLost(audio_io_handle_t ioHandle) const = 0; 276 277 virtual audio_unique_id_t newAudioUniqueId(audio_unique_id_use_t use) = 0; 278 279 virtual void acquireAudioSessionId(audio_session_t audioSession, pid_t pid, uid_t uid) = 0; 280 virtual void releaseAudioSessionId(audio_session_t audioSession, pid_t pid) = 0; 281 282 virtual status_t queryNumberEffects(uint32_t *numEffects) const = 0; 283 284 virtual status_t queryEffect(uint32_t index, effect_descriptor_t *pDescriptor) const = 0; 285 286 virtual status_t getEffectDescriptor(const effect_uuid_t *pEffectUUID, 287 const effect_uuid_t *pTypeUUID, 288 uint32_t preferredTypeFlag, 289 effect_descriptor_t *pDescriptor) const = 0; 290 291 virtual status_t createEffect(const media::CreateEffectRequest& request, 292 media::CreateEffectResponse* response) = 0; 293 294 virtual status_t moveEffects(audio_session_t session, audio_io_handle_t srcOutput, 295 audio_io_handle_t dstOutput) = 0; 296 297 virtual void setEffectSuspended(int effectId, 298 audio_session_t sessionId, 299 bool suspended) = 0; 300 301 virtual audio_module_handle_t loadHwModule(const char *name) = 0; 302 303 // helpers for android.media.AudioManager.getProperty(), see description there for meaning 304 // FIXME move these APIs to AudioPolicy to permit a more accurate implementation 305 // that looks on primary device for a stream with fast flag, primary flag, or first one. 306 virtual uint32_t getPrimaryOutputSamplingRate() = 0; 307 virtual size_t getPrimaryOutputFrameCount() = 0; 308 309 // Intended for AudioService to inform AudioFlinger of device's low RAM attribute, 310 // and should be called at most once. For a definition of what "low RAM" means, see 311 // android.app.ActivityManager.isLowRamDevice(). The totalMemory parameter 312 // is obtained from android.app.ActivityManager.MemoryInfo.totalMem. 313 virtual status_t setLowRamDevice(bool isLowRamDevice, int64_t totalMemory) = 0; 314 315 /* Get attributes for a given audio port */ 316 virtual status_t getAudioPort(struct audio_port_v7 *port) = 0; 317 318 /* Create an audio patch between several source and sink ports */ 319 virtual status_t createAudioPatch(const struct audio_patch *patch, 320 audio_patch_handle_t *handle) = 0; 321 322 /* Release an audio patch */ 323 virtual status_t releaseAudioPatch(audio_patch_handle_t handle) = 0; 324 325 /* List existing audio patches */ 326 virtual status_t listAudioPatches(unsigned int *num_patches, 327 struct audio_patch *patches) = 0; 328 /* Set audio port configuration */ 329 virtual status_t setAudioPortConfig(const struct audio_port_config *config) = 0; 330 331 /* Get the HW synchronization source used for an audio session */ 332 virtual audio_hw_sync_t getAudioHwSyncForSession(audio_session_t sessionId) = 0; 333 334 /* Indicate JAVA services are ready (scheduling, power management ...) */ 335 virtual status_t systemReady() = 0; 336 337 // Indicate audio policy service is ready 338 virtual status_t audioPolicyReady() = 0; 339 340 // Returns the number of frames per audio HAL buffer. 341 virtual size_t frameCountHAL(audio_io_handle_t ioHandle) const = 0; 342 343 /* List available microphones and their characteristics */ 344 virtual status_t getMicrophones(std::vector<media::MicrophoneInfoFw> *microphones) = 0; 345 346 virtual status_t setAudioHalPids(const std::vector<pid_t>& pids) = 0; 347 348 // Set vibrators' information. 349 // The values will be used to initialize HapticGenerator. 350 virtual status_t setVibratorInfos( 351 const std::vector<media::AudioVibratorInfo>& vibratorInfos) = 0; 352 353 virtual status_t updateSecondaryOutputs( 354 const TrackSecondaryOutputsMap& trackSecondaryOutputs) = 0; 355 356 virtual status_t getMmapPolicyInfos( 357 media::audio::common::AudioMMapPolicyType policyType, 358 std::vector<media::audio::common::AudioMMapPolicyInfo> *policyInfos) = 0; 359 360 virtual int32_t getAAudioMixerBurstCount() = 0; 361 362 virtual int32_t getAAudioHardwareBurstMinUsec() = 0; 363 364 virtual status_t setDeviceConnectedState(const struct audio_port_v7 *port, 365 media::DeviceConnectedState state) = 0; 366 367 virtual status_t setSimulateDeviceConnections(bool enabled) = 0; 368 369 virtual status_t setRequestedLatencyMode( 370 audio_io_handle_t output, audio_latency_mode_t mode) = 0; 371 372 virtual status_t getSupportedLatencyModes(audio_io_handle_t output, 373 std::vector<audio_latency_mode_t>* modes) = 0; 374 375 virtual status_t getSoundDoseInterface(const sp<media::ISoundDoseCallback>& callback, 376 sp<media::ISoundDose>* soundDose) = 0; 377 378 virtual status_t invalidateTracks(const std::vector<audio_port_handle_t>& portIds) = 0; 379 380 virtual status_t setBluetoothVariableLatencyEnabled(bool enabled) = 0; 381 382 virtual status_t isBluetoothVariableLatencyEnabled(bool* enabled) = 0; 383 384 virtual status_t supportsBluetoothVariableLatency(bool* support) = 0; 385 386 virtual status_t getAudioPolicyConfig(media::AudioPolicyConfig* output) = 0; 387 }; 388 389 /** 390 * A client-side adapter, wrapping an IAudioFlingerService instance and presenting it as an 391 * IAudioFlinger. Intended to be used by legacy client code that was written against IAudioFlinger, 392 * before IAudioFlingerService was introduced as an AIDL service. 393 * New clients should not use this adapter, but rather IAudioFlingerService directly, via 394 * BpAudioFlingerService. 395 */ 396 class AudioFlingerClientAdapter : public IAudioFlinger { 397 public: 398 explicit AudioFlingerClientAdapter(const sp<media::IAudioFlingerService> delegate); 399 400 status_t createTrack(const media::CreateTrackRequest& input, 401 media::CreateTrackResponse& output) override; 402 status_t createRecord(const media::CreateRecordRequest& input, 403 media::CreateRecordResponse& output) override; 404 uint32_t sampleRate(audio_io_handle_t ioHandle) const override; 405 audio_format_t format(audio_io_handle_t output) const override; 406 size_t frameCount(audio_io_handle_t ioHandle) const override; 407 uint32_t latency(audio_io_handle_t output) const override; 408 status_t setMasterVolume(float value) override; 409 status_t setMasterMute(bool muted) override; 410 float masterVolume() const override; 411 bool masterMute() const override; 412 status_t setMasterBalance(float balance) override; 413 status_t getMasterBalance(float* balance) const override; 414 status_t setStreamVolume(audio_stream_type_t stream, float value, 415 audio_io_handle_t output) override; 416 status_t setStreamMute(audio_stream_type_t stream, bool muted) override; 417 float streamVolume(audio_stream_type_t stream, 418 audio_io_handle_t output) const override; 419 bool streamMute(audio_stream_type_t stream) const override; 420 status_t setMode(audio_mode_t mode) override; 421 status_t setMicMute(bool state) override; 422 bool getMicMute() const override; 423 void setRecordSilenced(audio_port_handle_t portId, bool silenced) override; 424 status_t setParameters(audio_io_handle_t ioHandle, 425 const String8& keyValuePairs) override; 426 String8 getParameters(audio_io_handle_t ioHandle, const String8& keys) 427 const override; 428 void registerClient(const sp<media::IAudioFlingerClient>& client) override; 429 size_t getInputBufferSize(uint32_t sampleRate, audio_format_t format, 430 audio_channel_mask_t channelMask) const override; 431 status_t openOutput(const media::OpenOutputRequest& request, 432 media::OpenOutputResponse* response) override; 433 audio_io_handle_t openDuplicateOutput(audio_io_handle_t output1, 434 audio_io_handle_t output2) override; 435 status_t closeOutput(audio_io_handle_t output) override; 436 status_t suspendOutput(audio_io_handle_t output) override; 437 status_t restoreOutput(audio_io_handle_t output) override; 438 status_t openInput(const media::OpenInputRequest& request, 439 media::OpenInputResponse* response) override; 440 status_t closeInput(audio_io_handle_t input) override; 441 status_t setVoiceVolume(float volume) override; 442 status_t getRenderPosition(uint32_t* halFrames, uint32_t* dspFrames, 443 audio_io_handle_t output) const override; 444 uint32_t getInputFramesLost(audio_io_handle_t ioHandle) const override; 445 audio_unique_id_t newAudioUniqueId(audio_unique_id_use_t use) override; 446 void acquireAudioSessionId(audio_session_t audioSession, pid_t pid, uid_t uid) override; 447 void releaseAudioSessionId(audio_session_t audioSession, pid_t pid) override; 448 status_t queryNumberEffects(uint32_t* numEffects) const override; 449 status_t queryEffect(uint32_t index, effect_descriptor_t* pDescriptor) const override; 450 status_t getEffectDescriptor(const effect_uuid_t* pEffectUUID, 451 const effect_uuid_t* pTypeUUID, 452 uint32_t preferredTypeFlag, 453 effect_descriptor_t* pDescriptor) const override; 454 status_t createEffect(const media::CreateEffectRequest& request, 455 media::CreateEffectResponse* response) override; 456 status_t moveEffects(audio_session_t session, audio_io_handle_t srcOutput, 457 audio_io_handle_t dstOutput) override; 458 void setEffectSuspended(int effectId, 459 audio_session_t sessionId, 460 bool suspended) override; 461 audio_module_handle_t loadHwModule(const char* name) override; 462 uint32_t getPrimaryOutputSamplingRate() override; 463 size_t getPrimaryOutputFrameCount() override; 464 status_t setLowRamDevice(bool isLowRamDevice, int64_t totalMemory) override; 465 status_t getAudioPort(struct audio_port_v7* port) override; 466 status_t createAudioPatch(const struct audio_patch* patch, 467 audio_patch_handle_t* handle) override; 468 status_t releaseAudioPatch(audio_patch_handle_t handle) override; 469 status_t listAudioPatches(unsigned int* num_patches, 470 struct audio_patch* patches) override; 471 status_t setAudioPortConfig(const struct audio_port_config* config) override; 472 audio_hw_sync_t getAudioHwSyncForSession(audio_session_t sessionId) override; 473 status_t systemReady() override; 474 status_t audioPolicyReady() override; 475 476 size_t frameCountHAL(audio_io_handle_t ioHandle) const override; 477 status_t getMicrophones(std::vector<media::MicrophoneInfoFw>* microphones) override; 478 status_t setAudioHalPids(const std::vector<pid_t>& pids) override; 479 status_t setVibratorInfos(const std::vector<media::AudioVibratorInfo>& vibratorInfos) override; 480 status_t updateSecondaryOutputs( 481 const TrackSecondaryOutputsMap& trackSecondaryOutputs) override; 482 status_t getMmapPolicyInfos( 483 media::audio::common::AudioMMapPolicyType policyType, 484 std::vector<media::audio::common::AudioMMapPolicyInfo> *policyInfos) override; 485 int32_t getAAudioMixerBurstCount() override; 486 int32_t getAAudioHardwareBurstMinUsec() override; 487 status_t setDeviceConnectedState(const struct audio_port_v7 *port, 488 media::DeviceConnectedState state) override; 489 status_t setSimulateDeviceConnections(bool enabled) override; 490 status_t setRequestedLatencyMode(audio_io_handle_t output, 491 audio_latency_mode_t mode) override; 492 status_t getSupportedLatencyModes( 493 audio_io_handle_t output, std::vector<audio_latency_mode_t>* modes) override; 494 status_t setBluetoothVariableLatencyEnabled(bool enabled) override; 495 status_t isBluetoothVariableLatencyEnabled(bool* enabled) override; 496 status_t supportsBluetoothVariableLatency(bool* support) override; 497 status_t getSoundDoseInterface(const sp<media::ISoundDoseCallback>& callback, 498 sp<media::ISoundDose>* soundDose) override; 499 status_t invalidateTracks(const std::vector<audio_port_handle_t>& portIds) override; 500 status_t getAudioPolicyConfig(media::AudioPolicyConfig* output) override; 501 502 private: 503 const sp<media::IAudioFlingerService> mDelegate; 504 }; 505 506 /** 507 * A server-side adapter, wrapping an IAudioFlinger instance and presenting it as an 508 * IAudioFlingerService. Intended to be used by legacy server code that was written against 509 * IAudioFlinger, before IAudioFlingerService was introduced as an AIDL service. 510 * New servers should not use this adapter, but rather implement IAudioFlingerService directly, via 511 * BnAudioFlingerService. 512 */ 513 class AudioFlingerServerAdapter : public media::BnAudioFlingerService { 514 public: 515 using Status = binder::Status; 516 517 /** 518 * Legacy server should implement this interface in order to be wrapped. 519 */ 520 class Delegate : public IAudioFlinger { 521 friend class AudioFlingerServerAdapter; 522 public: 523 // expose the TransactionCode enum for TimeCheck purposes. 524 enum class TransactionCode { 525 CREATE_TRACK = media::BnAudioFlingerService::TRANSACTION_createTrack, 526 CREATE_RECORD = media::BnAudioFlingerService::TRANSACTION_createRecord, 527 SAMPLE_RATE = media::BnAudioFlingerService::TRANSACTION_sampleRate, 528 FORMAT = media::BnAudioFlingerService::TRANSACTION_format, 529 FRAME_COUNT = media::BnAudioFlingerService::TRANSACTION_frameCount, 530 LATENCY = media::BnAudioFlingerService::TRANSACTION_latency, 531 SET_MASTER_VOLUME = media::BnAudioFlingerService::TRANSACTION_setMasterVolume, 532 SET_MASTER_MUTE = media::BnAudioFlingerService::TRANSACTION_setMasterMute, 533 MASTER_VOLUME = media::BnAudioFlingerService::TRANSACTION_masterVolume, 534 MASTER_MUTE = media::BnAudioFlingerService::TRANSACTION_masterMute, 535 SET_STREAM_VOLUME = media::BnAudioFlingerService::TRANSACTION_setStreamVolume, 536 SET_STREAM_MUTE = media::BnAudioFlingerService::TRANSACTION_setStreamMute, 537 STREAM_VOLUME = media::BnAudioFlingerService::TRANSACTION_streamVolume, 538 STREAM_MUTE = media::BnAudioFlingerService::TRANSACTION_streamMute, 539 SET_MODE = media::BnAudioFlingerService::TRANSACTION_setMode, 540 SET_MIC_MUTE = media::BnAudioFlingerService::TRANSACTION_setMicMute, 541 GET_MIC_MUTE = media::BnAudioFlingerService::TRANSACTION_getMicMute, 542 SET_RECORD_SILENCED = media::BnAudioFlingerService::TRANSACTION_setRecordSilenced, 543 SET_PARAMETERS = media::BnAudioFlingerService::TRANSACTION_setParameters, 544 GET_PARAMETERS = media::BnAudioFlingerService::TRANSACTION_getParameters, 545 REGISTER_CLIENT = media::BnAudioFlingerService::TRANSACTION_registerClient, 546 GET_INPUTBUFFERSIZE = media::BnAudioFlingerService::TRANSACTION_getInputBufferSize, 547 OPEN_OUTPUT = media::BnAudioFlingerService::TRANSACTION_openOutput, 548 OPEN_DUPLICATE_OUTPUT = media::BnAudioFlingerService::TRANSACTION_openDuplicateOutput, 549 CLOSE_OUTPUT = media::BnAudioFlingerService::TRANSACTION_closeOutput, 550 SUSPEND_OUTPUT = media::BnAudioFlingerService::TRANSACTION_suspendOutput, 551 RESTORE_OUTPUT = media::BnAudioFlingerService::TRANSACTION_restoreOutput, 552 OPEN_INPUT = media::BnAudioFlingerService::TRANSACTION_openInput, 553 CLOSE_INPUT = media::BnAudioFlingerService::TRANSACTION_closeInput, 554 SET_VOICE_VOLUME = media::BnAudioFlingerService::TRANSACTION_setVoiceVolume, 555 GET_RENDER_POSITION = media::BnAudioFlingerService::TRANSACTION_getRenderPosition, 556 GET_INPUT_FRAMES_LOST = media::BnAudioFlingerService::TRANSACTION_getInputFramesLost, 557 NEW_AUDIO_UNIQUE_ID = media::BnAudioFlingerService::TRANSACTION_newAudioUniqueId, 558 ACQUIRE_AUDIO_SESSION_ID = media::BnAudioFlingerService::TRANSACTION_acquireAudioSessionId, 559 RELEASE_AUDIO_SESSION_ID = media::BnAudioFlingerService::TRANSACTION_releaseAudioSessionId, 560 QUERY_NUM_EFFECTS = media::BnAudioFlingerService::TRANSACTION_queryNumberEffects, 561 QUERY_EFFECT = media::BnAudioFlingerService::TRANSACTION_queryEffect, 562 GET_EFFECT_DESCRIPTOR = media::BnAudioFlingerService::TRANSACTION_getEffectDescriptor, 563 CREATE_EFFECT = media::BnAudioFlingerService::TRANSACTION_createEffect, 564 MOVE_EFFECTS = media::BnAudioFlingerService::TRANSACTION_moveEffects, 565 LOAD_HW_MODULE = media::BnAudioFlingerService::TRANSACTION_loadHwModule, 566 GET_PRIMARY_OUTPUT_SAMPLING_RATE = media::BnAudioFlingerService::TRANSACTION_getPrimaryOutputSamplingRate, 567 GET_PRIMARY_OUTPUT_FRAME_COUNT = media::BnAudioFlingerService::TRANSACTION_getPrimaryOutputFrameCount, 568 SET_LOW_RAM_DEVICE = media::BnAudioFlingerService::TRANSACTION_setLowRamDevice, 569 GET_AUDIO_PORT = media::BnAudioFlingerService::TRANSACTION_getAudioPort, 570 CREATE_AUDIO_PATCH = media::BnAudioFlingerService::TRANSACTION_createAudioPatch, 571 RELEASE_AUDIO_PATCH = media::BnAudioFlingerService::TRANSACTION_releaseAudioPatch, 572 LIST_AUDIO_PATCHES = media::BnAudioFlingerService::TRANSACTION_listAudioPatches, 573 SET_AUDIO_PORT_CONFIG = media::BnAudioFlingerService::TRANSACTION_setAudioPortConfig, 574 GET_AUDIO_HW_SYNC_FOR_SESSION = media::BnAudioFlingerService::TRANSACTION_getAudioHwSyncForSession, 575 SYSTEM_READY = media::BnAudioFlingerService::TRANSACTION_systemReady, 576 AUDIO_POLICY_READY = media::BnAudioFlingerService::TRANSACTION_audioPolicyReady, 577 FRAME_COUNT_HAL = media::BnAudioFlingerService::TRANSACTION_frameCountHAL, 578 GET_MICROPHONES = media::BnAudioFlingerService::TRANSACTION_getMicrophones, 579 SET_MASTER_BALANCE = media::BnAudioFlingerService::TRANSACTION_setMasterBalance, 580 GET_MASTER_BALANCE = media::BnAudioFlingerService::TRANSACTION_getMasterBalance, 581 SET_EFFECT_SUSPENDED = media::BnAudioFlingerService::TRANSACTION_setEffectSuspended, 582 SET_AUDIO_HAL_PIDS = media::BnAudioFlingerService::TRANSACTION_setAudioHalPids, 583 SET_VIBRATOR_INFOS = media::BnAudioFlingerService::TRANSACTION_setVibratorInfos, 584 UPDATE_SECONDARY_OUTPUTS = media::BnAudioFlingerService::TRANSACTION_updateSecondaryOutputs, 585 GET_MMAP_POLICY_INFOS = media::BnAudioFlingerService::TRANSACTION_getMmapPolicyInfos, 586 GET_AAUDIO_MIXER_BURST_COUNT = media::BnAudioFlingerService::TRANSACTION_getAAudioMixerBurstCount, 587 GET_AAUDIO_HARDWARE_BURST_MIN_USEC = media::BnAudioFlingerService::TRANSACTION_getAAudioHardwareBurstMinUsec, 588 SET_DEVICE_CONNECTED_STATE = media::BnAudioFlingerService::TRANSACTION_setDeviceConnectedState, 589 SET_SIMULATE_DEVICE_CONNECTIONS = media::BnAudioFlingerService::TRANSACTION_setSimulateDeviceConnections, 590 SET_REQUESTED_LATENCY_MODE = media::BnAudioFlingerService::TRANSACTION_setRequestedLatencyMode, 591 GET_SUPPORTED_LATENCY_MODES = media::BnAudioFlingerService::TRANSACTION_getSupportedLatencyModes, 592 SET_BLUETOOTH_VARIABLE_LATENCY_ENABLED = 593 media::BnAudioFlingerService::TRANSACTION_setBluetoothVariableLatencyEnabled, 594 IS_BLUETOOTH_VARIABLE_LATENCY_ENABLED = 595 media::BnAudioFlingerService::TRANSACTION_isBluetoothVariableLatencyEnabled, 596 SUPPORTS_BLUETOOTH_VARIABLE_LATENCY = 597 media::BnAudioFlingerService::TRANSACTION_supportsBluetoothVariableLatency, 598 GET_SOUND_DOSE_INTERFACE = media::BnAudioFlingerService::TRANSACTION_getSoundDoseInterface, 599 INVALIDATE_TRACKS = media::BnAudioFlingerService::TRANSACTION_invalidateTracks, 600 GET_AUDIO_POLICY_CONFIG = 601 media::BnAudioFlingerService::TRANSACTION_getAudioPolicyConfig, 602 }; 603 604 protected: 605 /** 606 * And optional hook, called on every transaction, allowing additional operations to be 607 * performed before/after the unparceling ofthe data and dispatching to the respective 608 * method. Useful for bulk operations, such as logging or permission checks. 609 * The implementer is responsible to invoke the provided delegate function, which is the 610 * actual onTransact(), unless an error occurs. 611 * By default, this is just a pass-through to the delegate. 612 */ onTransactWrapper(TransactionCode code,const Parcel & data,uint32_t flags,const std::function<status_t ()> & delegate)613 virtual status_t onTransactWrapper(TransactionCode code, 614 const Parcel& data, 615 uint32_t flags, 616 const std::function<status_t()>& delegate) { 617 (void) code; 618 (void) data; 619 (void) flags; 620 return delegate(); 621 } 622 623 /** 624 * An optional hook for implementing diagnostics dumping. 625 */ dump(int fd,const Vector<String16> & args)626 virtual status_t dump(int fd, const Vector<String16>& args) { 627 (void) fd; 628 (void) args; 629 return OK; 630 } 631 }; 632 633 explicit AudioFlingerServerAdapter( 634 const sp<AudioFlingerServerAdapter::Delegate>& delegate); 635 636 status_t onTransact(uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) override; 637 status_t dump(int fd, const Vector<String16>& args) override; 638 639 Status createTrack(const media::CreateTrackRequest& request, 640 media::CreateTrackResponse* _aidl_return) override; 641 Status createRecord(const media::CreateRecordRequest& request, 642 media::CreateRecordResponse* _aidl_return) override; 643 Status sampleRate(int32_t ioHandle, int32_t* _aidl_return) override; 644 Status format(int32_t output, 645 media::audio::common::AudioFormatDescription* _aidl_return) override; 646 Status frameCount(int32_t ioHandle, int64_t* _aidl_return) override; 647 Status latency(int32_t output, int32_t* _aidl_return) override; 648 Status setMasterVolume(float value) override; 649 Status setMasterMute(bool muted) override; 650 Status masterVolume(float* _aidl_return) override; 651 Status masterMute(bool* _aidl_return) override; 652 Status setMasterBalance(float balance) override; 653 Status getMasterBalance(float* _aidl_return) override; 654 Status setStreamVolume(media::audio::common::AudioStreamType stream, 655 float value, int32_t output) override; 656 Status setStreamMute(media::audio::common::AudioStreamType stream, bool muted) override; 657 Status streamVolume(media::audio::common::AudioStreamType stream, 658 int32_t output, float* _aidl_return) override; 659 Status streamMute(media::audio::common::AudioStreamType stream, bool* _aidl_return) override; 660 Status setMode(media::audio::common::AudioMode mode) override; 661 Status setMicMute(bool state) override; 662 Status getMicMute(bool* _aidl_return) override; 663 Status setRecordSilenced(int32_t portId, bool silenced) override; 664 Status setParameters(int32_t ioHandle, const std::string& keyValuePairs) override; 665 Status 666 getParameters(int32_t ioHandle, const std::string& keys, std::string* _aidl_return) override; 667 Status registerClient(const sp<media::IAudioFlingerClient>& client) override; 668 Status getInputBufferSize(int32_t sampleRate, 669 const media::audio::common::AudioFormatDescription& format, 670 const media::audio::common::AudioChannelLayout& channelMask, 671 int64_t* _aidl_return) override; 672 Status openOutput(const media::OpenOutputRequest& request, 673 media::OpenOutputResponse* _aidl_return) override; 674 Status openDuplicateOutput(int32_t output1, int32_t output2, int32_t* _aidl_return) override; 675 Status closeOutput(int32_t output) override; 676 Status suspendOutput(int32_t output) override; 677 Status restoreOutput(int32_t output) override; 678 Status openInput(const media::OpenInputRequest& request, 679 media::OpenInputResponse* _aidl_return) override; 680 Status closeInput(int32_t input) override; 681 Status setVoiceVolume(float volume) override; 682 Status getRenderPosition(int32_t output, media::RenderPosition* _aidl_return) override; 683 Status getInputFramesLost(int32_t ioHandle, int32_t* _aidl_return) override; 684 Status newAudioUniqueId(media::AudioUniqueIdUse use, int32_t* _aidl_return) override; 685 Status acquireAudioSessionId(int32_t audioSession, int32_t pid, int32_t uid) override; 686 Status releaseAudioSessionId(int32_t audioSession, int32_t pid) override; 687 Status queryNumberEffects(int32_t* _aidl_return) override; 688 Status queryEffect(int32_t index, media::EffectDescriptor* _aidl_return) override; 689 Status getEffectDescriptor(const media::audio::common::AudioUuid& effectUUID, 690 const media::audio::common::AudioUuid& typeUUID, 691 int32_t preferredTypeFlag, 692 media::EffectDescriptor* _aidl_return) override; 693 Status createEffect(const media::CreateEffectRequest& request, 694 media::CreateEffectResponse* _aidl_return) override; 695 Status moveEffects(int32_t session, int32_t srcOutput, int32_t dstOutput) override; 696 Status setEffectSuspended(int32_t effectId, int32_t sessionId, bool suspended) override; 697 Status loadHwModule(const std::string& name, int32_t* _aidl_return) override; 698 Status getPrimaryOutputSamplingRate(int32_t* _aidl_return) override; 699 Status getPrimaryOutputFrameCount(int64_t* _aidl_return) override; 700 Status setLowRamDevice(bool isLowRamDevice, int64_t totalMemory) override; 701 Status getAudioPort(const media::AudioPortFw& port, media::AudioPortFw* _aidl_return) override; 702 Status createAudioPatch(const media::AudioPatchFw& patch, int32_t* _aidl_return) override; 703 Status releaseAudioPatch(int32_t handle) override; 704 Status listAudioPatches(int32_t maxCount, 705 std::vector<media::AudioPatchFw>* _aidl_return) override; 706 Status setAudioPortConfig(const media::AudioPortConfigFw& config) override; 707 Status getAudioHwSyncForSession(int32_t sessionId, int32_t* _aidl_return) override; 708 Status systemReady() override; 709 Status audioPolicyReady() override; 710 Status frameCountHAL(int32_t ioHandle, int64_t* _aidl_return) override; 711 Status getMicrophones(std::vector<media::MicrophoneInfoFw>* _aidl_return) override; 712 Status setAudioHalPids(const std::vector<int32_t>& pids) override; 713 Status setVibratorInfos(const std::vector<media::AudioVibratorInfo>& vibratorInfos) override; 714 Status updateSecondaryOutputs( 715 const std::vector<media::TrackSecondaryOutputInfo>& trackSecondaryOutputInfos) override; 716 Status getMmapPolicyInfos( 717 media::audio::common::AudioMMapPolicyType policyType, 718 std::vector<media::audio::common::AudioMMapPolicyInfo> *_aidl_return) override; 719 Status getAAudioMixerBurstCount(int32_t* _aidl_return) override; 720 Status getAAudioHardwareBurstMinUsec(int32_t* _aidl_return) override; 721 Status setDeviceConnectedState(const media::AudioPortFw& port, 722 media::DeviceConnectedState state) override; 723 Status setSimulateDeviceConnections(bool enabled) override; 724 Status setRequestedLatencyMode( 725 int output, media::audio::common::AudioLatencyMode mode) override; 726 Status getSupportedLatencyModes(int output, 727 std::vector<media::audio::common::AudioLatencyMode>* _aidl_return) override; 728 Status setBluetoothVariableLatencyEnabled(bool enabled) override; 729 Status isBluetoothVariableLatencyEnabled(bool* enabled) override; 730 Status supportsBluetoothVariableLatency(bool* support) override; 731 Status getSoundDoseInterface(const sp<media::ISoundDoseCallback>& callback, 732 sp<media::ISoundDose>* _aidl_return) override; 733 Status invalidateTracks(const std::vector<int32_t>& portIds) override; 734 Status getAudioPolicyConfig(media::AudioPolicyConfig* _aidl_return) override; 735 private: 736 const sp<AudioFlingerServerAdapter::Delegate> mDelegate; 737 }; 738 739 }; // namespace android 740 741 #endif // ANDROID_IAUDIOFLINGER_H 742