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