@radhya/mach-push-react-native 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Radhya Softlabs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,37 @@
+# @radhya/mach-push-react-native
+
+Provider-neutral MACH Push for bare React Native and Expo development builds.
+
+The recommended setup requires no application wiring:
+
+```bash
+mach push setup
+```
+
+The command installs this package, adds automatic startup to the app entry
+point, and creates `mach-push.ts` (or `.js`) with editable receive, tap,
+registration, permission, and error callbacks. Re-running setup preserves that
+file.
+
+For a custom integration, use the low-level client:
+
+```ts
+import { createMachPush } from "@radhya/mach-push-react-native";
+
+const push = createMachPush({
+  projectId: "project_...",
+  appId: "push_app_...",
+  publishableKey: "mach_pk_...",
+  environment: __DEV__ ? "development" : "production",
+});
+
+await push.requestPermission();
+const registration = await push.register();
+
+push.addNotificationReceivedListener(console.log);
+push.addNotificationResponseReceivedListener(console.log);
+```
+
+Expo Go is not supported. Expo apps use `@radhya/mach/expo-plugin` from the
+main `@radhya/mach` package and then create a development or production build.
+Android requires the app's Firebase configuration.

package/android/build.gradle

@@ -0,0 +1,25 @@
+buildscript {
+  ext.getOrDefault = { name, fallback ->
+    rootProject.ext.has(name) ? rootProject.ext.get(name) : fallback
+  }
+}
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+
+android {
+  namespace "dev.getmach.push"
+  compileSdkVersion getOrDefault("compileSdkVersion", 35)
+
+  defaultConfig {
+    minSdkVersion getOrDefault("minSdkVersion", 23)
+    targetSdkVersion getOrDefault("targetSdkVersion", 35)
+  }
+}
+
+dependencies {
+  implementation "com.facebook.react:react-android:+"
+  implementation "com.google.firebase:firebase-messaging:24.1.0"
+  implementation "androidx.core:core-ktx:1.15.0"
+  implementation "org.jetbrains.kotlin:kotlin-stdlib"
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,12 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+  <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
+  <application>
+    <service
+      android:name=".MachPushMessagingService"
+      android:exported="false">
+      <intent-filter>
+        <action android:name="com.google.firebase.MESSAGING_EVENT" />
+      </intent-filter>
+    </service>
+  </application>
+</manifest>

package/android/src/main/java/dev/getmach/push/MachPushEventBus.kt

@@ -0,0 +1,46 @@
+package dev.getmach.push
+
+import android.os.Bundle
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.modules.core.DeviceEventManagerModule
+
+object MachPushEventBus {
+  const val RECEIVED_EVENT = "MachPushNotificationReceived"
+  const val OPENED_EVENT = "MachPushNotificationOpened"
+  const val EXTRA_PAYLOAD = "mach.push.payload"
+  const val EXTRA_TITLE = "mach.push.title"
+  const val EXTRA_BODY = "mach.push.body"
+
+  @Volatile
+  private var reactContext: ReactApplicationContext? = null
+
+  fun attach(context: ReactApplicationContext) {
+    reactContext = context
+  }
+
+  fun emit(name: String, title: String?, body: String?, data: Map<String, String>) {
+    val context = reactContext ?: return
+    if (!context.hasActiveReactInstance()) return
+    val payload = Arguments.createMap()
+    payload.putString("title", title)
+    payload.putString("body", body)
+    payload.putMap("data", Arguments.makeNativeMap(data))
+    payload.putString("platform", "android")
+    context
+      .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+      .emit(name, payload)
+  }
+
+  fun fromBundle(bundle: Bundle?): Map<String, String> {
+    if (bundle == null) return emptyMap()
+    return bundle.keySet()
+      .filterNot {
+        it == EXTRA_TITLE ||
+          it == EXTRA_BODY ||
+          it == EXTRA_PAYLOAD ||
+          it.startsWith("mach_")
+      }
+      .associateWith { bundle.get(it)?.toString().orEmpty() }
+  }
+}

package/android/src/main/java/dev/getmach/push/MachPushMessagingService.kt

@@ -0,0 +1,90 @@
+package dev.getmach.push
+
+import android.app.Notification
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.app.PendingIntent
+import android.content.Context
+import android.content.Intent
+import android.os.Build
+import androidx.core.app.NotificationCompat
+import com.google.firebase.messaging.FirebaseMessagingService
+import com.google.firebase.messaging.RemoteMessage
+import kotlin.math.absoluteValue
+
+class MachPushMessagingService : FirebaseMessagingService() {
+  override fun onNewToken(token: String) {
+    getSharedPreferences("mach.push", Context.MODE_PRIVATE)
+      .edit()
+      .putString("nativeToken", token)
+      .apply()
+  }
+
+  override fun onMessageReceived(message: RemoteMessage) {
+    val title = message.notification?.title ?: message.data["mach_title"]
+    val body = message.notification?.body ?: message.data["mach_body"]
+    val publicData = message.data.filterKeys { !it.startsWith("mach_") }
+    MachPushEventBus.emit(
+      MachPushEventBus.RECEIVED_EVENT,
+      title,
+      body,
+      publicData
+    )
+    showForegroundNotification(title, body, message.data)
+  }
+
+  private fun showForegroundNotification(
+    title: String?,
+    body: String?,
+    data: Map<String, String>
+  ) {
+    val manager = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+    val channelId = data["mach_android_channel_id"] ?: "mach_push_default"
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O &&
+      manager.getNotificationChannel(channelId) == null
+    ) {
+      manager.createNotificationChannel(
+        NotificationChannel(
+          channelId,
+          "Notifications",
+          NotificationManager.IMPORTANCE_HIGH
+        )
+      )
+    }
+
+    val launchIntent = packageManager.getLaunchIntentForPackage(packageName)
+      ?: Intent()
+    launchIntent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP or Intent.FLAG_ACTIVITY_SINGLE_TOP)
+    launchIntent.putExtra(MachPushEventBus.EXTRA_PAYLOAD, true)
+    launchIntent.putExtra(MachPushEventBus.EXTRA_TITLE, title)
+    launchIntent.putExtra(MachPushEventBus.EXTRA_BODY, body)
+    data.forEach { (key, value) -> launchIntent.putExtra(key, value) }
+    val pendingIntent = PendingIntent.getActivity(
+      this,
+      messageNotificationId(data),
+      launchIntent,
+      PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
+    )
+    val icon = applicationInfo.icon.takeIf { it != 0 } ?: android.R.drawable.ic_dialog_info
+    val notification = NotificationCompat.Builder(this, channelId)
+      .setSmallIcon(icon)
+      .setContentTitle(title ?: applicationInfo.loadLabel(packageManager))
+      .setContentText(body)
+      .setStyle(NotificationCompat.BigTextStyle().bigText(body))
+      .setAutoCancel(true)
+      .setPriority(NotificationCompat.PRIORITY_HIGH)
+      .setContentIntent(pendingIntent)
+      .apply {
+        if (data["mach_sound"] != null) {
+          setDefaults(Notification.DEFAULT_SOUND)
+        }
+      }
+      .build()
+    manager.notify(messageNotificationId(data), notification)
+  }
+
+  private fun messageNotificationId(data: Map<String, String>): Int {
+    return (data["mach_notification_id"]?.hashCode() ?: System.nanoTime().hashCode())
+      .absoluteValue
+  }
+}

package/android/src/main/java/dev/getmach/push/MachPushModule.kt

@@ -0,0 +1,162 @@
+package dev.getmach.push
+
+import android.Manifest
+import android.app.Activity
+import android.content.Intent
+import android.content.Context
+import android.content.pm.PackageManager
+import android.os.Build
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ActivityEventListener
+import com.facebook.react.modules.core.PermissionAwareActivity
+import com.facebook.react.modules.core.PermissionListener
+import com.google.firebase.messaging.FirebaseMessaging
+import java.util.Locale
+import java.util.TimeZone
+import java.util.UUID
+
+class MachPushModule(
+  private val context: ReactApplicationContext
+) : ReactContextBaseJavaModule(context), ActivityEventListener {
+  private val preferences =
+    context.getSharedPreferences("mach.push", Context.MODE_PRIVATE)
+
+  init {
+    MachPushEventBus.attach(context)
+    context.addActivityEventListener(this)
+  }
+
+  override fun getName() = "MachPush"
+
+  @ReactMethod
+  fun requestPermission(promise: Promise) {
+    if (Build.VERSION.SDK_INT < 33 ||
+      context.checkSelfPermission(Manifest.permission.POST_NOTIFICATIONS) ==
+      PackageManager.PERMISSION_GRANTED
+    ) {
+      promise.resolve("granted")
+      return
+    }
+    val activity = currentActivity as? PermissionAwareActivity
+    if (activity == null) {
+      promise.reject("MACH_PUSH_PERMISSION", "A foreground activity is required.")
+      return
+    }
+    val listener = PermissionListener { requestCode, _, grantResults ->
+      if (requestCode != 9472) return@PermissionListener false
+      promise.resolve(
+        if (grantResults.firstOrNull() == PackageManager.PERMISSION_GRANTED)
+          "granted"
+        else
+          "denied"
+      )
+      true
+    }
+    activity.requestPermissions(
+      arrayOf(Manifest.permission.POST_NOTIFICATIONS),
+      9472,
+      listener
+    )
+  }
+
+  @ReactMethod
+  fun getInstallationId(promise: Promise) {
+    val existing = preferences.getString("installationId", null)
+    if (existing != null) {
+      promise.resolve(existing)
+      return
+    }
+    val value = UUID.randomUUID().toString()
+    preferences.edit().putString("installationId", value).apply()
+    promise.resolve(value)
+  }
+
+  @ReactMethod
+  fun getNativeToken(promise: Promise) {
+    FirebaseMessaging.getInstance().token
+      .addOnSuccessListener { token ->
+        preferences.edit().putString("nativeToken", token).apply()
+        promise.resolve(token)
+      }
+      .addOnFailureListener { error ->
+        promise.reject("MACH_PUSH_REGISTRATION", error)
+      }
+  }
+
+  @ReactMethod
+  fun getDeviceInfo(promise: Promise) {
+    val packageInfo = context.packageManager.getPackageInfo(context.packageName, 0)
+    val result = Arguments.createMap()
+    result.putString("nativeAppId", context.packageName)
+    result.putString("deviceName", "${Build.MANUFACTURER} ${Build.MODEL}".trim())
+    result.putString("appVersion", packageInfo.versionName ?: "")
+    result.putString("osVersion", Build.VERSION.RELEASE ?: "")
+    result.putString("locale", Locale.getDefault().toLanguageTag())
+    result.putString("timezone", TimeZone.getDefault().id)
+    promise.resolve(result)
+  }
+
+  @ReactMethod
+  fun getMachPushToken(promise: Promise) {
+    promise.resolve(preferences.getString("machToken", null))
+  }
+
+  @ReactMethod
+  fun setMachPushToken(token: String?, promise: Promise) {
+    val editor = preferences.edit()
+    if (token == null) {
+      editor.remove("machToken")
+    } else {
+      editor.putString("machToken", token)
+    }
+    editor.apply()
+    promise.resolve(null)
+  }
+
+  @ReactMethod
+  fun getInitialNotification(promise: Promise) {
+    val intent = currentActivity?.intent
+    if (intent?.getBooleanExtra(MachPushEventBus.EXTRA_PAYLOAD, false) != true) {
+      promise.resolve(null)
+      return
+    }
+    promise.resolve(notificationMap(intent))
+    intent.removeExtra(MachPushEventBus.EXTRA_PAYLOAD)
+  }
+
+  @ReactMethod
+  fun addListener(@Suppress("UNUSED_PARAMETER") eventName: String) = Unit
+
+  @ReactMethod
+  fun removeListeners(@Suppress("UNUSED_PARAMETER") count: Int) = Unit
+
+  override fun onNewIntent(intent: Intent) {
+    if (!intent.getBooleanExtra(MachPushEventBus.EXTRA_PAYLOAD, false)) return
+    val data = MachPushEventBus.fromBundle(intent.extras)
+    MachPushEventBus.emit(
+      MachPushEventBus.OPENED_EVENT,
+      intent.getStringExtra(MachPushEventBus.EXTRA_TITLE),
+      intent.getStringExtra(MachPushEventBus.EXTRA_BODY),
+      data
+    )
+    intent.removeExtra(MachPushEventBus.EXTRA_PAYLOAD)
+  }
+
+  override fun onActivityResult(
+    activity: Activity,
+    requestCode: Int,
+    resultCode: Int,
+    data: Intent?
+  ) = Unit
+
+  private fun notificationMap(intent: Intent) = Arguments.createMap().apply {
+    putString("title", intent.getStringExtra(MachPushEventBus.EXTRA_TITLE))
+    putString("body", intent.getStringExtra(MachPushEventBus.EXTRA_BODY))
+    putMap("data", Arguments.makeNativeMap(MachPushEventBus.fromBundle(intent.extras)))
+    putString("platform", "android")
+  }
+}

package/android/src/main/java/dev/getmach/push/MachPushPackage.kt

@@ -0,0 +1,16 @@
+package dev.getmach.push
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+class MachPushPackage : ReactPackage {
+  override fun createNativeModules(
+    reactContext: ReactApplicationContext
+  ): List<NativeModule> = listOf(MachPushModule(reactContext))
+
+  override fun createViewManagers(
+    reactContext: ReactApplicationContext
+  ): List<ViewManager<*, *>> = emptyList()
+}

package/dist/index.d.ts

@@ -0,0 +1,37 @@
+import { MachPushClient, type MachPushConfig, type MachPushRegistration } from "@radhya/mach-push-core";
+import { type EmitterSubscription } from "react-native";
+export interface MachPushNotification {
+    title?: string;
+    body?: string;
+    data: Record<string, string>;
+    platform: "ios" | "android";
+}
+export declare class ReactNativeMachPush extends MachPushClient {
+    addNotificationReceivedListener(listener: (notification: MachPushNotification) => void): EmitterSubscription;
+    addNotificationResponseReceivedListener(listener: (notification: MachPushNotification) => void): EmitterSubscription;
+    getLastNotificationResponseAsync(): Promise<MachPushNotification | null>;
+}
+export declare function createMachPush(config: MachPushConfig): ReactNativeMachPush;
+export type MachPushPermissionStatus = "granted" | "denied" | "provisional";
+export interface MachPushSetupCallbacks {
+    onNotificationReceived?: (notification: MachPushNotification) => void | Promise<void>;
+    onNotificationOpened?: (notification: MachPushNotification) => void | Promise<void>;
+    onRegistered?: (registration: MachPushRegistration) => void | Promise<void>;
+    onPermissionChanged?: (status: MachPushPermissionStatus) => void | Promise<void>;
+    onError?: (error: Error) => void | Promise<void>;
+}
+export interface MachPushSetupResult {
+    client: ReactNativeMachPush;
+    permission: MachPushPermissionStatus;
+    registration?: MachPushRegistration;
+    removeListeners(): void;
+}
+/**
+ * Starts the complete default MACH Push experience:
+ * listeners, cold-start response, permission request, and device registration.
+ *
+ * Applications that need a custom permission moment can keep using
+ * `createMachPush` directly.
+ */
+export declare function setupMachPush(config: MachPushConfig, callbacks?: MachPushSetupCallbacks): Promise<MachPushSetupResult>;
+export * from "@radhya/mach-push-core";

package/dist/index.js

@@ -0,0 +1,123 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReactNativeMachPush = void 0;
+exports.createMachPush = createMachPush;
+exports.setupMachPush = setupMachPush;
+const mach_push_core_1 = require("@radhya/mach-push-core");
+const react_native_1 = require("react-native");
+const NativeMachPush = react_native_1.NativeModules.MachPush;
+function requireNativeModule() {
+    if (!NativeMachPush) {
+        throw new Error("MACH Push native module is unavailable. Rebuild the native app after installing @radhya/mach-push-react-native. Expo Go is not supported.");
+    }
+    return NativeMachPush;
+}
+const notificationEmitter = NativeMachPush
+    ? new react_native_1.NativeEventEmitter(NativeMachPush)
+    : null;
+class ReactNativeMachPush extends mach_push_core_1.MachPushClient {
+    addNotificationReceivedListener(listener) {
+        if (!notificationEmitter)
+            requireNativeModule();
+        return notificationEmitter.addListener("MachPushNotificationReceived", listener);
+    }
+    addNotificationResponseReceivedListener(listener) {
+        if (!notificationEmitter)
+            requireNativeModule();
+        return notificationEmitter.addListener("MachPushNotificationOpened", listener);
+    }
+    getLastNotificationResponseAsync() {
+        return requireNativeModule().getInitialNotification();
+    }
+}
+exports.ReactNativeMachPush = ReactNativeMachPush;
+function createMachPush(config) {
+    if (react_native_1.Platform.OS !== "ios" && react_native_1.Platform.OS !== "android") {
+        throw new Error("MACH Push supports iOS and Android native applications.");
+    }
+    const native = requireNativeModule();
+    const adapter = {
+        platform: react_native_1.Platform.OS,
+        requestPermission: () => native.requestPermission(),
+        getInstallationId: () => native.getInstallationId(),
+        getNativeToken: () => native.getNativeToken(),
+        getDeviceInfo: () => native.getDeviceInfo(),
+        getMachPushToken: () => native.getMachPushToken(),
+        setMachPushToken: (token) => native.setMachPushToken(token),
+    };
+    return new ReactNativeMachPush(config, adapter);
+}
+function asError(value) {
+    return value instanceof Error ? value : new Error(String(value));
+}
+async function reportCallbackError(callback, value) {
+    try {
+        await callback?.(asError(value));
+    }
+    catch {
+        // Application error handlers must never interrupt push registration.
+    }
+}
+async function invokeCallback(callback, value, onError) {
+    try {
+        await callback?.(value);
+    }
+    catch (error) {
+        await reportCallbackError(onError, error);
+    }
+}
+/**
+ * Starts the complete default MACH Push experience:
+ * listeners, cold-start response, permission request, and device registration.
+ *
+ * Applications that need a custom permission moment can keep using
+ * `createMachPush` directly.
+ */
+async function setupMachPush(config, callbacks = {}) {
+    const client = createMachPush(config);
+    const received = client.addNotificationReceivedListener((notification) => {
+        void invokeCallback(callbacks.onNotificationReceived, notification, callbacks.onError);
+    });
+    const opened = client.addNotificationResponseReceivedListener((notification) => {
+        void invokeCallback(callbacks.onNotificationOpened, notification, callbacks.onError);
+    });
+    const removeListeners = () => {
+        received.remove();
+        opened.remove();
+    };
+    try {
+        const initial = await client.getLastNotificationResponseAsync();
+        if (initial) {
+            await invokeCallback(callbacks.onNotificationOpened, initial, callbacks.onError);
+        }
+        const permission = await client.requestPermission();
+        await invokeCallback(callbacks.onPermissionChanged, permission, callbacks.onError);
+        if (permission === "denied") {
+            return { client, permission, removeListeners };
+        }
+        const registration = await client.register();
+        await invokeCallback(callbacks.onRegistered, registration, callbacks.onError);
+        return { client, permission, registration, removeListeners };
+    }
+    catch (value) {
+        const error = asError(value);
+        await reportCallbackError(callbacks.onError, error);
+        removeListeners();
+        throw error;
+    }
+}
+__exportStar(require("@radhya/mach-push-core"), exports);

package/getmach-push-react-native.podspec

@@ -0,0 +1,17 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "getmach-push-react-native"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.license      = package["license"]
+  s.author       = "MACH"
+  s.homepage     = "https://getmach.dev"
+  s.platforms    = { :ios => "13.0" }
+  s.source       = { :git => "https://bitbucket.org/nitscoder/mach-api.git", :tag => s.version }
+  s.source_files = "ios/**/*.{h,m,mm,swift}"
+  s.swift_version = "5.9"
+  s.dependency "React-Core"
+end

package/ios/MachPush.swift

@@ -0,0 +1,195 @@
+import Foundation
+import React
+import UIKit
+import UserNotifications
+
+@objc(MachPush)
+final class MachPush: RCTEventEmitter {
+  private var nativeTokenResolvers: [RCTPromiseResolveBlock] = []
+  private var nativeTokenRejecters: [RCTPromiseRejectBlock] = []
+  private var hasEventListeners = false
+
+  override init() {
+    super.init()
+    NotificationCenter.default.addObserver(
+      self,
+      selector: #selector(didRegisterToken(_:)),
+      name: Notification.Name("MachPushDidRegisterTokenNotification"),
+      object: nil
+    )
+    NotificationCenter.default.addObserver(
+      self,
+      selector: #selector(didReceiveNotification(_:)),
+      name: MachPushNotificationReceived,
+      object: nil
+    )
+    NotificationCenter.default.addObserver(
+      self,
+      selector: #selector(didOpenNotification(_:)),
+      name: MachPushNotificationOpened,
+      object: nil
+    )
+    MachPushNotificationDelegate.shared.install()
+    NotificationCenter.default.addObserver(
+      self,
+      selector: #selector(didFailRegistration(_:)),
+      name: Notification.Name("MachPushDidFailRegistrationNotification"),
+      object: nil
+    )
+  }
+
+  deinit {
+    NotificationCenter.default.removeObserver(self)
+  }
+
+  @objc static override func requiresMainQueueSetup() -> Bool { true }
+
+  override func supportedEvents() -> [String]! {
+    [
+      "MachPushNotificationReceived",
+      "MachPushNotificationOpened",
+    ]
+  }
+
+  override func startObserving() {
+    hasEventListeners = true
+  }
+
+  override func stopObserving() {
+    hasEventListeners = false
+  }
+
+  @objc(requestPermission:rejecter:)
+  func requestPermission(
+    resolve: @escaping RCTPromiseResolveBlock,
+    reject: @escaping RCTPromiseRejectBlock
+  ) {
+    UNUserNotificationCenter.current().requestAuthorization(
+      options: [.alert, .badge, .sound, .provisional]
+    ) { granted, error in
+      if let error {
+        reject("MACH_PUSH_PERMISSION", error.localizedDescription, error)
+        return
+      }
+      UNUserNotificationCenter.current().getNotificationSettings { settings in
+        DispatchQueue.main.async {
+          UIApplication.shared.registerForRemoteNotifications()
+        }
+        if settings.authorizationStatus == .provisional {
+          resolve("provisional")
+        } else {
+          resolve(granted ? "granted" : "denied")
+        }
+      }
+    }
+  }
+
+  @objc(getInstallationId:rejecter:)
+  func getInstallationId(
+    resolve: RCTPromiseResolveBlock,
+    reject: RCTPromiseRejectBlock
+  ) {
+    let defaults = UserDefaults.standard
+    if let existing = defaults.string(forKey: "mach.push.installationId") {
+      resolve(existing)
+      return
+    }
+    let value = UUID().uuidString.lowercased()
+    defaults.set(value, forKey: "mach.push.installationId")
+    resolve(value)
+  }
+
+  @objc(getNativeToken:rejecter:)
+  func getNativeToken(
+    resolve: @escaping RCTPromiseResolveBlock,
+    reject: @escaping RCTPromiseRejectBlock
+  ) {
+    if let token = UserDefaults.standard.string(forKey: "mach.push.nativeToken") {
+      resolve(token)
+      return
+    }
+    nativeTokenResolvers.append(resolve)
+    nativeTokenRejecters.append(reject)
+    DispatchQueue.main.async {
+      UIApplication.shared.registerForRemoteNotifications()
+    }
+  }
+
+  @objc(getDeviceInfo:rejecter:)
+  func getDeviceInfo(
+    resolve: RCTPromiseResolveBlock,
+    reject: RCTPromiseRejectBlock
+  ) {
+    resolve([
+      "nativeAppId": Bundle.main.bundleIdentifier ?? "",
+      "deviceName": UIDevice.current.model,
+      "appVersion": Bundle.main.infoDictionary?["CFBundleShortVersionString"] as? String ?? "",
+      "osVersion": UIDevice.current.systemVersion,
+      "locale": Locale.current.identifier,
+      "timezone": TimeZone.current.identifier
+    ])
+  }
+
+  @objc(getMachPushToken:rejecter:)
+  func getMachPushToken(
+    resolve: RCTPromiseResolveBlock,
+    reject: RCTPromiseRejectBlock
+  ) {
+    resolve(UserDefaults.standard.string(forKey: "mach.push.machToken"))
+  }
+
+  @objc(setMachPushToken:resolver:rejecter:)
+  func setMachPushToken(
+    token: String?,
+    resolve: RCTPromiseResolveBlock,
+    reject: RCTPromiseRejectBlock
+  ) {
+    if let token {
+      UserDefaults.standard.set(token, forKey: "mach.push.machToken")
+    } else {
+      UserDefaults.standard.removeObject(forKey: "mach.push.machToken")
+    }
+    resolve(nil)
+  }
+
+  @objc(getInitialNotification:rejecter:)
+  func getInitialNotification(
+    resolve: RCTPromiseResolveBlock,
+    reject: RCTPromiseRejectBlock
+  ) {
+    resolve(MachPushNotificationDelegate.shared.takeLastOpened())
+  }
+
+  @objc private func didRegisterToken(_ notification: Notification) {
+    guard let token = notification.userInfo?["token"] as? String else { return }
+    let resolvers = nativeTokenResolvers
+    nativeTokenResolvers.removeAll()
+    nativeTokenRejecters.removeAll()
+    resolvers.forEach { $0(token) }
+  }
+
+  @objc private func didFailRegistration(_ notification: Notification) {
+    let error = notification.userInfo?["error"] as? NSError
+    let rejecters = nativeTokenRejecters
+    nativeTokenResolvers.removeAll()
+    nativeTokenRejecters.removeAll()
+    rejecters.forEach {
+      $0(
+        "MACH_PUSH_REGISTRATION",
+        error?.localizedDescription ?? "APNs registration failed.",
+        error
+      )
+    }
+  }
+
+  @objc private func didReceiveNotification(_ notification: Notification) {
+    guard hasEventListeners, let value = notification.object else { return }
+    sendEvent(withName: "MachPushNotificationReceived", body: value)
+  }
+
+  @objc private func didOpenNotification(_ notification: Notification) {
+    guard hasEventListeners, let value = notification.object else { return }
+    MachPushNotificationDelegate.shared.clearLastOpened()
+    sendEvent(withName: "MachPushNotificationOpened", body: value)
+  }
+}

package/ios/MachPushAppDelegateInterceptor.m

@@ -0,0 +1,73 @@
+#import <Foundation/Foundation.h>
+#import <UIKit/UIKit.h>
+#import <objc/runtime.h>
+
+NSString * const MachPushDidRegisterTokenNotification = @"MachPushDidRegisterTokenNotification";
+NSString * const MachPushDidFailRegistrationNotification = @"MachPushDidFailRegistrationNotification";
+
+static BOOL MachPushSwizzle(Class cls, SEL original, SEL replacement) {
+  Method replacementMethod = class_getInstanceMethod(cls, replacement);
+  if (!replacementMethod) return NO;
+  Method originalMethod = class_getInstanceMethod(cls, original);
+  if (!originalMethod) {
+    class_addMethod(cls, original, method_getImplementation(replacementMethod), method_getTypeEncoding(replacementMethod));
+    return NO;
+  }
+  method_exchangeImplementations(originalMethod, replacementMethod);
+  return YES;
+}
+
+static BOOL MachPushHadRegisterHandler = NO;
+static BOOL MachPushHadFailureHandler = NO;
+
+@interface NSObject (MachPushAppDelegateInterceptor)
+@end
+
+@implementation NSObject (MachPushAppDelegateInterceptor)
+
++ (void)load {
+  dispatch_async(dispatch_get_main_queue(), ^{
+    Class appDelegateClass = NSClassFromString(@"AppDelegate");
+    if (!appDelegateClass) return;
+    MachPushHadRegisterHandler = MachPushSwizzle(
+      appDelegateClass,
+      @selector(application:didRegisterForRemoteNotificationsWithDeviceToken:),
+      @selector(mach_application:didRegisterForRemoteNotificationsWithDeviceToken:)
+    );
+    MachPushHadFailureHandler = MachPushSwizzle(
+      appDelegateClass,
+      @selector(application:didFailToRegisterForRemoteNotificationsWithError:),
+      @selector(mach_application:didFailToRegisterForRemoteNotificationsWithError:)
+    );
+  });
+}
+
+- (void)mach_application:(UIApplication *)application
+    didRegisterForRemoteNotificationsWithDeviceToken:(NSData *)deviceToken {
+  const unsigned char *bytes = deviceToken.bytes;
+  NSMutableString *token = [NSMutableString stringWithCapacity:deviceToken.length * 2];
+  for (NSUInteger index = 0; index < deviceToken.length; index++) {
+    [token appendFormat:@"%02x", bytes[index]];
+  }
+  [[NSUserDefaults standardUserDefaults] setObject:token forKey:@"mach.push.nativeToken"];
+  [[NSNotificationCenter defaultCenter]
+    postNotificationName:MachPushDidRegisterTokenNotification
+    object:nil
+    userInfo:@{ @"token": token }];
+  if (MachPushHadRegisterHandler) {
+    [self mach_application:application didRegisterForRemoteNotificationsWithDeviceToken:deviceToken];
+  }
+}
+
+- (void)mach_application:(UIApplication *)application
+    didFailToRegisterForRemoteNotificationsWithError:(NSError *)error {
+  [[NSNotificationCenter defaultCenter]
+    postNotificationName:MachPushDidFailRegistrationNotification
+    object:nil
+    userInfo:@{ @"error": error }];
+  if (MachPushHadFailureHandler) {
+    [self mach_application:application didFailToRegisterForRemoteNotificationsWithError:error];
+  }
+}
+
+@end

package/ios/MachPushBridge.m

@@ -0,0 +1,20 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+
+@interface RCT_EXTERN_MODULE(MachPush, RCTEventEmitter)
+RCT_EXTERN_METHOD(requestPermission:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(getInstallationId:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(getNativeToken:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(getDeviceInfo:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(getMachPushToken:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(setMachPushToken:(NSString * _Nullable)token
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(getInitialNotification:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+@end

package/ios/MachPushNotificationDelegate.swift

@@ -0,0 +1,124 @@
+import Foundation
+import UserNotifications
+
+let MachPushNotificationReceived =
+  Notification.Name("MachPushNotificationReceived")
+let MachPushNotificationOpened =
+  Notification.Name("MachPushNotificationOpened")
+
+final class MachPushNotificationDelegate: NSObject,
+  UNUserNotificationCenterDelegate
+{
+  static let shared = MachPushNotificationDelegate()
+
+  private var forwardDelegate: UNUserNotificationCenterDelegate?
+  private var lastOpened: [String: Any]?
+
+  func install() {
+    DispatchQueue.main.async {
+      let center = UNUserNotificationCenter.current()
+      if (center.delegate as AnyObject?) !== self {
+        self.forwardDelegate = center.delegate
+        center.delegate = self
+      }
+    }
+  }
+
+  func takeLastOpened() -> [String: Any]? {
+    defer { lastOpened = nil }
+    return lastOpened
+  }
+
+  func clearLastOpened() {
+    lastOpened = nil
+  }
+
+  private func payload(
+    _ notification: UNNotification
+  ) -> [String: Any] {
+    let content = notification.request.content
+    var data: [String: String] = [:]
+    for (key, value) in content.userInfo {
+      let name = String(describing: key)
+      if name == "aps" || name.hasPrefix("mach_") { continue }
+      if let text = value as? String {
+        data[name] = text
+      } else if let number = value as? NSNumber {
+        data[name] = number.stringValue
+      }
+    }
+    return [
+      "title": content.title,
+      "body": content.body,
+      "data": data,
+      "platform": "ios",
+    ]
+  }
+
+  func userNotificationCenter(
+    _ center: UNUserNotificationCenter,
+    willPresent notification: UNNotification,
+    withCompletionHandler completionHandler:
+      @escaping (UNNotificationPresentationOptions) -> Void
+  ) {
+    let value = payload(notification)
+    NotificationCenter.default.post(
+      name: MachPushNotificationReceived,
+      object: value
+    )
+    let machOptions: UNNotificationPresentationOptions
+    if #available(iOS 14.0, *) {
+      machOptions = [.banner, .list, .sound, .badge]
+    } else {
+      machOptions = [.alert, .sound, .badge]
+    }
+    if let forwardDelegate,
+      forwardDelegate.responds(
+        to: #selector(
+          UNUserNotificationCenterDelegate.userNotificationCenter(
+            _:willPresent:withCompletionHandler:
+          )
+        )
+      )
+    {
+      forwardDelegate.userNotificationCenter?(
+        center,
+        willPresent: notification
+      ) { forwardedOptions in
+        completionHandler(forwardedOptions.union(machOptions))
+      }
+      return
+    }
+    completionHandler(machOptions)
+  }
+
+  func userNotificationCenter(
+    _ center: UNUserNotificationCenter,
+    didReceive response: UNNotificationResponse,
+    withCompletionHandler completionHandler: @escaping () -> Void
+  ) {
+    let value = payload(response.notification)
+    lastOpened = value
+    NotificationCenter.default.post(
+      name: MachPushNotificationOpened,
+      object: value
+    )
+    if let forwardDelegate,
+      forwardDelegate.responds(
+        to: #selector(
+          UNUserNotificationCenterDelegate.userNotificationCenter(
+            _:didReceive:withCompletionHandler:
+          )
+        )
+      )
+    {
+      forwardDelegate.userNotificationCenter?(
+        center,
+        didReceive: response,
+        withCompletionHandler: completionHandler
+      )
+      return
+    }
+    completionHandler()
+  }
+}

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@radhya/mach-push-react-native",
+  "version": "0.1.0",
+  "description": "MACH Push for React Native and Expo development builds",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://bitbucket.org/nitscoder/mach-api.git",
+    "directory": "packages/push-react-native"
+  },
+  "homepage": "https://getmach.dev/push",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "react-native": "src/index.ts",
+  "files": [
+    "android",
+    "ios",
+    "src",
+    "dist",
+    "react-native.config.js",
+    "getmach-push-react-native.podspec",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\" && tsc -p tsconfig.json"
+  },
+  "dependencies": {
+    "@radhya/mach-push-core": "^0.1.0"
+  },
+  "peerDependencies": {
+    "react": ">=18",
+    "react-native": ">=0.73"
+  },
+  "devDependencies": {
+    "@types/react": "^19.1.0",
+    "react": "19.1.0",
+    "react-native": "0.81.5",
+    "typescript": "^5.9.3"
+  }
+}

package/react-native.config.js

@@ -0,0 +1,10 @@
+module.exports = {
+  dependency: {
+    platforms: {
+      ios: {},
+      android: {
+        sourceDir: "./android"
+      }
+    }
+  }
+};

package/src/index.ts

@@ -0,0 +1,215 @@
+import {
+  MachPushClient,
+  type MachPushConfig,
+  type MachPushDeviceInfo,
+  type MachPushNativeAdapter,
+  type MachPushRegistration,
+} from "@radhya/mach-push-core";
+import {
+  NativeEventEmitter,
+  NativeModules,
+  Platform,
+  type EmitterSubscription,
+} from "react-native";
+
+export interface MachPushNotification {
+  title?: string;
+  body?: string;
+  data: Record<string, string>;
+  platform: "ios" | "android";
+}
+
+interface NativeMachPushModule {
+  requestPermission(): Promise<"granted" | "denied" | "provisional">;
+  getInstallationId(): Promise<string>;
+  getNativeToken(): Promise<string>;
+  getDeviceInfo(): Promise<MachPushDeviceInfo>;
+  getMachPushToken(): Promise<string | null>;
+  setMachPushToken(token: string | null): Promise<void>;
+  getInitialNotification(): Promise<MachPushNotification | null>;
+}
+
+const NativeMachPush = NativeModules.MachPush as
+  | NativeMachPushModule
+  | undefined;
+
+function requireNativeModule(): NativeMachPushModule {
+  if (!NativeMachPush) {
+    throw new Error(
+      "MACH Push native module is unavailable. Rebuild the native app after installing @radhya/mach-push-react-native. Expo Go is not supported.",
+    );
+  }
+  return NativeMachPush;
+}
+
+const notificationEmitter = NativeMachPush
+  ? new NativeEventEmitter(NativeMachPush as any)
+  : null;
+
+export class ReactNativeMachPush extends MachPushClient {
+  addNotificationReceivedListener(
+    listener: (notification: MachPushNotification) => void,
+  ): EmitterSubscription {
+    if (!notificationEmitter) requireNativeModule();
+    return notificationEmitter!.addListener(
+      "MachPushNotificationReceived",
+      listener,
+    );
+  }
+
+  addNotificationResponseReceivedListener(
+    listener: (notification: MachPushNotification) => void,
+  ): EmitterSubscription {
+    if (!notificationEmitter) requireNativeModule();
+    return notificationEmitter!.addListener(
+      "MachPushNotificationOpened",
+      listener,
+    );
+  }
+
+  getLastNotificationResponseAsync() {
+    return requireNativeModule().getInitialNotification();
+  }
+}
+
+export function createMachPush(config: MachPushConfig): ReactNativeMachPush {
+  if (Platform.OS !== "ios" && Platform.OS !== "android") {
+    throw new Error("MACH Push supports iOS and Android native applications.");
+  }
+  const native = requireNativeModule();
+  const adapter: MachPushNativeAdapter = {
+    platform: Platform.OS,
+    requestPermission: () => native.requestPermission(),
+    getInstallationId: () => native.getInstallationId(),
+    getNativeToken: () => native.getNativeToken(),
+    getDeviceInfo: () => native.getDeviceInfo(),
+    getMachPushToken: () => native.getMachPushToken(),
+    setMachPushToken: (token) => native.setMachPushToken(token),
+  };
+  return new ReactNativeMachPush(config, adapter);
+}
+
+export type MachPushPermissionStatus =
+  | "granted"
+  | "denied"
+  | "provisional";
+
+export interface MachPushSetupCallbacks {
+  onNotificationReceived?: (
+    notification: MachPushNotification,
+  ) => void | Promise<void>;
+  onNotificationOpened?: (
+    notification: MachPushNotification,
+  ) => void | Promise<void>;
+  onRegistered?: (
+    registration: MachPushRegistration,
+  ) => void | Promise<void>;
+  onPermissionChanged?: (
+    status: MachPushPermissionStatus,
+  ) => void | Promise<void>;
+  onError?: (error: Error) => void | Promise<void>;
+}
+
+export interface MachPushSetupResult {
+  client: ReactNativeMachPush;
+  permission: MachPushPermissionStatus;
+  registration?: MachPushRegistration;
+  removeListeners(): void;
+}
+
+function asError(value: unknown): Error {
+  return value instanceof Error ? value : new Error(String(value));
+}
+
+async function reportCallbackError(
+  callback: MachPushSetupCallbacks["onError"],
+  value: unknown,
+) {
+  try {
+    await callback?.(asError(value));
+  } catch {
+    // Application error handlers must never interrupt push registration.
+  }
+}
+
+async function invokeCallback<T>(
+  callback: ((value: T) => void | Promise<void>) | undefined,
+  value: T,
+  onError: MachPushSetupCallbacks["onError"],
+) {
+  try {
+    await callback?.(value);
+  } catch (error) {
+    await reportCallbackError(onError, error);
+  }
+}
+
+/**
+ * Starts the complete default MACH Push experience:
+ * listeners, cold-start response, permission request, and device registration.
+ *
+ * Applications that need a custom permission moment can keep using
+ * `createMachPush` directly.
+ */
+export async function setupMachPush(
+  config: MachPushConfig,
+  callbacks: MachPushSetupCallbacks = {},
+): Promise<MachPushSetupResult> {
+  const client = createMachPush(config);
+  const received = client.addNotificationReceivedListener((notification) => {
+    void invokeCallback(
+      callbacks.onNotificationReceived,
+      notification,
+      callbacks.onError,
+    );
+  });
+  const opened = client.addNotificationResponseReceivedListener(
+    (notification) => {
+      void invokeCallback(
+        callbacks.onNotificationOpened,
+        notification,
+        callbacks.onError,
+      );
+    },
+  );
+  const removeListeners = () => {
+    received.remove();
+    opened.remove();
+  };
+
+  try {
+    const initial = await client.getLastNotificationResponseAsync();
+    if (initial) {
+      await invokeCallback(
+        callbacks.onNotificationOpened,
+        initial,
+        callbacks.onError,
+      );
+    }
+
+    const permission = await client.requestPermission();
+    await invokeCallback(
+      callbacks.onPermissionChanged,
+      permission,
+      callbacks.onError,
+    );
+    if (permission === "denied") {
+      return { client, permission, removeListeners };
+    }
+
+    const registration = await client.register();
+    await invokeCallback(
+      callbacks.onRegistered,
+      registration,
+      callbacks.onError,
+    );
+    return { client, permission, registration, removeListeners };
+  } catch (value) {
+    const error = asError(value);
+    await reportCallbackError(callbacks.onError, error);
+    removeListeners();
+    throw error;
+  }
+}
+
+export * from "@radhya/mach-push-core";