@instaread-co/react-native-instaread-sdk 1.3.4

package/CHANGELOG.md

@@ -0,0 +1,86 @@
+# Changelog
+
+## 1.3.4
+
+- Bundles InstareadSDK 1.4.4 (iOS) and 1.3.3 (Android). Both bring the same fix: the mini player
+  now follows `mobile_is_floating_player_enabled` being switched on or off once the app is
+  reopened, instead of keeping whatever it read when the process first started.
+- Android also reserves a few dp below the height the player page reports, so a bottom border or
+  shadow is not clipped on the compact design.
+- No change to this package's own API.
+
+## 1.3.3
+
+- Bundles InstareadSDK 1.4.3 (iOS) and 1.3.2 (Android). Both are documentation-only releases of
+  the native SDKs — the players themselves are byte-for-byte what 1.4.2 and 1.3.1 shipped, so
+  behaviour is unchanged.
+- The README's checksum step is now a command that verifies on its own,
+  `shasum -a 256 -c react-native-instaread-sdk-<version>.sha256`, instead of asking you to compare
+  two hashes by eye.
+- No change to this package's own API.
+
+## 1.3.2
+
+- Bundles InstareadSDK 1.3.1 (Android), which fixes a band of blank space under the player on
+  Android — or a clipped player — depending on which design the publication uses. 1.3.1 of this
+  package shipped the Android SDK from before that fix.
+- iOS is unaffected and stays on InstareadSDK 1.4.2. No change to this package's own API.
+
+## 1.3.1
+
+- Bundles InstareadSDK 1.4.2 (iOS), up from 1.4.0 — which brings 1.4.1's packaging work with it.
+  Nothing changed in the native player itself; both of those iOS releases were packaging only.
+- Android stays on InstareadSDK 1.3.0.
+- No change to this package's own API: `<InstareadPlayerView />` takes the same props and behaves
+  identically.
+
+## 1.3.0
+
+- **Dark mode.** `<InstareadPlayerView dark />` renders the dark player, on both platforms and
+  both Android architectures. Your app decides — the SDK never reads the device's appearance,
+  because an app with its own in-app theme toggle can be dark while the phone is light. The mini
+  player, its playlist sheet and its Now Playing panel follow the article player's palette rather
+  than carrying their own.
+- Bundles InstareadSDK 1.4.0 (iOS) and 1.3.0 (Android).
+
+## 1.2.0
+
+- **Android.** The package now ships both platforms: the Android half hosts the native
+  `InstareadPlayerView` from `co.instaread:sdk` (bundled as an `.aar`) exactly as the iOS half
+  hosts `InstareadSDK.xcframework`. Nothing about the player is reimplemented. The JS API is
+  unchanged — `InstareadPlayer.configure(...)` and `<InstareadPlayerView articleUrl=... />` work
+  the same on both.
+- Supports both Android architectures: a Fabric `ViewManager` with the generated delegate on the
+  new architecture, `@ReactProp` on the old one. Verified running on RN 0.79.7 (old) and 0.87.1
+  (new).
+- The player's height is reported natively and applied in JS, as on iOS. Reported in dp, so it is
+  correct on every screen density.
+- `style` now also ignores `width`/`minWidth`/`maxWidth`, alongside height and flex: the player
+  fills the container it is placed in on every platform, and its size is not the app's to set.
+- Bundles InstareadSDK 1.3.3 (iOS) and 1.2.3 (Android) — see `instareadNativeSdk` in
+  `package.json`.
+
+## 1.1.0
+
+- Bundles InstareadSDK 1.3.3, which adds Apple's privacy manifest (`PrivacyInfo.xcprivacy`) —
+  see `instareadNativeSdk` in `package.json`.
+- `InstareadPlayerView` gains `onReady` and `onError`, its only two signals (see the README). No
+  `onPlay`/`onPause`/`onEnded`/analytics hook — deliberately not exposed.
+- Supports the old architecture (Paper) as well as the New Architecture, so apps on older React
+  Native don't need to upgrade to integrate. Same JS API on both.
+- Widens support down to React Native 0.76 (from 0.84): built and run on 0.76.9, 0.79.7, 0.81.6,
+  0.84.1, 0.86.2 and 0.87.1, Xcode 26, both architectures where the version has one.
+- Codegen spec now imports from React Native's original module paths instead of its newer
+  re-exports, for compatibility across that wider version range.
+- `peerDependencies.react-native` lowered to `>=0.76.0`; `react` un-pinned.
+- `InstareadPlayerView`'s `style` prop no longer accepts height/flex sizing — the player's height
+  was never actually settable through it, so this only makes the type honest.
+- In development builds, warns to the console instead of failing silently when the native module
+  is missing or `UIBackgroundModes` lacks `audio`.
+
+## 1.0.0
+
+- First release. iOS only: on Android the view renders nothing and `configure` does nothing.
+- `InstareadPlayer.configure(publication)` and a self-sizing `<InstareadPlayerView articleUrl />`.
+- Bundles InstareadSDK 1.3.2 (see `instareadNativeSdk` in `package.json`).
+- React Native 0.84+ (built and run on 0.84.1, 0.86.2, 0.87.1), Xcode 26.

package/InstareadReactNative.podspec

@@ -0,0 +1,29 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+# The pod is deliberately not called "InstareadSdk": that differs from the native
+# framework "InstareadSDK" only by case, and on a case-insensitive filesystem the
+# two would share build products and module-cache entries.
+Pod::Spec.new do |s|
+  s.name         = "InstareadReactNative"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = "https://instaread.co"
+  s.license      = { :type => "Proprietary", :file => "LICENSE" }
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => min_ios_version_supported }
+  # Delivered as a zip and linked from the customer's node_modules; never fetched.
+  s.source       = { :path => "." }
+
+  # Not `ios/**`: the XCFramework below carries its own headers.
+  s.source_files = "ios/*.{h,m,mm,swift}"
+  s.private_header_files = "ios/*.h"
+  s.swift_version = "5.0"
+
+  # The native SDK, unchanged. Put it here with scripts/sync-ios-sdk.sh.
+  s.vendored_frameworks = "ios/Frameworks/InstareadSDK.xcframework"
+
+  install_modules_dependencies(s)
+end

package/LICENSE

@@ -0,0 +1,9 @@
+Copyright (c) 2026 Instaread. All rights reserved.
+
+This software is proprietary to Instaread. It is provided to Instaread
+customers for use in their own applications, under the terms of their agreement
+with Instaread. Without such an agreement no right to use, copy, modify or
+distribute it is granted.
+
+The package includes a compiled copy of InstareadSDK, which is covered by the
+same terms.

package/README.md

@@ -0,0 +1,146 @@
+# react-native-instaread-sdk
+
+Audio player for article screens in React Native, on iOS and Android. It hosts the native
+InstareadSDK, which renders Instaread's real web player inside a WebView — so it looks and
+behaves exactly like the web player — publishes it to the lock screen (and the notification
+shade on Android), and shows a floating mini player above your app while something plays.
+
+- **Same player as the web.** Nothing is re-implemented in JavaScript, and there is no
+  `react-native-webview` dependency.
+- **Read-only.** It plays audio that already exists for an article. It never triggers audio
+  generation.
+- **Server-driven.** Player design, colours and whether the mini player is on come from the
+  server per publication, so most changes need no app release.
+- **Both platforms, one API.** The same JavaScript runs on iOS and Android, and on both Android
+  architectures (New and old/Paper).
+
+## Requirements
+
+| | |
+|---|---|
+| React Native | 0.76 or newer, either architecture (New or old/Paper). Built and run on 0.76.9, 0.79.7, 0.81.6, 0.84.1, 0.86.2 and 0.87.1 — old architecture on 0.76–0.81 (the versions that still have one), New Architecture on all six |
+| iOS | 13.0+. Built with Xcode 26 |
+| Android | API 24 (7.0)+ |
+| Your `Info.plist` (iOS) | `UIBackgroundModes` containing `audio` — see below |
+| Android permissions | `FOREGROUND_SERVICE` and `FOREGROUND_SERVICE_MEDIA_PLAYBACK` are merged in for you. `POST_NOTIFICATIONS` on Android 13+ is yours to request — without it audio still plays, but the notification and lock-screen card do not appear |
+| Network | HTTPS to `player.instaread.co` and `player-api.instaread.co`. No ATS exceptions needed |
+| Permissions prompts | None from the SDK. No entitlements |
+
+**`UIBackgroundModes` → `audio` is yours to add.** It belongs to your app bundle; the SDK cannot
+grant it. Without it, playback stops and the lock screen goes empty as soon as the screen locks.
+
+```xml
+<key>UIBackgroundModes</key>
+<array>
+    <string>audio</string>
+</array>
+```
+
+## Install
+
+You receive `react-native-instaread-sdk-<version>.zip`. Nothing to publish or download from a
+registry; the native SDK is inside.
+
+1. Unzip it into your project, e.g. `vendor/`. Keep the folder inside your project.
+2. Add it as a dependency:
+
+   ```sh
+   npm install ./vendor/react-native-instaread-sdk
+   # yarn:  yarn add file:./vendor/react-native-instaread-sdk
+   ```
+
+3. Install pods:
+
+   ```sh
+   cd ios && pod install
+   ```
+
+4. iOS: add `audio` to `UIBackgroundModes` (above), then rebuild.
+5. Android: nothing else. Rebuild the app.
+
+To verify the download, run `shasum -a 256 -c react-native-instaread-sdk-<version>.sha256` next to the zip. It prints `OK`.
+
+## Use
+
+```tsx
+import { InstareadPlayer, InstareadPlayerView } from 'react-native-instaread-sdk';
+
+// Once, at app start — before anything renders.
+InstareadPlayer.configure('yourslug');
+
+// Wherever the player goes on an article screen.
+<InstareadPlayerView articleUrl={article.canonicalUrl} />
+```
+
+That is the whole integration. There is no client to create and nothing to pass around: every
+`InstareadPlayerView` and the mini player share the SDK's own state, so pressing Play on one
+article's player shows up in the mini player anywhere else in your app.
+
+## API
+
+| | Notes |
+|---|---|
+| `InstareadPlayer.configure(publication)` | Once, at startup. Sets the publication `InstareadPlayerView` uses and shows the mini player in its own window above your app (above your tab bar if you have one). |
+| `<InstareadPlayerView articleUrl publication? style? onReady? onError? />` | `articleUrl` is the article's own page URL, the same one the web player is given. `publication` overrides the configured slug for this one player. `style` is for layout only (margins, alignment) — the height is the player's own. |
+
+`InstareadPlayerView` sizes itself: zero height until there is something to show, then the
+loader, then the player. It never scrolls on its own, so place it inside your article's
+`ScrollView`.
+
+**`onReady` and `onError`** are the only two signals the player gives your code:
+
+- `onReady()` fires once the player has shown something for this article — the player itself, or
+  Instaread's "Audio Coming Soon" state. Changing `articleUrl` or `publication` resets it.
+- `onError()` fires once if nothing has rendered about 15 seconds after mounting (or after
+  `articleUrl`/`publication` changes) — usually a wrong or not-yet-enabled `publication`, or no
+  network. It's a guess made on the React Native side, not a report from the player itself: the
+  native SDK never distinguishes a real failure from an unusually slow load, so `onError` can fire
+  on a slow connection that would have come through fine a moment later. It never fires once
+  `onReady` has.
+
+There is deliberately no `onPlay`/`onPause`/`onEnded`/analytics hook: what happens inside the
+player, and the mini player's own behaviour, are not exposed — see *How it behaves* below.
+
+## How it behaves
+
+- **`publication`** is your Instaread slug. It must match exactly, and Instaread must have set it
+  up for the app SDK.
+- **An article whose audio isn't ready** shows Instaread's "Audio Coming Soon" state. The SDK
+  never starts audio processing.
+- **The mini player** only appears for publications where it is switched on (see below). Leaving
+  an article screen while it plays keeps the audio going, controlled from the mini player.
+
+## Server-side settings
+
+Set per publication by Instaread, not in the app — which is why they change without a release:
+
+| Key | Effect |
+|---|---|
+| `mobile_playerType` | Inline design: `acoustic` (default), `compact` or `rectangular` |
+| `mobile_is_floating_player_enabled` | Whether the mini player exists at all. **Off by default — the usual reason a mini player never appears** |
+| `mobile_mini_player_bottom_height` | Extra points the mini bar sits above the bottom. `0` by default. Use it when your bottom UI isn't a native `UITabBar` (React Navigation's bottom tabs, for instance, are not one — ask Instaread to set this) |
+
+## Privacy
+
+The native SDK ships Apple's privacy manifest (`PrivacyInfo.xcprivacy`) inside the framework.
+It collects an anonymous device ID (a random UUID kept in the Keychain, not the advertising ID)
+and playback interactions, for analytics and app functionality, not linked to identity and not
+used for tracking. Your own App Store privacy label is still yours to fill in.
+
+## Troubleshooting
+
+| Symptom | Likely cause |
+|---|---|
+| Nothing shows | Wrong `publication` slug, or not enabled for the app SDK. Check that `configure` ran before the first `InstareadPlayerView` |
+| Player works, no mini player | `mobile_is_floating_player_enabled` is off for the publication |
+| Audio stops when the screen locks (iOS) | `UIBackgroundModes` → `audio` missing from your `Info.plist` |
+| No notification or lock-screen card (Android 13+) | Your app has not requested `POST_NOTIFICATIONS` |
+| Mini player covers your bottom tab bar | It is not a native `UITabBar`; ask Instaread to set `mobile_mini_player_bottom_height` |
+| `pod install` can't find `InstareadReactNative` | The folder was unzipped outside your project, or `npm install` wasn't re-run after moving it |
+
+In a Debug build the native SDK prints reasons prefixed `InstareadSDK:` — to the Xcode console on
+iOS, to logcat on Android. A release build prints nothing.
+
+## License
+
+Proprietary. See `LICENSE`.

package/android/build.gradle

@@ -0,0 +1,105 @@
+// The Android half of the wrapper. It hosts the native InstareadSDK for
+// Android exactly as the iOS half hosts InstareadSDK.xcframework: the SDK is
+// bundled, used through its public API, and nothing about the player is
+// reimplemented here.
+
+buildscript {
+  repositories {
+    google()
+    mavenCentral()
+  }
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.7.2"
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:2.0.21"
+  }
+}
+
+apply plugin: "com.android.library"
+apply plugin: "org.jetbrains.kotlin.android"
+apply plugin: "com.facebook.react"
+
+def reactNativeArchitectures() {
+  def value = rootProject.getProperties().get("reactNativeArchitectures")
+  return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
+}
+
+def isNewArchitectureEnabled() {
+  return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
+}
+
+android {
+  namespace "com.instaread.reactnative"
+
+  compileSdkVersion safeExtGet("compileSdkVersion", 35)
+
+  defaultConfig {
+    // The native SDK's own floor; raising it here would raise it for every
+    // app that installs this package.
+    minSdkVersion safeExtGet("minSdkVersion", 24)
+    targetSdkVersion safeExtGet("targetSdkVersion", 35)
+    buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
+  }
+
+  buildFeatures {
+    buildConfig true
+  }
+
+  sourceSets {
+    main {
+      // The generated ViewManagerDelegate/interface differ between the two
+      // architectures, so each gets its own thin ViewManager subclass and the
+      // shared code stays in src/main.
+      if (isNewArchitectureEnabled()) {
+        java.srcDirs += ["src/newarch"]
+      } else {
+        java.srcDirs += ["src/oldarch"]
+      }
+    }
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_17
+    targetCompatibility JavaVersion.VERSION_17
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+  }
+}
+
+kotlin {
+  jvmToolchain(17)
+}
+
+repositories {
+  mavenCentral()
+  google()
+}
+
+dependencies {
+  implementation "com.facebook.react:react-android"
+
+  // The native SDK, vendored by scripts/sync-android-sdk.sh. A plain file
+  // dependency rather than the Maven repository the customer zip ships:
+  // a library module that declares its own repositories{} breaks any app whose
+  // settings.gradle uses FAIL_ON_PROJECT_REPOS, and this wrapper must not care
+  // how a partner's Gradle is set up.
+  implementation files("$projectDir/libs/instaread-sdk.aar")
+
+  // An .aar carries no dependency metadata, so the SDK's own dependencies are
+  // declared here instead. sync-android-sdk.sh reads them out of the SDK's POM
+  // and fails if this list has drifted — do not edit these by hand.
+  implementation "androidx.media:media:1.7.0"
+  implementation "androidx.core:core-ktx:1.13.1"
+  implementation "androidx.startup:startup-runtime:1.2.0"
+}
+
+react {
+  jsRootDir = file("../src/")
+  libraryName = "InstareadReactNative"
+  codegenJavaPackageName = "com.instaread.reactnative"
+}
+
+def safeExtGet(prop, fallback) {
+  rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+}

package/android/libs/instaread-sdk.version

@@ -0,0 +1 @@
+1.3.3

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,6 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+    <!-- Empty on purpose. Everything the player needs — the FOREGROUND_SERVICE
+         permissions, the playback service and the androidx.startup initializer
+         — is declared by the native SDK's own manifest and merged in from the
+         .aar, exactly as it is for a plain Android app. -->
+</manifest>

package/android/src/main/java/com/instaread/reactnative/InstareadNativePlayerViewManagerBase.kt

@@ -0,0 +1,38 @@
+package com.instaread.reactnative
+
+import com.facebook.react.uimanager.SimpleViewManager
+import com.facebook.react.uimanager.ThemedReactContext
+
+/**
+ * Everything the two architectures share. The only difference between them is
+ * how props reach the view — the new architecture goes through a generated
+ * delegate, the old one through `@ReactProp` — so each has a thin subclass in
+ * src/newarch and src/oldarch and the real work stays here.
+ */
+abstract class InstareadNativePlayerViewManagerBase : SimpleViewManager<InstareadPlayerHostView>() {
+
+    override fun getName() = NAME
+
+    public override fun createViewInstance(context: ThemedReactContext) =
+        InstareadPlayerHostView(context)
+
+    /** Runs once per update after every prop has been set — see the view's own
+     * note on why the player is built here rather than in a setter. */
+    override fun onAfterUpdateTransaction(view: InstareadPlayerHostView) {
+        super.onAfterUpdateTransaction(view)
+        view.commitProps()
+    }
+
+    /** Makes `onHeightChange` reach the JS prop of the same name. */
+    override fun getExportedCustomDirectEventTypeConstants(): MutableMap<String, Any> =
+        mutableMapOf(
+            InstareadPlayerHostView.HEIGHT_CHANGE_EVENT to
+                mapOf("registrationName" to InstareadPlayerHostView.HEIGHT_CHANGE_EVENT),
+        )
+
+    companion object {
+        /** Must match the name given to codegenNativeComponent in
+         * src/InstareadNativePlayerNativeComponent.ts. */
+        const val NAME = "InstareadNativePlayer"
+    }
+}

package/android/src/main/java/com/instaread/reactnative/InstareadPlayerHostView.kt

@@ -0,0 +1,133 @@
+package com.instaread.reactnative
+
+import android.view.View
+import android.widget.FrameLayout
+import co.instaread.sdk.InstareadPlayerView
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.uimanager.events.Event
+
+/**
+ * Hosts one native `InstareadPlayerView` and reports how tall it wants to be —
+ * the Android counterpart of InstareadPlayerHost.swift, and the only place this
+ * wrapper touches the SDK. It uses the SDK's public API exactly as a plain
+ * Android app would and adds nothing to it.
+ *
+ * The player sizes itself (zero height, then the loading placeholder, then the
+ * player), but a React Native view's height comes from JS. So this measures the
+ * player after every layout pass and hands the height to `onHeightChange`; JS
+ * turns it into the component's height. Same contract as iOS, which reads
+ * `intrinsicContentSize` for the same reason.
+ */
+class InstareadPlayerHostView(private val reactContext: ThemedReactContext) :
+    FrameLayout(reactContext) {
+
+    private var player: InstareadPlayerView? = null
+    private var publication = ""
+    private var articleUrl = ""
+    private var dark = false
+    private var reportedHeightDp = 0.0
+    private var pendingPublication = ""
+    private var pendingArticleUrl = ""
+    private var pendingDark = false
+
+    // Props arrive one at a time; the player is built once both have landed,
+    // from onAfterUpdateTransaction. Building on each setter would load the
+    // article twice whenever both change together.
+    fun setPublicationProp(value: String?) {
+        pendingPublication = value ?: ""
+    }
+
+    fun setArticleUrlProp(value: String?) {
+        pendingArticleUrl = value ?: ""
+    }
+
+    fun setDarkProp(value: Boolean) {
+        pendingDark = value
+    }
+
+    fun commitProps() {
+        if (pendingPublication == publication && pendingArticleUrl == articleUrl && pendingDark == dark) return
+        publication = pendingPublication
+        articleUrl = pendingArticleUrl
+        dark = pendingDark
+        rebuildPlayer()
+    }
+
+    private fun rebuildPlayer() {
+        player?.let { removeView(it) }
+        player = null
+        reportedHeightDp = 0.0
+
+        // Nothing to show without an article; an empty publication falls back
+        // to the one passed to InstareadPlayer.configure.
+        if (articleUrl.isNotEmpty()) {
+            val created = if (publication.isEmpty()) {
+                InstareadPlayerView(context, articleUrl, null, dark)
+            } else {
+                InstareadPlayerView(context, articleUrl, publication, dark)
+            }
+            addView(created, LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT))
+            player = created
+        }
+        requestLayout()
+    }
+
+    /**
+     * React Native lays its own views out and never runs Android's layout pass
+     * on their children, so a plain `requestLayout()` from the player — which
+     * is how it announces its measured height once the page has rendered —
+     * would go nowhere. Re-running measure/layout here is what makes the
+     * player's own sizing reach JS at all.
+     */
+    override fun requestLayout() {
+        super.requestLayout()
+        post(measureAndLayout)
+    }
+
+    private val measureAndLayout = Runnable {
+        measure(
+            MeasureSpec.makeMeasureSpec(width, MeasureSpec.EXACTLY),
+            MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED),
+        )
+        layout(left, top, right, bottom)
+        reportHeightIfNeeded()
+    }
+
+    private fun reportHeightIfNeeded() {
+        // In density-independent pixels: JS style values are dp, the measured
+        // value is px. Sending px would make the player several times too tall
+        // on any real handset.
+        val density = resources.displayMetrics.density
+        val heightDp = ((player?.measuredHeight ?: 0) / density).toDouble()
+        if (kotlin.math.abs(heightDp - reportedHeightDp) < 0.5) return
+        reportedHeightDp = heightDp
+
+        val surfaceId = UIManagerHelper.getSurfaceId(reactContext)
+        UIManagerHelper.getEventDispatcherForReactTag(reactContext, id)
+            ?.dispatchEvent(HeightChangeEvent(surfaceId, id, heightDp))
+    }
+
+    /** Dispatched through the EventDispatcher rather than RCTEventEmitter, so
+     * the same code path works on both the old and the new architecture. */
+    private class HeightChangeEvent(
+        surfaceId: Int,
+        viewId: Int,
+        private val heightDp: Double,
+    ) : Event<HeightChangeEvent>(surfaceId, viewId) {
+        override fun getEventName() = EVENT_NAME
+
+        override fun getEventData(): WritableMap =
+            Arguments.createMap().apply { putDouble("height", heightDp) }
+
+        companion object {
+            const val EVENT_NAME = "onHeightChange"
+        }
+    }
+
+    companion object {
+        const val HEIGHT_CHANGE_EVENT = HeightChangeEvent.EVENT_NAME
+    }
+}

package/android/src/main/java/com/instaread/reactnative/InstareadReactNativeModule.kt

@@ -0,0 +1,35 @@
+package com.instaread.reactnative
+
+import co.instaread.sdk.InstareadPlayer
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.module.annotations.ReactModule
+
+/**
+ * `InstareadPlayer.configure(publication)` for JS — the Android half of
+ * InstareadBridge in InstareadPlayerHost.swift.
+ *
+ * Declared as a plain module rather than against the generated TurboModule
+ * spec so one class serves both architectures: JS reaches it through
+ * `TurboModuleRegistry.get`, which falls back to the legacy registry.
+ */
+@ReactModule(name = InstareadReactNativeModule.NAME)
+class InstareadReactNativeModule(reactContext: ReactApplicationContext) :
+    ReactContextBaseJavaModule(reactContext) {
+
+    override fun getName() = NAME
+
+    @ReactMethod
+    fun configure(publication: String) {
+        val application = reactApplicationContext.applicationContext as? android.app.Application ?: return
+        // The SDK's own entry point, unchanged: sets the publication every
+        // player uses and brings up the mini player.
+        InstareadPlayer.configure(application, publication)
+    }
+
+    companion object {
+        /** Must match the name in src/NativeInstareadReactNative.ts. */
+        const val NAME = "InstareadReactNative"
+    }
+}

package/android/src/main/java/com/instaread/reactnative/InstareadReactNativePackage.kt

@@ -0,0 +1,20 @@
+package com.instaread.reactnative
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+/**
+ * What React Native's autolinking finds. Registers the two things this package
+ * exposes: the player view and `InstareadPlayer.configure`.
+ */
+class InstareadReactNativePackage : ReactPackage {
+
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> =
+        listOf(InstareadReactNativeModule(reactContext))
+
+    override fun createViewManagers(
+        reactContext: ReactApplicationContext,
+    ): List<ViewManager<*, *>> = listOf(InstareadNativePlayerViewManager())
+}

package/android/src/newarch/java/com/instaread/reactnative/InstareadNativePlayerViewManager.kt

@@ -0,0 +1,33 @@
+package com.instaread.reactnative
+
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.ViewManagerDelegate
+import com.facebook.react.viewmanagers.InstareadNativePlayerManagerDelegate
+import com.facebook.react.viewmanagers.InstareadNativePlayerManagerInterface
+
+/**
+ * New architecture (Fabric). Props arrive through the delegate generated from
+ * src/InstareadNativePlayerNativeComponent.ts, so this class only forwards
+ * them; everything else is in the shared base.
+ */
+@ReactModule(name = InstareadNativePlayerViewManagerBase.NAME)
+class InstareadNativePlayerViewManager :
+    InstareadNativePlayerViewManagerBase(),
+    InstareadNativePlayerManagerInterface<InstareadPlayerHostView> {
+
+    private val delegate = InstareadNativePlayerManagerDelegate(this)
+
+    override fun getDelegate(): ViewManagerDelegate<InstareadPlayerHostView> = delegate
+
+    override fun setPublication(view: InstareadPlayerHostView, value: String?) {
+        view.setPublicationProp(value)
+    }
+
+    override fun setArticleUrl(view: InstareadPlayerHostView, value: String?) {
+        view.setArticleUrlProp(value)
+    }
+
+    override fun setDark(view: InstareadPlayerHostView, value: Boolean) {
+        view.setDarkProp(value)
+    }
+}