Lifecycle

Synchronous on the calling thread; safe from the main thread.

fun notifyAppReady()

Method on the NitroPushClient. Returns a Promise but resolves on the next tick — feel free to fire-and-forget.

client.notifyAppReady(): Promise<void>;

From a Lifecycle observer in MainActivity, OR after your splash screen finishes.

import com.nitropush.sdk.NitroPushSdk

override fun onResume() {
  super.onResume()
  NitroPushSdk.shared.notifyAppReady()
}

From a top-level useEffect that runs on every mount of your root component.

import { useEffect } from 'react';
import { client } from './updates'; // wherever you called configureWith()

export function App() {
  useEffect(() => {
    client.notifyAppReady().catch(() => {});
  }, []);
  return /* your app */;
}

Throws on integrity failure (the staged bundle's hash didn't match).

fun restartApp(onlyIfUpdateIsPending: Boolean)

Resolves once the bridge has been told to reload.

client.restartApp(onlyIfUpdateIsPending: boolean): Promise<void>;

Call after presenting the user-facing confirmation.

NitroPushSdk.shared.restartApp(onlyIfUpdateIsPending = true)

Wire it to a button onPress.

await client.restartApp(true);

No-ops if the releaseId isn't reachable from the current pointers.

NitroPushSdk.shared.rollback("rel-abc-123")

On the LocalPackage instance (returned from getCurrentPackage / getPendingPackage / remote.download). Mirrors local.install().

// Scoped to a package — no releaseId needed; the LocalPackage already
// knows its own id.
const pending = await client.getPendingPackage();
if (pending) {
  await pending.rollback();
}

Synchronous; safe from any thread.

NitroPushSdk.shared.clearPendingUpdate()

Not exposed via JS. From JS, the equivalent is calling `pending.rollback()` on the LocalPackage returned by `client.getPendingPackage()`.

// No top-level / client equivalent. Use the LocalPackage method:
const pending = await client.getPendingPackage();
if (pending) await pending.rollback();

NitroPushSdk.shared.clearUpdates()

await client.clearUpdates();

Both methods return NlLocalPackage? — synchronous, safe to call from any thread.

val active = NitroPushSdk.shared.getCurrentPackage()  // running now
val pending = NitroPushSdk.shared.getPendingPackage() // staged for next activation

if (pending != null) {
  println("Update ready: ${pending.label}")
}

JS exposes a sync variant on the client too (`getUpdateMetadataSync`) for first-paint usage.

import { client } from './updates';

// Async — what's running now (or null when on the binary bundle).
const running = await client.getCurrentPackage();

// Sync variant — useful for showing the running version on a settings
// screen at first paint without a microtask hop.
const runningSync = client.getUpdateMetadataSync();

// Async — what's staged for next activation.
const pending = await client.getPendingPackage();
if (pending) {
  // show "Update ready — restart to apply"
}

Call from ReactNativeHost.getJSBundleFile() — returns null if no OTA is active.

override fun getJSBundleFile(): String? {
  if (BuildConfig.DEBUG) return null
  return NitroPushSdk.shared.activeBundleFile()
}

Returns a numeric listener id; pass it to remove.

val id = NitroPushSdk.shared.addDownloadProgressListener { p ->
  println("${p.receivedBytes} / ${p.totalBytes}")
}
// later
NitroPushSdk.shared.removeDownloadProgressListener(id)

No top-level subscription. Use sync()'s onProgress or remote.download(onProgress) on the manual flow.

// JS: progress is per-call. Two equivalent forms:

// 1. Through sync()'s fourth arg.
await sync(client, {}, undefined, (p) => {
  console.log(`${p.receivedBytes} / ${p.totalBytes}`);
});

// 2. Manual flow — the callback lives on remote.download.
const remote = await client.checkForUpdate();
if (remote) {
  const local = await remote.download((p) => {
    console.log(`${p.receivedBytes} / ${p.totalBytes}`);
  });
  await local.install(InstallMode.ON_NEXT_RESTART, 0);
}

Logs via android.util.Log.i (and .w for failures). Tag: NitroPush. Tail with `adb logcat | grep NitroPush`.

// In MainApplication.onCreate, after configure():
NitroPushSdk.shared.setEnableLogs(true)
// → I/NitroPush: configure serverUrl=… deploymentKey=… …
//   I/NitroPush: checkForUpdate GET http://…/api/sdk/releases/latest?…
//   I/NitroPush: downloadManifestRelease GET https://…/manifest.json
//   I/NitroPush: installUpdate.ON_NEXT_RESTART staged; will activate on next cold start
//   I/NitroPush: notifyAppReady → install_completed releaseId=…

Not exposed via JS — toggle from native at bootstrap time. The native trace covers JS-triggered calls too.

// No JS toggle today. Flip it on from MainApplication.kt / AppDelegate.swift.
// The native trace covers everything — including calls triggered from JS.