React Native SDK

npm install react-native-appspacer

cd ios && pod install && cd ..

npx appspacer setup

// MainApplication.kt
import com.facebook.react.ReactHostDelegate
import com.facebook.react.ReactHostImpl
 
override val reactHost: ReactHost by lazy {
    val delegate = object : ReactHostDelegate {
        override fun getJsBundleFilePath(): String? =
            com.appspacer.AppSpacerModule.getCustomBundlePath(applicationContext)
 
        override fun getJsMainModulePath(): String = "index"
 
        override fun getReactPackages(): List<ReactPackage> =
            PackageList(this@MainApplication).packages
    }
 
    ReactHostImpl(applicationContext, delegate, SurfaceDelegateFactory { null }, true, true)
}

// MainApplication.kt
override val reactNativeHost: ReactNativeHost =
    object : DefaultReactNativeHost(this) {
        override fun getJSBundleFile(): String? =
            com.appspacer.AppSpacerModule.getCustomBundlePath(applicationContext)
 
        override fun getJSMainModuleName(): String = "index"
 
        override fun getPackages(): List<ReactPackage> =
            PackageList(this@MainApplication).packages
 
        override fun getUseDeveloperSupport(): Boolean = BuildConfig.DEBUG
    }

#import <AppSpacerModule.h>
 
- (NSURL *)bundleURL {
  return [AppSpacerModule bundleURL];
}

import AppSpacerModule
 
override func bundleURL() -> URL? {
    return AppSpacerModule.bundleURL()
}

import { AppSpacer } from 'react-native-appspacer';
 
AppSpacer.init({
  apiUrl: 'https://your-api.example.com/api',
  deploymentKey: 'sk_YOUR_DEPLOYMENT_KEY',
  appVersion: '1.0.0',
});

AppSpacer.init({
  apiUrl: 'https://your-api.example.com/api',
  deploymentKey: 'sk_YOUR_DEPLOYMENT_KEY',
  appVersion: '1.0.0',
  checkInterval: 300,
});

import { withAppSpacer, InstallMode, UpdateUIType } from 'react-native-appspacer';
 
const App = () => {
  return <MainNavigator />;
};
 
export default withAppSpacer({
  deploymentKey: 'sk_YOUR_DEPLOYMENT_KEY',
  appVersion: '1.0.0',
  updateDialog: true,                // Show premium themed update prompt
  updateUI: UpdateUIType.GLASS,       // Choose from 5 visual themes
  installMode: InstallMode.IMMEDIATE, // Restart immediately after install
})(App);

import { useEffect } from 'react';
import { AppSpacer, InstallMode } from 'react-native-appspacer';
 
function App() {
  useEffect(() => {
    AppSpacer.sync({ installMode: InstallMode.IMMEDIATE });
  }, []);
 
  return <MainApp />;
}

import { useEffect } from 'react';
import { AppSpacer, InstallMode } from 'react-native-appspacer';
 
function App() {
  useEffect(() => {
    AppSpacer.sync({ installMode: InstallMode.ON_NEXT_RESTART });
  }, []);
 
  return <MainApp />;
}

import { useEffect } from 'react';
import { AppSpacer, InstallMode } from 'react-native-appspacer';
 
function App() {
  useEffect(() => {
    AppSpacer.sync({ installMode: InstallMode.ON_NEXT_RESUME });
  }, []);
 
  return <MainApp />;
}

import { useEffect } from 'react';
import { View, Text, Button, ActivityIndicator } from 'react-native';
import { useAppSpacerUpdate, UpdateStatus } from 'react-native-appspacer';
 
function App() {
  const { status, update, error, checkForUpdate, downloadUpdate, restartApp } =
    useAppSpacerUpdate();
 
  useEffect(() => {
    checkForUpdate();
  }, []);
 
  if (status === UpdateStatus.CHECKING) {
    return (
      <View style={{ flex: 1, justifyContent: 'center', alignItems: 'center' }}>
        <ActivityIndicator size="large" />
        <Text>Checking for updates...</Text>
      </View>
    );
  }
 
  if (status === UpdateStatus.UPDATE_AVAILABLE && update) {
    return (
      <View style={{ flex: 1, justifyContent: 'center', alignItems: 'center' }}>
        <Text style={{ fontSize: 18, fontWeight: 'bold' }}>Update Available</Text>
        <Text>{update.description}</Text>
        {update.packageSize && (
          <Text style={{ color: '#666' }}>
            Size: {(update.packageSize / 1024 / 1024).toFixed(1)} MB
          </Text>
        )}
        <Button title="Download & Install" onPress={downloadUpdate} />
      </View>
    );
  }
 
  if (status === UpdateStatus.DOWNLOADING) {
    return (
      <View style={{ flex: 1, justifyContent: 'center', alignItems: 'center' }}>
        <ActivityIndicator size="large" />
        <Text>Downloading update...</Text>
      </View>
    );
  }
 
  if (status === UpdateStatus.INSTALLED) {
    return (
      <View style={{ flex: 1, justifyContent: 'center', alignItems: 'center' }}>
        <Text style={{ fontSize: 18 }}>✅ Update Ready</Text>
        <Button title="Restart to Apply" onPress={restartApp} />
      </View>
    );
  }
 
  if (status === UpdateStatus.ERROR) {
    return (
      <View style={{ flex: 1, justifyContent: 'center', alignItems: 'center' }}>
        <Text style={{ color: 'red' }}>Update error: {error}</Text>
        <Button title="Retry" onPress={checkForUpdate} />
      </View>
    );
  }
 
  return <MainApp />;
}

import { useEffect } from 'react';
import { AppSpacer } from 'react-native-appspacer';
 
function App() {
  useEffect(() => {
    // Mandatory updates → auto IMMEDIATE
    // Optional updates → ON_NEXT_RESTART
    AppSpacer.sync();
  }, []);
 
  return <MainApp />;
}

import { useAppSpacerUpdate } from 'react-native-appspacer';
 
const {
  status,          // UpdateStatus — current state of the update process
  update,          // AppSpacerUpdate | null — info about available update
  error,           // string | null — error message when status is ERROR
  checkForUpdate,  // () => Promise<void> — check server for updates
  downloadUpdate,  // () => Promise<void> — download and verify pending update
  restartApp,      // () => void — reload app with new bundle
  sync,            // (options?) => Promise<void> — full lifecycle helper
} = useAppSpacerUpdate();

AppSpacer.init({
  apiUrl: 'https://your-api.example.com/api',
  deploymentKey: 'sk_YOUR_KEY',
  appVersion: '1.0.0',
  checkInterval: 0,
});

const update = await AppSpacer.checkForUpdate();
 
if (update.updateAvailable) {
  console.log('New version:', update.label);
  console.log('Description:', update.description);
  console.log('Mandatory:', update.mandatory);
  console.log('Size:', update.packageSize, 'bytes');
}

await AppSpacer.downloadUpdate();
// Update is now on disk, verified, and ready — restart to apply

// Auto-restart immediately
await AppSpacer.sync({ installMode: InstallMode.IMMEDIATE });
 
// Apply on next cold start
await AppSpacer.sync({ installMode: InstallMode.ON_NEXT_RESTART });
 
// Apply when app comes back from background
await AppSpacer.sync({ installMode: InstallMode.ON_NEXT_RESUME });
 
// Default: IMMEDIATE for mandatory, ON_NEXT_RESTART for optional
await AppSpacer.sync();

AppSpacer.restartApp();

AppSpacer.notifyAppReady();

const status = AppSpacer.getStatus(); // e.g. UpdateStatus.IDLE

const unsubscribe = AppSpacer.onStatusChange((status, detail) => {
  console.log('Status changed:', status, detail);
});
 
// Later:
unsubscribe();

AppSpacer.destroy();

interface AppSpacerConfig {
  apiUrl?: string;         // Backend URL (default: https://api.appspacer.com/api)
  deploymentKey: string;   // Deployment key (e.g. "sk_xxxx")
  appVersion: string;      // Native app version (e.g. "1.0.0")
  checkInterval?: number;  // Auto-check interval in seconds (default: 0)
}

interface AppSpacerUpdate {
  updateAvailable: boolean;  // Whether an update is available
  releaseId?: string;        // Server-assigned release ID
  packageUrl?: string;       // Download URL for the zip
  hash?: string;             // SHA-256 hash for verification
  mandatory?: boolean;       // Whether this is a mandatory update
  description?: string;      // Release description
  label?: string;            // Release label (e.g. "v1", "v2")
  packageSize?: number;      // Package size in bytes
}

enum UpdateStatus {
  IDLE              // No update activity
  CHECKING          // Checking the server
  UPDATE_AVAILABLE  // An update is available
  DOWNLOADING       // Downloading the bundle
  INSTALLING        // Verifying and installing
  INSTALLED         // Ready, awaiting restart
  UP_TO_DATE        // Already on latest version
  ERROR             // Something went wrong
}

enum InstallMode {
  IMMEDIATE        // Restart immediately after install
  ON_NEXT_RESTART  // Apply on next cold start
  ON_NEXT_RESUME   // Apply when app returns from background
}

enum UpdateUIType {
  PREMIUM_DARK   // Sleek dark mode with glow effects (default)
  GLASS          // Modern glassmorphism
  MINIMAL        // Clean minimalist light theme
  BOTTOM_SHEET   // iOS-inspired slide-up sheet
  FULL_SCREEN    // Immersive full-screen experience
}

interface UpdateDialogOptions {
  title?: string;                       // Default: "Update Available"
  message?: string;                     // Default: "An update is available..."
  installButtonLabel?: string;          // Default: "Install"
  ignoreButtonLabel?: string;           // Default: "Ignore"
  mandatoryContinueButtonLabel?: string; // Default: "Continue"
  mandatoryUpdateMessage?: string;       // Default: "An update is available that must be installed."
  appendReleaseDescription?: boolean;   // Default: true
}

App Boots
   ↓
AppSpacer.init()  ← calls notifyAppReady() automatically
   ↓
IDLE → CHECKING → (no update) → UP_TO_DATE
                → (update found) → UPDATE_AVAILABLE
                                       ↓
                                  DOWNLOADING
                                       ↓
                                  INSTALLING
                                       ↓
                                  INSTALLED
                                       ↓
                            ┌──────────┼──────────────┐
                            ↓          ↓              ↓
                       IMMEDIATE   ON_NEXT_RESTART  ON_NEXT_RESUME
                       (restart    (waits for       (waits for app
                        now)        cold start)      to resume)
                            ↓          ↓              ↓
                        App reloads with new bundle
                            ↓
                     notifyAppReady() ← confirms update is stable