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 #include "audio_manager_base.h"
17 #include "audio_system_manager.h"
18 #include "audio_log.h"
19 #include "i_audio_process.h"
20 #include "audio_effect_server.h"
21
22 using namespace std;
23
24 namespace OHOS {
25 namespace AudioStandard {
LoadEffectLibrariesReadData(vector<Library> & libList,vector<Effect> & effectList,MessageParcel & data,int32_t countLib,int32_t countEff)26 static void LoadEffectLibrariesReadData(vector<Library>& libList, vector<Effect>& effectList, MessageParcel &data,
27 int32_t countLib, int32_t countEff)
28 {
29 int32_t i;
30 for (i = 0; i < countLib; i++) {
31 string libName = data.ReadString();
32 string libPath = data.ReadString();
33 libList.push_back({libName, libPath});
34 }
35 for (i = 0; i < countEff; i++) {
36 string effectName = data.ReadString();
37 string libName = data.ReadString();
38 effectList.push_back({effectName, libName});
39 }
40 }
41
LoadEffectLibrariesWriteReply(const vector<Effect> & successEffectList,MessageParcel & reply)42 static void LoadEffectLibrariesWriteReply(const vector<Effect>& successEffectList, MessageParcel &reply)
43 {
44 reply.WriteInt32(successEffectList.size());
45 for (Effect effect: successEffectList) {
46 reply.WriteString(effect.name);
47 reply.WriteString(effect.libraryName);
48 }
49 }
50
OnRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)51 int AudioManagerStub::OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option)
52 {
53 AUDIO_DEBUG_LOG("OnRemoteRequest, cmd = %{public}u", code);
54 if (data.ReadInterfaceToken() != GetDescriptor()) {
55 AUDIO_ERR_LOG("AudioManagerStub: ReadInterfaceToken failed");
56 return -1;
57 }
58
59 switch (code) {
60 case static_cast<uint32_t>(AudioServerInterfaceCode::SET_AUDIO_PARAMETER): {
61 AUDIO_DEBUG_LOG("SET_AUDIO_PARAMETER AudioManagerStub");
62 const std::string key = data.ReadString();
63 const std::string value = data.ReadString();
64 AUDIO_DEBUG_LOG("SET_AUDIO_PARAMETER key-value pair from client= %{public}s, %{public}s",
65 key.c_str(), value.c_str());
66 SetAudioParameter(key, value);
67 return AUDIO_OK;
68 }
69 case static_cast<uint32_t>(AudioServerInterfaceCode::GET_AUDIO_PARAMETER): {
70 AUDIO_DEBUG_LOG("GET_AUDIO_PARAMETER AudioManagerStub");
71 const std::string key = data.ReadString();
72 AUDIO_DEBUG_LOG("GET_AUDIO_PARAMETER key received from client= %{public}s", key.c_str());
73 const std::string value = GetAudioParameter(key);
74 reply.WriteString(value);
75 return AUDIO_OK;
76 }
77 case static_cast<uint32_t>(AudioServerInterfaceCode::RETRIEVE_COOKIE): {
78 AUDIO_DEBUG_LOG("RETRIEVE_COOKIE AudioManagerStub");
79 int32_t size = 0;
80 const char *cookieInfo = RetrieveCookie(size);
81 reply.WriteInt32(size);
82 if (size > 0) {
83 AUDIO_DEBUG_LOG("cookie received from server");
84 reply.WriteRawData(static_cast<const void *>(cookieInfo), size);
85 free((void *)cookieInfo);
86 cookieInfo = nullptr;
87 }
88 return AUDIO_OK;
89 }
90 case static_cast<uint32_t>(AudioServerInterfaceCode::GET_TRANSACTION_ID): {
91 AUDIO_DEBUG_LOG("GET_TRANSACTION_ID AudioManagerStub");
92 DeviceType deviceType = (static_cast<DeviceType>(data.ReadInt32()));
93 DeviceRole deviceRole = (static_cast<DeviceRole>(data.ReadInt32()));
94 uint64_t transactionId = GetTransactionId(deviceType, deviceRole);
95
96 reply.WriteUint64(transactionId);
97
98 return AUDIO_OK;
99 }
100 case static_cast<uint32_t>(AudioServerInterfaceCode::SET_MICROPHONE_MUTE): {
101 AUDIO_DEBUG_LOG("SET_MICROPHONE_MUTE AudioManagerStub");
102 bool isMute = data.ReadBool();
103 AUDIO_DEBUG_LOG("SET_MICROPHONE_MUTE isMute value from client= %{public}d", isMute);
104 int32_t result = SetMicrophoneMute(isMute);
105 reply.WriteInt32(result);
106 return AUDIO_OK;
107 }
108 case static_cast<uint32_t>(AudioServerInterfaceCode::IS_MICROPHONE_MUTE): {
109 AUDIO_DEBUG_LOG("IS_MICROPHONE_MUTE AudioManagerStub");
110 bool isMute = IsMicrophoneMute();
111 reply.WriteBool(isMute);
112 return AUDIO_OK;
113 }
114 case static_cast<uint32_t>(AudioServerInterfaceCode::SET_AUDIO_SCENE): {
115 AUDIO_DEBUG_LOG("SET_AUDIO_SCENE AudioManagerStub");
116 AudioScene audioScene = (static_cast<AudioScene>(data.ReadInt32()));
117 DeviceType activeDevice = (static_cast<DeviceType>(data.ReadInt32()));
118 int32_t result = SetAudioScene(audioScene, activeDevice);
119 reply.WriteInt32(result);
120 return AUDIO_OK;
121 }
122 case static_cast<uint32_t>(AudioServerInterfaceCode::UPDATE_ROUTE_REQ): {
123 AUDIO_DEBUG_LOG("UPDATE_ROUTE_REQ AudioManagerStub");
124 DeviceType type = static_cast<DeviceType>(data.ReadInt32());
125 DeviceFlag flag = static_cast<DeviceFlag>(data.ReadInt32());
126 int32_t ret = UpdateActiveDeviceRoute(type, flag);
127 reply.WriteInt32(ret);
128 return AUDIO_OK;
129 }
130 case static_cast<uint32_t>(AudioServerInterfaceCode::SET_PARAMETER_CALLBACK): {
131 AUDIO_DEBUG_LOG("SET_PARAMETER_CALLBACK AudioManagerStub");
132 sptr<IRemoteObject> object = data.ReadRemoteObject();
133 if (object == nullptr) {
134 AUDIO_ERR_LOG("AudioManagerStub: SET_PARAMETER_CALLBACK obj is null");
135 return AUDIO_ERR;
136 }
137 int32_t result = SetParameterCallback(object);
138 reply.WriteInt32(result);
139 return AUDIO_OK;
140 }
141 case static_cast<uint32_t>(AudioServerInterfaceCode::SET_WAKEUP_CLOSE_CALLBACK): {
142 AUDIO_DEBUG_LOG("SET_WAKEUP_CLOSE_CALLBACK AudioManagerStub");
143 sptr<IRemoteObject> object = data.ReadRemoteObject();
144 if (object == nullptr) {
145 AUDIO_ERR_LOG("AudioManagerStub: SET_WAKEUP_CLOSE_CALLBACK obj is null");
146 return AUDIO_ERR;
147 }
148 int32_t result = SetWakeupSourceCallback(object);
149 reply.WriteInt32(result);
150 return AUDIO_OK;
151 }
152 case static_cast<uint32_t>(AudioServerInterfaceCode::SET_REMOTE_AUDIO_PARAMETER): {
153 AUDIO_DEBUG_LOG("SET_AUDIO_PARAMETER AudioManagerStub");
154 const std::string networkId = data.ReadString();
155 AudioParamKey key = static_cast<AudioParamKey>(data.ReadInt32());
156 const std::string condtion = data.ReadString();
157 const std::string value = data.ReadString();
158 AUDIO_DEBUG_LOG("SET_AUDIO_PARAMETER key-value pair from client= %{public}d, %{public}s",
159 key, value.c_str());
160 SetAudioParameter(networkId, key, condtion, value);
161 return AUDIO_OK;
162 }
163 case static_cast<uint32_t>(AudioServerInterfaceCode::GET_REMOTE_AUDIO_PARAMETER): {
164 AUDIO_DEBUG_LOG("GET_AUDIO_PARAMETER AudioManagerStub");
165 const std::string networkId = data.ReadString();
166 AudioParamKey key = static_cast<AudioParamKey>(data.ReadInt32());
167 const std::string condition = data.ReadString();
168 AUDIO_DEBUG_LOG("GET_AUDIO_PARAMETER key received from client= %{public}d", key);
169 const std::string value = GetAudioParameter(networkId, key, condition);
170 reply.WriteString(value);
171 return AUDIO_OK;
172 }
173 case static_cast<uint32_t>(AudioServerInterfaceCode::NOTIFY_DEVICE_INFO): {
174 AUDIO_DEBUG_LOG("NOTIFY_DEVICE_INFO AudioManagerStub");
175 const std::string networkId = data.ReadString();
176 const bool connected = data.ReadBool();
177 NotifyDeviceInfo(networkId, connected);
178 return AUDIO_OK;
179 }
180 case static_cast<uint32_t>(AudioServerInterfaceCode::CHECK_REMOTE_DEVICE_STATE): {
181 AUDIO_DEBUG_LOG("CHECK_REMOTE_DEVICE_STATE AudioManagerStub");
182 std::string networkId = data.ReadString();
183 DeviceRole deviceRole = static_cast<DeviceRole>(data.ReadInt32());
184 bool isStartDevice = data.ReadBool();
185 int32_t result = CheckRemoteDeviceState(networkId, deviceRole, isStartDevice);
186 reply.WriteInt32(result);
187 return AUDIO_OK;
188 }
189 case static_cast<uint32_t>(AudioServerInterfaceCode::SET_VOICE_VOLUME): {
190 AUDIO_DEBUG_LOG("SET_VOICE_VOLUME AudioManagerStub");
191 const float volume = data.ReadFloat();
192 int32_t result = SetVoiceVolume(volume);
193 reply.WriteInt32(result);
194 return AUDIO_OK;
195 }
196 case static_cast<uint32_t>(AudioServerInterfaceCode::SET_AUDIO_MONO_STATE): {
197 AUDIO_DEBUG_LOG("SET_AUDIO_MONO_STATE AudioManagerStub");
198 bool audioMonoState = data.ReadBool();
199 SetAudioMonoState(audioMonoState);
200 return AUDIO_OK;
201 }
202 case static_cast<uint32_t>(AudioServerInterfaceCode::SET_AUDIO_BALANCE_VALUE): {
203 AUDIO_DEBUG_LOG("SET_AUDIO_BALANCE_VALUE AudioManagerStub");
204 float audioBalanceValue = data.ReadFloat();
205 SetAudioBalanceValue(audioBalanceValue);
206 return AUDIO_OK;
207 }
208 case static_cast<uint32_t>(AudioServerInterfaceCode::CREATE_AUDIOPROCESS): {
209 AUDIO_DEBUG_LOG("CREATE_AUDIOPROCESS AudioManagerStub");
210 AudioProcessConfig config;
211 ProcessConfig::ReadConfigFromParcel(config, data);
212 sptr<IRemoteObject> process = CreateAudioProcess(config);
213 if (process == nullptr) {
214 AUDIO_ERR_LOG("CREATE_AUDIOPROCESS AudioManagerStub CreateAudioProcess failed");
215 return AUDIO_ERR;
216 }
217 reply.WriteRemoteObject(process);
218 return AUDIO_OK;
219 }
220 case static_cast<uint32_t>(AudioServerInterfaceCode::LOAD_AUDIO_EFFECT_LIBRARIES): {
221 vector<Library> libList = {};
222 vector<Effect> effectList = {};
223 int32_t countLib = data.ReadInt32();
224 int32_t countEff = data.ReadInt32();
225 if ((countLib < 0) || (countLib > AUDIO_EFFECT_COUNT_UPPER_LIMIT) ||
226 (countEff < 0) || (countEff > AUDIO_EFFECT_COUNT_UPPER_LIMIT)) {
227 AUDIO_ERR_LOG("LOAD_AUDIO_EFFECT_LIBRARIES read data failed");
228 return AUDIO_ERR;
229 }
230 LoadEffectLibrariesReadData(libList, effectList, data, countLib, countEff);
231 if (countLib > 0) {
232 //load lib and reply success list
233 vector<Effect> successEffectList = {};
234 bool loadSuccess = LoadAudioEffectLibraries(libList, effectList, successEffectList);
235 if (!loadSuccess) {
236 AUDIO_ERR_LOG("Load audio effect libraries failed, please check log");
237 return AUDIO_ERR;
238 }
239 LoadEffectLibrariesWriteReply(successEffectList, reply);
240 }
241 return AUDIO_OK;
242 }
243 case static_cast<uint32_t>(AudioServerInterfaceCode::REQUEST_THREAD_PRIORITY): {
244 uint32_t tid = data.ReadUint32();
245 string bundleName = data.ReadString();
246 RequestThreadPriority(tid, bundleName);
247 return AUDIO_OK;
248 }
249 case static_cast<uint32_t>(AudioServerInterfaceCode::CREATE_AUDIO_EFFECT_CHAIN_MANAGER): {
250 int32_t i;
251 vector<EffectChain> effectChains = {};
252 vector<int32_t> countEffect = {};
253 int32_t countChains = data.ReadInt32();
254 CHECK_AND_RETURN_RET_LOG(countChains >= 0 && countChains <= AUDIO_EFFECT_CHAIN_COUNT_UPPER_LIMIT,
255 AUDIO_ERR, "Create audio effect chain manager failed, please check log");
256 for (i = 0; i < countChains; i++) {
257 int32_t count = data.ReadInt32();
258 CHECK_AND_RETURN_RET_LOG(count >= 0 && count <= AUDIO_EFFECT_COUNT_PER_CHAIN_UPPER_LIMIT,
259 AUDIO_ERR, "Create audio effect chain manager failed, please check log");
260 countEffect.emplace_back(count);
261 }
262
263 for (int32_t count: countEffect) {
264 EffectChain effectChain;
265 effectChain.name = data.ReadString();
266 for (i = 0; i < count; i++) {
267 effectChain.apply.emplace_back(data.ReadString());
268 }
269 effectChains.emplace_back(effectChain);
270 }
271
272 unordered_map<string, string> sceneTypeToEffectChainNameMap;
273 int32_t mapSize = data.ReadInt32();
274 CHECK_AND_RETURN_RET_LOG(mapSize >= 0 && mapSize <= AUDIO_EFFECT_CHAIN_CONFIG_UPPER_LIMIT,
275 AUDIO_ERR, "Create audio effect chain manager failed, please check log");
276 for (i = 0; i < mapSize; i++) {
277 string key = data.ReadString();
278 string value = data.ReadString();
279 sceneTypeToEffectChainNameMap[key] = value;
280 }
281
282 bool createSuccess = CreateEffectChainManager(effectChains, sceneTypeToEffectChainNameMap);
283 if (!createSuccess) {
284 AUDIO_ERR_LOG("Create audio effect chain manager failed, please check log");
285 return AUDIO_ERR;
286 }
287 return AUDIO_OK;
288 }
289 case static_cast<uint32_t>(AudioServerInterfaceCode::SET_OUTPUT_DEVICE_SINK): {
290 int32_t deviceType = data.ReadInt32();
291 CHECK_AND_RETURN_RET_LOG(deviceType >= DEVICE_TYPE_NONE && deviceType <= DEVICE_TYPE_MAX, AUDIO_ERR,
292 "Set output device sink failed, please check log");
293 std::string sinkName = data.ReadString();
294 bool ret = SetOutputDeviceSink(deviceType, sinkName);
295 if (!ret) {
296 AUDIO_ERR_LOG("Set output device sink failed, please check log");
297 return AUDIO_ERR;
298 }
299 return AUDIO_OK;
300 }
301 case static_cast<uint32_t>(AudioServerInterfaceCode::CREATE_PLAYBACK_CAPTURER_MANAGER): {
302 bool ret = CreatePlaybackCapturerManager();
303 reply.WriteBool(ret);
304 return AUDIO_OK;
305 }
306 case static_cast<uint32_t>(AudioServerInterfaceCode::SET_SUPPORT_STREAM_USAGE): {
307 vector<int32_t> usage;
308 size_t cnt = static_cast<size_t>(data.ReadInt32());
309 CHECK_AND_RETURN_RET_LOG(cnt <= AUDIO_SUPPORTED_STREAM_USAGES.size(), AUDIO_ERR,
310 "Set support stream usage failed, please check");
311 for (size_t i = 0; i < cnt; i++) {
312 int32_t tmp_usage = data.ReadInt32();
313 if (find(AUDIO_SUPPORTED_STREAM_USAGES.begin(), AUDIO_SUPPORTED_STREAM_USAGES.end(), tmp_usage) ==
314 AUDIO_SUPPORTED_STREAM_USAGES.end()) {
315 continue;
316 }
317 usage.emplace_back(tmp_usage);
318 }
319 int32_t ret = SetSupportStreamUsage(usage);
320 reply.WriteInt32(ret);
321 return AUDIO_OK;
322 }
323 case static_cast<uint32_t>(AudioServerInterfaceCode::REGISET_POLICY_PROVIDER): {
324 AUDIO_DEBUG_LOG("REGISET_POLICY_PROVIDER AudioManagerStub");
325 sptr<IRemoteObject> object = data.ReadRemoteObject();
326 if (object == nullptr) {
327 AUDIO_ERR_LOG("AudioManagerStub: REGISET_POLICY_PROVIDER obj is null");
328 return AUDIO_ERR;
329 }
330 int32_t result = RegiestPolicyProvider(object);
331 reply.WriteInt32(result);
332 return AUDIO_OK;
333 }
334 case static_cast<uint32_t>(AudioServerInterfaceCode::SET_CAPTURE_SILENT_STATE): {
335 bool state = false;
336 int32_t flag = data.ReadInt32();
337 if (flag == 1) {
338 state = true;
339 }
340 int32_t ret = SetCaptureSilentState(state);
341 reply.WriteInt32(ret);
342 return AUDIO_OK;
343 }
344 default: {
345 AUDIO_ERR_LOG("default case, need check AudioManagerStub");
346 return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
347 }
348 }
349 }
350 } // namespace AudioStandard
351 } // namespace OHOS
352