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; 38 TaskHandle(std::shared_ptr<TaskHandlerWrap> handler, std::shared_ptr<InnerTaskHandle> InnerTaskHandle, handler_(handler)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)45 bool IsSame(const TaskHandle &other) const 46 { 47 return innerTaskHandle_ == other.innerTaskHandle_; 48 } 49 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 static std::shared_ptr<TaskHandlerWrap> GetFfrtHandler(); 65 66 TaskHandlerWrap(TaskHandlerWrap &) = delete; 67 void operator=(TaskHandlerWrap &) = delete; 68 virtual ~TaskHandlerWrap(); 69 /** 70 * Submit task to be scheduled and executed 71 * @return TaskHandle, could be used later 72 */ 73 TaskHandle SubmitTask(const std::function<void()> &task); 74 TaskHandle SubmitTask(const std::function<void()> &task, const std::string &name); 75 TaskHandle SubmitTask(const std::function<void()> &task, int64_t delayMillis); 76 TaskHandle SubmitTask(const std::function<void()> &task, TaskQoS taskQos); 77 TaskHandle SubmitTask(const std::function<void()> &task, const std::string &name, 78 int64_t delayMillis, bool forceSubmit = true); 79 TaskHandle SubmitTask(const std::function<void()> &task, const TaskAttribute &taskAttr); 80 // Task can't be canceled by name if submited with this mothed 81 TaskHandle SubmitTaskJust(const std::function<void()> &task, const std::string &name, 82 int64_t delayMillis); 83 // This is only used for compatibility and could be be wrong if multi tasks with same name submited. 84 // TaskHandle::Cancel is prefered. 85 bool CancelTask(const std::string &name); 86 protected: 87 TaskHandlerWrap(); 88 virtual std::shared_ptr<InnerTaskHandle> SubmitTaskInner(std::function<void()> &&task, 89 const TaskAttribute &taskAttr) = 0; 90 virtual bool CancelTaskInner(const std::shared_ptr<InnerTaskHandle> &taskHandle) = 0; 91 virtual void WaitTaskInner(const std::shared_ptr<InnerTaskHandle> &taskHandle) = 0; 92 bool RemoveTask(const std::string &name, const TaskHandle &taskHandle); 93 protected: 94 // this is used only for compatibility 95 std::unordered_map<std::string, TaskHandle> tasks_; 96 std::unique_ptr<ffrt::mutex> tasksMutex_; 97 }; 98 } // namespace AAFWK 99 } // namespace OHOS 100 #endif // OHOS_ABILITY_RUNTIME_TASK_HANDLER_WRAP_H