1 /*
2  * Copyright (c) 2023 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 #ifndef OHOS_ABILITY_RUNTIME_TASK_HANDLER_WRAP_H
17 #define OHOS_ABILITY_RUNTIME_TASK_HANDLER_WRAP_H
18 
19 #include <string>
20 #include <memory>
21 #include <unordered_map>
22 #include <functional>
23 
24 #include "task_utils_wrap.h"
25 
26 namespace ffrt {
27 class mutex;
28 };
29 
30 namespace OHOS {
31 namespace AAFwk {
32 class TaskHandlerWrap;
33 class InnerTaskHandle;
34 class TaskHandle {
35 friend class TaskHandlerWrap;
36 public:
37     TaskHandle() = default;
TaskHandle(std::shared_ptr<TaskHandlerWrap> handler, std::shared_ptr<InnerTaskHandle> InnerTaskHandle, TaskStatus status = TaskStatus::PENDING)38     TaskHandle(std::shared_ptr<TaskHandlerWrap> handler, std::shared_ptr<InnerTaskHandle> InnerTaskHandle,
39         TaskStatus status = TaskStatus::PENDING) : handler_(handler), innerTaskHandle_(InnerTaskHandle)
40     {
41         status_ = std::make_shared<TaskStatus>(status);
42     }
43     bool Cancel() const;
44     void Sync() const;
IsSame(const TaskHandle &other) const45     bool IsSame(const TaskHandle &other) const
46     {
47         return innerTaskHandle_ == other.innerTaskHandle_;
48     }
operator bool() const49     explicit operator bool() const
50     {
51         return status_ && innerTaskHandle_;
52     }
53 private:
54     std::weak_ptr<TaskHandlerWrap> handler_;
55     std::shared_ptr<InnerTaskHandle> innerTaskHandle_;
56     std::shared_ptr<TaskStatus> status_;
57 };
58 
59 class TaskHandlerWrap : public std::enable_shared_from_this<TaskHandlerWrap> {
60 friend class TaskHandle;
61 public:
62     static std::shared_ptr<TaskHandlerWrap> CreateQueueHandler(const std::string &queueName,
63         TaskQoS queueQos = TaskQoS::DEFAULT);
64 
65     static std::shared_ptr<TaskHandlerWrap> CreateConcurrentQueueHandler(const std::string &queueName,
66         int32_t concurrentNum, TaskQoS queueQos = TaskQoS::DEFAULT);
67 
68     static std::shared_ptr<TaskHandlerWrap> GetFfrtHandler();
69 
70     TaskHandlerWrap(TaskHandlerWrap &) = delete;
71     void operator=(TaskHandlerWrap &) = delete;
72     virtual ~TaskHandlerWrap();
73     /**
74      * Submit task to be scheduled and executed
75      * @return TaskHandle, could be used later
76      */
77     TaskHandle SubmitTask(const std::function<void()> &task);
78     TaskHandle SubmitTask(const std::function<void()> &task, const std::string &name);
79     TaskHandle SubmitTask(const std::function<void()> &task, int64_t delayMillis);
80     TaskHandle SubmitTask(const std::function<void()> &task, TaskQoS taskQos);
81     TaskHandle SubmitTask(const std::function<void()> &task, const std::string &name,
82         int64_t delayMillis, bool forceSubmit = true);
83     TaskHandle SubmitTask(const std::function<void()> &task, const TaskAttribute &taskAttr);
84     // Task can't be canceled by name if submited with this mothed
85     TaskHandle SubmitTaskJust(const std::function<void()> &task, const std::string &name,
86         int64_t delayMillis);
87     // This is only used for compatibility and could be be wrong if multi tasks with same name submited.
88     // TaskHandle::Cancel is prefered.
89     bool CancelTask(const std::string &name);
90 protected:
91     TaskHandlerWrap();
92     virtual std::shared_ptr<InnerTaskHandle> SubmitTaskInner(std::function<void()> &&task,
93         const TaskAttribute &taskAttr) = 0;
94     virtual bool CancelTaskInner(const std::shared_ptr<InnerTaskHandle> &taskHandle) = 0;
95     virtual void WaitTaskInner(const std::shared_ptr<InnerTaskHandle> &taskHandle) = 0;
96     bool RemoveTask(const std::string &name, const TaskHandle &taskHandle);
97 protected:
98     // this is used only for compatibility
99     std::unordered_map<std::string, TaskHandle> tasks_;
100     std::unique_ptr<ffrt::mutex> tasksMutex_;
101 };
102 
103 class AutoSyncTaskHandle {
104 public:
AutoSyncTaskHandle(const TaskHandle &handle)105     explicit AutoSyncTaskHandle(const TaskHandle &handle) : handle_(handle) {}
~AutoSyncTaskHandle()106     ~AutoSyncTaskHandle()
107     {
108         Sync();
109     }
110 
111     AutoSyncTaskHandle(AutoSyncTaskHandle&) = delete;
112     void operator=(AutoSyncTaskHandle&) = delete;
113 
Sync()114     void Sync()
115     {
116         auto handle = handle_;
117         handle_ = TaskHandle();
118         if (handle) {
119             handle.Sync();
120         }
121     }
122 private:
123     TaskHandle handle_;
124 };
125 }  // namespace AAFWK
126 }  // namespace OHOS
127 #endif // OHOS_ABILITY_RUNTIME_TASK_HANDLER_WRAP_H