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