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