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