initial_commit

Author: pioner921227

.gitignore

@@ -84,3 +84,6 @@ android/generated
 
 # React Native Nitro Modules
 nitrogen/
+
+rust/fetcher-rust/target
+rust/fetcher-rust/ios/universal

SyncTasks.podspec

@@ -14,6 +14,8 @@ Pod::Spec.new do |s|
   s.source       = { :git => "https://github.com/pioner92/react-native-sync-tasks.git", :tag => "#{s.version}" }
 
   s.source_files = "ios/**/*.{h,m,mm}", "cpp/**/*.{hpp,cpp,c,h}"
+  s.vendored_frameworks = 'ios/rust/fetcher.xcframework'
+
 
 # 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.

android/CMakeLists.txt

@@ -12,7 +12,9 @@ add_library(rnsynctasks   SHARED
             ../cpp/JSTask.cpp
             ../cpp/JSManager.hpp
             ../cpp/JSManager.cpp
-            ../cpp/helpers/helpers.h
+            ../cpp/helpers/helpers.hpp
+            ../cpp/helpers/FetchService.cpp
+            ../cpp/helpers/FetchService.hpp
             cpp-adapter.cpp
 )
 

android/build.gradle

@@ -155,6 +155,7 @@ def kotlin_version = getExtOrDefault("kotlinVersion")
 dependencies {
   implementation "com.facebook.react:react-android"
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+  implementation("com.squareup.okhttp3:okhttp:4.12.0")
 }
 
 if (isNewArchitectureEnabled()) {

android/cpp-adapter.cpp

@@ -7,10 +7,60 @@
 #include <fbjni/detail/Registration.h>
 #include <typeinfo>
 #include "react-native-sync-tasks.hpp"
+#include "helpers/FetchService.hpp"
 
 
 using namespace facebook;
 
+JavaVM* g_vm = nullptr;
+jobject g_classLoader = nullptr;
+jmethodID g_loadClass = nullptr;
+
+JNIEnv* getJNIEnv() {
+    JNIEnv* env = nullptr;
+    if (g_vm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6) != JNI_OK) {
+        // Поток не прикреплён — нужно attach
+        g_vm->AttachCurrentThread(&env, nullptr);
+    }
+    return env;
+}
+
+extern "C"
+JNIEXPORT void JNICALL
+Java_com_synctasks_SyncTasksModule_nativeSetClassLoader(JNIEnv* env, jclass, jobject classLoader) {
+    g_classLoader = env->NewGlobalRef(classLoader);
+    jclass classLoaderClass = env->FindClass("java/lang/ClassLoader");
+    g_loadClass = env->GetMethodID(classLoaderClass, "loadClass", "(Ljava/lang/String;)Ljava/lang/Class;");
+}
+
+void setupClassLoader(JNIEnv* env) {
+    jclass contextClass = env->FindClass("com/synctasks/SyncTasksModule");
+    jclass classClass = env->FindClass("java/lang/Class");
+    jmethodID getClassLoader = env->GetMethodID(classClass, "getClassLoader", "()Ljava/lang/ClassLoader;");
+    jobject classLoader = env->CallObjectMethod(contextClass, getClassLoader);
+    g_classLoader = env->NewGlobalRef(classLoader);
+
+    jclass classLoaderClass = env->FindClass("java/lang/ClassLoader");
+    g_loadClass = env->GetMethodID(classLoaderClass, "loadClass", "(Ljava/lang/String;)Ljava/lang/Class;");
+}
+
+jclass findClassSafe(JNIEnv* env, const char* name) {
+    if (!g_classLoader || !g_loadClass) {
+        __android_log_print(ANDROID_LOG_ERROR, "SYNC_TASKS", "ClassLoader not initialized");
+        return nullptr;
+    }
+    jstring strClassName = env->NewStringUTF(name);
+    jclass clazz = (jclass)env->CallObjectMethod(g_classLoader, g_loadClass, strClassName);
+    env->DeleteLocalRef(strClassName);
+
+    if (env->ExceptionCheck()) {
+        env->ExceptionDescribe();
+        env->ExceptionClear();
+        return nullptr;
+    }
+    return clazz;
+}
+
 struct SyncTasksBridge : jni::JavaClass<SyncTasksBridge> {
 public:
     static constexpr auto kJavaDescriptor = "Lcom/synctasks/SyncTasksModule;";
@@ -29,14 +79,70 @@ struct SyncTasksBridge : jni::JavaClass<SyncTasksBridge> {
         auto jsiRuntime = reinterpret_cast<jsi::Runtime*>(jsiRuntimePointer);
         auto jsCallInvoker = jsCallInvokerHolder->cthis()->getCallInvoker();
 
+        auto fetch = [](std::string&& url, FetchHeaders&& headers) -> FetchResponse {
+            JNIEnv* env = getJNIEnv();
+
+            jclass fetcherClass = findClassSafe(env, "com.synctasks.Fetcher");
+            if (!fetcherClass) {
+                return FetchError{"Fetcher class not found", "", 0};
+            }
 
-        sh::synctasks::install(jsiRuntime, jsCallInvoker);
+            jmethodID fetchMethod = env->GetStaticMethodID(fetcherClass, "fetch", "(Ljava/lang/String;Ljava/util/Map;)Ljava/lang/String;");
+            if (!fetchMethod) {
+                return FetchError{"Fetcher.fetch() not found", "", 0};
+            }
 
-        // Установите JSI
-        // sqldb::install(jsiRuntime, jsCallInvoker, dbPathStr);
+            jstring jUrl = env->NewStringUTF(url.c_str());
+
+            jclass mapClass = env->FindClass("java/util/HashMap");
+            jmethodID init = env->GetMethodID(mapClass, "<init>", "()V");
+            jobject jMap = env->NewObject(mapClass, init);
+
+            jmethodID put = env->GetMethodID(mapClass, "put", "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;");
+
+            for (const auto& [k, v] : headers) {
+                jstring jk = env->NewStringUTF(k.c_str());
+                jstring jv = env->NewStringUTF(v.c_str());
+                env->CallObjectMethod(jMap, put, jk, jv);
+                env->DeleteLocalRef(jk);
+                env->DeleteLocalRef(jv);
+            }
+
+            jstring jResult = (jstring)env->CallStaticObjectMethod(fetcherClass, fetchMethod, jUrl, jMap);
+
+//            jclass pairClass = env->FindClass("kotlin/Pair");
+//            jmethodID getFirst = env->GetMethodID(pairClass, "getFirst", "()Ljava/lang/Object;");
+//            jmethodID getSecond = env->GetMethodID(pairClass, "getSecond", "()Ljava/lang/Object;");
+
+
+//            jobject jCodeObj = env->CallObjectMethod(resultPair, getFirst);
+//            jobject jBodyObj = env->CallObjectMethod(resultPair, getSecond);
+
+//            const char* cstr = env->GetStringUTFChars(jResult, nullptr);
+//            std::string body(cstr);
+//            env->ReleaseStringUTFChars(jResult, cstr);
+//
+//            env->DeleteLocalRef(jUrl);
+//            env->DeleteLocalRef(jMap);
+//            env->DeleteLocalRef(jResult);
+//            env->DeleteLocalRef(fetcherClass);
+
+            return FetchBody("");
+        };
+
+        sh::synctasks::install(jsiRuntime, jsCallInvoker,std::move(fetch));
     }
 };
 
 JNIEXPORT jint JNI_OnLoad(JavaVM *vm, void *) {
+    g_vm = vm;
+
+    JNIEnv* env = nullptr;
+    if (vm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6) != JNI_OK) {
+        return JNI_ERR;
+    }
+
+    setupClassLoader(env);
+
     return jni::initialize(vm, [] { SyncTasksBridge::registerNatives(); });
 }

android/src/main/java/com/synctasks/SyncTasksModule.kt

@@ -6,6 +6,27 @@ import com.facebook.react.bridge.ReactContextBaseJavaModule
 import com.facebook.react.bridge.ReactMethod
 import com.facebook.react.common.annotations.FrameworkAPI
 import com.facebook.react.turbomodule.core.CallInvokerHolderImpl
+import okhttp3.OkHttpClient
+import okhttp3.Request
+
+
+object Fetcher {
+  @JvmStatic
+  fun fetch(url: String, headers: Map<String, String>): String {
+    val client = OkHttpClient()
+
+    val builder = Request.Builder()
+      .url(url)
+
+    headers.forEach { (k, v) -> builder.addHeader(k, v) }
+
+    val response = client.newCall(builder.build()).execute()
+
+    val body = response.body?.string() ?: ""
+
+    return body;
+  }
+}
 
 @OptIn(FrameworkAPI::class)
 class SyncTasksModule internal constructor(val context: ReactApplicationContext) :

cpp/JSManager.cpp

@@ -6,9 +6,9 @@
 //
 
 #include "JSManager.hpp"
-#include "TaskScheduler.hpp"
+#include "core/TaskScheduler.hpp"
 #include "constants.hpp"
-#include "helpers/helpers.h"
+#include "helpers/helpers.hpp"
 
 jsi::Object createJSTaskManager(jsi::Runtime& rt) {
   jsi::Object taskManagerJS = jsi::Object(rt);
@@ -19,10 +19,12 @@ jsi::Object createJSTaskManager(jsi::Runtime& rt) {
       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));
+        if(!args[0].isObject() || !args[0].asObject(rt).hasNativeState<Task>(rt)){
+          throw jsi::JSError(rt, createErrorString("addTask -> Invalid argument").data());
+        }
+
+        t_manager->addTask(args[0].asObject(rt).getNativeState<Task>(rt));
 
         return jsi::Value(true);
       });
@@ -32,16 +34,20 @@ jsi::Object createJSTaskManager(jsi::Runtime& rt) {
       [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");
+          throw jsi::JSError(rt, createErrorString("addTasks -> Argument must be an array").data());
         }
 
         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);
+
+          jsi::Value taskValue = jsTasks.getValueAtIndex(rt, i);
+
+          if(!taskValue.isObject() || !taskValue.asObject(rt).hasNativeState<Task>(rt)){
+            throw jsi::JSError(rt, createErrorString("addTasks -> Invalid argument").data());
+          }
+
+          std::shared_ptr<Task> task = taskValue.asObject(rt).getNativeState<Task>(rt);
 
           t_manager->addTask(std::move(task));
         }