1 /*
2 * Copyright (C) 2024 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 #define MLOG_TAG "EnhancementServiceAdapter"
17
18 #include "enhancement_service_adapter.h"
19
20 #include "ipc_skeleton.h"
21 #include "media_log.h"
22 #include "medialibrary_errno.h"
23 #include <dlfcn.h>
24 #include "dynamic_loader.h"
25 #include "enhancement_service_callback.h"
26 #include "cloud_enhancement_dfx_get_count.h"
27
28 using namespace std;
29 #ifdef ABILITY_CLOUD_ENHANCEMENT_SUPPORT
30 using namespace OHOS::MediaEnhance;
31 #endif
32
33 namespace OHOS {
34 namespace Media {
35 #ifdef ABILITY_CLOUD_ENHANCEMENT_SUPPORT
36 MediaEnhanceClientHandle* clientWrapper = nullptr;
37 mutex EnhancementServiceAdapter::mtx_;
38
39 using CreateMCEClient = MediaEnhanceClientHandle* (*)(MediaEnhance_TASK_TYPE taskType);
40 using DestroyMCEClient = void (*)(MediaEnhanceClientHandle* client);
41
42 using CreateMCEBundle = MediaEnhanceBundleHandle* (*)();
43 using DestroyMCEBundle = void (*)(MediaEnhanceBundleHandle* bundle);
44
45 using BundleHandleGetInt = int32_t (*)(MediaEnhanceBundleHandle* bundle, const char* key, uint32_t keyLen);
46 using BundleHandleGetResBuffer = int32_t (*)(MediaEnhanceBundleHandle* bundle, Raw_Data** rawDatas, uint32_t* size);
47 using BundleHandlePutInt = void (*)(MediaEnhanceBundleHandle* bundle, const char* key, uint32_t keyLen, int32_t value);
48 using BundleHandlePutString = void (*)(MediaEnhanceBundleHandle* bundle, const char* key, uint32_t keyLen,
49 const char* value, uint32_t valueLen);
50 using BundleDeleteRawData = void (*)(Raw_Data* rawDatas, uint32_t size);
51
52 using ClientLoadSA = int32_t (*)(MediaEnhanceClientHandle* client);
53 using ClientIsConnected = bool (*)(MediaEnhanceClientHandle* client);
54 using ClientAddTask = int32_t (*)(MediaEnhanceClientHandle* client, const char* taskId, uint32_t taskIdLen,
55 MediaEnhanceBundleHandle* bundle);
56 using ClientSetResultCallback = int32_t (*)(MediaEnhanceClientHandle* client, MediaEnhance_Callbacks* callbacks);
57 using ClientGetPendingTask = int32_t (*)(MediaEnhanceClientHandle* client, Pending_Task** taskIdList, uint32_t* size);
58 using ClientDeletePendingTask = void (*)(Pending_Task* taskIdList, uint32_t size);
59 using ClientStopService = int32_t (*)(MediaEnhanceClientHandle* client);
60 using ClientCancelTask = int32_t (*)(MediaEnhanceClientHandle* client, const char* taskId, uint32_t taskIdLen);
61 using ClientRemoveTask = int32_t (*)(MediaEnhanceClientHandle* client, const char* taskId, uint32_t taskIdLen);
62 using ClientPauseAllTasks = int32_t (*)(MediaEnhanceClientHandle* client,
63 MediaEnhanceBundleHandle* bundle);
64 using ClientResumeAllTasks = int32_t (*)(MediaEnhanceClientHandle* client,
65 MediaEnhanceBundleHandle* bundle);
66
67 CreateMCEClient createMCEClientFunc = nullptr;
68 DestroyMCEClient destroyMCEClientFunc = nullptr;
69
70 ClientLoadSA clientLoadSaFunc = nullptr;
71 ClientIsConnected clientIsConnectedFunc = nullptr;
72 ClientAddTask clientAddTaskFunc = nullptr;
73 ClientSetResultCallback clientSetResultCallback = nullptr;
74 ClientGetPendingTask clientGetPendingTask = nullptr;
75 ClientDeletePendingTask clientDeletePendingTask = nullptr;
76 ClientStopService clientStopServiceFunc = nullptr;
77 ClientCancelTask clientCancelTaskFunc = nullptr;
78 ClientRemoveTask clientRemoveTaskFunc = nullptr;
79 ClientPauseAllTasks clientPauseAllTasksFunc = nullptr;
80 ClientResumeAllTasks clientResumeAllTasksFunc = nullptr;
81
82 CreateMCEBundle createMCEBundleFunc = nullptr;
83 DestroyMCEBundle destroyMCEBundleFunc = nullptr;
84
85 BundleHandleGetInt bundleHandleGetIntFunc = nullptr;
86 BundleHandleGetResBuffer bundleGetResBufferFunc = nullptr;
87 BundleHandlePutInt bundleHandlePutIntFunc = nullptr;
88 BundleHandlePutString bundleHandlePutStringFunc = nullptr;
89 BundleDeleteRawData bundleDeleteRawData = nullptr;
90
91 shared_ptr<DynamicLoader> EnhancementServiceAdapter::dynamicLoader_
92 = make_shared<DynamicLoader>();
93
ClientFuncInit()94 void EnhancementServiceAdapter::ClientFuncInit()
95 {
96 createMCEClientFunc = (CreateMCEClient)dynamicLoader_->GetFunction(MEDIA_CLOUD_ENHANCE_LIB_SO,
97 "CreateMediaEnhanceClient");
98 if (createMCEClientFunc == nullptr) {
99 MEDIA_ERR_LOG("CreateMediaEnhanceClient dlsym failed.error:%{public}s", dlerror());
100 return;
101 }
102
103 destroyMCEClientFunc = (DestroyMCEClient)dynamicLoader_->GetFunction(MEDIA_CLOUD_ENHANCE_LIB_SO,
104 "DestroyMediaEnhanceClient");
105 if (destroyMCEClientFunc == nullptr) {
106 MEDIA_ERR_LOG("DestroyMediaEnhanceClient dlsym failed.error:%{public}s", dlerror());
107 return;
108 }
109
110 clientLoadSaFunc = (ClientLoadSA)dynamicLoader_->GetFunction(MEDIA_CLOUD_ENHANCE_LIB_SO,
111 "MediaEnhanceClient_LoadSA");
112 if (clientLoadSaFunc == nullptr) {
113 MEDIA_ERR_LOG("MediaEnhanceClient_LoadSA dlsym failed.error:%{public}s", dlerror());
114 return;
115 }
116
117 clientIsConnectedFunc = (ClientIsConnected)dynamicLoader_->GetFunction(MEDIA_CLOUD_ENHANCE_LIB_SO,
118 "MediaEnhanceClient_IsConnected");
119 if (clientIsConnectedFunc == nullptr) {
120 MEDIA_ERR_LOG("MediaEnhanceClient_IsConnected dlsym failed.error:%{public}s", dlerror());
121 return;
122 }
123
124 clientSetResultCallback = (ClientSetResultCallback)dynamicLoader_->GetFunction(MEDIA_CLOUD_ENHANCE_LIB_SO,
125 "MediaEnhanceClient_SetResultCallback");
126 if (clientSetResultCallback == nullptr) {
127 MEDIA_ERR_LOG("MediaEnhanceClient_SetResultCallback dlsym failed.error:%{public}s", dlerror());
128 return;
129 }
130 }
131
TaskFuncInit()132 void EnhancementServiceAdapter::TaskFuncInit()
133 {
134 clientAddTaskFunc = (ClientAddTask)dynamicLoader_->GetFunction(MEDIA_CLOUD_ENHANCE_LIB_SO,
135 "MediaEnhanceClient_AddTask");
136 if (clientAddTaskFunc == nullptr) {
137 MEDIA_ERR_LOG("MediaEnhanceClient_AddTask dlsym failed.error:%{public}s", dlerror());
138 return;
139 }
140
141 clientGetPendingTask = (ClientGetPendingTask)dynamicLoader_->GetFunction(MEDIA_CLOUD_ENHANCE_LIB_SO,
142 "MediaEnhanceClient_GetPendingTasks");
143 if (clientGetPendingTask == nullptr) {
144 MEDIA_ERR_LOG("MediaEnhanceClient_GetPendingTasks dlsym failed. error:%{public}s", dlerror());
145 return;
146 }
147
148 clientDeletePendingTask = (ClientDeletePendingTask)dynamicLoader_->GetFunction(MEDIA_CLOUD_ENHANCE_LIB_SO,
149 "MediaEnhance_DeletePendingTasks");
150 if (clientDeletePendingTask == nullptr) {
151 MEDIA_ERR_LOG("MediaEnhance_DeletePendingTasks dlsym failed. error:%{public}s", dlerror());
152 return;
153 }
154
155 clientStopServiceFunc = (ClientStopService)dynamicLoader_->GetFunction(MEDIA_CLOUD_ENHANCE_LIB_SO,
156 "MediaEnhanceClient_StopService");
157 if (clientStopServiceFunc == nullptr) {
158 MEDIA_ERR_LOG("MediaEnhanceClient_StopService dlsym failed. error:%{public}s", dlerror());
159 return;
160 }
161
162 clientCancelTaskFunc = (ClientCancelTask)dynamicLoader_->GetFunction(MEDIA_CLOUD_ENHANCE_LIB_SO,
163 "MediaEnhanceClient_CancelTask");
164 if (clientCancelTaskFunc == nullptr) {
165 MEDIA_ERR_LOG("MediaEnhanceClient_CancelTask dlsym failed. error:%{public}s", dlerror());
166 return;
167 }
168
169 clientRemoveTaskFunc = (ClientRemoveTask)dynamicLoader_->GetFunction(MEDIA_CLOUD_ENHANCE_LIB_SO,
170 "MediaEnhanceClient_RemoveTask");
171 if (clientRemoveTaskFunc == nullptr) {
172 MEDIA_ERR_LOG("MediaEnhanceClient_RemoveTask dlsym failed. error:%{public}s", dlerror());
173 return;
174 }
175
176 clientPauseAllTasksFunc = (ClientPauseAllTasks)dynamicLoader_->GetFunction(MEDIA_CLOUD_ENHANCE_LIB_SO,
177 "MediaEnhanceClient_PauseAllTasks");
178 if (clientPauseAllTasksFunc == nullptr) {
179 MEDIA_ERR_LOG("MediaEnhanceClient_PauseAllTasks dlsym failed.error:%{public}s", dlerror());
180 return;
181 }
182
183 clientResumeAllTasksFunc = (ClientResumeAllTasks)dynamicLoader_->GetFunction(MEDIA_CLOUD_ENHANCE_LIB_SO,
184 "MediaEnhanceClient_ResumeAllTasks");
185 if (clientResumeAllTasksFunc == nullptr) {
186 MEDIA_ERR_LOG("MediaEnhanceClient_ResumeAllTasks dlsym failed.error:%{public}s", dlerror());
187 return;
188 }
189 }
190
BundleFuncInit()191 void EnhancementServiceAdapter::BundleFuncInit()
192 {
193 bundleHandleGetIntFunc = (BundleHandleGetInt)dynamicLoader_->GetFunction(MEDIA_CLOUD_ENHANCE_LIB_SO,
194 "MediaEnhanceBundle_GetInt");
195 if (bundleHandleGetIntFunc == nullptr) {
196 MEDIA_ERR_LOG("MediaEnhanceBundle_GetInt dlsym failed. error:%{public}s", dlerror());
197 return;
198 }
199
200 bundleGetResBufferFunc = (BundleHandleGetResBuffer)dynamicLoader_->GetFunction(MEDIA_CLOUD_ENHANCE_LIB_SO,
201 "MediaEnhanceBundle_GetResultBuffers");
202 if (bundleGetResBufferFunc == nullptr) {
203 MEDIA_ERR_LOG("MediaEnhanceBundle_GetResultBuffers dlsym failed. error:%{public}s", dlerror());
204 return;
205 }
206
207 bundleHandlePutIntFunc = (BundleHandlePutInt)dynamicLoader_->GetFunction(MEDIA_CLOUD_ENHANCE_LIB_SO,
208 "MediaEnhanceBundle_PutInt");
209 if (bundleHandlePutIntFunc == nullptr) {
210 MEDIA_ERR_LOG("MediaEnhanceBundle_PutInt dlsym failed. error:%{public}s", dlerror());
211 return;
212 }
213
214 bundleHandlePutStringFunc = (BundleHandlePutString)dynamicLoader_->GetFunction(MEDIA_CLOUD_ENHANCE_LIB_SO,
215 "MediaEnhanceBundle_PutString");
216 if (bundleHandlePutStringFunc == nullptr) {
217 MEDIA_ERR_LOG("MediaEnhanceBundle_PutString dlsym failed. error:%{public}s", dlerror());
218 return;
219 }
220
221 bundleDeleteRawData = (BundleDeleteRawData)dynamicLoader_->GetFunction(MEDIA_CLOUD_ENHANCE_LIB_SO,
222 "MediaEnhance_DeleteRawDataList");
223 if (bundleDeleteRawData == nullptr) {
224 MEDIA_ERR_LOG("MediaEnhance_DeleteRawDataList dlsym failed. error:%{public}s", dlerror());
225 return;
226 }
227 }
228
InitEnhancementClient(MediaEnhance_TASK_TYPE taskType)229 void EnhancementServiceAdapter::InitEnhancementClient(MediaEnhance_TASK_TYPE taskType)
230 {
231 if (createMCEClientFunc == nullptr) {
232 createMCEClientFunc = (CreateMCEClient)dynamicLoader_->GetFunction(MEDIA_CLOUD_ENHANCE_LIB_SO,
233 "CreateMediaEnhanceClient");
234 }
235 if (createMCEClientFunc == nullptr) {
236 MEDIA_ERR_LOG("CreateMediaEnhanceClient dlsym failed.error:%{public}s", dlerror());
237 return;
238 }
239 if (clientWrapper == nullptr && createMCEClientFunc != nullptr) {
240 MEDIA_INFO_LOG("createMCEClientFunc by dlopen func.");
241 clientWrapper = createMCEClientFunc(taskType);
242 }
243 }
244
DestroyEnhancementClient()245 void EnhancementServiceAdapter::DestroyEnhancementClient()
246 {
247 if (destroyMCEClientFunc == nullptr) {
248 destroyMCEClientFunc = (DestroyMCEClient)dynamicLoader_->GetFunction(MEDIA_CLOUD_ENHANCE_LIB_SO,
249 "DestroyMediaEnhanceClient");
250 }
251 if (destroyMCEClientFunc == nullptr) {
252 MEDIA_ERR_LOG("DestroyMediaEnhanceClient dlsym failed.error:%{public}s", dlerror());
253 return;
254 }
255 destroyMCEClientFunc(clientWrapper);
256 clientWrapper = nullptr;
257 }
258 #endif
259
EnhancementServiceAdapter()260 EnhancementServiceAdapter::EnhancementServiceAdapter()
261 {
262 #ifdef ABILITY_CLOUD_ENHANCEMENT_SUPPORT
263 ClientFuncInit();
264 TaskFuncInit();
265 BundleFuncInit();
266 LoadEnhancementService();
267 #else
268 MEDIA_ERR_LOG("not supply cloud enhancement service");
269 #endif
270 }
271
~EnhancementServiceAdapter()272 EnhancementServiceAdapter::~EnhancementServiceAdapter()
273 {
274 #ifdef ABILITY_CLOUD_ENHANCEMENT_SUPPORT
275 createMCEClientFunc = nullptr;
276 destroyMCEClientFunc = nullptr;
277 clientLoadSaFunc = nullptr;
278 clientIsConnectedFunc = nullptr;
279 clientAddTaskFunc = nullptr;
280 clientSetResultCallback = nullptr;
281 clientGetPendingTask = nullptr;
282 clientDeletePendingTask = nullptr;
283 clientStopServiceFunc = nullptr;
284 clientCancelTaskFunc = nullptr;
285 clientRemoveTaskFunc = nullptr;
286 createMCEBundleFunc = nullptr;
287 destroyMCEBundleFunc = nullptr;
288 bundleHandleGetIntFunc = nullptr;
289 bundleGetResBufferFunc = nullptr;
290 bundleHandlePutIntFunc = nullptr;
291 bundleHandlePutStringFunc = nullptr;
292 bundleDeleteRawData = nullptr;
293 clientPauseAllTasksFunc = nullptr;
294 clientResumeAllTasksFunc = nullptr;
295 DestroyEnhancementClient();
296 #else
297 MEDIA_ERR_LOG("not supply cloud enhancement service");
298 #endif
299 }
300
301 #ifdef ABILITY_CLOUD_ENHANCEMENT_SUPPORT
SetResultCallback()302 int32_t EnhancementServiceAdapter::SetResultCallback()
303 {
304 if (clientWrapper == nullptr) {
305 MEDIA_ERR_LOG("clientWrapper is nullptr!");
306 return E_ERR;
307 }
308 MediaEnhance_Callbacks callbacks = {
309 .onSuccessFunc = &EnhancementServiceCallback::OnSuccess,
310 .onFailedFunc = &EnhancementServiceCallback::OnFailed,
311 .onSAReconnectedFunc = &EnhancementServiceCallback::OnServiceReconnected,
312 };
313 if (clientSetResultCallback == nullptr) {
314 clientSetResultCallback = (ClientSetResultCallback)dynamicLoader_->GetFunction(MEDIA_CLOUD_ENHANCE_LIB_SO,
315 "MediaEnhanceClient_SetResultCallback");
316 }
317 if (clientSetResultCallback == nullptr) {
318 MEDIA_ERR_LOG("MediaEnhanceClient_SetResultCallback dlsym failed.error:%{public}s", dlerror());
319 return E_ERR;
320 }
321 int32_t ret = clientSetResultCallback(clientWrapper, &callbacks);
322 if (ret != E_OK) {
323 MEDIA_ERR_LOG("Enhancement Service clientSetResultCallback failed:%{public}d", ret);
324 }
325 return ret;
326 }
327
LoadSA()328 int32_t EnhancementServiceAdapter::LoadSA()
329 {
330 if (clientWrapper == nullptr) {
331 MEDIA_ERR_LOG("clientWrapper is nullptr!");
332 return E_ERR;
333 }
334 if (clientLoadSaFunc == nullptr) {
335 clientLoadSaFunc = (ClientLoadSA)dynamicLoader_->GetFunction(MEDIA_CLOUD_ENHANCE_LIB_SO,
336 "MediaEnhanceClient_LoadSA");
337 }
338 if (clientLoadSaFunc == nullptr) {
339 MEDIA_ERR_LOG("MediaEnhanceClient_LoadSA dlsym failed.error:%{public}s", dlerror());
340 return E_ERR;
341 }
342 int32_t ret = clientLoadSaFunc(clientWrapper);
343 if (ret != E_OK) {
344 MEDIA_ERR_LOG("Enhancement Service LoadSA failed:%{public}d", ret);
345 }
346 return ret;
347 }
348
IsConnected(MediaEnhanceClientHandle * clientWrapper)349 bool EnhancementServiceAdapter::IsConnected(MediaEnhanceClientHandle* clientWrapper)
350 {
351 if (clientWrapper == nullptr) {
352 MEDIA_ERR_LOG("clientWrapper is nullptr!");
353 return E_ERR;
354 }
355 if (clientIsConnectedFunc == nullptr) {
356 clientIsConnectedFunc = (ClientIsConnected)dynamicLoader_->GetFunction(MEDIA_CLOUD_ENHANCE_LIB_SO,
357 "MediaEnhanceClient_IsConnected");
358 }
359 if (clientIsConnectedFunc == nullptr) {
360 MEDIA_ERR_LOG("MediaEnhanceClient_IsConnected dlsym failed.error:%{public}s", dlerror());
361 return false;
362 }
363 return clientIsConnectedFunc(clientWrapper);
364 }
365
LoadEnhancementService()366 int32_t EnhancementServiceAdapter::LoadEnhancementService()
367 {
368 unique_lock<mutex> lock(mtx_);
369 if (clientWrapper == nullptr) {
370 MEDIA_WARN_LOG("EnhancementServiceAdapter clientWrapper is nullptr, make client pointer");
371 InitEnhancementClient(MediaEnhance_TASK_TYPE::TYPE_CAMERA);
372 }
373 if (!IsConnected(clientWrapper)) {
374 int ret = LoadSA();
375 if (ret != E_OK) {
376 MEDIA_ERR_LOG("EnhancementServiceAdapter load enhancement service SA error");
377 return ret;
378 }
379 MEDIA_INFO_LOG("EnhancementServiceAdapter load enhancement service SA");
380 SetResultCallback();
381 }
382 return E_OK;
383 }
384
IsConnected()385 bool EnhancementServiceAdapter::IsConnected()
386 {
387 if (clientWrapper == nullptr) {
388 MEDIA_WARN_LOG("EnhancementServiceAdapter get mediaEnhanceClient error, make client pointer again");
389 InitEnhancementClient(MediaEnhance_TASK_TYPE::TYPE_CAMERA);
390 }
391 return IsConnected(clientWrapper);
392 }
393
CreateBundle()394 MediaEnhanceBundleHandle* EnhancementServiceAdapter::CreateBundle()
395 {
396 if (createMCEBundleFunc == nullptr) {
397 createMCEBundleFunc = (CreateMCEBundle)dynamicLoader_->GetFunction(MEDIA_CLOUD_ENHANCE_LIB_SO,
398 "CreateMediaEnhanceBundle");
399 }
400 if (createMCEBundleFunc == nullptr) {
401 MEDIA_ERR_LOG("createMCEBundleFunc dlsym failed.error:%{public}s", dlerror());
402 return nullptr;
403 }
404 return createMCEBundleFunc();
405 }
406
DestroyBundle(MediaEnhanceBundleHandle * bundle)407 void EnhancementServiceAdapter::DestroyBundle(MediaEnhanceBundleHandle* bundle)
408 {
409 if (destroyMCEBundleFunc == nullptr) {
410 destroyMCEBundleFunc = (DestroyMCEBundle)dynamicLoader_->GetFunction(MEDIA_CLOUD_ENHANCE_LIB_SO,
411 "DestroyMediaEnhanceBundle");
412 }
413 if (destroyMCEBundleFunc == nullptr) {
414 MEDIA_ERR_LOG("destroyMCEBundleFunc dlsym failed.error:%{public}s", dlerror());
415 return;
416 }
417 destroyMCEBundleFunc(bundle);
418 }
419
GetInt(MediaEnhanceBundleHandle * bundle,const char * key)420 int32_t EnhancementServiceAdapter::GetInt(MediaEnhanceBundleHandle* bundle, const char* key)
421 {
422 if (bundleHandleGetIntFunc == nullptr) {
423 bundleHandleGetIntFunc = (BundleHandleGetInt)dynamicLoader_->GetFunction(MEDIA_CLOUD_ENHANCE_LIB_SO,
424 "MediaEnhanceBundle_GetInt");
425 }
426 if (bundleHandleGetIntFunc == nullptr) {
427 MEDIA_ERR_LOG("MediaEnhanceBundle_GetInt dlsym failed. error:%{public}s", dlerror());
428 return E_ERR;
429 }
430 return bundleHandleGetIntFunc(bundle, key, strlen(key));
431 }
432
FillTaskWithResultBuffer(MediaEnhanceBundleHandle * bundle,CloudEnhancementThreadTask & task)433 int32_t EnhancementServiceAdapter::FillTaskWithResultBuffer(MediaEnhanceBundleHandle* bundle,
434 CloudEnhancementThreadTask& task)
435 {
436 Raw_Data* rawDateVec;
437 uint32_t size;
438 if (bundleGetResBufferFunc == nullptr) {
439 bundleGetResBufferFunc = (BundleHandleGetResBuffer)dynamicLoader_->GetFunction(MEDIA_CLOUD_ENHANCE_LIB_SO,
440 "MediaEnhanceBundle_GetResultBuffers");
441 }
442 if (bundleGetResBufferFunc == nullptr) {
443 MEDIA_ERR_LOG("MediaEnhanceBundle_GetResultBuffers dlsym failed. error:%{public}s", dlerror());
444 return E_ERR;
445 }
446 bundleGetResBufferFunc(bundle, &rawDateVec, &size);
447 if (rawDateVec == nullptr || size == 0) {
448 MEDIA_ERR_LOG("MediaEnhanceBundle_GetResultBuffers rawDateVec is nullptr or size = 0");
449 return E_ERR;
450 }
451 uint8_t *addr = rawDateVec[0].buffer;
452 uint32_t bytes = rawDateVec[0].size;
453 uint8_t *copyData = new uint8_t[bytes];
454 int32_t ret = memcpy_s(copyData, bytes, addr, bytes);
455 if (ret != E_OK) {
456 MEDIA_ERR_LOG("copy result buffer failed");
457 delete[] copyData;
458 copyData = nullptr;
459 return E_ERR;
460 }
461 task.addr = copyData;
462 task.bytes = bytes;
463 DeleteRawData(rawDateVec, size);
464 return E_OK;
465 }
466
PutInt(MediaEnhanceBundleHandle * bundle,const char * key,int32_t value)467 void EnhancementServiceAdapter::PutInt(MediaEnhanceBundleHandle* bundle, const char* key,
468 int32_t value)
469 {
470 if (bundleHandlePutIntFunc == nullptr) {
471 bundleHandlePutIntFunc = (BundleHandlePutInt)dynamicLoader_->GetFunction(MEDIA_CLOUD_ENHANCE_LIB_SO,
472 "MediaEnhanceBundle_PutInt");
473 }
474 if (bundleHandlePutIntFunc == nullptr) {
475 MEDIA_ERR_LOG("MediaEnhanceBundle_GetRawDataList dlsym failed. error:%{public}s", dlerror());
476 return;
477 }
478 bundleHandlePutIntFunc(bundle, key, strlen(key), value);
479 }
480
PutString(MediaEnhanceBundleHandle * bundle,const char * key,const char * value)481 void EnhancementServiceAdapter::PutString(MediaEnhanceBundleHandle* bundle, const char* key,
482 const char* value)
483 {
484 if (bundleHandlePutStringFunc == nullptr) {
485 bundleHandlePutStringFunc = (BundleHandlePutString)dynamicLoader_->GetFunction(MEDIA_CLOUD_ENHANCE_LIB_SO,
486 "MediaEnhanceBundle_PutString");
487 }
488 if (bundleHandlePutStringFunc == nullptr) {
489 MEDIA_ERR_LOG("MediaEnhanceBundle_PutString dlsym failed. error:%{public}s", dlerror());
490 return;
491 }
492 bundleHandlePutStringFunc(bundle, key, strlen(key), value, strlen(value));
493 }
494
DeleteRawData(Raw_Data * rawData,uint32_t size)495 void EnhancementServiceAdapter::DeleteRawData(Raw_Data* rawData, uint32_t size)
496 {
497 if (bundleDeleteRawData == nullptr) {
498 bundleDeleteRawData = (BundleDeleteRawData)dynamicLoader_->GetFunction(MEDIA_CLOUD_ENHANCE_LIB_SO,
499 "MediaEnhance_DeleteRawDataList");
500 }
501 if (bundleDeleteRawData == nullptr) {
502 MEDIA_ERR_LOG("MediaEnhance_DeleteRawDataList dlsym failed. error:%{public}s", dlerror());
503 return;
504 }
505 bundleDeleteRawData(rawData, size);
506 }
507
AddTask(const string & taskId,MediaEnhanceBundleHandle * bundle)508 int32_t EnhancementServiceAdapter::AddTask(const string& taskId, MediaEnhanceBundleHandle* bundle)
509 {
510 if (taskId.empty() || bundle == nullptr) {
511 MEDIA_ERR_LOG("taskId is invalid or bundle is nullptr!");
512 return E_ERR;
513 }
514 int32_t ret = LoadEnhancementService();
515 if (ret != E_OK) {
516 return ret;
517 }
518 int32_t triggerType = GetInt(bundle, MediaEnhance_Bundle_Key::TRIGGER_TYPE);
519 if (clientAddTaskFunc == nullptr) {
520 clientAddTaskFunc = (ClientAddTask)dynamicLoader_->GetFunction(MEDIA_CLOUD_ENHANCE_LIB_SO,
521 "MediaEnhanceClient_AddTask");
522 }
523 if (clientAddTaskFunc == nullptr) {
524 MEDIA_ERR_LOG("MediaEnhanceClient_AddTask dlsym failed.error:%{public}s", dlerror());
525 return E_ERR;
526 }
527 ret = clientAddTaskFunc(clientWrapper, taskId.c_str(), strlen(taskId.c_str()), bundle);
528 if (ret == E_OK) {
529 CloudEnhancementGetCount::GetInstance().AddStartTime(taskId);
530 MEDIA_INFO_LOG("add task: enter taskId: %{public}s, triggerType: %{public}d",
531 taskId.c_str(), triggerType);
532 }
533 return ret;
534 }
535
RemoveTask(const string & taskId)536 int32_t EnhancementServiceAdapter::RemoveTask(const string &taskId)
537 {
538 int32_t ret = LoadEnhancementService();
539 if (ret != E_OK) {
540 return ret;
541 }
542 if (clientRemoveTaskFunc == nullptr) {
543 clientRemoveTaskFunc = (ClientRemoveTask)dynamicLoader_->GetFunction(MEDIA_CLOUD_ENHANCE_LIB_SO,
544 "MediaEnhanceClient_RemoveTask");
545 }
546 if (clientRemoveTaskFunc == nullptr) {
547 MEDIA_ERR_LOG("MediaEnhanceClient_RemoveTask dlsym failed. error:%{public}s", dlerror());
548 return E_ERR;
549 }
550 ret = clientRemoveTaskFunc(clientWrapper, taskId.c_str(), strlen(taskId.c_str()));
551 if (ret != E_OK) {
552 return E_ERR;
553 }
554 MEDIA_INFO_LOG("remove task id: %{public}s", taskId.c_str());
555 return E_OK;
556 }
557
CancelTask(const string & taskId)558 int32_t EnhancementServiceAdapter::CancelTask(const string &taskId)
559 {
560 int32_t ret = LoadEnhancementService();
561 if (ret != E_OK) {
562 return ret;
563 }
564 if (clientCancelTaskFunc == nullptr) {
565 clientCancelTaskFunc = (ClientCancelTask)dynamicLoader_->GetFunction(MEDIA_CLOUD_ENHANCE_LIB_SO,
566 "MediaEnhanceClient_CancelTask");
567 }
568 if (clientCancelTaskFunc == nullptr) {
569 MEDIA_ERR_LOG("MediaEnhanceClient_CancelTask dlsym failed. error:%{public}s", dlerror());
570 return E_ERR;
571 }
572 ret = clientCancelTaskFunc(clientWrapper, taskId.c_str(), strlen(taskId.c_str()));
573 if (ret != E_OK) {
574 return E_ERR;
575 }
576 MEDIA_INFO_LOG("cancel task id: %{public}s", taskId.c_str());
577 return E_OK;
578 }
579
CancelAllTasks()580 int32_t EnhancementServiceAdapter::CancelAllTasks()
581 {
582 int32_t ret = LoadEnhancementService();
583 if (ret != E_OK) {
584 return ret;
585 }
586 if (clientStopServiceFunc == nullptr) {
587 clientStopServiceFunc = (ClientStopService)dynamicLoader_->GetFunction(MEDIA_CLOUD_ENHANCE_LIB_SO,
588 "MediaEnhanceClient_StopService");
589 }
590 if (clientStopServiceFunc == nullptr) {
591 MEDIA_ERR_LOG("MediaEnhanceClient_StopService dlsym failed. error:%{public}s", dlerror());
592 return E_ERR;
593 }
594 return clientStopServiceFunc(clientWrapper);
595 }
596
PauseAllTasks(MediaEnhanceBundleHandle * bundle)597 int32_t EnhancementServiceAdapter::PauseAllTasks(MediaEnhanceBundleHandle* bundle)
598 {
599 int32_t ret = LoadEnhancementService();
600 if (ret != E_OK) {
601 return ret;
602 }
603 if (clientPauseAllTasksFunc == nullptr) {
604 clientPauseAllTasksFunc = (ClientPauseAllTasks)dynamicLoader_->GetFunction(MEDIA_CLOUD_ENHANCE_LIB_SO,
605 "MediaEnhanceClient_PauseAllTasks");
606 }
607 if (clientPauseAllTasksFunc == nullptr) {
608 MEDIA_ERR_LOG("MediaEnhanceClient_PauseAllTasks dlsym failed. error:%{public}s", dlerror());
609 return E_ERR;
610 }
611 MEDIA_INFO_LOG("MediaEnhanceClient_PauseAllTasks success");
612 return clientPauseAllTasksFunc(clientWrapper, bundle);
613 }
614
ResumeAllTasks(MediaEnhanceBundleHandle * bundle)615 int32_t EnhancementServiceAdapter::ResumeAllTasks(MediaEnhanceBundleHandle* bundle)
616 {
617 int32_t ret = LoadEnhancementService();
618 if (ret != E_OK) {
619 return ret;
620 }
621 if (clientResumeAllTasksFunc == nullptr) {
622 clientResumeAllTasksFunc = (ClientResumeAllTasks)dynamicLoader_->GetFunction(MEDIA_CLOUD_ENHANCE_LIB_SO,
623 "MediaEnhanceClient_ResumeAllTasks");
624 }
625 if (clientResumeAllTasksFunc == nullptr) {
626 MEDIA_ERR_LOG("MediaEnhanceClient_ResumeAllTasks dlsym failed. error:%{public}s", dlerror());
627 return E_ERR;
628 }
629 MEDIA_INFO_LOG("MediaEnhanceClient_ResumeAllTasks success");
630 return clientResumeAllTasksFunc(clientWrapper, bundle);
631 }
632
GetPendingTasks(vector<std::string> & taskIdList)633 int32_t EnhancementServiceAdapter::GetPendingTasks(vector<std::string> &taskIdList)
634 {
635 int32_t ret = LoadEnhancementService();
636 if (ret != E_OK) {
637 return ret;
638 }
639 if (clientGetPendingTask == nullptr) {
640 clientGetPendingTask = (ClientGetPendingTask)dynamicLoader_->GetFunction(MEDIA_CLOUD_ENHANCE_LIB_SO,
641 "MediaEnhanceClient_GetPendingTasks");
642 }
643 if (clientGetPendingTask == nullptr) {
644 MEDIA_ERR_LOG("MediaEnhanceClient_GetPendingTasks dlsym failed. error:%{public}s", dlerror());
645 return E_ERR;
646 }
647 Pending_Task* pendingTaskIdList;
648 uint32_t size;
649 ret = clientGetPendingTask(clientWrapper, &pendingTaskIdList, &size);
650 if (ret != E_OK) {
651 return ret;
652 }
653 for (uint32_t i = 0; i < size; i++) {
654 taskIdList.push_back(pendingTaskIdList[i].taskId);
655 }
656 DeletePendingTasks(pendingTaskIdList, size);
657 return E_OK;
658 }
659
DeletePendingTasks(Pending_Task * taskIdList,uint32_t size)660 void EnhancementServiceAdapter::DeletePendingTasks(Pending_Task* taskIdList, uint32_t size)
661 {
662 int32_t ret = LoadEnhancementService();
663 CHECK_AND_RETURN(ret == E_OK);
664
665 if (clientGetPendingTask == nullptr) {
666 clientDeletePendingTask = (ClientDeletePendingTask)dynamicLoader_->GetFunction(MEDIA_CLOUD_ENHANCE_LIB_SO,
667 "MediaEnhance_DeletePendingTasks");
668 }
669 CHECK_AND_RETURN_LOG(clientDeletePendingTask != nullptr,
670 "MediaEnhance_DeletePendingTasks dlsym failed. error:%{public}s", dlerror());
671 clientDeletePendingTask(taskIdList, size);
672 }
673 #endif
674 } // namespace Media
675 } // namespace OHOS