@onekeyfe/react-native-app-update 1.1.21

package/android/src/main/java/com/margelo/nitro/reactnativeappupdate/ReactNativeAppUpdatePackage.kt

@@ -0,0 +1,24 @@
+package com.margelo.nitro.reactnativeappupdate
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfoProvider
+
+class ReactNativeAppUpdatePackage : BaseReactPackage() {
+    override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+        return null
+    }
+
+    override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+        return ReactModuleInfoProvider { HashMap() }
+    }
+
+    companion object {
+        init {
+            System.loadLibrary("reactnativeappupdate")
+        }
+    }
+}
+
+

package/android/src/main/res/xml/app_update_file_paths.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<paths>
+    <cache-path name="apks" path="apks/" />
+</paths>

package/ios/ReactNativeAppUpdate.swift

@@ -0,0 +1,41 @@
+import NitroModules
+import ReactNativeNativeLogger
+
+class ReactNativeAppUpdate: HybridReactNativeAppUpdateSpec {
+
+    func downloadAPK(params: AppUpdateDownloadParams) throws -> Promise<Void> {
+        OneKeyLog.debug("AppUpdate", "downloadAPK not available on iOS")
+        return Promise.resolved(withResult: ())
+    }
+
+    func downloadASC(params: AppUpdateFileParams) throws -> Promise<Void> {
+        OneKeyLog.debug("AppUpdate", "downloadASC not available on iOS")
+        return Promise.resolved(withResult: ())
+    }
+
+    func verifyASC(params: AppUpdateFileParams) throws -> Promise<Void> {
+        OneKeyLog.debug("AppUpdate", "verifyASC not available on iOS")
+        return Promise.resolved(withResult: ())
+    }
+
+    func verifyAPK(params: AppUpdateFileParams) throws -> Promise<Void> {
+        OneKeyLog.debug("AppUpdate", "verifyAPK not available on iOS")
+        return Promise.resolved(withResult: ())
+    }
+
+    func installAPK(params: AppUpdateFileParams) throws -> Promise<Void> {
+        OneKeyLog.debug("AppUpdate", "installAPK not available on iOS")
+        return Promise.resolved(withResult: ())
+    }
+
+    func clearCache() throws -> Promise<Void> {
+        return Promise.resolved(withResult: ())
+    }
+
+    func addDownloadListener(callback: @escaping (DownloadEvent) -> Void) throws -> Double {
+        return 0
+    }
+
+    func removeDownloadListener(id: Double) throws {
+    }
+}

package/lib/module/ReactNativeAppUpdate.nitro.js

@@ -0,0 +1,4 @@
+"use strict";
+
+export {};
+//# sourceMappingURL=ReactNativeAppUpdate.nitro.js.map

package/lib/module/ReactNativeAppUpdate.nitro.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../src","sources":["ReactNativeAppUpdate.nitro.ts"],"mappings":"","ignoreList":[]}

package/lib/module/index.js

@@ -0,0 +1,6 @@
+"use strict";
+
+import { NitroModules } from 'react-native-nitro-modules';
+const ReactNativeAppUpdateHybridObject = NitroModules.createHybridObject('ReactNativeAppUpdate');
+export const ReactNativeAppUpdate = ReactNativeAppUpdateHybridObject;
+//# sourceMappingURL=index.js.map

package/lib/module/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["NitroModules","ReactNativeAppUpdateHybridObject","createHybridObject","ReactNativeAppUpdate"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":";;AAAA,SAASA,YAAY,QAAQ,4BAA4B;AAGzD,MAAMC,gCAAgC,GACpCD,YAAY,CAACE,kBAAkB,CAA2B,sBAAsB,CAAC;AAEnF,OAAO,MAAMC,oBAAoB,GAAGF,gCAAgC","ignoreList":[]}

package/lib/module/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/typescript/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/typescript/src/ReactNativeAppUpdate.nitro.d.ts

@@ -0,0 +1,28 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+export interface AppUpdateDownloadParams {
+    downloadUrl: string;
+    notificationTitle: string;
+    fileSize: number;
+}
+export interface AppUpdateFileParams {
+    downloadUrl: string;
+}
+export interface DownloadEvent {
+    type: string;
+    progress: number;
+    message: string;
+}
+export interface ReactNativeAppUpdate extends HybridObject<{
+    ios: 'swift';
+    android: 'kotlin';
+}> {
+    downloadAPK(params: AppUpdateDownloadParams): Promise<void>;
+    downloadASC(params: AppUpdateFileParams): Promise<void>;
+    verifyASC(params: AppUpdateFileParams): Promise<void>;
+    verifyAPK(params: AppUpdateFileParams): Promise<void>;
+    installAPK(params: AppUpdateFileParams): Promise<void>;
+    clearCache(): Promise<void>;
+    addDownloadListener(callback: (event: DownloadEvent) => void): number;
+    removeDownloadListener(id: number): void;
+}
+//# sourceMappingURL=ReactNativeAppUpdate.nitro.d.ts.map

package/lib/typescript/src/ReactNativeAppUpdate.nitro.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReactNativeAppUpdate.nitro.d.ts","sourceRoot":"","sources":["../../../src/ReactNativeAppUpdate.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAE/D,MAAM,WAAW,uBAAuB;IACtC,WAAW,EAAE,MAAM,CAAC;IACpB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,mBAAmB;IAClC,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,oBACf,SAAQ,YAAY,CAAC;IAAE,GAAG,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,QAAQ,CAAA;CAAE,CAAC;IACzD,WAAW,CAAC,MAAM,EAAE,uBAAuB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5D,WAAW,CAAC,MAAM,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACxD,SAAS,CAAC,MAAM,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACtD,SAAS,CAAC,MAAM,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACtD,UAAU,CAAC,MAAM,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACvD,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAE5B,mBAAmB,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,GAAG,MAAM,CAAC;IACtE,sBAAsB,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1C"}

package/lib/typescript/src/index.d.ts

@@ -0,0 +1,4 @@
+import type { ReactNativeAppUpdate as ReactNativeAppUpdateType } from './ReactNativeAppUpdate.nitro';
+export declare const ReactNativeAppUpdate: ReactNativeAppUpdateType;
+export type * from './ReactNativeAppUpdate.nitro';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,IAAI,wBAAwB,EAAE,MAAM,8BAA8B,CAAC;AAKrG,eAAO,MAAM,oBAAoB,0BAAmC,CAAC;AACrE,mBAAmB,8BAA8B,CAAC"}

package/nitro.json

@@ -0,0 +1,17 @@
+{
+  "cxxNamespace": ["reactnativeappupdate"],
+  "ios": {
+    "iosModuleName": "ReactNativeAppUpdate"
+  },
+  "android": {
+    "androidNamespace": ["reactnativeappupdate"],
+    "androidCxxLibName": "reactnativeappupdate"
+  },
+  "autolinking": {
+    "ReactNativeAppUpdate": {
+      "swift": "ReactNativeAppUpdate",
+      "kotlin": "ReactNativeAppUpdate"
+    }
+  },
+  "ignorePaths": ["node_modules"]
+}

package/nitrogen/generated/android/c++/JAppUpdateDownloadParams.hpp

@@ -0,0 +1,65 @@
+///
+/// JAppUpdateDownloadParams.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "AppUpdateDownloadParams.hpp"
+
+#include <string>
+
+namespace margelo::nitro::reactnativeappupdate {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "AppUpdateDownloadParams" and the the Kotlin data class "AppUpdateDownloadParams".
+   */
+  struct JAppUpdateDownloadParams final: public jni::JavaClass<JAppUpdateDownloadParams> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/reactnativeappupdate/AppUpdateDownloadParams;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct AppUpdateDownloadParams by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    AppUpdateDownloadParams toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldDownloadUrl = clazz->getField<jni::JString>("downloadUrl");
+      jni::local_ref<jni::JString> downloadUrl = this->getFieldValue(fieldDownloadUrl);
+      static const auto fieldNotificationTitle = clazz->getField<jni::JString>("notificationTitle");
+      jni::local_ref<jni::JString> notificationTitle = this->getFieldValue(fieldNotificationTitle);
+      static const auto fieldFileSize = clazz->getField<double>("fileSize");
+      double fileSize = this->getFieldValue(fieldFileSize);
+      return AppUpdateDownloadParams(
+        downloadUrl->toStdString(),
+        notificationTitle->toStdString(),
+        fileSize
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JAppUpdateDownloadParams::javaobject> fromCpp(const AppUpdateDownloadParams& value) {
+      using JSignature = JAppUpdateDownloadParams(jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, double);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        jni::make_jstring(value.downloadUrl),
+        jni::make_jstring(value.notificationTitle),
+        value.fileSize
+      );
+    }
+  };
+
+} // namespace margelo::nitro::reactnativeappupdate

package/nitrogen/generated/android/c++/JAppUpdateFileParams.hpp

@@ -0,0 +1,57 @@
+///
+/// JAppUpdateFileParams.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "AppUpdateFileParams.hpp"
+
+#include <string>
+
+namespace margelo::nitro::reactnativeappupdate {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "AppUpdateFileParams" and the the Kotlin data class "AppUpdateFileParams".
+   */
+  struct JAppUpdateFileParams final: public jni::JavaClass<JAppUpdateFileParams> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/reactnativeappupdate/AppUpdateFileParams;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct AppUpdateFileParams by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    AppUpdateFileParams toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldDownloadUrl = clazz->getField<jni::JString>("downloadUrl");
+      jni::local_ref<jni::JString> downloadUrl = this->getFieldValue(fieldDownloadUrl);
+      return AppUpdateFileParams(
+        downloadUrl->toStdString()
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JAppUpdateFileParams::javaobject> fromCpp(const AppUpdateFileParams& value) {
+      using JSignature = JAppUpdateFileParams(jni::alias_ref<jni::JString>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        jni::make_jstring(value.downloadUrl)
+      );
+    }
+  };
+
+} // namespace margelo::nitro::reactnativeappupdate

package/nitrogen/generated/android/c++/JDownloadEvent.hpp

@@ -0,0 +1,65 @@
+///
+/// JDownloadEvent.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "DownloadEvent.hpp"
+
+#include <string>
+
+namespace margelo::nitro::reactnativeappupdate {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "DownloadEvent" and the the Kotlin data class "DownloadEvent".
+   */
+  struct JDownloadEvent final: public jni::JavaClass<JDownloadEvent> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/reactnativeappupdate/DownloadEvent;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct DownloadEvent by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    DownloadEvent toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldType = clazz->getField<jni::JString>("type");
+      jni::local_ref<jni::JString> type = this->getFieldValue(fieldType);
+      static const auto fieldProgress = clazz->getField<double>("progress");
+      double progress = this->getFieldValue(fieldProgress);
+      static const auto fieldMessage = clazz->getField<jni::JString>("message");
+      jni::local_ref<jni::JString> message = this->getFieldValue(fieldMessage);
+      return DownloadEvent(
+        type->toStdString(),
+        progress,
+        message->toStdString()
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JDownloadEvent::javaobject> fromCpp(const DownloadEvent& value) {
+      using JSignature = JDownloadEvent(jni::alias_ref<jni::JString>, double, jni::alias_ref<jni::JString>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        jni::make_jstring(value.type),
+        value.progress,
+        jni::make_jstring(value.message)
+      );
+    }
+  };
+
+} // namespace margelo::nitro::reactnativeappupdate

package/nitrogen/generated/android/c++/JFunc_void_DownloadEvent.hpp

@@ -0,0 +1,78 @@
+///
+/// JFunc_void_DownloadEvent.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include "DownloadEvent.hpp"
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JDownloadEvent.hpp"
+#include <string>
+
+namespace margelo::nitro::reactnativeappupdate {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(event: DownloadEvent) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_DownloadEvent: public jni::JavaClass<JFunc_void_DownloadEvent> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/reactnativeappupdate/Func_void_DownloadEvent;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_DownloadEvent` instance holds through JNI.
+     */
+    void invoke(const DownloadEvent& event) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JDownloadEvent> /* event */)>("invoke");
+      method(self(), JDownloadEvent::fromCpp(event));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_DownloadEvent that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_DownloadEvent_cxx final: public jni::HybridClass<JFunc_void_DownloadEvent_cxx, JFunc_void_DownloadEvent> {
+  public:
+    static jni::local_ref<JFunc_void_DownloadEvent::javaobject> fromCpp(const std::function<void(const DownloadEvent& /* event */)>& func) {
+      return JFunc_void_DownloadEvent_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_DownloadEvent_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JDownloadEvent> event) {
+      _func(event->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const DownloadEvent& /* event */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/reactnativeappupdate/Func_void_DownloadEvent_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_DownloadEvent_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_DownloadEvent_cxx(const std::function<void(const DownloadEvent& /* event */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const DownloadEvent& /* event */)> _func;
+  };
+
+} // namespace margelo::nitro::reactnativeappupdate

package/nitrogen/generated/android/c++/JHybridReactNativeAppUpdateSpec.cpp

@@ -0,0 +1,162 @@
+///
+/// JHybridReactNativeAppUpdateSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#include "JHybridReactNativeAppUpdateSpec.hpp"
+
+// Forward declaration of `AppUpdateDownloadParams` to properly resolve imports.
+namespace margelo::nitro::reactnativeappupdate { struct AppUpdateDownloadParams; }
+// Forward declaration of `AppUpdateFileParams` to properly resolve imports.
+namespace margelo::nitro::reactnativeappupdate { struct AppUpdateFileParams; }
+// Forward declaration of `DownloadEvent` to properly resolve imports.
+namespace margelo::nitro::reactnativeappupdate { struct DownloadEvent; }
+
+#include <NitroModules/Promise.hpp>
+#include <NitroModules/JPromise.hpp>
+#include "AppUpdateDownloadParams.hpp"
+#include "JAppUpdateDownloadParams.hpp"
+#include <string>
+#include "AppUpdateFileParams.hpp"
+#include "JAppUpdateFileParams.hpp"
+#include "DownloadEvent.hpp"
+#include <functional>
+#include "JFunc_void_DownloadEvent.hpp"
+#include <NitroModules/JNICallable.hpp>
+#include "JDownloadEvent.hpp"
+
+namespace margelo::nitro::reactnativeappupdate {
+
+  jni::local_ref<JHybridReactNativeAppUpdateSpec::jhybriddata> JHybridReactNativeAppUpdateSpec::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  void JHybridReactNativeAppUpdateSpec::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridReactNativeAppUpdateSpec::initHybrid),
+    });
+  }
+
+  size_t JHybridReactNativeAppUpdateSpec::getExternalMemorySize() noexcept {
+    static const auto method = javaClassStatic()->getMethod<jlong()>("getMemorySize");
+    return method(_javaPart);
+  }
+
+  void JHybridReactNativeAppUpdateSpec::dispose() noexcept {
+    static const auto method = javaClassStatic()->getMethod<void()>("dispose");
+    method(_javaPart);
+  }
+
+  std::string JHybridReactNativeAppUpdateSpec::toString() {
+    static const auto method = javaClassStatic()->getMethod<jni::JString()>("toString");
+    auto javaString = method(_javaPart);
+    return javaString->toStdString();
+  }
+
+  // Properties
+  
+
+  // Methods
+  std::shared_ptr<Promise<void>> JHybridReactNativeAppUpdateSpec::downloadAPK(const AppUpdateDownloadParams& params) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<JAppUpdateDownloadParams> /* params */)>("downloadAPK");
+    auto __result = method(_javaPart, JAppUpdateDownloadParams::fromCpp(params));
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<void>> JHybridReactNativeAppUpdateSpec::downloadASC(const AppUpdateFileParams& params) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<JAppUpdateFileParams> /* params */)>("downloadASC");
+    auto __result = method(_javaPart, JAppUpdateFileParams::fromCpp(params));
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<void>> JHybridReactNativeAppUpdateSpec::verifyASC(const AppUpdateFileParams& params) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<JAppUpdateFileParams> /* params */)>("verifyASC");
+    auto __result = method(_javaPart, JAppUpdateFileParams::fromCpp(params));
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<void>> JHybridReactNativeAppUpdateSpec::verifyAPK(const AppUpdateFileParams& params) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<JAppUpdateFileParams> /* params */)>("verifyAPK");
+    auto __result = method(_javaPart, JAppUpdateFileParams::fromCpp(params));
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<void>> JHybridReactNativeAppUpdateSpec::installAPK(const AppUpdateFileParams& params) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<JAppUpdateFileParams> /* params */)>("installAPK");
+    auto __result = method(_javaPart, JAppUpdateFileParams::fromCpp(params));
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<void>> JHybridReactNativeAppUpdateSpec::clearCache() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("clearCache");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  double JHybridReactNativeAppUpdateSpec::addDownloadListener(const std::function<void(const DownloadEvent& /* event */)>& callback) {
+    static const auto method = javaClassStatic()->getMethod<double(jni::alias_ref<JFunc_void_DownloadEvent::javaobject> /* callback */)>("addDownloadListener_cxx");
+    auto __result = method(_javaPart, JFunc_void_DownloadEvent_cxx::fromCpp(callback));
+    return __result;
+  }
+  void JHybridReactNativeAppUpdateSpec::removeDownloadListener(double id) {
+    static const auto method = javaClassStatic()->getMethod<void(double /* id */)>("removeDownloadListener");
+    method(_javaPart, id);
+  }
+
+} // namespace margelo::nitro::reactnativeappupdate

package/nitrogen/generated/android/c++/JHybridReactNativeAppUpdateSpec.hpp

@@ -0,0 +1,72 @@
+///
+/// HybridReactNativeAppUpdateSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <NitroModules/JHybridObject.hpp>
+#include <fbjni/fbjni.h>
+#include "HybridReactNativeAppUpdateSpec.hpp"
+
+
+
+
+namespace margelo::nitro::reactnativeappupdate {
+
+  using namespace facebook;
+
+  class JHybridReactNativeAppUpdateSpec: public jni::HybridClass<JHybridReactNativeAppUpdateSpec, JHybridObject>,
+                                         public virtual HybridReactNativeAppUpdateSpec {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/reactnativeappupdate/HybridReactNativeAppUpdateSpec;";
+    static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+    static void registerNatives();
+
+  protected:
+    // C++ constructor (called from Java via `initHybrid()`)
+    explicit JHybridReactNativeAppUpdateSpec(jni::alias_ref<jhybridobject> jThis) :
+      HybridObject(HybridReactNativeAppUpdateSpec::TAG),
+      HybridBase(jThis),
+      _javaPart(jni::make_global(jThis)) {}
+
+  public:
+    ~JHybridReactNativeAppUpdateSpec() override {
+      // Hermes GC can destroy JS objects on a non-JNI Thread.
+      jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
+    }
+
+  public:
+    size_t getExternalMemorySize() noexcept override;
+    void dispose() noexcept override;
+    std::string toString() override;
+
+  public:
+    inline const jni::global_ref<JHybridReactNativeAppUpdateSpec::javaobject>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    std::shared_ptr<Promise<void>> downloadAPK(const AppUpdateDownloadParams& params) override;
+    std::shared_ptr<Promise<void>> downloadASC(const AppUpdateFileParams& params) override;
+    std::shared_ptr<Promise<void>> verifyASC(const AppUpdateFileParams& params) override;
+    std::shared_ptr<Promise<void>> verifyAPK(const AppUpdateFileParams& params) override;
+    std::shared_ptr<Promise<void>> installAPK(const AppUpdateFileParams& params) override;
+    std::shared_ptr<Promise<void>> clearCache() override;
+    double addDownloadListener(const std::function<void(const DownloadEvent& /* event */)>& callback) override;
+    void removeDownloadListener(double id) override;
+
+  private:
+    friend HybridBase;
+    using HybridBase::HybridBase;
+    jni::global_ref<JHybridReactNativeAppUpdateSpec::javaobject> _javaPart;
+  };
+
+} // namespace margelo::nitro::reactnativeappupdate