DOCSEARCHbyAlgolia
Submit Docs

Airborne OTA Updates

website·Indexed 36 days ago

https://airborne.juspay.in/docs/

A platform for shipping over-the-air (OTA) code and asset updates to React Native, Android, and iOS apps without app store delays. It includes a Rust-based control plane server, a React Native SDK for bundle delivery, and the airborne-devkit CLI for managing releases.

Tokens
43.8K
Snippets
164
Records
282
Agent score
42%

What's inside Airborne

  1. Overview of Airborne OTA updates for React Native and JS apps

    Airborne provides over-the-air (OTA) deployment capabilities for React Native and any JavaScript-based mobile applications. It allows developers to bypass app store review delays by deploying code and assets directly to users. Key features include dimension-based targeting for specific user segments, gradual rollouts with instant rollback capabilities, and real-time analytics to monitor deployment success and user adoption.

  2. Overview of Airborne OTA Update System

    Airborne is a system for shipping code and asset updates to React Native, Android, and iOS applications over-the-air (OTA), bypassing the need for app store reviews for every change. It allows developers to bundle JavaScript and assets, target specific user segments, ramp traffic gradually, and perform instant rollbacks. The system can be used via a Juspay-hosted service or by self-hosting the entire stack.

  3. Overview of Airborne Bare Integration for Expo

    The bare Airborne integration for Expo follows the same process as the plain React Native bare flow. It uses the same native dependencies, HyperOTAServices / AirborneServices wiring, and reload-after-download capabilities. This advanced flow is intended for users who need low-level control; otherwise, the React Native SDK Expo track is recommended.

    Prerequisites:

    • Run npx expo prebuild to generate the native android/ and ios/ projects, as the bare flow modifies native code directly.
    • Familiarity with the React Native (bare) integration flow.

  4. Overview of Airborne React Native SDK OTA updates

    The Airborne React Native SDK enables over-the-air (OTA) updates for an app's JavaScript bundle and assets. Instead of relying solely on a static bundle compiled into the binary, the SDK manages the boot process by fetching the latest packages and resources based on a release config. If downloads do not complete within the boot/release timeout, the SDK falls back to the bundled assets shipped with the app binary to ensure the app always boots.

  5. Overview of Airborne Files

    In Airborne, a file is a single artifact (such as a JavaScript bundle, image, or JSON blob) that an app downloads over the air. Each file is identified by a unique file path and hosted at a specific URL. Airborne maintains a full version history for every file path. Files are the building blocks that are later combined into packages and shipped in releases.

  6. Overview of Cohorts and Cohort Dimensions

    A cohort segments users to allow targeting a whole group with a single value in a release, avoiding the need to specify version ranges repeatedly. Cohorts are built upon a cohort dimension (a dimension that depends on a standard dimension). There are two primary ways to define these segments: Checkpoints (version comparisons) and Groups (explicit member lists).

  7. Update Android Application onCreate for Airborne

    Initialize Airborne in the onCreate method of MainApplication before loading React Native. This ensures the SDK can provide the bundle path immediately upon React Native startup. For the New Architecture, set the release level before calling initializeAirborne().
    override fun onCreate() {
    super.onCreate()
    DefaultNewArchitectureEntryPoint.releaseLevel = try {
        ReleaseLevel.valueOf(BuildConfig.REACT_NATIVE_RELEASE_LEVEL.uppercase())
    } catch (e: IllegalArgumentException) {
        ReleaseLevel.STABLE
    }
    initializeAirborne()
    loadReactNative(this)
    ApplicationLifecycleDispatcher.onApplicationCreate(this)
}

  8. Understand the Airborne Organisation and Application hierarchy

    Airborne uses a two-level hierarchy to manage over-the-air updates:

    1. Organisation: The top-level workspace for a team or company. It owns applications and manages the user roster.
    2. Application: A unit within an organisation that represents the target for shipping updates (e.g., one mobile app per platform). All technical assets—including files, packages, releases, dimensions, cohorts, remote configs, views, and tokens—are scoped to a specific application.

  9. Understand the role of Packages in Airborne

    A package is an immutable snapshot that bundles together a set of specific file versions into a single, versioned unit. Every package must have exactly one index file (the main entry point) and can optionally contain multiple supporting package files. Because packages are immutable, updating files requires registering new file versions and creating a new package version.

  10. Create a new application within an organisation

    To create a new application, click + Create Application on the Organisation Overview page. Provide the following details in the dialog:

    • Application name: Required, up to 64 characters.
    • Description: Optional.

    Click 'Create Application' to finalize.

    Best Practice: Create a separate application for each shippable target (e.g., one per platform), as files, packages, releases, and tokens are scoped to a single application.

  11. Understand how Airborne handles OTA bundle loading

    Airborne initializes before React Native mounts to fetch the latest release config and download packages. It blocks the bundle-loading path until the bundle is ready, ensuring the app starts with the correct version:

    • Android: AirborneReactNativeHost.getJSBundleFile() returns airborneInstance.getBundlePath(), which resolves only after the bundle is available.
    • iOS: The startApp delegate method is called with the OTA bundle URL, and React Native starts from that location.

    If the network is unavailable or the timeout is reached during the first launch, Airborne boots using the bundled release config shipped within the app binary and continues updating in the background.

  12. Airborne Server Overview

    The Airborne server is a Rust-based control plane built on Actix-web for managing over-the-air (OTA) updates. It serves two primary roles: a management API for administrative tasks (organizations, apps, files, packages, releases, and RBAC) and a release delivery endpoint that SDKs use to fetch release configurations at boot. The server also hosts the bundled dashboard UI.