1 /*
2 * Copyright (c) 2023 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 #include "audio_haptic_manager_impl.h"
17
18 #include "audio_haptic_player_impl.h"
19
20 #include "audio_haptic_log.h"
21 #include "media_errors.h"
22
23 #include "isoundpool.h"
24 #include "player.h"
25
26 namespace {
27 constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {LOG_CORE, LOG_DOMAIN_AUDIO_NAPI, "AudioHapticManagerImpl"};
28 }
29
30 namespace OHOS {
31 namespace Media {
32 const std::int32_t MAX_PLAYER_NUM = 128;
33
34 std::shared_ptr<AudioHapticManager> AudioHapticManagerFactory::audioHapticManager_ = nullptr;
35 std::mutex AudioHapticManagerFactory::audioHapticManagerMutex_;
36
CreateAudioHapticManager()37 std::shared_ptr<AudioHapticManager> AudioHapticManagerFactory::CreateAudioHapticManager()
38 {
39 std::lock_guard<std::mutex> lock(audioHapticManagerMutex_);
40 if (audioHapticManager_ == nullptr) {
41 audioHapticManager_ = std::make_shared<AudioHapticManagerImpl>();
42 }
43 CHECK_AND_RETURN_RET_LOG(audioHapticManager_ != nullptr, nullptr, "Failed to create audio haptic manager object");
44
45 return audioHapticManager_;
46 }
47
AudioHapticManagerImpl()48 AudioHapticManagerImpl::AudioHapticManagerImpl()
49 {
50 audioHapticPlayerMap_.clear();
51 curPlayerIndex_ = 0;
52 curPlayerCount_ = 0;
53 }
54
~AudioHapticManagerImpl()55 AudioHapticManagerImpl::~AudioHapticManagerImpl()
56 {
57 audioHapticPlayerMap_.clear();
58 curPlayerIndex_ = 0;
59 curPlayerCount_ = 0;
60 }
61
RegisterSourceWithEffectId(const std::string & audioUri,const std::string & effectId)62 int32_t AudioHapticManagerImpl::RegisterSourceWithEffectId(const std::string &audioUri, const std::string &effectId)
63 {
64 std::lock_guard<std::mutex> lock(audioHapticManagerMutex_);
65 if (effectId == "") {
66 MEDIA_LOGE("RegisterSourceWithEffectId failed. The effectId is empty!");
67 return -1;
68 }
69 if (curPlayerCount_ >= MAX_PLAYER_NUM) {
70 MEDIA_LOGE("RegisterSourceWithEffectId failed. curPlayerCount_: %{public}d", curPlayerCount_);
71 return -1;
72 }
73 curPlayerIndex_ = (curPlayerIndex_ + 1) % MAX_PLAYER_NUM;
74 while (audioHapticPlayerMap_[curPlayerIndex_] != nullptr) {
75 curPlayerIndex_ = (curPlayerIndex_ + 1) % MAX_PLAYER_NUM;
76 }
77 int32_t sourceId = curPlayerIndex_;
78 HapticSource sourceUri = {"", effectId};
79 audioHapticPlayerMap_[sourceId] = std::make_shared<AudioHapticPlayerInfo>(audioUri, sourceUri,
80 AUDIO_LATENCY_MODE_FAST, AudioStandard::StreamUsage::STREAM_USAGE_MUSIC);
81 curPlayerCount_ += 1;
82 MEDIA_LOGI("Finish to RegisterSourceWithEffectId. effectId: %{public}s, sourceId: %{public}d",
83 effectId.c_str(), sourceId);
84 return sourceId;
85 }
86
RegisterSource(const std::string & audioUri,const std::string & hapticUri)87 int32_t AudioHapticManagerImpl::RegisterSource(const std::string &audioUri, const std::string &hapticUri)
88 {
89 std::lock_guard<std::mutex> lock(audioHapticManagerMutex_);
90
91 if (curPlayerCount_ >= MAX_PLAYER_NUM) {
92 MEDIA_LOGE("RegisterSource failed curPlayerCount_: %{public}d", curPlayerCount_);
93 return -1;
94 }
95 curPlayerIndex_ = (curPlayerIndex_ + 1) % MAX_PLAYER_NUM;
96 while (audioHapticPlayerMap_[curPlayerIndex_] != nullptr) {
97 curPlayerIndex_ = (curPlayerIndex_ + 1) % MAX_PLAYER_NUM;
98 }
99 int32_t sourceId = curPlayerIndex_;
100 HapticSource sourceUri = {hapticUri, ""};
101 audioHapticPlayerMap_[sourceId] = std::make_shared<AudioHapticPlayerInfo>(audioUri, sourceUri,
102 AUDIO_LATENCY_MODE_NORMAL, AudioStandard::StreamUsage::STREAM_USAGE_MUSIC);
103 curPlayerCount_ += 1;
104 MEDIA_LOGI("Finish to RegisterSource. audioUri: %{public}s, hapticUri: %{public}s, sourceId: %{public}d",
105 audioUri.c_str(), hapticUri.c_str(), sourceId);
106 return sourceId;
107 }
108
UnregisterSource(const int32_t & sourceID)109 int32_t AudioHapticManagerImpl::UnregisterSource(const int32_t &sourceID)
110 {
111 std::lock_guard<std::mutex> lock(audioHapticManagerMutex_);
112
113 if (audioHapticPlayerMap_.count(sourceID) == 0 || audioHapticPlayerMap_[sourceID] == nullptr) {
114 MEDIA_LOGE("UnregisterSource failed sourceID: %{public}d", sourceID);
115 return MSERR_INVALID_VAL;
116 }
117 audioHapticPlayerMap_[sourceID] = nullptr;
118 audioHapticPlayerMap_.erase(sourceID);
119 curPlayerCount_ -= 1;
120 MEDIA_LOGI("Finish to UnregisterSource. sourceId: %{public}d", sourceID);
121 return MSERR_OK;
122 }
123
CheckAudioLatencyMode(const int32_t & sourceId,const AudioLatencyMode & latencyMode)124 bool AudioHapticManagerImpl::CheckAudioLatencyMode(const int32_t &sourceId, const AudioLatencyMode &latencyMode)
125 {
126 if (latencyMode != AUDIO_LATENCY_MODE_NORMAL && latencyMode != AUDIO_LATENCY_MODE_FAST) {
127 MEDIA_LOGE("The AudioLatencyMode %{public}d is invalid!", latencyMode);
128 return false;
129 }
130
131 // effectId can only be used for low latency mode.
132 HapticSource source = audioHapticPlayerMap_[sourceId]->hapticSource_;
133 if (source.effectId != "" && latencyMode != AUDIO_LATENCY_MODE_FAST) {
134 MEDIA_LOGE("The effectId source can only be used for low latency mode!");
135 return false;
136 }
137
138 return true;
139 }
140
SetAudioLatencyMode(const int32_t & sourceId,const AudioLatencyMode & latencyMode)141 int32_t AudioHapticManagerImpl::SetAudioLatencyMode(const int32_t &sourceId, const AudioLatencyMode &latencyMode)
142 {
143 std::lock_guard<std::mutex> lock(audioHapticManagerMutex_);
144 if (audioHapticPlayerMap_.count(sourceId) == 0 || audioHapticPlayerMap_[sourceId] == nullptr) {
145 MEDIA_LOGE("SetAudioLatencyMode: failed for invalid sourceID: %{public}d", sourceId);
146 return MSERR_INVALID_VAL;
147 }
148 if (!CheckAudioLatencyMode(sourceId, latencyMode)) {
149 MEDIA_LOGE("SetAudioLatencyMode: failed for invalid latencyMode: %{public}d", latencyMode);
150 return MSERR_INVALID_VAL;
151 }
152 audioHapticPlayerMap_[sourceId]->latencyMode_ = latencyMode;
153 return MSERR_OK;
154 }
155
CheckAudioStreamUsage(const AudioStandard::StreamUsage & streamUsage)156 bool AudioHapticManagerImpl::CheckAudioStreamUsage(const AudioStandard::StreamUsage &streamUsage)
157 {
158 switch (streamUsage) {
159 case AudioStandard::STREAM_USAGE_MUSIC:
160 case AudioStandard::STREAM_USAGE_VOICE_COMMUNICATION:
161 case AudioStandard::STREAM_USAGE_VOICE_ASSISTANT:
162 case AudioStandard::STREAM_USAGE_ALARM:
163 case AudioStandard::STREAM_USAGE_VOICE_MESSAGE:
164 case AudioStandard::STREAM_USAGE_RINGTONE:
165 case AudioStandard::STREAM_USAGE_VOICE_RINGTONE:
166 case AudioStandard::STREAM_USAGE_NOTIFICATION:
167 case AudioStandard::STREAM_USAGE_ACCESSIBILITY:
168 case AudioStandard::STREAM_USAGE_SYSTEM:
169 case AudioStandard::STREAM_USAGE_MOVIE:
170 case AudioStandard::STREAM_USAGE_GAME:
171 case AudioStandard::STREAM_USAGE_AUDIOBOOK:
172 case AudioStandard::STREAM_USAGE_NAVIGATION:
173 case AudioStandard::STREAM_USAGE_DTMF:
174 case AudioStandard::STREAM_USAGE_ENFORCED_TONE:
175 return true;
176 default:
177 break;
178 }
179 MEDIA_LOGE("CheckAudioStreamUsage: streamUsage %{public}d is invalid", streamUsage);
180 return false;
181 }
182
SetStreamUsage(const int32_t & sourceID,const AudioStandard::StreamUsage & streamUsage)183 int32_t AudioHapticManagerImpl::SetStreamUsage(const int32_t &sourceID, const AudioStandard::StreamUsage &streamUsage)
184 {
185 std::lock_guard<std::mutex> lock(audioHapticManagerMutex_);
186 if (audioHapticPlayerMap_.count(sourceID) == 0 || audioHapticPlayerMap_[sourceID] == nullptr) {
187 MEDIA_LOGE("SetStreamUsage: failed for invalid sourceID: %{public}d", sourceID);
188 return MSERR_INVALID_VAL;
189 }
190 if (!CheckAudioStreamUsage(streamUsage)) {
191 MEDIA_LOGE("SetStreamUsage: failed for invalid latencyMode: %{public}d", streamUsage);
192 return MSERR_INVALID_VAL;
193 }
194 audioHapticPlayerMap_[sourceID]->streamUsage_ = streamUsage;
195 return MSERR_OK;
196 }
197
CreatePlayer(const int32_t & sourceID,const AudioHapticPlayerOptions & audioHapticPlayerOptions)198 std::shared_ptr<AudioHapticPlayer> AudioHapticManagerImpl::CreatePlayer(const int32_t &sourceID,
199 const AudioHapticPlayerOptions &audioHapticPlayerOptions)
200 {
201 std::lock_guard<std::mutex> lock(audioHapticManagerMutex_);
202 if (audioHapticPlayerMap_.count(sourceID) == 0 || audioHapticPlayerMap_[sourceID] == nullptr) {
203 MEDIA_LOGE("CreatePlayer failed for sourceID: %{public}d", sourceID);
204 return nullptr;
205 }
206
207 std::shared_ptr<AudioHapticPlayerInfo> audioHapticPlayerInfo = audioHapticPlayerMap_[sourceID];
208 AudioHapticPlayerParam param = AudioHapticPlayerParam(audioHapticPlayerOptions,
209 audioHapticPlayerInfo->audioUri_, audioHapticPlayerInfo->hapticSource_,
210 audioHapticPlayerInfo->latencyMode_, audioHapticPlayerInfo->streamUsage_);
211 std::shared_ptr<AudioHapticPlayer> audioHapticPlayer = AudioHapticPlayerFactory::CreateAudioHapticPlayer(param);
212
213 if (audioHapticPlayer == nullptr) {
214 MEDIA_LOGE("CreatePlayer failed for sourceID: %{public}d", sourceID);
215 return nullptr;
216 }
217 return audioHapticPlayer;
218 }
219 } // namesapce AudioStandard
220 } // namespace OHOS
221