1 /* 2 * Copyright (c) 2021-2022 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #ifndef ST_AUDIO_SYSTEM_MANAGER_H 17 #define ST_AUDIO_SYSTEM_MANAGER_H 18 19 #include <cstdlib> 20 #include <map> 21 #include <mutex> 22 #include <vector> 23 #include <unordered_map> 24 25 #include "parcel.h" 26 #include "audio_info.h" 27 #include "audio_interrupt_callback.h" 28 #include "audio_group_manager.h" 29 #include "audio_manager_base.h" 30 31 namespace OHOS { 32 namespace AudioStandard { 33 class AudioDeviceDescriptor; 34 class AudioDeviceDescriptor : public Parcelable { 35 friend class AudioSystemManager; 36 public: 37 DeviceType getType(); 38 DeviceRole getRole(); 39 DeviceType deviceType_; 40 DeviceRole deviceRole_; 41 int32_t deviceId_; 42 int32_t channelMasks_; 43 std::string deviceName_; 44 std::string macAddress_; 45 int32_t interruptGroupId_; 46 int32_t volumeGroupId_; 47 std::string networkId_; 48 AudioStreamInfo audioStreamInfo_ = {}; 49 AudioDeviceDescriptor(); 50 AudioDeviceDescriptor(DeviceType type, DeviceRole role, int32_t interruptGroupId, int32_t volumeGroupId, 51 std::string networkId); 52 AudioDeviceDescriptor(DeviceType type, DeviceRole role); 53 AudioDeviceDescriptor(const AudioDeviceDescriptor &deviceDescriptor); 54 virtual ~AudioDeviceDescriptor(); 55 bool Marshalling(Parcel &parcel) const override; 56 static sptr<AudioDeviceDescriptor> Unmarshalling(Parcel &parcel); 57 58 void SetDeviceInfo(std::string deviceName, std::string macAddress); 59 void SetDeviceCapability(const AudioStreamInfo &audioStreamInfo, int32_t channelMask); 60 }; 61 62 class InterruptGroupInfo; 63 class InterruptGroupInfo : public Parcelable { 64 friend class AudioSystemManager; 65 public: 66 int32_t interruptGroupId_; 67 int32_t mappingId_; 68 std::string groupName_; 69 std::string networkId_; 70 ConnectType connectType_; 71 InterruptGroupInfo(); 72 InterruptGroupInfo(int32_t interruptGroupId, int32_t mappingId, std::string groupName, std::string networkId, 73 ConnectType type); 74 virtual ~InterruptGroupInfo(); 75 bool Marshalling(Parcel &parcel) const override; 76 static sptr<InterruptGroupInfo> Unmarshalling(Parcel &parcel); 77 }; 78 79 class VolumeGroupInfo; 80 class VolumeGroupInfo : public Parcelable { 81 friend class AudioSystemManager; 82 public: 83 int32_t volumeGroupId_; 84 int32_t mappingId_; 85 std::string groupName_; 86 std::string networkId_; 87 ConnectType connectType_; 88 VolumeGroupInfo(); 89 VolumeGroupInfo(int32_t volumeGroupId, int32_t mappingId, std::string groupName, std::string networkId, 90 ConnectType type); 91 virtual ~VolumeGroupInfo(); 92 bool Marshalling(Parcel &parcel) const override; 93 static sptr<VolumeGroupInfo> Unmarshalling(Parcel &parcel); 94 }; 95 96 struct DeviceChangeAction { 97 DeviceChangeType type; 98 std::vector<sptr<AudioDeviceDescriptor>> deviceDescriptors; 99 }; 100 101 /** 102 * @brief AudioRendererFilter is used for select speficed AudioRenderer. 103 */ 104 class AudioRendererFilter; 105 class AudioRendererFilter : public Parcelable { 106 friend class AudioSystemManager; 107 public: 108 AudioRendererFilter(); 109 virtual ~AudioRendererFilter(); 110 111 int32_t uid = -1; 112 AudioRendererInfo rendererInfo = {}; 113 AudioStreamType streamType = AudioStreamType::STREAM_DEFAULT; 114 int32_t streamId = -1; 115 116 bool Marshalling(Parcel &parcel) const override; 117 static sptr<AudioRendererFilter> Unmarshalling(Parcel &in); 118 }; 119 120 /** 121 * @brief AudioCapturerFilter is used for select speficed audiocapturer. 122 */ 123 class AudioCapturerFilter; 124 class AudioCapturerFilter : public Parcelable { 125 friend class AudioSystemManager; 126 public: 127 AudioCapturerFilter(); 128 virtual ~AudioCapturerFilter(); 129 130 int32_t uid = -1; 131 132 bool Marshalling(Parcel &parcel) const override; 133 static sptr<AudioCapturerFilter> Unmarshalling(Parcel &in); 134 }; 135 136 // AudioManagerCallback OnInterrupt is added to handle compilation error in call manager 137 // Once call manager adapt to new interrupt APIs, this will be removed 138 class AudioManagerCallback { 139 public: 140 virtual ~AudioManagerCallback() = default; 141 /** 142 * Called when an interrupt is received. 143 * 144 * @param interruptAction Indicates the InterruptAction information needed by client. 145 * For details, refer InterruptAction struct in audio_info.h 146 */ 147 virtual void OnInterrupt(const InterruptAction &interruptAction) = 0; 148 }; 149 150 class AudioManagerInterruptCallbackImpl : public AudioInterruptCallback { 151 public: 152 explicit AudioManagerInterruptCallbackImpl(); 153 virtual ~AudioManagerInterruptCallbackImpl(); 154 155 void OnInterrupt(const InterruptEventInternal &interruptEvent) override; 156 void SaveCallback(const std::weak_ptr<AudioManagerCallback> &callback); 157 private: 158 std::weak_ptr<AudioManagerCallback> callback_; 159 std::shared_ptr<AudioManagerCallback> cb_; 160 }; 161 162 class AudioManagerDeviceChangeCallback { 163 public: 164 virtual ~AudioManagerDeviceChangeCallback() = default; 165 /** 166 * Called when an interrupt is received. 167 * 168 * @param deviceChangeAction Indicates the DeviceChangeAction information needed by client. 169 * For details, refer DeviceChangeAction struct 170 */ 171 virtual void OnDeviceChange(const DeviceChangeAction &deviceChangeAction) = 0; 172 }; 173 174 class VolumeKeyEventCallback { 175 public: 176 virtual ~VolumeKeyEventCallback() = default; 177 /** 178 * @brief VolumeKeyEventCallback will be executed when hard volume key is pressed up/down 179 * 180 * @param volumeEvent the volume event info. 181 **/ 182 virtual void OnVolumeKeyEvent(VolumeEvent volumeEvent) = 0; 183 }; 184 185 class AudioParameterCallback { 186 public: 187 virtual ~AudioParameterCallback() = default; 188 virtual void OnAudioParameterChange(const std::string networkId, const AudioParamKey key, 189 const std::string& condition, const std::string& value) = 0; 190 }; 191 192 /** 193 * @brief The AudioSystemManager class is an abstract definition of audio manager. 194 * Provides a series of client/interfaces for audio management 195 */ 196 197 class AudioSystemManager { 198 public: 199 const std::vector<AudioVolumeType> GET_STREAM_ALL_VOLUME_TYPES { 200 STREAM_MUSIC, 201 STREAM_RING, 202 STREAM_VOICE_CALL, 203 STREAM_VOICE_ASSISTANT 204 }; 205 static AudioSystemManager *GetInstance(); 206 static float MapVolumeToHDI(int32_t volume); 207 static int32_t MapVolumeFromHDI(float volume); 208 static AudioStreamType GetStreamType(ContentType contentType, StreamUsage streamUsage); 209 int32_t SetVolume(AudioVolumeType volumeType, int32_t volume) const; 210 int32_t GetVolume(AudioVolumeType volumeType) const; 211 int32_t SetLowPowerVolume(int32_t streamId, float volume) const; 212 float GetLowPowerVolume(int32_t streamId) const; 213 float GetSingleStreamVolume(int32_t streamId) const; 214 int32_t GetMaxVolume(AudioVolumeType volumeType); 215 int32_t GetMinVolume(AudioVolumeType volumeType); 216 int32_t SetMute(AudioVolumeType volumeType, bool mute) const; 217 bool IsStreamMute(AudioVolumeType volumeType) const; 218 int32_t SetMicrophoneMute(bool isMute); 219 bool IsMicrophoneMute(API_VERSION api_v = API_7); 220 int32_t SelectOutputDevice(std::vector<sptr<AudioDeviceDescriptor>> audioDeviceDescriptors) const; 221 int32_t SelectInputDevice(std::vector<sptr<AudioDeviceDescriptor>> audioDeviceDescriptors) const; 222 std::string GetSelectedDeviceInfo(int32_t uid, int32_t pid, AudioStreamType streamType) const; 223 int32_t SelectOutputDevice(sptr<AudioRendererFilter> audioRendererFilter, 224 std::vector<sptr<AudioDeviceDescriptor>> audioDeviceDescriptors) const; 225 int32_t SelectInputDevice(sptr<AudioCapturerFilter> audioCapturerFilter, 226 std::vector<sptr<AudioDeviceDescriptor>> audioDeviceDescriptors) const; 227 std::vector<sptr<AudioDeviceDescriptor>> GetDevices(DeviceFlag deviceFlag); 228 const std::string GetAudioParameter(const std::string key); 229 void SetAudioParameter(const std::string &key, const std::string &value); 230 const char *RetrieveCookie(int32_t &size); 231 uint64_t GetTransactionId(DeviceType deviceType, DeviceRole deviceRole); 232 int32_t SetDeviceActive(ActiveDeviceType deviceType, bool flag) const; 233 bool IsDeviceActive(ActiveDeviceType deviceType) const; 234 DeviceType GetActiveOutputDevice(); 235 DeviceType GetActiveInputDevice(); 236 bool IsStreamActive(AudioVolumeType volumeType) const; 237 int32_t SetRingerMode(AudioRingerMode ringMode); 238 AudioRingerMode GetRingerMode(); 239 int32_t SetAudioScene(const AudioScene &scene); 240 AudioScene GetAudioScene() const; 241 int32_t SetDeviceChangeCallback(const DeviceFlag flag, const std::shared_ptr<AudioManagerDeviceChangeCallback> 242 &callback); 243 int32_t UnsetDeviceChangeCallback(); 244 int32_t SetRingerModeCallback(const int32_t clientId, 245 const std::shared_ptr<AudioRingerModeCallback> &callback); 246 int32_t UnsetRingerModeCallback(const int32_t clientId) const; 247 int32_t RegisterVolumeKeyEventCallback(const int32_t clientPid, 248 const std::shared_ptr<VolumeKeyEventCallback> &callback); 249 int32_t UnregisterVolumeKeyEventCallback(const int32_t clientPid); 250 251 // Below APIs are added to handle compilation error in call manager 252 // Once call manager adapt to new interrupt APIs, this will be removed 253 int32_t SetAudioManagerCallback(const AudioVolumeType streamType, 254 const std::shared_ptr<AudioManagerCallback> &callback); 255 int32_t UnsetAudioManagerCallback(const AudioVolumeType streamType) const; 256 int32_t ActivateAudioInterrupt(const AudioInterrupt &audioInterrupt); 257 int32_t DeactivateAudioInterrupt(const AudioInterrupt &audioInterrupt) const; 258 int32_t SetAudioManagerInterruptCallback(const std::shared_ptr<AudioManagerCallback> &callback); 259 int32_t UnsetAudioManagerInterruptCallback(); 260 int32_t RequestAudioFocus(const AudioInterrupt &audioInterrupt); 261 int32_t AbandonAudioFocus(const AudioInterrupt &audioInterrupt); 262 int32_t ReconfigureAudioChannel(const uint32_t &count, DeviceType deviceType); 263 bool RequestIndependentInterrupt(FocusType focusType); 264 bool AbandonIndependentInterrupt(FocusType focusType); 265 int32_t GetAudioLatencyFromXml() const; 266 uint32_t GetSinkLatencyFromXml() const; 267 int32_t UpdateStreamState(const int32_t clientUid, StreamSetState streamSetState, 268 AudioStreamType audioStreamType); 269 AudioPin GetPinValueFromType(DeviceType deviceType, DeviceRole deviceRole) const; 270 DeviceType GetTypeValueFromPin(AudioPin pin) const; 271 std::vector<sptr<VolumeGroupInfo>> GetVolumeGroups(std::string networkId); 272 std::shared_ptr<AudioGroupManager> GetGroupManager(int32_t groupId); 273 std::vector<sptr<AudioDeviceDescriptor>> GetActiveOutputDeviceDescriptors(); 274 private: 275 static constexpr int32_t MAX_VOLUME_LEVEL = 15; 276 static constexpr int32_t MIN_VOLUME_LEVEL = 0; 277 static constexpr int32_t CONST_FACTOR = 100; 278 279 AudioSystemManager(); 280 virtual ~AudioSystemManager(); 281 282 const sptr<IStandardAudioService> GetAudioSystemManagerProxy(); 283 uint32_t GetCallingPid(); 284 void AudioServerDied(pid_t pid); 285 286 static const std::map<std::pair<ContentType, StreamUsage>, AudioStreamType> streamTypeMap_; 287 static std::map<std::pair<ContentType, StreamUsage>, AudioStreamType> CreateStreamMap(); 288 289 int32_t cbClientId_ = -1; 290 int32_t volumeChangeClientPid_ = -1; 291 AudioRingerMode ringModeBackup_; 292 std::shared_ptr<AudioManagerDeviceChangeCallback> deviceChangeCallback_ = nullptr; 293 std::shared_ptr<AudioInterruptCallback> audioInterruptCallback_ = nullptr; 294 std::shared_ptr<AudioRingerModeCallback> ringerModeCallback_ = nullptr; 295 std::vector<std::shared_ptr<AudioGroupManager>> groupManagerMap_; 296 }; 297 } // namespace AudioStandard 298 } // namespace OHOS 299 #endif // ST_AUDIO_SYSTEM_MANAGER_H 300