@voipsdk/react-native-voipcloud 0.2.1

package/README.md

@@ -0,0 +1,172 @@
+# react-native-voipcloud
+
+> Platform: Android (RN 0.70+, Android 12+).
+
+---
+
+## Install
+
+```bash
+npm install react-native-voipcloud
+# or:
+yarn add react-native-voipcloud
+```
+
+Android autolinks the `VoipCloudPackage` if you are on React Native 0.60+.
+
+For older RN versions, add manually to `MainApplication.java`:
+```java
+packages.add(new com.voipcloud.sdk.rn.VoipCloudPackage());
+```
+
+Required `AndroidManifest.xml` permissions (declare in **your** app):
+```xml
+<uses-permission android:name="android.permission.INTERNET" />
+<uses-permission android:name="android.permission.RECORD_AUDIO" />
+<uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS" />
+<uses-permission android:name="android.permission.WAKE_LOCK" />
+<uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
+<uses-permission android:name="android.permission.FOREGROUND_SERVICE_PHONE_CALL" />
+```
+
+Runtime permissions to request:
+`RECORD_AUDIO`, `POST_NOTIFICATIONS` (Android 13+), `BLUETOOTH_CONNECT`.
+
+---
+
+## Quick start
+
+```ts
+import { VoipCloud } from 'react-native-voipcloud';
+
+// 1. Apply the license your operator issued.
+try {
+    await VoipCloud.License.set(myToken);
+} catch (e) {
+    // VC_LICENSE — token format / signature / expiry / bundle issues.
+}
+
+// 2. Start the engine.
+await VoipCloud.init({ userAgent: 'acme-voip/1.0' });
+
+// 3. Register a SIP account.
+const accId = await VoipCloud.register({
+    uri:       'sip:alice@example.com',
+    registrar: 'sip:example.com:5061;transport=tls',
+    username:  'alice',
+    password:  '••••••',
+    transport: 'TLS',
+});
+
+// 4. Make a call.
+const callId = await VoipCloud.makeCall(accId, 'sip:bob@example.com');
+
+// 5. In-call controls.
+await VoipCloud.hold(callId);                      // put on hold
+await VoipCloud.unhold(callId);                    // resume
+await VoipCloud.mute(callId, true);                // mute mic
+await VoipCloud.sendDtmf(callId, '1234#');         // send DTMF
+await VoipCloud.transferCall(callId, 'sip:charlie@example.com'); // blind transfer
+await VoipCloud.hangup(callId);                    // end this call
+await VoipCloud.hangupAllCalls();                  // end every active call
+
+// 6. Subscribe to events.
+const sub = VoipCloud.on('callState', ({ callId, state }) => {
+    console.log('call', callId, '→', state);
+});
+const subMedia = VoipCloud.on('callMediaState', ({ callId, hasAudio, isHold, isMuted }) => {
+    console.log('media', callId, { hasAudio, isHold, isMuted });
+});
+// sub.remove() / subMedia.remove() when done
+
+// 7. License refresh is automatic.
+//    If your token's payload includes a `ref` field, the SDK starts a
+//    24 h refresher in the background after `License.set` succeeds.
+//    No URL configuration needed on the app side.
+//
+//    Optional: stop the refresher when the user logs out.
+await VoipCloud.License.stopRefresh();
+
+// 8. Tear down the SDK on app exit.
+await VoipCloud.shutdown();
+```
+
+---
+
+## Error codes (Promise rejection.code)
+
+Mọi method trả Promise; khi reject, `code` mang một trong các mã sau.
+Cụ thể lỗi license được tách thành các mã granular để app dễ hiển thị
+thông báo phù hợp.
+
+License (từ `License.set` / `License.status`):
+
+| code                  | Ý nghĩa                                              |
+|-----------------------|------------------------------------------------------|
+| `VC_NO_LICENSE`       | Chưa cài token, hoặc token đã bị reset               |
+| `VC_BAD_FORMAT`       | Token sai định dạng (không phải base64url JWT)       |
+| `VC_BAD_SIGNATURE`    | Chữ ký Ed25519 không hợp lệ                          |
+| `VC_EXPIRED`          | Token hết hạn                                        |
+| `VC_NOT_ACTIVE`       | Token bị tạm khoá (status ≠ active)                  |
+| `VC_REVOKED`          | Token đã bị thu hồi                                  |
+| `VC_BUNDLE_MISMATCH`  | Bundle id app không khớp `bundle_id` trong token     |
+| `VC_PAYLOAD_TOO_BIG`  | Payload token quá lớn                                |
+| `VC_CLOCK_SKEW`       | Đồng hồ thiết bị bị chỉnh lùi so với mốc server     |
+| `VC_LICENSE`          | Lỗi license chung không khớp các mã trên             |
+| `VC_STATUS`           | Đọc trạng thái thất bại                              |
+
+Endpoint / call:
+
+| code                  | Ý nghĩa                                              |
+|-----------------------|------------------------------------------------------|
+| `VC_INIT`             | Endpoint không khởi động được                        |
+| `VC_SHUTDOWN`         | Lỗi khi `shutdown()` dọn endpoint                    |
+| `VC_REGISTER`         | `register()` thất bại                                |
+| `VC_UNREGISTER`       | `unregister()` thất bại                              |
+| `VC_NO_ACCOUNT`       | accountId không tồn tại                              |
+| `VC_MAKE_CALL`        | `makeCall()` thất bại (bao gồm `VC_CCU_EXCEEDED`)    |
+| `VC_CCU_EXCEEDED`     | Vượt số cuộc gọi đồng thời license cho phép          |
+| `VC_NO_CALL`          | callId không tồn tại                                 |
+| `VC_ANSWER`           | `answer()` thất bại                                  |
+| `VC_HANGUP`           | `hangup()` thất bại                                  |
+| `VC_HOLD` / `VC_UNHOLD` | `hold()` / `unhold()` thất bại                     |
+| `VC_MUTE`             | `mute()` thất bại (vd: chưa init endpoint)            |
+| `VC_DTMF`             | `sendDtmf()` thất bại                                |
+| `VC_TRANSFER`         | `transferCall()` thất bại                            |
+| `VC_HANGUP_ALL`       | `hangupAllCalls()` thất bại                          |
+
+`message` đính kèm là `pj_strerror` từ PJSIP, hữu ích khi log.
+
+---
+
+## Events
+
+Account / call lifecycle (do PJSIP phát):
+
+```ts
+VoipCloud.on('registrationState', e => /* { accountId, code, reason } */);
+VoipCloud.on('incomingCall',      e => /* { accountId, callId, from, to } */);
+VoipCloud.on('callState',         e => /* { callId, state, code, reason } */);
+VoipCloud.on('callMediaState',    e => /* { callId, hasAudio, isHold, isMuted } */);
+```
+
+Per-action xác nhận (bridge phát sau khi action thành công — tiện cho
+UI bind 1-1 với từng nút bấm):
+
+```ts
+VoipCloud.on('callHold',      e => /* { callId } */);
+VoipCloud.on('callUnhold',    e => /* { callId } */);
+VoipCloud.on('callMute',      e => /* { callId, isMuted } */);
+VoipCloud.on('callDtmfSent',  e => /* { callId, digits } */);
+VoipCloud.on('callTransfer',  e => /* { callId, destinationUri } */);
+```
+
+Remote-driven (PJSIP forward từ callback gốc):
+
+```ts
+// REFER multi-stage: nhận một event mỗi NOTIFY; finalNotify=true là kết quả cuối.
+VoipCloud.on('callTransferStatus', e => /* { callId, statusCode, reason, finalNotify } */);
+
+// DTMF do đầu remote gửi qua RTP (RFC 2833).
+VoipCloud.on('incomingDtmf',       e => /* { callId, digit, duration } */);
+```

package/android/build.gradle

@@ -0,0 +1,61 @@
+// react-native-voipcloud — Android library module.
+//
+// Consumer apps that include this package via Gradle pull in:
+//   * com.voipcloud.sdk.* from voipcloud-release.aar
+//   * com.voipcloud.sdk.rn.* React Native bridge classes (this module)
+//
+// The AAR ships its own ProGuard rules (proguard.txt) which R8 auto-
+// applies to the consumer release build; no extra setup needed.
+
+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'
+    }
+}
+
+apply plugin: 'com.android.library'
+
+def safeExtGet(prop, fallback) {
+    rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+}
+
+android {
+    namespace 'com.voipcloud.sdk.rn'
+    compileSdkVersion safeExtGet('compileSdkVersion', 34)
+
+    defaultConfig {
+        minSdkVersion safeExtGet('minSdkVersion', 31)
+        targetSdkVersion safeExtGet('targetSdkVersion', 34)
+
+        ndk {
+            // The AAR ships native libs for these three ABIs only.
+            abiFilters 'arm64-v8a', 'armeabi-v7a', 'x86_64'
+        }
+    }
+
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_17
+        targetCompatibility JavaVersion.VERSION_17
+    }
+}
+
+repositories {
+    google()
+    mavenCentral()
+    flatDir { dirs 'src/main/libs' }
+}
+
+dependencies {
+    // Prebuilt PJSIP + license layer (com.voipcloud.sdk.*).
+    implementation(name: 'voipcloud-release', ext: 'aar')
+
+    // Pin to a permissive range — the consumer app controls the actual
+    // React Native version via its own classpath.
+    implementation 'com.facebook.react:react-native:+'
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android" />

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

@@ -0,0 +1,428 @@
+package com.voipcloud.sdk.rn;
+
+import android.provider.Settings;
+import androidx.annotation.NonNull;
+
+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.ReadableMap;
+import com.facebook.react.bridge.WritableMap;
+
+import com.voipcloud.sdk.AccountConfig;
+import com.voipcloud.sdk.AuthCredInfo;
+import com.voipcloud.sdk.CallOpParam;
+import com.voipcloud.sdk.CallSendDtmfParam;
+import com.voipcloud.sdk.Endpoint;
+import com.voipcloud.sdk.EpConfig;
+import com.voipcloud.sdk.License;
+import com.voipcloud.sdk.LicenseRefresher;
+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_destroy_flag;
+
+import com.voipcloud.sdk.rn.internal.Events;
+import com.voipcloud.sdk.rn.internal.ManagedAccount;
+import com.voipcloud.sdk.rn.internal.ManagedCall;
+import com.voipcloud.sdk.rn.internal.ManagedCallRegistry;
+
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * React Native bridge for the VoipCloud SDK.  All methods are async
+ * Promises; license-gate failures rejecting with code "VC_<ENUM>".
+ */
+public class VoipCloudModule extends ReactContextBaseJavaModule {
+
+    static {
+        // Load the prebuilt PJSIP + license-layer library.  Names must
+        // match jniLibs path inside the AAR: jni/<abi>/libvoipcloud.so.
+        // libc++_shared is co-located and pulled in implicitly by the
+        // loader as a NEEDED dependency.
+        System.loadLibrary("voipcloud");
+    }
+
+    private final ReactApplicationContext ctx;
+    private final ManagedCallRegistry calls = new ManagedCallRegistry();
+    private final ConcurrentHashMap<Integer, ManagedAccount> accounts = new ConcurrentHashMap<>();
+    private final AtomicInteger nextAccKey = new AtomicInteger(1);
+
+    private Endpoint endpoint;
+    private boolean inited = false;
+    /** Last token accepted by License.set; reused by the refresher. */
+    private volatile String licenseToken = null;
+    /** Refresh URL currently driving LicenseRefresher.  Used to detect
+     *  when a token rotation also rotates the refresh endpoint. */
+    private volatile String activeRefreshUrl = null;
+
+    public VoipCloudModule(ReactApplicationContext ctx) {
+        super(ctx);
+        this.ctx = ctx;
+
+        // Tell native the consumer app's package up front so subsequent
+        // License.set() can enforce the bundle_id binding embedded in
+        // the token.  Also anchor the clock-skew detector.
+        License.setBundle(ctx.getPackageName());
+        License.setStateDir(ctx.getFilesDir().getAbsolutePath());
+    }
+
+    @NonNull
+    @Override
+    public String getName() { return "VoipCloud"; }
+
+    // ============== License ============================================
+
+    @ReactMethod
+    public void setLicense(String token, Promise promise) {
+        try {
+            License.set(token);
+            licenseToken = token;
+            bootstrapRefresher(License.refreshUrl());
+            promise.resolve(null);
+        } catch (Throwable t) {
+            // Stop any refresher tied to the previous (now-rejected) token.
+            stopRefresherInternal();
+            promise.reject(mapLicenseError(t), t.getMessage(), t);
+        }
+    }
+
+    /**
+     * Start, restart, or no-op the LicenseRefresher to match the URL
+     * embedded in the most recently accepted token.  The consumer app
+     * never specifies a URL — it travels inside the signed token.
+     */
+    private void bootstrapRefresher(String refreshUrl) {
+        if (refreshUrl == null || refreshUrl.isEmpty()) {
+            // Token opted out of refresh.  Stop any leftover loop.
+            stopRefresherInternal();
+            return;
+        }
+        // If the URL is unchanged, the existing refresher is still
+        // correct — just leave it running so its next 24 h fire reuses
+        // the now-updated token via its internal cache.
+        if (refreshUrl.equals(activeRefreshUrl)) return;
+
+        // URL changed (or first start) — restart with the new endpoint.
+        try { LicenseRefresher.stop(); } catch (Throwable ignored) {}
+        LicenseRefresher.start(ctx, refreshUrl, licenseToken, autoDeviceId());
+        activeRefreshUrl = refreshUrl;
+    }
+
+    private void stopRefresherInternal() {
+        try { LicenseRefresher.stop(); } catch (Throwable ignored) {}
+        activeRefreshUrl = null;
+    }
+
+    /**
+     * Stable per-install identifier without asking the consumer.  On
+     * Android 8+ the ANDROID_ID is scoped to package+signing key, so
+     * it survives reinstalls of the same APK but rotates if the app is
+     * sideloaded by another publisher — exactly the semantics a
+     * license server wants.
+     */
+    private String autoDeviceId() {
+        try {
+            String id = Settings.Secure.getString(
+                    ctx.getContentResolver(), Settings.Secure.ANDROID_ID);
+            if (id != null && !id.isEmpty()) return id;
+        } catch (Throwable ignored) {}
+        // Fall back to a manifest-derived label.
+        return ctx.getPackageName() + ":" + android.os.Build.FINGERPRINT;
+    }
+
+    /** Translate a PJSUA2 Error into the granular VC_* code surfaced to JS. */
+    private static String mapLicenseError(Throwable t) {
+        String msg = t.getMessage();
+        if (msg == null) return "VC_LICENSE";
+        if (msg.contains("license not set"))           return "VC_NO_LICENSE";
+        if (msg.contains("malformed"))                  return "VC_BAD_FORMAT";
+        if (msg.contains("signature invalid"))          return "VC_BAD_SIGNATURE";
+        if (msg.contains("license expired"))            return "VC_EXPIRED";
+        if (msg.contains("not active"))                 return "VC_NOT_ACTIVE";
+        if (msg.contains("revoked"))                    return "VC_REVOKED";
+        if (msg.contains("bundle id mismatch"))         return "VC_BUNDLE_MISMATCH";
+        if (msg.contains("concurrent calls"))           return "VC_CCU_EXCEEDED";
+        if (msg.contains("payload too large"))          return "VC_PAYLOAD_TOO_BIG";
+        if (msg.contains("clock rolled back"))          return "VC_CLOCK_SKEW";
+        return "VC_LICENSE";
+    }
+
+    @ReactMethod
+    public void getLicenseStatus(Promise promise) {
+        try {
+            WritableMap m = Arguments.createMap();
+            m.putBoolean("valid",       License.isValid());
+            m.putString ("status",      License.status());
+            m.putString ("customerId",  License.customerId());
+            m.putInt    ("ccu",         License.maxCcu());
+            m.putInt    ("currentCalls",License.currentCalls());
+            m.putDouble ("expiry",      License.expiryUnix());
+            m.putDouble ("serverTime",  License.serverTime());
+            promise.resolve(m);
+        } catch (Throwable t) {
+            promise.reject("VC_STATUS", t.getMessage(), t);
+        }
+    }
+
+    /**
+     * The refresher bootstraps itself from token.ref during
+     * setLicense(); the consumer never starts it manually.  We expose
+     * stop() only so apps can pause refresh during user logout / SDK
+     * shutdown.
+     */
+    @ReactMethod
+    public void stopLicenseRefresh(Promise promise) {
+        stopRefresherInternal();
+        promise.resolve(null);
+    }
+
+    // ============== Endpoint lifecycle =================================
+
+    @ReactMethod
+    public void init(ReadableMap config, Promise promise) {
+        try {
+            if (inited) { promise.resolve(null); return; }
+            endpoint = new Endpoint();
+            endpoint.libCreate();
+
+            EpConfig epCfg = new EpConfig();
+            if (config.hasKey("userAgent"))
+                epCfg.getUaConfig().setUserAgent(config.getString("userAgent"));
+            if (config.hasKey("stunServer")) {
+                com.voipcloud.sdk.StringVector v = new com.voipcloud.sdk.StringVector();
+                v.add(config.getString("stunServer"));
+                epCfg.getUaConfig().setStunServer(v);
+            }
+            if (config.hasKey("logLevel"))
+                epCfg.getLogConfig().setLevel(config.getInt("logLevel"));
+
+            endpoint.libInit(epCfg);
+
+            // Default transports — TLS handled per-account via registrar URI.
+            TransportConfig udp = new TransportConfig();
+            endpoint.transportCreate(pjsip_transport_type_e.PJSIP_TRANSPORT_UDP, udp);
+            TransportConfig tcp = new TransportConfig();
+            endpoint.transportCreate(pjsip_transport_type_e.PJSIP_TRANSPORT_TCP, tcp);
+
+            endpoint.libStart();
+            inited = true;
+            promise.resolve(null);
+        } catch (Throwable t) {
+            promise.reject("VC_INIT", t.getMessage(), t);
+        }
+    }
+
+    @ReactMethod
+    public void shutdown(Promise promise) {
+        try {
+            calls.clear();
+            for (ManagedAccount a : accounts.values()) a.delete();
+            accounts.clear();
+            if (endpoint != null) {
+                endpoint.libDestroy(pjsua_destroy_flag.PJSUA_DESTROY_NO_NETWORK);
+                endpoint.delete();
+                endpoint = null;
+            }
+            inited = false;
+            promise.resolve(null);
+        } catch (Throwable t) {
+            promise.reject("VC_SHUTDOWN", t.getMessage(), t);
+        }
+    }
+
+    // ============== Account ============================================
+
+    @ReactMethod
+    public void register(ReadableMap cfg, Promise promise) {
+        try {
+            AccountConfig acfg = new AccountConfig();
+            acfg.setIdUri(cfg.getString("uri"));
+            acfg.getRegConfig().setRegistrarUri(cfg.getString("registrar"));
+
+            AuthCredInfo cred = new AuthCredInfo(
+                    "digest", "*",
+                    cfg.getString("username"), 0,
+                    cfg.getString("password"));
+            acfg.getSipConfig().getAuthCreds().add(cred);
+
+            ManagedAccount acc = new ManagedAccount(ctx, calls);
+            acc.create(acfg);
+            int id = acc.accountId();
+            accounts.put(id, acc);
+            promise.resolve(id);
+        } catch (Throwable t) {
+            promise.reject("VC_REGISTER", t.getMessage(), t);
+        }
+    }
+
+    @ReactMethod
+    public void unregister(int accountId, Promise promise) {
+        try {
+            ManagedAccount acc = accounts.remove(accountId);
+            if (acc != null) {
+                acc.setRegistration(false);
+                acc.delete();
+            }
+            promise.resolve(null);
+        } catch (Throwable t) {
+            promise.reject("VC_UNREGISTER", t.getMessage(), t);
+        }
+    }
+
+    // ============== Call ===============================================
+
+    @ReactMethod
+    public void makeCall(int accountId, String uri, Promise promise) {
+        try {
+            ManagedAccount acc = accounts.get(accountId);
+            if (acc == null) { promise.reject("VC_NO_ACCOUNT", "unknown accountId"); return; }
+            ManagedCall call = new ManagedCall(ctx, acc);
+            call.makeCall(uri, new CallOpParam(true));
+            calls.put(call);
+            promise.resolve(call.callId());
+        } catch (Throwable t) {
+            promise.reject("VC_MAKE_CALL", t.getMessage(), t);
+        }
+    }
+
+    @ReactMethod
+    public void answer(int callId, Promise promise) {
+        try {
+            ManagedCall call = calls.get(callId);
+            if (call == null) { promise.reject("VC_NO_CALL", "unknown callId"); return; }
+            CallOpParam op = new CallOpParam();
+            op.setStatusCode(pjsip_status_code.PJSIP_SC_OK);
+            call.answer(op);
+            promise.resolve(null);
+        } catch (Throwable t) {
+            promise.reject("VC_ANSWER", t.getMessage(), t);
+        }
+    }
+
+    @ReactMethod
+    public void hangup(int callId, Promise promise) {
+        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);
+            call.hangup(op);
+            calls.remove(callId);
+            promise.resolve(null);
+        } catch (Throwable t) {
+            promise.reject("VC_HANGUP", t.getMessage(), t);
+        }
+    }
+
+    @ReactMethod
+    public void hold(int callId, Promise promise) {
+        try {
+            ManagedCall call = calls.get(callId);
+            if (call == null) { promise.reject("VC_NO_CALL", "unknown callId"); return; }
+            call.setHold(new CallOpParam(true));
+            WritableMap ev = Arguments.createMap();
+            ev.putInt("callId", callId);
+            Events.emit(getReactApplicationContext(), Events.CALL_HOLD, ev);
+            promise.resolve(null);
+        } catch (Throwable t) {
+            promise.reject("VC_HOLD", t.getMessage(), t);
+        }
+    }
+
+    @ReactMethod
+    public void unhold(int callId, Promise promise) {
+        try {
+            ManagedCall call = calls.get(callId);
+            if (call == null) { promise.reject("VC_NO_CALL", "unknown callId"); return; }
+            // PJSUA2 re-INVITE without an explicit hold flag re-offers
+            // sendrecv SDP; that releases the existing hold.
+            call.reinvite(new CallOpParam(true));
+            WritableMap ev = Arguments.createMap();
+            ev.putInt("callId", callId);
+            Events.emit(getReactApplicationContext(), Events.CALL_UNHOLD, ev);
+            promise.resolve(null);
+        } catch (Throwable t) {
+            promise.reject("VC_UNHOLD", t.getMessage(), t);
+        }
+    }
+
+    @ReactMethod
+    public void mute(int callId, boolean on, Promise promise) {
+        try {
+            ManagedCall call = calls.get(callId);
+            if (call == null) { promise.reject("VC_NO_CALL", "unknown callId"); return; }
+            if (endpoint == null) { promise.reject("VC_INIT", "endpoint not started"); return; }
+            call.setMuted(endpoint, on);
+            WritableMap ev = Arguments.createMap();
+            ev.putInt("callId", callId);
+            ev.putBoolean("isMuted", on);
+            Events.emit(getReactApplicationContext(), Events.CALL_MUTE, ev);
+            promise.resolve(null);
+        } catch (Throwable t) {
+            promise.reject("VC_MUTE", t.getMessage(), t);
+        }
+    }
+
+    @ReactMethod
+    public void sendDtmf(int callId, String digits, Promise promise) {
+        try {
+            ManagedCall call = calls.get(callId);
+            if (call == null) { promise.reject("VC_NO_CALL", "unknown callId"); return; }
+            CallSendDtmfParam p = new CallSendDtmfParam();
+            p.setDigits(digits);
+            call.sendDtmf(p);
+            WritableMap ev = Arguments.createMap();
+            ev.putInt("callId", callId);
+            ev.putString("digits", digits);
+            Events.emit(getReactApplicationContext(), Events.CALL_DTMF_SENT, ev);
+            promise.resolve(null);
+        } catch (Throwable t) {
+            promise.reject("VC_DTMF", t.getMessage(), t);
+        }
+    }
+
+    /**
+     * Blind-transfer a call (REFER).  The Promise resolves once the
+     * REFER is *sent* — progress of the remote-side INVITE comes
+     * through `callTransferStatus` events (statusCode + finalNotify).
+     */
+    @ReactMethod
+    public void transferCall(int callId, String destinationUri, Promise promise) {
+        try {
+            ManagedCall call = calls.get(callId);
+            if (call == null) { promise.reject("VC_NO_CALL", "unknown callId"); return; }
+            call.xfer(destinationUri, new CallOpParam(true));
+            WritableMap ev = Arguments.createMap();
+            ev.putInt("callId", callId);
+            ev.putString("destinationUri", destinationUri);
+            Events.emit(getReactApplicationContext(), Events.CALL_TRANSFER, ev);
+            promise.resolve(null);
+        } catch (Throwable t) {
+            promise.reject("VC_TRANSFER", t.getMessage(), t);
+        }
+    }
+
+    /**
+     * End every active call in one shot.  Useful for SDK shutdown or
+     * a global "end all" UI action.  Each call still emits its own
+     * DISCONNECTED callState.
+     */
+    @ReactMethod
+    public void hangupAllCalls(Promise promise) {
+        try {
+            if (endpoint != null) endpoint.hangupAllCalls();
+            promise.resolve(null);
+        } catch (Throwable t) {
+            promise.reject("VC_HANGUP_ALL", t.getMessage(), t);
+        }
+    }
+
+    // RN event-emitter contract — required on RN 0.65+ when used with
+    // NativeEventEmitter on the JS side.
+    @ReactMethod public void addListener(String eventName)   { /* no-op */ }
+    @ReactMethod public void removeListeners(int count)      { /* no-op */ }
+}

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

@@ -0,0 +1,21 @@
+package com.voipcloud.sdk.rn;
+
+import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.uimanager.ViewManager;
+
+import java.util.Collections;
+import java.util.List;
+
+public class VoipCloudPackage implements ReactPackage {
+    @Override
+    public List<NativeModule> createNativeModules(ReactApplicationContext ctx) {
+        return Collections.singletonList(new VoipCloudModule(ctx));
+    }
+
+    @Override
+    public List<ViewManager> createViewManagers(ReactApplicationContext ctx) {
+        return Collections.emptyList();
+    }
+}