@voipsdk/react-native-voipcloud 1.0.0 → 1.0.2

package/CHANGELOG.md

@@ -0,0 +1,57 @@
+# Changelog
+
+All notable changes to `@voipsdk/react-native-voipcloud` are documented here.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [1.1.0] - 2026-07-06
+
+### Added
+
+- **iOS support — full feature parity with Android.** All 14 methods (`init`, `shutdown`, `register`, `unregister`, `makeCall`, `answer`, `hangup`, `hangupAllCalls`, `hold`, `unhold`, `mute`, `sendDtmf`, `transferCall`, `reconnectCallAudio`) and all 11 events are now implemented natively on iOS. No method rejects with `VC_NOT_IMPLEMENTED` anymore.
+- iOS native layer: `VoipCloudEngine` (Objective-C++ PJSUA2 wrapper — multi-account/multi-call registry, NAT survival, SRTP optional, audio bridging, `AVAudioSession` management) driving an `RCTEventEmitter` bridge (`VoipCloud.mm`). Same event names, payloads and `VC_*` error codes as Android.
+- Ships the prebuilt, self-contained `ios/VoipCloud.xcframework` (PJSIP + OpenSSL 3.0.16). Podspec vendors it via `vendored_frameworks`, links `libc++`/`libresolv` + the required system frameworks, and sets `gnu++17`.
+- iOS simulator now covers both `arm64` (Apple Silicon) and `x86_64` — build scripts produce a fat simulator slice; device stays `arm64`.
+
+### Changed
+
+- Build scripts (`build-openssl.sh`, `build-pjproject.sh`, `build-xcframework.sh`) parametrized by slice (`device` / `simulator-x86_64` / `simulator-arm64`); `build-xcframework.sh` lipos the two simulator arches and syncs the result into `package/ios/`.
+
+## [1.0.1] - 2026-07-06
+
+### Added
+
+- `hangup(callId, mode?)` — optional `mode`: `'busy'`, `'cancel'`, or `'normal'` (default).
+- `reconnectCallAudio(callId)` — re-wire PJSIP audio bridge after Android route changes (speaker/earpiece).
+- `sipCallId` on `incomingCall` and `callState` events — stable SIP Call-ID header across systems.
+- Native sync helpers for background/Telecom UI: `answerCallSync`, `hangupCallSync`, `reconnectCallAudioSync`, `reconnectAllCallsAudioSync`.
+- Automatic 180 Ringing on incoming calls so callers hear ringback before answer.
+- `ManagedCallRegistry.snapshot()` for iterating active calls.
+- VoicePBX hook: `VoipIncomingNotifier.onIncomingCall` dispatched on inbound INVITE (reflection, no hard dependency).
+
+### Fixed
+
+- Register FinalizerDaemon thread with PJSIP to prevent `SIGABRT` ("Calling pjlib from unknown/external thread") when SWIG finalizers run on GC.
+- Disable software AEC (`ecTailLen=0`); rely on Android hardware AEC for VOICE_COMMUNICATION.
+- Audio quality: 48 kHz sound device, quality 10, VAD disabled — reduces crackling from double resampling.
+- NAT survival: contact/via rewrite, UDP keep-alive (20s), shorter REGISTER interval (120s).
+- Auto-connect capture ↔ call ↔ playback when media becomes active (required for two-way audio on Android).
+- Hold/unhold: defer audio reconnect until `onCallMediaState` confirms media status (fixes hold state desync).
+- Unhold sends `PJSUA_CALL_UNHOLD` flag on re-INVITE.
+- Remove call from registry on disconnect instead of only on explicit hangup.
+- Refresh PJSIP playback devices before reconnecting audio after route changes.
+
+### Changed
+
+- `ManagedAccount` and `ManagedCall` now hold `Endpoint` reference for audio bridging.
+- Incoming `ManagedCall` constructor requires `ManagedCallRegistry` parameter.
+
+## [1.0.0] - 2026-06-30
+
+### Added
+
+- Initial public release: PJSIP VoIP SDK for React Native (Android).
+- Core API: `init`, `shutdown`, `register`, `makeCall`, `answer`, `hangup`, hold/unhold, mute, DTMF, transfer.
+- Event subscriptions via `VoipCloud.on(...)`.
+- Ships `voipcloud-release.aar` with `libvoipcloud.so` for `arm64-v8a`, `armeabi-v7a`, `x86_64`.

package/README.md

@@ -1,7 +1,9 @@
 # @voipsdk/react-native-voipcloud
 
-> Public PJSIP VoIP SDK for React Native — Android only (RN 0.70+, Android 12 / API 31+).  
-> Package: `@voipsdk/react-native-voipcloud@1.0.0`
+> Public PJSIP VoIP SDK for React Native — Android **and** iOS (RN 0.70+).  
+> Package: `@voipsdk/react-native-voipcloud@1.1.0`
+
+Android and iOS expose the **same** JS API, events and `VC_*` error codes.
 
 ---
 
@@ -10,9 +12,8 @@
 | | |
 |---|---|
 | React Native | ≥ 0.70 |
-| Android | API 31+ (Android 12+) |
-| ABIs | `arm64-v8a`, `armeabi-v7a`, `x86_64` (emulator) |
-| iOS | Stub only — rejects with `VC_NOT_IMPLEMENTED` |
+| Android | API 31+ (Android 12+) — ABIs `arm64-v8a`, `armeabi-v7a`, `x86_64` |
+| iOS | 13.0+ — device `arm64`, simulator `arm64` + `x86_64` |
 
 ---
 
@@ -24,6 +25,8 @@ npm install @voipsdk/react-native-voipcloud
 yarn add @voipsdk/react-native-voipcloud
 ```
 
+### Android
+
 Rebuild the native app after install:
 
 ```bash
@@ -36,6 +39,24 @@ React Native 0.60+ autolinks `VoipCloudPackage`. For older RN, add manually in `
 packages.add(new com.voipcloud.sdk.rn.VoipCloudPackage());
 ```
 
+### iOS
+
+Autolinking installs the pod (which vendors the prebuilt `VoipCloud.xcframework` — PJSIP + OpenSSL, self-contained). Just run:
+
+```bash
+cd ios && pod install
+```
+
+Then add a microphone usage string to your app **`Info.plist`** (required or the OS kills the app on first mic access):
+
+```xml
+<key>NSMicrophoneUsageDescription</key>
+<string>Microphone access is needed for calls.</string>
+```
+
+For calls to keep running when the app is backgrounded, enable the **Audio** background mode
+(`UIBackgroundModes` → `audio`) in your app target. VoIP push / CallKit is not bundled — see the roadmap.
+
 ### Android permissions
 
 Declare in **your** app `AndroidManifest.xml`:
@@ -127,7 +148,8 @@ export function useVoipEvents() {
 | `unregister(accountId)` | Unregister account |
 | `makeCall(accountId, uri)` | Outbound call → `callId` |
 | `answer(callId)` | Answer incoming call |
-| `hangup(callId)` | End one call |
+| `hangup(callId, mode?)` | End one call (`mode`: `'normal'` \| `'busy'` \| `'cancel'`) |
+| `reconnectCallAudio(callId)` | Re-wire audio after speaker/earpiece route change |
 | `hangupAllCalls()` | End all active calls |
 | `hold(callId)` / `unhold(callId)` | Hold / resume |
 | `mute(callId, on)` | Mute / unmute microphone |
@@ -160,8 +182,8 @@ export function useVoipEvents() {
 | Event | Payload highlights |
 |-------|-------------------|
 | `registrationState` | `{ accountId, code, reason }` |
-| `incomingCall` | `{ accountId, callId, from, to }` |
-| `callState` | `{ callId, state, code, reason }` |
+| `incomingCall` | `{ accountId, callId, from, to, sipCallId? }` |
+| `callState` | `{ callId, state, code, reason, sipCallId? }` |
 | `callMediaState` | `{ callId, hasAudio, isHold, isMuted }` |
 | `callHold` / `callUnhold` | `{ callId }` |
 | `callMute` | `{ callId, isMuted }` |
@@ -197,12 +219,14 @@ try {
 | `VC_MAKE_CALL` / `VC_ANSWER` / `VC_HANGUP` | Call operation error |
 | `VC_NO_CALL` | Unknown `callId` |
 | `VC_HOLD` / `VC_UNHOLD` / `VC_MUTE` / `VC_DTMF` / `VC_TRANSFER` | In-call control error |
+| `VC_AUDIO` | Audio bridge / `reconnectCallAudio` error |
+| `VC_HANGUP_ALL` | `hangupAllCalls` error |
 
 ---
 
-## Native artifacts (Android)
+## Native artifacts
 
-Shipped inside `android/src/main/libs/voipcloud-release.aar`:
+**Android** — inside `android/src/main/libs/voipcloud-release.aar`:
 
 | Artifact | Name |
 |----------|------|
@@ -211,7 +235,17 @@ Shipped inside `android/src/main/libs/voipcloud-release.aar`:
 | RN bridge module | `VoipsdkReactNativeVoipcloud` (JS: `VoipCloud`) |
 | Java SDK | `com.voipcloud.sdk.*` |
 
-This package does **not** use upstream `libpjsua2.so` / `pjsua2JNI`.
+**iOS** — under `ios/`:
+
+| Artifact | Name |
+|----------|------|
+| Prebuilt framework | `VoipCloud.xcframework` — PJSIP + OpenSSL, static, self-contained |
+| PJSUA2 wrapper | `VoipCloudEngine` (Objective-C++) |
+| RN bridge module | `VoipsdkReactNativeVoipcloud` (`RCTEventEmitter`, JS: `VoipCloud`) |
+
+The iOS framework is rebuilt from `vendor/pjproject` + `vendor/openssl` via
+`scripts/build-openssl.sh` → `build-pjproject.sh {device,simulator-x86_64,simulator-arm64}`
+→ `build-xcframework.sh` (the last step also copies it into `ios/`).
 
 ---
 
@@ -223,11 +257,24 @@ Run `cd android && ./gradlew clean assembleDebug`. Confirm `@voipsdk/react-nativ
 **`VC_NATIVE_LOAD`**  
 Ensure your device ABI is supported (`arm64-v8a` on most phones). For release builds, R8 applies ProGuard rules from the AAR automatically.
 
+**Android build: duplicate `libc++_shared.so`**  
+If another native library also bundles the C++ runtime, add to `android/app/build.gradle`:
+
+```gradle
+android { packagingOptions { pickFirst '**/libc++_shared.so' } }
+```
+
 **Registration fails (`VC_REGISTER`)**  
 Check `registrar`, credentials, and network. TLS requires a valid server certificate or appropriate PJSIP TLS settings on the PBX side.
 
 **No audio**  
-Grant `RECORD_AUDIO` at runtime before placing a call.
+Android: grant `RECORD_AUDIO` at runtime before placing a call.
+iOS: add `NSMicrophoneUsageDescription` to `Info.plist` and accept the mic permission prompt.
+
+**iOS: `pod install` can't find headers / link errors**  
+Ensure `ios/VoipCloud.xcframework` exists in the installed package (it ships in the npm tarball).
+Re-run `pod install`; the podspec adds the framework's per-slice `Headers/` to the search path
+and links `libc++` + the required system frameworks.
 
 ---
 

package/android/build.gradle

@@ -8,14 +8,20 @@
 //   * com.voipcloud.sdk.rn.* React Native bridge (this module)
 
 buildscript {
-    repositories {
-        google()
-        mavenCentral()
-    }
-    dependencies {
-        // Pinned to the AGP version known to compile with React Native
-        // 0.74 + AS Iguana.  Bump in lockstep with peerDependencies.
-        classpath 'com.android.tools.build:gradle:8.2.1'
+    // Only needed when this library is opened as a STANDALONE Gradle project.
+    // When an app consumes it via autolinking, the app already provides the
+    // Android Gradle plugin on the classpath — injecting a second AGP version
+    // here would clash with the app's AGP. Guard so the consumer build is
+    // untouched.
+    if (project == rootProject) {
+        repositories {
+            google()
+            mavenCentral()
+        }
+        dependencies {
+            // AGP version known to compile with React Native 0.74.
+            classpath 'com.android.tools.build:gradle:8.2.1'
+        }
     }
 }
 

package/android/src/main/java/com/voipcloud/sdk/rn/VoipCloudModule.java

@@ -19,7 +19,9 @@ import com.voipcloud.sdk.EpConfig;
 import com.voipcloud.sdk.TransportConfig;
 import com.voipcloud.sdk.pjsip_status_code;
 import com.voipcloud.sdk.pjsip_transport_type_e;
+import com.voipcloud.sdk.pjsua_call_flag;
 import com.voipcloud.sdk.pjsua_destroy_flag;
+import com.voipcloud.sdk.AudDevManager;
 
 import com.voipcloud.sdk.rn.internal.BridgeGuard;
 import com.voipcloud.sdk.rn.internal.Events;
@@ -53,6 +55,36 @@ public class VoipCloudModule extends ReactContextBaseJavaModule {
     @Override
     public String getName() { return "VoipsdkReactNativeVoipcloud"; }
 
+    /**
+     * PJSIP aborts (SIGABRT, "Calling pjlib from unknown/external thread")
+     * when pjlib is entered from a thread never passed to
+     * pj_thread_register(). SWIG finalizers run on the runtime's
+     * FinalizerDaemon thread and call native destructors that touch pjlib
+     * (CallOpParam, EpConfig, CallInfo, ... dropped to the GC), so that
+     * thread must be registered too. There is no API to run code on
+     * FinalizerDaemon directly — enqueue a sacrificial object whose
+     * finalizer registers it, and force a finalization pass now, while no
+     * other SDK garbage is pending yet.
+     */
+    private static void registerFinalizerDaemonThread(final Endpoint ep) {
+        new Object() {
+            @Override
+            protected void finalize() throws Throwable {
+                try {
+                    if (!ep.libIsThreadRegistered()) {
+                        ep.libRegisterThread("FinalizerDaemon");
+                    }
+                } catch (Throwable ignored) {
+                    // Endpoint already destroyed or registration raced — the
+                    // next init() enqueues a fresh registration.
+                }
+                super.finalize();
+            }
+        };
+        System.gc();
+        System.runFinalization();
+    }
+
     private void destroyEndpointQuietly() {
         if (endpoint == null) return;
         try {
@@ -76,6 +108,7 @@ public class VoipCloudModule extends ReactContextBaseJavaModule {
         try {
             ep = new Endpoint();
             ep.libCreate();
+            registerFinalizerDaemonThread(ep);
 
             EpConfig epCfg = new EpConfig();
             if (config.hasKey("userAgent") && !config.isNull("userAgent"))
@@ -88,6 +121,26 @@ public class VoipCloudModule extends ReactContextBaseJavaModule {
             if (config.hasKey("logLevel") && !config.isNull("logLevel"))
                 epCfg.getLogConfig().setLevel(config.getInt("logLevel"));
 
+            // Disable PJSIP's software echo canceller: it is CPU-heavy on
+            // mobile and a common cause of crackling/choppy audio. Android
+            // applies its hardware AEC to VOICE_COMMUNICATION streams.
+            try {
+                epCfg.getMedConfig().setEcTailLen(0);
+            } catch (Throwable ignored) {}
+
+            // Audio quality: run the sound device at the Android native rate
+            // (48 kHz) so the HAL does not resample a 16 kHz stream a second
+            // time (double resampling on the JNI audio backend is the main
+            // source of crackling/harsh speaker audio). The conference
+            // bridge stays at 16 kHz; PJSIP resamples once with the
+            // high-quality (large filter) resampler. VAD is disabled so
+            // silence suppression cannot chop word edges.
+            try {
+                epCfg.getMedConfig().setSndClockRate(48000);
+                epCfg.getMedConfig().setQuality(10);
+                epCfg.getMedConfig().setNoVad(true);
+            } catch (Throwable ignored) {}
+
             ep.libInit(epCfg);
 
             TransportConfig udp = new TransportConfig();
@@ -146,10 +199,21 @@ public class VoipCloudModule extends ReactContextBaseJavaModule {
             acfg.setIdUri(uri);
             acfg.getRegConfig().setRegistrarUri(registrar);
 
+            // NAT survival: without keep-alives and contact rewrite the
+            // registration "succeeds" but the NAT mapping dies within a
+            // minute and inbound INVITEs never reach the device.
+            acfg.getNatConfig().setContactRewriteUse(1);
+            acfg.getNatConfig().setViaRewriteUse(1);
+            acfg.getNatConfig().setUdpKaIntervalSec(20);
+            // Short re-REGISTER interval keeps the binding fresh behind NAT.
+            acfg.getRegConfig().setTimeoutSec(120);
+            acfg.getRegConfig().setFirstRetryIntervalSec(5);
+            acfg.getRegConfig().setRetryIntervalSec(30);
+
             AuthCredInfo cred = new AuthCredInfo("digest", "*", username, 0, password);
             acfg.getSipConfig().getAuthCreds().add(cred);
 
-            ManagedAccount acc = new ManagedAccount(ctx, calls);
+            ManagedAccount acc = new ManagedAccount(ctx, calls, endpoint);
             acc.create(acfg);
             int id = acc.accountId();
             if (id < 0) {
@@ -195,7 +259,8 @@ public class VoipCloudModule extends ReactContextBaseJavaModule {
                 promise.reject("VC_NO_ACCOUNT", "Unknown accountId " + accountId + ". Call register() first.");
                 return;
             }
-            ManagedCall call = new ManagedCall(ctx, acc);
+            ManagedCall call = new ManagedCall(ctx, acc, calls);
+            call.bindEndpoint(endpoint);
             call.makeCall(uri.trim(), new CallOpParam(true));
             int callId = call.callId();
             if (callId < 0) {
@@ -229,21 +294,57 @@ public class VoipCloudModule extends ReactContextBaseJavaModule {
     }
 
     @ReactMethod
-    public void hangup(int callId, Promise promise) {
+    public void hangup(int callId, String mode, Promise promise) {
         if (!BridgeGuard.ensureNative(promise)) return;
         try {
             ManagedCall call = calls.get(callId);
             if (call == null) { promise.resolve(null); return; }
-            CallOpParam op = new CallOpParam();
-            op.setStatusCode(pjsip_status_code.PJSIP_SC_DECLINE);
+            CallOpParam op = new CallOpParam(true);
+            if ("busy".equals(mode)) {
+                op.setStatusCode(pjsip_status_code.PJSIP_SC_BUSY_HERE);
+            } else if ("cancel".equals(mode)) {
+                op.setStatusCode(pjsip_status_code.PJSIP_SC_REQUEST_TERMINATED);
+            }
             call.hangup(op);
-            calls.remove(callId);
             promise.resolve(null);
         } catch (Throwable t) {
             BridgeGuard.reject(promise, "VC_HANGUP", "Failed to hang up call", t);
         }
     }
 
+    /** Synchronous answer for native notification / Telecom UI when JS is inactive. */
+    public boolean answerCallSync(int callId) {
+        if (!inited) return false;
+        try {
+            ManagedCall call = calls.get(callId);
+            if (call == null) return false;
+            CallOpParam op = new CallOpParam();
+            op.setStatusCode(pjsip_status_code.PJSIP_SC_OK);
+            call.answer(op);
+            return true;
+        } catch (Throwable t) {
+            return false;
+        }
+    }
+
+    /** Synchronous hangup for native notification / Telecom UI when JS is inactive. */
+    public boolean hangupCallSync(int callId, String mode) {
+        try {
+            ManagedCall call = calls.get(callId);
+            if (call == null) return false;
+            CallOpParam op = new CallOpParam(true);
+            if ("busy".equals(mode)) {
+                op.setStatusCode(pjsip_status_code.PJSIP_SC_BUSY_HERE);
+            } else if ("cancel".equals(mode)) {
+                op.setStatusCode(pjsip_status_code.PJSIP_SC_REQUEST_TERMINATED);
+            }
+            call.hangup(op);
+            return true;
+        } catch (Throwable t) {
+            return false;
+        }
+    }
+
     @ReactMethod
     public void hold(int callId, Promise promise) {
         if (!BridgeGuard.ensureNative(promise)) return;
@@ -252,6 +353,10 @@ public class VoipCloudModule extends ReactContextBaseJavaModule {
             ManagedCall call = requireCall(callId, promise);
             if (call == null) return;
             call.setHold(new CallOpParam(true));
+            // Do NOT reconnect audio here: the hold re-INVITE is still in
+            // flight, so reconnecting emits a media-state snapshot with the
+            // OLD hold flag and desyncs the JS hold state. onCallMediaState
+            // rewires the bridge once the media status actually changes.
             WritableMap ev = Arguments.createMap();
             ev.putInt("callId", callId);
             Events.emit(getReactApplicationContext(), Events.CALL_HOLD, ev);
@@ -268,7 +373,11 @@ public class VoipCloudModule extends ReactContextBaseJavaModule {
         try {
             ManagedCall call = requireCall(callId, promise);
             if (call == null) return;
-            call.reinvite(new CallOpParam(true));
+            CallOpParam prm = new CallOpParam(true);
+            prm.getOpt().setFlag(pjsua_call_flag.PJSUA_CALL_UNHOLD);
+            call.reinvite(prm);
+            // See hold(): audio is rewired by onCallMediaState when the
+            // unhold re-INVITE completes and media becomes ACTIVE again.
             WritableMap ev = Arguments.createMap();
             ev.putInt("callId", callId);
             Events.emit(getReactApplicationContext(), Events.CALL_UNHOLD, ev);
@@ -278,6 +387,52 @@ public class VoipCloudModule extends ReactContextBaseJavaModule {
         }
     }
 
+    private void refreshPjsipPlaybackDevices() {
+        if (endpoint == null) return;
+        try {
+            AudDevManager adm = endpoint.audDevManager();
+            adm.refreshDevs();
+        } catch (Throwable ignored) {}
+    }
+
+    /** Reconnect PJSIP audio bridge after Android route changes (speaker/earpiece). */
+    public boolean reconnectCallAudioSync(int callId) {
+        if (!inited) return false;
+        ManagedCall call = calls.get(callId);
+        if (call == null) return false;
+        try {
+            refreshPjsipPlaybackDevices();
+            call.reconnectAudioMedia();
+            return true;
+        } catch (Throwable t) {
+            return false;
+        }
+    }
+
+    public int reconnectAllCallsAudioSync() {
+        if (!inited) return 0;
+        refreshPjsipPlaybackDevices();
+        int count = 0;
+        for (ManagedCall call : calls.snapshot()) {
+            try {
+                call.reconnectAudioMedia();
+                count++;
+            } catch (Throwable ignored) {}
+        }
+        return count;
+    }
+
+    @ReactMethod
+    public void reconnectCallAudio(int callId, Promise promise) {
+        if (!BridgeGuard.ensureNative(promise)) return;
+        if (!BridgeGuard.ensureInited(inited, promise)) return;
+        if (reconnectCallAudioSync(callId)) {
+            promise.resolve(null);
+        } else {
+            promise.reject("VC_AUDIO", "Failed to reconnect call audio");
+        }
+    }
+
     @ReactMethod
     public void mute(int callId, boolean on, Promise promise) {
         if (!BridgeGuard.ensureNative(promise)) return;

package/android/src/main/java/com/voipcloud/sdk/rn/internal/ManagedAccount.java

@@ -7,8 +7,10 @@ import com.facebook.react.bridge.WritableMap;
 import com.voipcloud.sdk.Account;
 import com.voipcloud.sdk.AccountInfo;
 import com.voipcloud.sdk.CallOpParam;
+import com.voipcloud.sdk.Endpoint;
 import com.voipcloud.sdk.OnIncomingCallParam;
 import com.voipcloud.sdk.OnRegStateParam;
+import com.voipcloud.sdk.pjsip_status_code;
 
 /**
  * Account subclass forwarding PJSUA2 callbacks to JS as RN events.
@@ -17,10 +19,12 @@ import com.voipcloud.sdk.OnRegStateParam;
 public final class ManagedAccount extends Account {
     private final ReactContext ctx;
     private final ManagedCallRegistry callRegistry;
+    private final Endpoint endpoint;
 
-    public ManagedAccount(ReactContext ctx, ManagedCallRegistry callRegistry) {
+    public ManagedAccount(ReactContext ctx, ManagedCallRegistry callRegistry, Endpoint endpoint) {
         this.ctx = ctx;
         this.callRegistry = callRegistry;
+        this.endpoint = endpoint;
     }
 
     public int accountId() {
@@ -41,23 +45,63 @@ public final class ManagedAccount extends Account {
         // Allocate a ManagedCall so we can fire callState events for
         // this inbound leg.  The consumer must call answer(callId) or
         // hangup(callId) to proceed.
-        ManagedCall call = new ManagedCall(ctx, this, prm.getCallId());
+        ManagedCall call = new ManagedCall(ctx, this, prm.getCallId(), callRegistry);
+        call.bindEndpoint(endpoint);
         callRegistry.put(call);
 
+        // Send 180 Ringing immediately: without a provisional response the
+        // caller hears dead silence and many PBX/trunk setups drop the call
+        // before the callee can answer.
+        try {
+            CallOpParam ringing = new CallOpParam();
+            ringing.setStatusCode(pjsip_status_code.PJSIP_SC_RINGING);
+            call.answer(ringing);
+        } catch (Throwable ignored) {}
+
+        String from = "";
+        String to = "";
         try {
             AccountInfo accInfo = getInfo();
+            com.voipcloud.sdk.CallInfo callInfo = call.getInfo();
+            from = callInfo.getRemoteUri();
+            to = accInfo.getUri();
             WritableMap payload = Arguments.createMap();
             payload.putInt("accountId", accountId());
             payload.putInt("callId", call.callId());
-            payload.putString("from", call.getInfo().getRemoteUri());
-            payload.putString("to",   accInfo.getUri());
+            payload.putString("from", from);
+            payload.putString("to", to);
+            // SIP Call-ID header — stable across systems (PBX CDR, CRM sync),
+            // unlike the numeric PJSUA call slot which is recycled.
+            payload.putString("sipCallId", callInfo.getCallIdString());
             Events.emit(ctx, Events.INCOMING_CALL, payload);
         } catch (Exception ignored) {
-            // If we cannot pull info, still notify with what we have.
             WritableMap payload = Arguments.createMap();
             payload.putInt("accountId", accountId());
             payload.putInt("callId", call.callId());
             Events.emit(ctx, Events.INCOMING_CALL, payload);
         }
+        dispatchIncomingToApp(ctx, accountId(), call.callId(), from, to);
+    }
+
+    /** Notify VoicePBX native layer before JS (background incoming calls). */
+    private static void dispatchIncomingToApp(
+            ReactContext ctx, int accountId, int callId, String from, String to) {
+        try {
+            Class<?> cls = Class.forName("com.voicepbx.voip.VoipIncomingNotifier");
+            cls.getMethod(
+                    "onIncomingCall",
+                    android.content.Context.class,
+                    int.class,
+                    int.class,
+                    String.class,
+                    String.class)
+                .invoke(
+                    null,
+                    ctx.getApplicationContext(),
+                    accountId,
+                    callId,
+                    from != null ? from : "",
+                    to != null ? to : "");
+        } catch (Throwable ignored) {}
     }
 }