Remove old TaskManager system
Replace it with a newer, fancier, WorkQueue-inspired
one that's just a global common thread pool.
Test: hwuiunit passes
Change-Id: Ib5d03104a08bbac9a4ec67a1bfc0db2b35d6700f
diff --git a/libs/hwui/thread/Barrier.h b/libs/hwui/thread/Barrier.h
deleted file mode 100644
index bb750ca..0000000
--- a/libs/hwui/thread/Barrier.h
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
- * Copyright (C) 2013 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef ANDROID_HWUI_BARRIER_H
-#define ANDROID_HWUI_BARRIER_H
-
-#include <utils/Condition.h>
-
-namespace android {
-namespace uirenderer {
-
-class Barrier {
-public:
- explicit Barrier(Condition::WakeUpType type = Condition::WAKE_UP_ALL)
- : mType(type), mOpened(false) {}
- ~Barrier() {}
-
- void open() {
- Mutex::Autolock l(mLock);
- mOpened = true;
- mCondition.signal(mType);
- }
-
- void wait() const {
- Mutex::Autolock l(mLock);
- while (!mOpened) {
- mCondition.wait(mLock);
- }
- }
-
-private:
- Condition::WakeUpType mType;
- volatile bool mOpened;
- mutable Mutex mLock;
- mutable Condition mCondition;
-};
-
-} // namespace uirenderer
-} // namespace android
-
-#endif // ANDROID_HWUI_BARRIER_H
diff --git a/libs/hwui/thread/CommonPool.cpp b/libs/hwui/thread/CommonPool.cpp
new file mode 100644
index 0000000..7f94a15
--- /dev/null
+++ b/libs/hwui/thread/CommonPool.cpp
@@ -0,0 +1,90 @@
+/*
+ * Copyright (C) 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "CommonPool.h"
+
+#include <sys/resource.h>
+#include <utils/Trace.h>
+#include "renderthread/RenderThread.h"
+
+#include <array>
+
+namespace android {
+namespace uirenderer {
+
+CommonPool::CommonPool() {
+ ATRACE_CALL();
+
+ CommonPool* pool = this;
+ // Create 2 workers
+ for (int i = 0; i < THREAD_COUNT; i++) {
+ std::thread worker([pool, i] {
+ {
+ std::array<char, 20> name{"hwuiTask"};
+ snprintf(name.data(), name.size(), "hwuiTask%d", i);
+ auto self = pthread_self();
+ pthread_setname_np(self, name.data());
+ setpriority(PRIO_PROCESS, 0, PRIORITY_FOREGROUND);
+ auto startHook = renderthread::RenderThread::getOnStartHook();
+ if (startHook) {
+ startHook(name.data());
+ }
+ }
+ pool->workerLoop();
+ });
+ worker.detach();
+ }
+}
+
+void CommonPool::post(Task&& task) {
+ static CommonPool pool;
+ pool.enqueue(std::move(task));
+}
+
+void CommonPool::enqueue(Task&& task) {
+ std::unique_lock lock(mLock);
+ while (!mWorkQueue.hasSpace()) {
+ lock.unlock();
+ usleep(100);
+ lock.lock();
+ }
+ mWorkQueue.push(std::move(task));
+ if (mWaitingThreads == THREAD_COUNT || (mWaitingThreads > 0 && mWorkQueue.size() > 1)) {
+ mCondition.notify_one();
+ }
+}
+
+void CommonPool::workerLoop() {
+ std::unique_lock lock(mLock);
+ while (true) {
+ if (!mWorkQueue.hasWork()) {
+ mWaitingThreads++;
+ mCondition.wait(lock);
+ mWaitingThreads--;
+ }
+ // Need to double-check that work is still available now that we have the lock
+ // It may have already been grabbed by a different thread
+ while (mWorkQueue.hasWork()) {
+ auto work = mWorkQueue.pop();
+ lock.unlock();
+ work();
+ lock.lock();
+ }
+ }
+}
+
+} // namespace uirenderer
+} // namespace android
\ No newline at end of file
diff --git a/libs/hwui/thread/CommonPool.h b/libs/hwui/thread/CommonPool.h
new file mode 100644
index 0000000..aef2990
--- /dev/null
+++ b/libs/hwui/thread/CommonPool.h
@@ -0,0 +1,115 @@
+/*
+ * Copyright (C) 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FRAMEWORKS_BASE_COMMONPOOL_H
+#define FRAMEWORKS_BASE_COMMONPOOL_H
+
+#include "utils/Macros.h"
+
+#include <log/log.h>
+
+#include <condition_variable>
+#include <functional>
+#include <future>
+#include <mutex>
+
+namespace android {
+namespace uirenderer {
+
+template <class T, int SIZE>
+class ArrayQueue {
+ PREVENT_COPY_AND_ASSIGN(ArrayQueue);
+ static_assert(SIZE > 0, "Size must be positive");
+
+public:
+ ArrayQueue() = default;
+ ~ArrayQueue() = default;
+
+ constexpr size_t capacity() const { return SIZE; }
+ constexpr bool hasWork() const { return mHead != mTail; }
+ constexpr bool hasSpace() const { return ((mHead + 1) % SIZE) != mTail; }
+ constexpr int size() const {
+ if (mHead > mTail) {
+ return mHead - mTail;
+ } else {
+ return mTail - mHead + SIZE;
+ }
+ }
+
+ constexpr void push(T&& t) {
+ int newHead = (mHead + 1) % SIZE;
+ LOG_ALWAYS_FATAL_IF(newHead == mTail, "no space");
+
+ mBuffer[mHead] = std::move(t);
+ mHead = newHead;
+ }
+
+ constexpr T&& pop() {
+ LOG_ALWAYS_FATAL_IF(mTail == mHead, "empty");
+ int index = mTail;
+ mTail = (mTail + 1) % SIZE;
+ return std::move(mBuffer[index]);
+ }
+
+private:
+ T mBuffer[SIZE];
+ int mHead = 0;
+ int mTail = 0;
+};
+
+class CommonPool {
+ PREVENT_COPY_AND_ASSIGN(CommonPool);
+
+public:
+ using Task = std::function<void()>;
+ static constexpr auto THREAD_COUNT = 2;
+ static constexpr auto QUEUE_SIZE = 128;
+
+ static void post(Task&& func);
+
+ template <class F>
+ static auto async(F&& func) -> std::future<decltype(func())> {
+ typedef std::packaged_task<decltype(func())()> task_t;
+ auto task = std::make_shared<task_t>(std::forward<F>(func));
+ post([task]() { std::invoke(*task); });
+ return task->get_future();
+ }
+
+ template <class F>
+ static auto runSync(F&& func) -> decltype(func()) {
+ std::packaged_task<decltype(func())()> task{std::forward<F>(func)};
+ post([&task]() { std::invoke(task); });
+ return task.get_future().get();
+ };
+
+private:
+ CommonPool();
+ ~CommonPool() {}
+
+ void enqueue(Task&&);
+
+ void workerLoop();
+
+ std::mutex mLock;
+ std::condition_variable mCondition;
+ int mWaitingThreads = 0;
+ ArrayQueue<Task, QUEUE_SIZE> mWorkQueue;
+};
+
+} // namespace uirenderer
+} // namespace android
+
+#endif // FRAMEWORKS_BASE_COMMONPOOL_H
diff --git a/libs/hwui/thread/Future.h b/libs/hwui/thread/Future.h
deleted file mode 100644
index df53348e..0000000
--- a/libs/hwui/thread/Future.h
+++ /dev/null
@@ -1,59 +0,0 @@
-/*
- * Copyright (C) 2013 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef ANDROID_HWUI_FUTURE_H
-#define ANDROID_HWUI_FUTURE_H
-
-#include <utils/RefBase.h>
-
-#include "Barrier.h"
-
-namespace android {
-namespace uirenderer {
-
-template <typename T>
-class Future : public LightRefBase<Future<T> > {
-public:
- explicit Future(Condition::WakeUpType type = Condition::WAKE_UP_ONE)
- : mBarrier(type), mResult() {}
- ~Future() {}
-
- /**
- * Returns the result of this future, blocking if
- * the result is not available yet.
- */
- T get() const {
- mBarrier.wait();
- return mResult;
- }
-
- /**
- * This method must be called only once.
- */
- void produce(T result) {
- mResult = result;
- mBarrier.open();
- }
-
-private:
- Barrier mBarrier;
- T mResult;
-};
-
-} // namespace uirenderer
-} // namespace android
-
-#endif // ANDROID_HWUI_FUTURE_H
diff --git a/libs/hwui/thread/Signal.h b/libs/hwui/thread/Signal.h
deleted file mode 100644
index 6d33ac4..0000000
--- a/libs/hwui/thread/Signal.h
+++ /dev/null
@@ -1,59 +0,0 @@
-/*
- * Copyright (C) 2013 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef ANDROID_HWUI_SIGNAL_H
-#define ANDROID_HWUI_SIGNAL_H
-
-#include <stdint.h>
-#include <sys/types.h>
-#include <utils/threads.h>
-
-namespace android {
-namespace uirenderer {
-
-class Signal {
-public:
- explicit Signal(Condition::WakeUpType type = Condition::WAKE_UP_ALL)
- : mType(type), mSignaled(false) {}
- ~Signal() {}
-
- void signal() {
- {
- Mutex::Autolock l(mLock);
- mSignaled = true;
- }
- mCondition.signal(mType);
- }
-
- void wait() {
- Mutex::Autolock l(mLock);
- while (!mSignaled) {
- mCondition.wait(mLock);
- }
- mSignaled = false;
- }
-
-private:
- Condition::WakeUpType mType;
- volatile bool mSignaled;
- mutable Mutex mLock;
- mutable Condition mCondition;
-};
-
-} // namespace uirenderer
-} // namespace android
-
-#endif // ANDROID_HWUI_SIGNAL_H
diff --git a/libs/hwui/thread/Task.h b/libs/hwui/thread/Task.h
deleted file mode 100644
index 228ce19..0000000
--- a/libs/hwui/thread/Task.h
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
- * Copyright (C) 2013 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef ANDROID_HWUI_TASK_H
-#define ANDROID_HWUI_TASK_H
-
-#include <utils/RefBase.h>
-#include <utils/Trace.h>
-
-#include "Future.h"
-
-namespace android {
-namespace uirenderer {
-
-class TaskBase : public RefBase {
-public:
- TaskBase() {}
- virtual ~TaskBase() {}
-};
-
-template <typename T>
-class Task : public TaskBase {
-public:
- Task() : mFuture(new Future<T>()) {}
- virtual ~Task() {}
-
- T getResult() const { return mFuture->get(); }
-
- void setResult(T result) { mFuture->produce(result); }
-
-protected:
- const sp<Future<T> >& future() const { return mFuture; }
-
-private:
- sp<Future<T> > mFuture;
-};
-
-} // namespace uirenderer
-} // namespace android
-
-#endif // ANDROID_HWUI_TASK_H
diff --git a/libs/hwui/thread/TaskManager.cpp b/libs/hwui/thread/TaskManager.cpp
deleted file mode 100644
index de10ff1..0000000
--- a/libs/hwui/thread/TaskManager.cpp
+++ /dev/null
@@ -1,139 +0,0 @@
-/*
- * Copyright (C) 2013 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <sys/resource.h>
-#include <sys/sysinfo.h>
-
-#include "Task.h"
-#include "TaskManager.h"
-#include "TaskProcessor.h"
-#include "utils/MathUtils.h"
-#include "renderthread/RenderThread.h"
-
-namespace android {
-namespace uirenderer {
-
-///////////////////////////////////////////////////////////////////////////////
-// Manager
-///////////////////////////////////////////////////////////////////////////////
-
-TaskManager::TaskManager() {
- // Get the number of available CPUs. This value does not change over time.
- int cpuCount = sysconf(_SC_NPROCESSORS_CONF);
-
- // Really no point in making more than 2 of these worker threads, but
- // we do want to limit ourselves to 1 worker thread on dual-core devices.
- int workerCount = cpuCount > 2 ? 2 : 1;
- for (int i = 0; i < workerCount; i++) {
- String8 name;
- name.appendFormat("hwuiTask%d", i + 1);
- mThreads.push_back(new WorkerThread(name));
- }
-}
-
-TaskManager::~TaskManager() {
- for (size_t i = 0; i < mThreads.size(); i++) {
- mThreads[i]->exit();
- }
-}
-
-bool TaskManager::canRunTasks() const {
- return mThreads.size() > 0;
-}
-
-void TaskManager::stop() {
- for (size_t i = 0; i < mThreads.size(); i++) {
- mThreads[i]->exit();
- }
-}
-
-bool TaskManager::addTaskBase(const sp<TaskBase>& task, const sp<TaskProcessorBase>& processor) {
- if (mThreads.size() > 0) {
- TaskWrapper wrapper(task, processor);
-
- size_t minQueueSize = INT_MAX;
- sp<WorkerThread> thread;
-
- for (size_t i = 0; i < mThreads.size(); i++) {
- if (mThreads[i]->getTaskCount() < minQueueSize) {
- thread = mThreads[i];
- minQueueSize = mThreads[i]->getTaskCount();
- }
- }
-
- return thread->addTask(wrapper);
- }
- return false;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// Thread
-///////////////////////////////////////////////////////////////////////////////
-
-status_t TaskManager::WorkerThread::readyToRun() {
- setpriority(PRIO_PROCESS, 0, PRIORITY_FOREGROUND);
- auto onStartHook = renderthread::RenderThread::getOnStartHook();
- if (onStartHook) {
- onStartHook(mName.c_str());
- }
-
- return NO_ERROR;
-}
-
-bool TaskManager::WorkerThread::threadLoop() {
- mSignal.wait();
- std::vector<TaskWrapper> tasks;
- {
- Mutex::Autolock l(mLock);
- tasks.swap(mTasks);
- }
-
- for (size_t i = 0; i < tasks.size(); i++) {
- const TaskWrapper& task = tasks[i];
- task.mProcessor->process(task.mTask);
- }
-
- return true;
-}
-
-bool TaskManager::WorkerThread::addTask(const TaskWrapper& task) {
- if (!isRunning()) {
- run(mName.string(), PRIORITY_DEFAULT);
- } else if (exitPending()) {
- return false;
- }
-
- {
- Mutex::Autolock l(mLock);
- mTasks.push_back(task);
- }
- mSignal.signal();
-
- return true;
-}
-
-size_t TaskManager::WorkerThread::getTaskCount() const {
- Mutex::Autolock l(mLock);
- return mTasks.size();
-}
-
-void TaskManager::WorkerThread::exit() {
- requestExit();
- mSignal.signal();
-}
-
-} // namespace uirenderer
-} // namespace android
diff --git a/libs/hwui/thread/TaskManager.h b/libs/hwui/thread/TaskManager.h
deleted file mode 100644
index 6c67222..0000000
--- a/libs/hwui/thread/TaskManager.h
+++ /dev/null
@@ -1,108 +0,0 @@
-/*
- * Copyright (C) 2013 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef ANDROID_HWUI_TASK_MANAGER_H
-#define ANDROID_HWUI_TASK_MANAGER_H
-
-#include <utils/Mutex.h>
-#include <utils/String8.h>
-#include <utils/Thread.h>
-
-#include "Signal.h"
-
-#include <vector>
-
-namespace android {
-namespace uirenderer {
-
-template <typename T>
-class Task;
-class TaskBase;
-
-template <typename T>
-class TaskProcessor;
-class TaskProcessorBase;
-
-class TaskManager {
-public:
- TaskManager();
- ~TaskManager();
-
- /**
- * Returns true if this task manager can run tasks,
- * false otherwise. This method will typically return
- * false on a single CPU core device.
- */
- bool canRunTasks() const;
-
- /**
- * Stops all allocated threads. Adding tasks will start
- * the threads again as necessary.
- */
- void stop();
-
-private:
- template <typename T>
- friend class TaskProcessor;
-
- template <typename T>
- bool addTask(const sp<Task<T> >& task, const sp<TaskProcessor<T> >& processor) {
- return addTaskBase(sp<TaskBase>(task), sp<TaskProcessorBase>(processor));
- }
-
- bool addTaskBase(const sp<TaskBase>& task, const sp<TaskProcessorBase>& processor);
-
- struct TaskWrapper {
- TaskWrapper() : mTask(), mProcessor() {}
-
- TaskWrapper(const sp<TaskBase>& task, const sp<TaskProcessorBase>& processor)
- : mTask(task), mProcessor(processor) {}
-
- sp<TaskBase> mTask;
- sp<TaskProcessorBase> mProcessor;
- };
-
- class WorkerThread : public Thread {
- public:
- explicit WorkerThread(const String8& name)
- : Thread(false), mSignal(Condition::WAKE_UP_ONE), mName(name) {}
-
- bool addTask(const TaskWrapper& task);
- size_t getTaskCount() const;
- void exit();
-
- private:
- virtual status_t readyToRun() override;
- virtual bool threadLoop() override;
-
- // Lock for the list of tasks
- mutable Mutex mLock;
- std::vector<TaskWrapper> mTasks;
-
- // Signal used to wake up the thread when a new
- // task is available in the list
- mutable Signal mSignal;
-
- const String8 mName;
- };
-
- std::vector<sp<WorkerThread> > mThreads;
-};
-
-} // namespace uirenderer
-} // namespace android
-
-#endif // ANDROID_HWUI_TASK_MANAGER_H
diff --git a/libs/hwui/thread/TaskProcessor.h b/libs/hwui/thread/TaskProcessor.h
deleted file mode 100644
index 8117ae6..0000000
--- a/libs/hwui/thread/TaskProcessor.h
+++ /dev/null
@@ -1,76 +0,0 @@
-/*
- * Copyright (C) 2013 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef ANDROID_HWUI_TASK_PROCESSOR_H
-#define ANDROID_HWUI_TASK_PROCESSOR_H
-
-#include <utils/RefBase.h>
-
-#include "Task.h"
-#include "TaskManager.h"
-
-namespace android {
-namespace uirenderer {
-
-class TaskProcessorBase : public RefBase {
-public:
- TaskProcessorBase() {}
- virtual ~TaskProcessorBase(){};
-
- virtual void process(const sp<TaskBase>& task) = 0;
-};
-
-template <typename T>
-class TaskProcessor : public TaskProcessorBase {
-public:
- explicit TaskProcessor(TaskManager* manager) : mManager(manager) {}
- virtual ~TaskProcessor() {}
-
- void add(const sp<Task<T> >& task) {
- if (!addImpl(task)) {
- // fall back to immediate execution
- process(task);
- }
- }
-
- virtual void onProcess(const sp<Task<T> >& task) = 0;
-
-private:
- bool addImpl(const sp<Task<T> >& task);
-
- virtual void process(const sp<TaskBase>& task) override {
- sp<Task<T> > realTask = static_cast<Task<T>*>(task.get());
- // This is the right way to do it but sp<> doesn't play nice
- // sp<Task<T> > realTask = static_cast<sp<Task<T> > >(task);
- onProcess(realTask);
- }
-
- TaskManager* mManager;
-};
-
-template <typename T>
-bool TaskProcessor<T>::addImpl(const sp<Task<T> >& task) {
- if (mManager) {
- sp<TaskProcessor<T> > self(this);
- return mManager->addTask(task, self);
- }
- return false;
-}
-
-}; // namespace uirenderer
-}; // namespace android
-
-#endif // ANDROID_HWUI_TASK_PROCESSOR_H
diff --git a/libs/hwui/thread/WorkQueue.h b/libs/hwui/thread/WorkQueue.h
index 7a6e638..42f8503 100644
--- a/libs/hwui/thread/WorkQueue.h
+++ b/libs/hwui/thread/WorkQueue.h
@@ -26,7 +26,6 @@
#include <functional>
#include <future>
#include <mutex>
-#include <variant>
#include <vector>
namespace android::uirenderer {