1/*
2 * Copyright (C) 2013 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#ifndef ANDROID_HWUI_TASK_MANAGER_H
18#define ANDROID_HWUI_TASK_MANAGER_H
19
20#include <utils/Mutex.h>
21#include <utils/String8.h>
22#include <utils/Thread.h>
23
24#include "Signal.h"
25
26#include <vector>
27
28namespace android {
29namespace uirenderer {
30
31template <typename T>
32class Task;
33class TaskBase;
34
35template <typename T>
36class TaskProcessor;
37class TaskProcessorBase;
38
39class TaskManager {
40public:
41    TaskManager();
42    ~TaskManager();
43
44    /**
45     * Returns true if this task  manager can run tasks,
46     * false otherwise. This method will typically return
47     * false on a single CPU core device.
48     */
49    bool canRunTasks() const;
50
51    /**
52     * Stops all allocated threads. Adding tasks will start
53     * the threads again as necessary.
54     */
55    void stop();
56
57private:
58    template <typename T>
59    friend class TaskProcessor;
60
61    template<typename T>
62    bool addTask(const sp<Task<T> >& task, const sp<TaskProcessor<T> >& processor) {
63        return addTaskBase(sp<TaskBase>(task), sp<TaskProcessorBase>(processor));
64    }
65
66    bool addTaskBase(const sp<TaskBase>& task, const sp<TaskProcessorBase>& processor);
67
68    struct TaskWrapper {
69        TaskWrapper(): mTask(), mProcessor() { }
70
71        TaskWrapper(const sp<TaskBase>& task, const sp<TaskProcessorBase>& processor):
72            mTask(task), mProcessor(processor) {
73        }
74
75        sp<TaskBase> mTask;
76        sp<TaskProcessorBase> mProcessor;
77    };
78
79    class WorkerThread: public Thread {
80    public:
81        WorkerThread(const String8 name): mSignal(Condition::WAKE_UP_ONE), mName(name) { }
82
83        bool addTask(const TaskWrapper& task);
84        size_t getTaskCount() const;
85        void exit();
86
87    private:
88        virtual status_t readyToRun() override;
89        virtual bool threadLoop() override;
90
91        // Lock for the list of tasks
92        mutable Mutex mLock;
93        std::vector<TaskWrapper> mTasks;
94
95        // Signal used to wake up the thread when a new
96        // task is available in the list
97        mutable Signal mSignal;
98
99        const String8 mName;
100    };
101
102    std::vector<sp<WorkerThread> > mThreads;
103};
104
105}; // namespace uirenderer
106}; // namespace android
107
108#endif // ANDROID_HWUI_TASK_MANAGER_H
109