1 /*
2 * Copyright (c) 2021-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
16 #include "task_factory.h"
17
18 #include "anonymous_string.h"
19 #include "disable_task.h"
20 #include "distributed_hardware_log.h"
21 #include "enable_task.h"
22 #include "exit_dfwk_task.h"
23 #include "meta_disable_task.h"
24 #include "meta_enable_task.h"
25 #include "offline_task.h"
26 #include "online_task.h"
27 #include "task_board.h"
28
29 namespace OHOS {
30 namespace DistributedHardware {
31 #undef DH_LOG_TAG
32 #define DH_LOG_TAG "TaskFactory"
33
34 IMPLEMENT_SINGLE_INSTANCE(TaskFactory);
CreateTask(TaskType taskType,TaskParam taskParam,std::shared_ptr<Task> fatherTask)35 std::shared_ptr<Task> TaskFactory::CreateTask(TaskType taskType, TaskParam taskParam, std::shared_ptr<Task> fatherTask)
36 {
37 DHLOGI("taskType: %{public}d, networkId: %{public}s, uuid: %{public}s, dhId: %{public}s",
38 static_cast<int32_t>(taskType), GetAnonyString(taskParam.networkId).c_str(),
39 GetAnonyString(taskParam.uuid).c_str(), GetAnonyString(taskParam.dhId).c_str());
40 std::shared_ptr<Task> task = nullptr;
41 switch (taskType) {
42 case TaskType::ENABLE: {
43 task = CreateEnableTask(taskParam);
44 break;
45 }
46 case TaskType::DISABLE: {
47 task = CreateDisableTask(taskParam);
48 break;
49 }
50 case TaskType::ON_LINE: {
51 task = std::make_shared<OnLineTask>(taskParam.networkId, taskParam.uuid, taskParam.udid,
52 taskParam.dhId, taskParam.dhType);
53 break;
54 }
55 case TaskType::OFF_LINE: {
56 task = std::make_shared<OffLineTask>(taskParam.networkId, taskParam.uuid, taskParam.udid,
57 taskParam.dhId, taskParam.dhType);
58 break;
59 }
60 default: {
61 task = CreateTaskEx(taskType, taskParam, fatherTask);
62 break;
63 }
64 }
65 if (task == nullptr) {
66 DHLOGE("Create task failed, task is nullptr, type: %{public}d", taskType);
67 return task;
68 }
69 if (fatherTask != nullptr) {
70 task->SetFatherTask(fatherTask);
71 fatherTask->AddChildrenTask(task);
72 }
73 TaskBoard::GetInstance().AddTask(task);
74 return task;
75 }
76
CreateEnableTask(const TaskParam & taskParam)77 std::shared_ptr<Task> TaskFactory::CreateEnableTask(const TaskParam &taskParam)
78 {
79 auto enableTask = std::make_shared<EnableTask>(taskParam.networkId, taskParam.uuid, taskParam.udid,
80 taskParam.dhId, taskParam.dhType);
81 if (enableTask != nullptr) {
82 enableTask->SetEffectSink(taskParam.effectSink);
83 enableTask->SetEffectSource(taskParam.effectSource);
84 enableTask->SetCallingUid(taskParam.callingUid);
85 enableTask->SetCallingPid(taskParam.callingPid);
86 }
87 return enableTask;
88 }
89
CreateDisableTask(const TaskParam & taskParam)90 std::shared_ptr<Task> TaskFactory::CreateDisableTask(const TaskParam &taskParam)
91 {
92 auto disableTask = std::make_shared<DisableTask>(taskParam.networkId, taskParam.uuid, taskParam.udid,
93 taskParam.dhId, taskParam.dhType);
94 if (disableTask != nullptr) {
95 disableTask->SetEffectSink(taskParam.effectSink);
96 disableTask->SetEffectSource(taskParam.effectSource);
97 disableTask->SetCallingUid(taskParam.callingUid);
98 disableTask->SetCallingPid(taskParam.callingPid);
99 }
100 return disableTask;
101 }
102
CreateTaskEx(TaskType taskType,const TaskParam & taskParam,std::shared_ptr<Task> fatherTask)103 std::shared_ptr<Task> TaskFactory::CreateTaskEx(TaskType taskType,
104 const TaskParam &taskParam, std::shared_ptr<Task> fatherTask)
105 {
106 std::shared_ptr<Task> task = nullptr;
107 switch (taskType) {
108 case TaskType::META_ENABLE: {
109 task = std::make_shared<MetaEnableTask>(taskParam.networkId, taskParam.uuid, taskParam.udid,
110 taskParam.dhId, taskParam.dhType);
111 break;
112 }
113 case TaskType::META_DISABLE: {
114 task = std::make_shared<MetaDisableTask>(taskParam.networkId, taskParam.uuid, taskParam.udid,
115 taskParam.dhId, taskParam.dhType);
116 break;
117 }
118 case TaskType::EXIT_DFWK: {
119 task = std::make_shared<ExitDfwkTask>(taskParam.networkId, taskParam.uuid, taskParam.udid,
120 taskParam.dhId, taskParam.dhType);
121 break;
122 }
123 default: {
124 DHLOGE("CreateTask type invalid, type: %{public}d", taskType);
125 return nullptr;
126 }
127 }
128 return task;
129 }
130 } // namespace DistributedHardware
131 } // namespace OHOS
132