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