1 /*
2 * Copyright (c) 2024-2025 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 #include "multimedia_audio_stream_manager_impl.h"
16
17 #include "audio_manager_log.h"
18 #include "cj_lambda.h"
19 #include "multimedia_audio_common.h"
20 #include "multimedia_audio_error.h"
21
22 namespace OHOS {
23 namespace AudioStandard {
24 extern "C" {
MMAAudioStreamManagerImpl()25 MMAAudioStreamManagerImpl::MMAAudioStreamManagerImpl()
26 {
27 streamMgr_ = AudioStreamManager::GetInstance();
28 cachedClientId_ = getpid();
29 callback_ = std::make_shared<CjAudioCapturerStateChangeCallback>();
30 callbackRenderer_ = std::make_shared<CjAudioRendererStateChangeCallback>();
31 }
32
~MMAAudioStreamManagerImpl()33 MMAAudioStreamManagerImpl::~MMAAudioStreamManagerImpl()
34 {
35 streamMgr_ = nullptr;
36 }
37
IsActive(int32_t volumeType)38 bool MMAAudioStreamManagerImpl::IsActive(int32_t volumeType)
39 {
40 return streamMgr_->IsStreamActive(GetNativeAudioVolumeType(volumeType));
41 }
42
GetAudioEffectInfoArray(int32_t usage,int32_t * errorCode)43 CArrI32 MMAAudioStreamManagerImpl::GetAudioEffectInfoArray(int32_t usage, int32_t* errorCode)
44 {
45 AudioSceneEffectInfo audioSceneEffectInfo {};
46 int32_t ret = streamMgr_->GetEffectInfoArray(audioSceneEffectInfo, static_cast<StreamUsage>(usage));
47 if (ret != AUDIO_OK) {
48 AUDIO_ERR_LOG("GetEffectInfoArray failure!");
49 *errorCode = CJ_ERR_SYSTEM;
50 return CArrI32();
51 }
52 CArrI32 arr {};
53 arr.size = static_cast<int64_t>(audioSceneEffectInfo.mode.size());
54 if (arr.size == 0) {
55 return CArrI32();
56 }
57 int32_t mallocSize = static_cast<int32_t>(sizeof(int32_t)) * static_cast<int32_t>(arr.size);
58 if (mallocSize > static_cast<int32_t>(sizeof(int32_t) * MAX_MEM_MALLOC_SIZE)) {
59 *errorCode = CJ_ERR_SYSTEM;
60 return CArrI32();
61 }
62 auto head = static_cast<int32_t*>(malloc(mallocSize));
63 if (head == nullptr) {
64 *errorCode = CJ_ERR_NO_MEMORY;
65 return CArrI32();
66 }
67 if (memset_s(head, arr.size, 0, arr.size) != EOK) {
68 free(head);
69 head = nullptr;
70 *errorCode = CJ_ERR_SYSTEM;
71 return CArrI32();
72 }
73 for (int32_t i = 0; i < static_cast<int32_t>(arr.size); i++) {
74 head[i] = static_cast<int32_t>(audioSceneEffectInfo.mode[i]);
75 }
76 arr.head = head;
77 return arr;
78 }
79
GetCurrentRendererChangeInfos(int32_t * errorCode)80 CArrAudioRendererChangeInfo MMAAudioStreamManagerImpl::GetCurrentRendererChangeInfos(int32_t* errorCode)
81 {
82 std::vector<std::shared_ptr<AudioRendererChangeInfo>> audioRendererChangeInfos {};
83 int32_t ret = streamMgr_->GetCurrentRendererChangeInfos(audioRendererChangeInfos);
84 if (ret != AUDIO_OK) {
85 AUDIO_ERR_LOG("GetCurrentRendererChangeInfos failure!");
86 *errorCode = CJ_ERR_SYSTEM;
87 return CArrAudioRendererChangeInfo();
88 }
89 CArrAudioRendererChangeInfo arrInfo {};
90 arrInfo.size = static_cast<int64_t>(audioRendererChangeInfos.size());
91 if (arrInfo.size == 0) {
92 return CArrAudioRendererChangeInfo();
93 }
94 int32_t mallocSize = static_cast<int32_t>(sizeof(CAudioRendererChangeInfo)) * static_cast<int32_t>(arrInfo.size);
95 if (mallocSize > static_cast<int32_t>(sizeof(CAudioRendererChangeInfo) * MAX_MEM_MALLOC_SIZE)) {
96 *errorCode = CJ_ERR_SYSTEM;
97 return CArrAudioRendererChangeInfo();
98 }
99 auto head = static_cast<CAudioRendererChangeInfo*>(malloc(mallocSize));
100 if (head == nullptr) {
101 *errorCode = CJ_ERR_NO_MEMORY;
102 return CArrAudioRendererChangeInfo();
103 }
104 arrInfo.head = head;
105 if (memset_s(head, arrInfo.size, 0, arrInfo.size) != EOK) {
106 free(head);
107 *errorCode = CJ_ERR_SYSTEM;
108 return CArrAudioRendererChangeInfo();
109 }
110 for (int32_t i = 0; i < static_cast<int32_t>(audioRendererChangeInfos.size()); i++) {
111 Convert2CAudioRendererChangeInfo(head[i], *(audioRendererChangeInfos[i]), errorCode);
112 if (*errorCode != SUCCESS_CODE) {
113 FreeCArrAudioRendererChangeInfo(arrInfo);
114 *errorCode = CJ_ERR_SYSTEM;
115 return CArrAudioRendererChangeInfo();
116 }
117 }
118 return arrInfo;
119 }
120
GetAudioCapturerInfoArray(int32_t * errorCode)121 CArrAudioCapturerChangeInfo MMAAudioStreamManagerImpl::GetAudioCapturerInfoArray(int32_t* errorCode)
122 {
123 std::vector<std::shared_ptr<AudioCapturerChangeInfo>> audioCapturerChangeInfos {};
124 int32_t ret = streamMgr_->GetCurrentCapturerChangeInfos(audioCapturerChangeInfos);
125 if (ret != AUDIO_OK) {
126 AUDIO_ERR_LOG("GetCurrentCapturerChangeInfos failure!");
127 *errorCode = CJ_ERR_SYSTEM;
128 return CArrAudioCapturerChangeInfo();
129 }
130 CArrAudioCapturerChangeInfo arrInfo {};
131 arrInfo.size = static_cast<int64_t>(audioCapturerChangeInfos.size());
132 if (arrInfo.size == 0) {
133 return CArrAudioCapturerChangeInfo();
134 }
135 int32_t mallocSize = static_cast<int32_t>(sizeof(CAudioRendererChangeInfo)) * static_cast<int32_t>(arrInfo.size);
136 if (mallocSize > static_cast<int32_t>(sizeof(AudioCapturerChangeInfo) * MAX_MEM_MALLOC_SIZE)) {
137 *errorCode = CJ_ERR_SYSTEM;
138 return CArrAudioCapturerChangeInfo();
139 }
140 auto head = static_cast<CAudioCapturerChangeInfo*>(malloc(mallocSize));
141 if (head == nullptr) {
142 *errorCode = CJ_ERR_NO_MEMORY;
143 return CArrAudioCapturerChangeInfo();
144 }
145 arrInfo.head = head;
146 if (memset_s(head, arrInfo.size, 0, arrInfo.size) != EOK) {
147 free(head);
148 *errorCode = CJ_ERR_SYSTEM;
149 return CArrAudioCapturerChangeInfo();
150 }
151 for (int32_t i = 0; i < static_cast<int32_t>(audioCapturerChangeInfos.size()); i++) {
152 Convert2CAudioCapturerChangeInfo(head[i], *(audioCapturerChangeInfos[i]), errorCode);
153 if (*errorCode != SUCCESS_CODE) {
154 FreeCArrAudioCapturerChangeInfo(arrInfo);
155 *errorCode = CJ_ERR_SYSTEM;
156 return CArrAudioCapturerChangeInfo();
157 }
158 }
159 return arrInfo;
160 }
161
RegisterCallback(int32_t callbackType,void (* callback)(),int32_t * errorCode)162 void MMAAudioStreamManagerImpl::RegisterCallback(int32_t callbackType, void (*callback)(), int32_t* errorCode)
163 {
164 if (callbackType == AudioStreamManagerCallbackType::CAPTURER_CHANGE) {
165 auto func = CJLambda::Create(reinterpret_cast<void (*)(CArrAudioCapturerChangeInfo)>(callback));
166 if (func == nullptr) {
167 AUDIO_ERR_LOG("AudioCapturerChangeInfo event created failure!");
168 *errorCode = CJ_ERR_SYSTEM;
169 return;
170 }
171 callback_->RegisterFunc(func);
172 int32_t ret = streamMgr_->RegisterAudioCapturerEventListener(cachedClientId_, callback_);
173 if (ret != SUCCESS_CODE) {
174 AUDIO_ERR_LOG("Register AudioCapturerChangeInfo event failure!");
175 *errorCode = CJ_ERR_SYSTEM;
176 return;
177 }
178 }
179 if (callbackType == AudioStreamManagerCallbackType::RENDERER_CHANGE) {
180 auto func = CJLambda::Create(reinterpret_cast<void (*)(CArrAudioRendererChangeInfo)>(callback));
181 if (func == nullptr) {
182 AUDIO_ERR_LOG("AudioRendererChangeInfo event created failure!");
183 *errorCode = CJ_ERR_SYSTEM;
184 return;
185 }
186 callbackRenderer_->RegisterFunc(func);
187 int32_t ret = streamMgr_->RegisterAudioRendererEventListener(cachedClientId_, callbackRenderer_);
188 if (ret != SUCCESS_CODE) {
189 AUDIO_ERR_LOG("Register AudioRendererChangeInfo event failure!");
190 *errorCode = CJ_ERR_SYSTEM;
191 }
192 }
193 }
194 }
195 } // namespace AudioStandard
196 } // namespace OHOS
197