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
26namespace ffrt {
27class mutex;
28};
29
30namespace OHOS {
31namespace AAFwk {
32class TaskHandlerWrap;
33class InnerTaskHandle;
34class TaskHandle {
35friend class TaskHandlerWrap;
36public:
37    TaskHandle() = default;
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;
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    }
53private:
54    std::weak_ptr<TaskHandlerWrap> handler_;
55    std::shared_ptr<InnerTaskHandle> innerTaskHandle_;
56    std::shared_ptr<TaskStatus> status_;
57};
58
59class TaskHandlerWrap : public std::enable_shared_from_this<TaskHandlerWrap> {
60friend class TaskHandle;
61public:
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);
90protected:
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);
97protected:
98    // this is used only for compatibility
99    std::unordered_map<std::string, TaskHandle> tasks_;
100    std::unique_ptr<ffrt::mutex> tasksMutex_;
101};
102
103class AutoSyncTaskHandle {
104public:
105    explicit AutoSyncTaskHandle(const TaskHandle &handle) : handle_(handle) {}
106    ~AutoSyncTaskHandle()
107    {
108        Sync();
109    }
110
111    AutoSyncTaskHandle(AutoSyncTaskHandle&) = delete;
112    void operator=(AutoSyncTaskHandle&) = delete;
113
114    void Sync()
115    {
116        auto handle = handle_;
117        handle_ = TaskHandle();
118        if (handle) {
119            handle.Sync();
120        }
121    }
122private:
123    TaskHandle handle_;
124};
125}  // namespace AAFWK
126}  // namespace OHOS
127#endif // OHOS_ABILITY_RUNTIME_TASK_HANDLER_WRAP_H