use android ALooper as rxcpp scheduler on android platform

Author: harry75369

include/Application/RunLoop.hpp

@@ -21,6 +21,12 @@
 #include <rxcpp/operators/rx-observe_on.hpp>
 #include <rxcpp/schedulers/rx-runloop.hpp>
 
+#if defined(__ANDROID__)
+#include <android/looper.h>
+#endif
+
+#include "Utility/Log.hpp"
+
 namespace VGG
 {
 
@@ -33,7 +39,15 @@ class RunLoop
 
   rxcpp::observe_on_one_worker thread()
   {
+#if defined(__ANDROID__)
+    ALooper* looper = ALooper_forThread();
+    if (looper == nullptr) {
+      looper = ALooper_prepare(ALOOPER_PREPARE_ALLOW_NON_CALLBACKS);
+    }
+    return rxcpp::observe_on_new_thread();
+#else
     return rxcpp::observe_on_run_loop(m_runLoop);
+#endif
   }
 
   bool empty() const

include/Utility/VggTimer.hpp

@@ -27,12 +27,15 @@ class Timer
   using TCallback = std::function<void()>;
 
 private:
+  double                        m_interval;
   TCallback                     m_callback;
+  bool                          m_repeats;
   rxcpp::composite_subscription m_timer;
 
 public:
   Timer(double interval, TCallback callback, bool repeats = false);
+  bool setup();
   void invalidate();
 };
 
-} // namespace VGG
+} // namespace VGG

src/Application/UIScrollView.cpp

@@ -316,14 +316,19 @@ void UIScrollView::setScrollAnimation(std::shared_ptr<UIScrollViewAnimation> ani
 
   if (!m_scrollTimer)
   {
-    m_scrollTimer.reset(new Timer(
+    auto t = new Timer(
       1. / 60,
       [this]()
       {
         VERBOSE("UIScrollView: call updateScrollAnimation by timer");
         this->updateScrollAnimation();
       },
-      true));
+      true);
+    m_scrollTimer.reset(t);
+    if (!m_scrollTimer->setup())
+    {
+      WARN("Failed to setup scroll timer");
+    }
   }
 }
 

src/Utility/VggTimer.cpp

@@ -37,35 +37,45 @@ namespace VGG
 {
 
 Timer::Timer(double interval, TCallback callback, bool repeats)
-  : m_callback(callback)
+  : m_interval(interval)
+  , m_callback(callback)
+  , m_repeats(repeats)
 {
-  auto period = std::chrono::milliseconds(static_cast<int64_t>(interval * 1000));
+}
+
+bool Timer::setup()
+{
+  auto period = std::chrono::milliseconds(static_cast<int64_t>(m_interval * 1000));
 
-  if (repeats)
+  if (m_repeats)
   {
     auto values = rxcpp::observable<>::interval(period);
-    m_timer = values.observe_on(RunLoop::sharedInstance()->thread())
-                .subscribe([this](int v) { this->m_callback(); }, []() {});
+    auto observeTarget = RunLoop::sharedInstance()->thread();
+    auto s = values
+#if defined(__ANDROID__)
+      .subscribe_on(rxcpp::observe_on_new_thread())
+#endif
+      .observe_on(observeTarget);
+    m_timer = s.subscribe([this](int v) { if (this->m_callback) { this->m_callback(); } }, []() {});
   }
   else
   {
     auto values = rxcpp::observable<>::timer(period);
-    m_timer = values.observe_on(RunLoop::sharedInstance()->thread())
-                .subscribe(
-                  [this](int v)
-                  {
-                    if (this->m_callback)
-                    {
-                      this->m_callback();
-                    }
-                  },
-                  []() {});
+    auto observeTarget = RunLoop::sharedInstance()->thread();
+    auto s = values
+#if defined(__ANDROID__)
+      .subscribe_on(rxcpp::observe_on_new_thread())
+#endif
+      .observe_on(observeTarget);
+    m_timer = s.subscribe([this](int v) { if (this->m_callback) { this->m_callback(); } }, []() {});
   }
+
+  return true;
 }
 
 void Timer::invalidate()
 {
   m_timer.unsubscribe();
 }
 
-} // namespace VGG
+} // namespace VGG