added task manager for ios

Author: pioner921227

SyncTasks.podspec

@@ -15,6 +15,9 @@ Pod::Spec.new do |s|
 
   s.source_files = "ios/**/*.{h,m,mm}", "cpp/**/*.{hpp,cpp,c,h}"
 
+  s.dependency 'curl'
+
+
 # Use install_modules_dependencies helper to install the dependencies if React Native version >=0.71.0.
 # See https://github.com/facebook/react-native/blob/febf6b7f33fdb4904669f99d795eba4c0f95d7bf/scripts/cocoapods/new_architecture.rb#L79.
 if respond_to?(:install_modules_dependencies, true)

cpp/JSManager.cpp

@@ -0,0 +1,78 @@
+//
+//  JSManager2.cpp
+//  SyncTasks
+//
+//  Created by Oleksandr Shumihin on 12/4/25.
+//
+
+#include "JSManager.hpp"
+#include "TaskScheduler.h"
+#include "constants.h"
+#include "helpers/helpers.h"
+
+jsi::Object createJSTaskManager(jsi::Runtime& rt) {
+  jsi::Object taskManagerJS = jsi::Object(rt);
+
+  auto t_manager = std::make_shared<TaskScheduler>(THREADS_COUNT);
+
+  jsi::Function addTask = jsi::Function::createFromHostFunction(
+      rt, jsi::PropNameID::forAscii(rt, ADD_TASK_KEY), 1,
+      [t_manager](jsi::Runtime& rt, const jsi::Value& thisVal,
+                  const jsi::Value* args, size_t count) {
+        std::shared_ptr<Task> task =
+            args[0].asObject(rt).getNativeState<Task>(rt);
+
+        t_manager->addTask(std::move(task));
+
+        return jsi::Value(true);
+      });
+
+  jsi::Function addTasks = jsi::Function::createFromHostFunction(
+      rt, jsi::PropNameID::forAscii(rt, ADD_TASKS_KEY), 1,
+      [t_manager](jsi::Runtime& rt, const jsi::Value& thisVal,
+                  const jsi::Value* args, size_t count) {
+        if (!checkJSType<jsi::Array>(rt, args[0])) {
+          throw jsi::JSError(
+              rt, "[SyncTasksManager]: addTasks -> Argument must be an array");
+        }
+
+        jsi::Array jsTasks = args[0].asObject(rt).asArray(rt);
+
+        for (int i = 0; i < jsTasks.length(rt); ++i) {
+          std::shared_ptr<Task> task =
+              jsTasks.getValueAtIndex(rt, i).asObject(rt).getNativeState<Task>(
+                  rt);
+
+          t_manager->addTask(std::move(task));
+        }
+
+        return jsi::Value(true);
+      });
+
+  jsi::Function startAll = jsi::Function::createFromHostFunction(
+      rt, jsi::PropNameID::forAscii(rt, START_ALL_KEY), 1,
+      [t_manager](jsi::Runtime& rt, const jsi::Value& thisVal,
+                  const jsi::Value* args, size_t count) {
+        t_manager->start();
+        return jsi::Value(true);
+      });
+
+  jsi::Function stopAll = jsi::Function::createFromHostFunction(
+      rt, jsi::PropNameID::forAscii(rt, STOP_ALL_KEY), 1,
+      [t_manager](jsi::Runtime& rt, const jsi::Value& thisVal,
+                  const jsi::Value* args, size_t count) {
+        t_manager->stop();
+        return jsi::Value(true);
+      });
+
+  taskManagerJS.setNativeState(rt, t_manager);
+
+  taskManagerJS.setProperty(rt, ADD_TASK_KEY, std::move(addTask));
+  taskManagerJS.setProperty(rt, ADD_TASKS_KEY, std::move(addTasks));
+  taskManagerJS.setProperty(rt, START_ALL_KEY, std::move(startAll));
+  taskManagerJS.setProperty(rt, STOP_ALL_KEY, std::move(stopAll));
+
+  taskManagerJS.setExternalMemoryPressure(rt, sizeof(TaskScheduler));
+
+  return taskManagerJS;
+}

cpp/JSManager.hpp

@@ -0,0 +1,25 @@
+//
+//  JSManager2.hpp
+//  SyncTasks
+//
+//  Created by Oleksandr Shumihin on 12/4/25.
+//
+
+#ifndef JSManager_hpp
+#define JSManager_hpp
+
+#include <stdio.h>
+
+
+#include "jsi/jsi.h"
+
+using namespace facebook;
+
+
+jsi::Object createJSTaskManager(jsi::Runtime& rt);
+
+
+
+
+
+#endif /* JSManager_hpp */

cpp/JSTask.cpp

@@ -0,0 +1,20 @@
+//
+//  JSTask2.hpp
+//  SyncTasks
+//
+//  Created by Oleksandr Shumihin on 12/4/25.
+//
+
+#ifndef JSTask_hpp
+#define JSTask_hpp
+
+#include <stdio.h>
+
+#include "jsi/jsi.h"
+#include <ReactCommon/CallInvoker.h>
+
+using namespace facebook;
+
+jsi::Function createJSTaskCreator(jsi::Runtime& rt,std::shared_ptr<react::CallInvoker> callInvoker);
+
+#endif /* JSTask_hpp */

cpp/JSTask.hpp

@@ -0,0 +1,219 @@
+//
+//  TaskScheduler.cpp
+//  intch_application
+//
+//  Created by Oleksandr Shumihin on 10/4/25.
+//  Copyright © 2025 Facebook. All rights reserved.
+//
+
+#pragma once
+
+#include "atomic"
+#include "jsi/jsi.h"
+#include "queue"
+#include "thread"
+
+using namespace std;
+using namespace facebook;
+
+class Task : public jsi::NativeState {
+ public:
+  Task(std::string id, int intervalMs, std::function<void(Task&)> job)
+      : id_(std::move(id)), intervalMs_(intervalMs), job_(std::move(job)) {}
+
+  ~Task() = default;
+
+  void run() {
+    if (job_ && ready_ && !stopped_)
+      job_(*this);
+  }
+
+  const std::string& getId() const { return id_; }
+  int getInterval() const { return intervalMs_; }
+
+  void stop() { stopped_ = true; }
+
+  void start() {
+    if (ready_) {
+      stopped_ = false;
+    }
+  }
+
+  bool isStopped() const { return stopped_; }
+  bool isReady() const { return ready_; }
+
+  void makeReady() { ready_ = true; }
+
+  void setLastBodyHash(size_t value){
+    lastBodyHash_ = value;
+  }
+
+  bool hasSameBodyHash(size_t value) const {
+    return lastBodyHash_ == value;
+  }
+
+ private:
+  std::string id_;
+  std::function<void(Task& t)> job_;
+  std::atomic<bool> stopped_ = true;
+  size_t lastBodyHash_;
+  int intervalMs_;
+  bool ready_ = false;
+};
+
+// ========== ThreadPool ==========
+class ThreadPool {
+ public:
+  ThreadPool(size_t numThreads) {
+    stop_ = false;
+    for (size_t i = 0; i < numThreads; ++i) {
+      workers_.emplace_back([this]() {
+        while (true) {
+          std::function<void()> task;
+
+          {
+            std::unique_lock lock(queueMutex_);
+            cv_.wait(lock, [this]() { return stop_ || !tasks_.empty(); });
+
+            if (stop_ && tasks_.empty())
+              return;
+
+            task = std::move(tasks_.front());
+            tasks_.pop();
+          }
+
+          task();
+        }
+      });
+    }
+  }
+
+  ~ThreadPool() {
+    {
+      std::unique_lock lock(queueMutex_);
+      stop_ = true;
+    }
+    cv_.notify_all();
+    for (auto& worker : workers_) {
+      if (worker.joinable())
+        worker.join();
+    }
+  }
+
+  void enqueue(std::function<void()> job) {
+    {
+      std::unique_lock lock(queueMutex_);
+      tasks_.push(std::move(job));
+    }
+    cv_.notify_one();
+  }
+
+ private:
+  std::vector<std::thread> workers_;
+  std::queue<std::function<void()>> tasks_;
+  std::mutex queueMutex_;
+  std::condition_variable cv_;
+  bool stop_;
+};
+
+// ========== TaskEntry (for priority_queue) ==========
+struct TaskEntry {
+  std::chrono::steady_clock::time_point nextRun;
+  std::shared_ptr<Task> task;
+
+  TaskEntry(std::chrono::steady_clock::time_point next,std::shared_ptr<Task> t):nextRun(std::move(next)), task(std::move(t)) {
+    task->makeReady();
+  }
+
+  bool operator<(const TaskEntry& other) const {
+    return nextRun > other.nextRun;  // min-heap
+  }
+};
+
+// ========== TaskScheduler ==========
+class TaskScheduler : public jsi::NativeState {
+ public:
+  TaskScheduler(int numThreads = 4) : pool_(numThreads), running_(false) {}
+  ~TaskScheduler() { stop(); };
+
+  void addTask(const std::shared_ptr<Task>& task) {
+    std::unique_lock lock(mutex_);
+
+    if(taskMap_.contains(task->getId())){
+      return;
+    }
+
+    tasks_.emplace(std::chrono::steady_clock::now() +
+      std::chrono::milliseconds(task->getInterval()),
+      task);
+
+    taskMap_[task->getId()] = task;
+    cv_.notify_all();
+  }
+
+  void start() {
+    if (!running_) {
+      running_ = true;
+      schedulerThread_ = std::thread(&TaskScheduler::schedulerLoop, this);
+    }
+
+    for (auto& [id, task] : taskMap_) {
+      task->start();
+    }
+  }
+
+  void stop() {
+    {
+      std::unique_lock lock(mutex_);
+      running_ = false;
+    }
+
+    for (auto& [id, task] : taskMap_) {
+      task->stop();
+    }
+    cv_.notify_all();
+    if (schedulerThread_.joinable())
+      schedulerThread_.join();
+  }
+
+  bool hasTaskWithId(const std::string& id){
+    return taskMap_.contains(id);
+  }
+
+ private:
+  std::priority_queue<TaskEntry> tasks_;
+  std::unordered_map<std::string, std::shared_ptr<Task>> taskMap_;
+  std::mutex mutex_;
+  std::condition_variable cv_;
+  ThreadPool pool_;
+  std::thread schedulerThread_;
+  bool running_;
+
+  void schedulerLoop() {
+    while (running_) {
+      std::unique_lock lock(mutex_);
+
+      if (tasks_.empty()) {
+        cv_.wait(lock);
+        continue;
+      }
+
+      auto now = std::chrono::steady_clock::now();
+      TaskEntry entry = tasks_.top();
+
+      if (entry.nextRun <= now) {
+        tasks_.pop();
+
+        auto taskToRun = entry.task;
+        pool_.enqueue([taskToRun]() { taskToRun->run(); });
+
+        // Reschedule
+        entry.nextRun =
+            now + std::chrono::milliseconds(taskToRun->getInterval());
+        tasks_.emplace(entry);
+      } else {
+        cv_.wait_until(lock, entry.nextRun);
+      }
+    }
+  }
+};

cpp/TaskScheduler.h

@@ -0,0 +1,24 @@
+//
+//  constants.hpp
+//  Pods
+//
+//  Created by Oleksandr Shumihin on 12/4/25.
+//
+
+#pragma once
+
+constexpr const char* CONFIG_KEY = "config";
+constexpr const char* URL_KEY = "url";
+constexpr const char* INTERVAL_KEY = "interval";
+constexpr const char* HEADERS_KEY = "headers";
+constexpr const char* ON_DATA_KEY = "onData";
+constexpr const char* ON_ERROR_KEY = "onError";
+constexpr const char* SYNC_TASK_MANAGER_KEY = "SyncTasksManager";
+constexpr const char* CREATE_TASK_KEY = "createTask";
+
+constexpr const char* ADD_TASK_KEY = "addTask";
+constexpr const char* ADD_TASKS_KEY = "addTasks";
+constexpr const char* START_ALL_KEY = "startAll";
+constexpr const char* STOP_ALL_KEY = "stopAll";
+
+constexpr int THREADS_COUNT = 4;