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