@voipsdk/react-native-voipcloud 1.0.1 → 1.0.3

package/ios/VoipCloudEngine.mm

@@ -0,0 +1,655 @@
+//
+//  VoipCloudEngine.mm — @voipsdk/react-native-voipcloud (iOS)
+//  Objective-C++ wrapper around PJSUA2.  See VoipCloudEngine.h.
+//
+#import "VoipCloudEngine.h"
+#import <AVFoundation/AVFoundation.h>
+#include <pjsua2.hpp>
+#include <pjsua-lib/pjsua.h>
+#include <string>
+#include <map>
+#include <algorithm>
+#include <cctype>
+
+using namespace pj;
+
+static NSString *const kVCErrorDomain = @"VoipCloudEngine";
+
+static NSError *VCMakeError(NSInteger code, NSString *msg) {
+    return [NSError errorWithDomain:kVCErrorDomain
+                               code:code
+                           userInfo:@{ NSLocalizedDescriptionKey: msg ?: @"Unknown error" }];
+}
+
+static NSString *VCStr(const std::string &s) {
+    return [NSString stringWithUTF8String:s.c_str()] ?: @"";
+}
+
+// pjsip_inv_state -> the JS CallState string (matches Android invStateName()).
+static NSString *VCInvStateName(pjsip_inv_state s) {
+    switch (s) {
+        case PJSIP_INV_STATE_NULL:         return @"NULL";
+        case PJSIP_INV_STATE_CALLING:      return @"CALLING";
+        case PJSIP_INV_STATE_INCOMING:     return @"INCOMING";
+        case PJSIP_INV_STATE_EARLY:        return @"EARLY";
+        case PJSIP_INV_STATE_CONNECTING:   return @"CONNECTING";
+        case PJSIP_INV_STATE_CONFIRMED:    return @"CONFIRMED";
+        case PJSIP_INV_STATE_DISCONNECTED: return @"DISCONNECTED";
+        default:                           return @"UNKNOWN";
+    }
+}
+
+@class VoipCloudEngine;
+class VCCall;
+class VCAccount;
+
+#pragma mark - Private engine interface (used by the C++ callbacks)
+
+@interface VoipCloudEngine ()
+- (void)emitEvent:(NSString *)name body:(NSDictionary *)body;
+- (void)storeCall:(VCCall *)call withId:(int)cid;
+- (void)removeCallId:(int)cid;
+- (VCCall *)callForId:(int)cid;
+- (void)activateAudioSession;
+- (void)deactivateAudioSessionIfIdle;
+@end
+
+#pragma mark - Log writer (PJSIP logs -> NSLog)
+
+class VCLogWriter : public LogWriter {
+public:
+    virtual void write(const LogEntry &entry) override {
+        NSLog(@"[PJSIP] %s", entry.msg.c_str());
+    }
+};
+
+#pragma mark - Call (subclass PJSUA2 Call)
+
+class VCCall : public Call {
+public:
+    __unsafe_unretained VoipCloudEngine *owner;
+    int  cachedId;
+    bool isMuted;
+
+    VCCall(Account &acc, int call_id = PJSUA_INVALID_ID)
+        : Call(acc, call_id), owner(nil), cachedId(call_id), isMuted(false) {}
+
+    int cid() {
+        try { return getId(); } catch (...) { return cachedId; }
+    }
+
+    // Wire capture <-> call <-> playback whenever media is active. PJSIP does
+    // not auto-bridge; mirror Android ManagedCall.connectAudioMedia().
+    void connectAudioMedia() {
+        try {
+            AudDevManager &adm = Endpoint::instance().audDevManager();
+            AudioMedia mic = adm.getCaptureDevMedia();
+            AudioMedia speaker = adm.getPlaybackDevMedia();
+            CallInfo info = getInfo();
+            for (unsigned i = 0; i < info.media.size(); i++) {
+                if (info.media[i].type != PJMEDIA_TYPE_AUDIO) continue;
+                if (info.media[i].status == PJSUA_CALL_MEDIA_ACTIVE) {
+                    AudioMedia leg = getAudioMedia((int)i);
+                    if (!isMuted) mic.startTransmit(leg);
+                    leg.startTransmit(speaker);
+                } else {
+                    try {
+                        AudioMedia leg = getAudioMedia((int)i);
+                        mic.stopTransmit(leg);
+                        leg.stopTransmit(speaker);
+                    } catch (...) {}
+                }
+            }
+        } catch (...) {}
+    }
+
+    void reconnectAudioMedia() {
+        try { Endpoint::instance().audDevManager().refreshDevs(); } catch (...) {}
+        connectAudioMedia();
+        emitMediaState();
+    }
+
+    // Toggle the local microphone for this call (bridge-level state).
+    void setMuted(bool muted) {
+        try {
+            AudDevManager &adm = Endpoint::instance().audDevManager();
+            AudioMedia mic = adm.getCaptureDevMedia();
+            CallInfo info = getInfo();
+            for (unsigned i = 0; i < info.media.size(); i++) {
+                if (info.media[i].type != PJMEDIA_TYPE_AUDIO) continue;
+                if (info.media[i].status != PJSUA_CALL_MEDIA_ACTIVE) continue;
+                AudioMedia leg = getAudioMedia((int)i);
+                if (muted) mic.stopTransmit(leg);
+                else       mic.startTransmit(leg);
+            }
+        } catch (Error &err) { /* fall through, flag still tracked */ }
+        isMuted = muted;
+        emitMediaState();
+    }
+
+    // Build + emit callMediaState { callId, hasAudio, isHold, isMuted }.
+    void emitMediaState() {
+        BOOL hasAudio = NO, isHold = NO;
+        try {
+            CallInfo info = getInfo();
+            for (unsigned i = 0; i < info.media.size(); i++) {
+                if (info.media[i].type != PJMEDIA_TYPE_AUDIO) continue;
+                pjsua_call_media_status st = info.media[i].status;
+                if (st == PJSUA_CALL_MEDIA_ACTIVE) hasAudio = YES;
+                else if (st == PJSUA_CALL_MEDIA_LOCAL_HOLD ||
+                         st == PJSUA_CALL_MEDIA_REMOTE_HOLD) isHold = YES;
+            }
+        } catch (...) {}
+        [owner emitEvent:@"callMediaState" body:@{
+            @"callId":   @(cid()),
+            @"hasAudio": @(hasAudio),
+            @"isHold":   @(isHold),
+            @"isMuted":  @(isMuted),
+        }];
+    }
+
+    virtual void onCallState(OnCallStateParam &prm) override;
+    virtual void onCallMediaState(OnCallMediaStateParam &prm) override;
+    virtual void onCallTransferStatus(OnCallTransferStatusParam &prm) override;
+    virtual void onDtmfDigit(OnDtmfDigitParam &prm) override;
+};
+
+#pragma mark - Account (subclass PJSUA2 Account)
+
+class VCAccount : public Account {
+public:
+    __unsafe_unretained VoipCloudEngine *owner;
+    int cachedId;
+    VCAccount() : owner(nil), cachedId(-1) {}
+    int aid() { try { return getId(); } catch (...) { return cachedId; } }
+    virtual void onRegState(OnRegStateParam &prm) override;
+    virtual void onIncomingCall(OnIncomingCallParam &iprm) override;
+};
+
+#pragma mark - C++ callback implementations
+
+void VCAccount::onRegState(OnRegStateParam &prm) {
+    [owner emitEvent:@"registrationState" body:@{
+        @"accountId": @(aid()),
+        @"code":      @(prm.code),
+        @"reason":    VCStr(prm.reason),
+    }];
+}
+
+void VCAccount::onIncomingCall(OnIncomingCallParam &iprm) {
+    VCCall *call = new VCCall(*this, iprm.callId);
+    call->owner = owner;
+    [owner storeCall:call withId:iprm.callId];
+
+    // Send 180 Ringing immediately — without a provisional response many
+    // PBX/trunk setups drop the call before the callee can answer.
+    try {
+        CallOpParam ringing;
+        ringing.statusCode = PJSIP_SC_RINGING;
+        call->answer(ringing);
+    } catch (...) {}
+
+    NSString *from = @"", *to = @"", *sipCallId = @"";
+    try {
+        CallInfo ci = call->getInfo();
+        from = VCStr(ci.remoteUri);
+        sipCallId = VCStr(ci.callIdString);
+        to = VCStr(getInfo().uri);
+    } catch (...) {}
+
+    [owner emitEvent:@"incomingCall" body:@{
+        @"accountId": @(aid()),
+        @"callId":    @(iprm.callId),
+        @"from":      from,
+        @"to":        to,
+        @"sipCallId": sipCallId,
+    }];
+}
+
+void VCCall::onCallState(OnCallStateParam &prm) {
+    (void)prm;
+    CallInfo info;
+    try {
+        info = getInfo();
+    } catch (...) {
+        // Post-disconnect getInfo can throw; emit a minimal payload.
+        [owner emitEvent:@"callState" body:@{
+            @"callId": @(cachedId),
+            @"state":  @"DISCONNECTED",
+            @"code":   @(0),
+            @"reason": @"",
+        }];
+        int cid_ = cachedId;
+        VoipCloudEngine *eng = owner;
+        dispatch_async(dispatch_get_main_queue(), ^{ [eng removeCallId:cid_]; });
+        return;
+    }
+
+    NSMutableDictionary *body = [@{
+        @"callId": @(cid()),
+        @"state":  VCInvStateName(info.state),
+        @"code":   @(info.lastStatusCode),
+        @"reason": VCStr(info.lastReason),
+    } mutableCopy];
+    body[@"sipCallId"] = VCStr(info.callIdString);
+    [owner emitEvent:@"callState" body:body];
+
+    if (info.state == PJSIP_INV_STATE_DISCONNECTED ||
+        info.state == PJSIP_INV_STATE_NULL) {
+        int cid_ = cid();
+        VoipCloudEngine *eng = owner;
+        dispatch_async(dispatch_get_main_queue(), ^{ [eng removeCallId:cid_]; });
+    }
+}
+
+void VCCall::onCallMediaState(OnCallMediaStateParam &prm) {
+    (void)prm;
+    connectAudioMedia();
+    emitMediaState();
+}
+
+void VCCall::onCallTransferStatus(OnCallTransferStatusParam &prm) {
+    [owner emitEvent:@"callTransferStatus" body:@{
+        @"callId":      @(cid()),
+        @"statusCode":  @((int)prm.statusCode),
+        @"reason":      VCStr(prm.reason),
+        @"finalNotify": @(prm.finalNotify ? YES : NO),
+    }];
+}
+
+void VCCall::onDtmfDigit(OnDtmfDigitParam &prm) {
+    [owner emitEvent:@"incomingDtmf" body:@{
+        @"callId":   @(cid()),
+        @"digit":    VCStr(prm.digit),
+        @"duration": @((double)prm.duration),
+    }];
+}
+
+#pragma mark - Engine
+
+@implementation VoipCloudEngine {
+    Endpoint                 *_ep;
+    VCLogWriter              *_logWriter;
+    std::map<int, VCAccount*> _accounts;
+    std::map<int, VCCall*>    _calls;
+    // Transport ids returned by transportCreate, so an account can be pinned to
+    // the SAME socket/port for REGISTER + INVITE + in-dialog re-INVITE/BYE
+    // (stable NAT binding across hold/unhold). -1 = that transport not created.
+    int                       _udpTransportId;
+    int                       _tcpTransportId;
+    int                       _tlsTransportId;
+}
+
++ (instancetype)shared {
+    static VoipCloudEngine *inst;
+    static dispatch_once_t once;
+    dispatch_once(&once, ^{ inst = [[VoipCloudEngine alloc] init]; });
+    return inst;
+}
+
+#pragma mark Lifecycle
+
+- (BOOL)startWithConfig:(NSDictionary *)config error:(NSError **)error {
+    if (_isStarted) return YES;
+    try {
+        _ep = new Endpoint();
+        _ep->libCreate();
+
+        _logWriter = new VCLogWriter();
+
+        EpConfig epCfg;
+        int logLevel = 4;
+        if ([config[@"logLevel"] isKindOfClass:[NSNumber class]])
+            logLevel = [config[@"logLevel"] intValue];
+        epCfg.logConfig.level = logLevel;
+        epCfg.logConfig.consoleLevel = logLevel;
+        epCfg.logConfig.writer = _logWriter;
+
+        NSString *ua = config[@"userAgent"];
+        epCfg.uaConfig.userAgent = [ua isKindOfClass:[NSString class]]
+            ? std::string(ua.UTF8String) : std::string("VoipCloud/1.0");
+
+        NSString *stun = config[@"stunServer"];
+        if ([stun isKindOfClass:[NSString class]] && stun.length) {
+            epCfg.uaConfig.stunServer.push_back(std::string(stun.UTF8String));
+        }
+
+        // Audio: run the sound device at 48 kHz, disable VAD — matches the
+        // Android tuning to avoid double-resampling artifacts / word chopping.
+        epCfg.medConfig.sndClockRate = 48000;
+        epCfg.medConfig.quality = 10;
+        epCfg.medConfig.noVad = true;
+
+        _ep->libInit(epCfg);
+
+        // Ephemeral ports (0) avoid "Address already in use" for SIP clients.
+        // Keep each transport id so registerAccountWithConfig can pin the
+        // account to the matching one (0 is a valid id → init to -1).
+        _udpTransportId = _tcpTransportId = _tlsTransportId = -1;
+        { TransportConfig t; t.port = 0; _udpTransportId = _ep->transportCreate(PJSIP_TRANSPORT_UDP, t); }
+        { TransportConfig t; t.port = 0; _tcpTransportId = _ep->transportCreate(PJSIP_TRANSPORT_TCP, t); }
+        {
+            TransportConfig t; t.port = 0;
+            t.tlsConfig.verifyServer = false;
+            t.tlsConfig.verifyClient = false;
+            t.tlsConfig.method = PJSIP_TLSV1_2_METHOD;
+            _tlsTransportId = _ep->transportCreate(PJSIP_TRANSPORT_TLS, t);
+        }
+
+        _ep->libStart();
+
+        // Codec allow-list. The PBX/proxy speaks G.711 (+G722 fallback); PJSIP's
+        // full default set (speex 8k/16k/32k, iLBC, …) makes the proxy rewrite
+        // the m= line and shift dynamic payload-type numbers → wrong codec map →
+        // broken audio. Priority 0 = codec not offered at all. Order: PCMU/PCMA
+        // first, G722 as fallback, so the far end answers G.711. Codec priority
+        // is endpoint-global in PJSIP, so it is configured once here.
+        try {
+            CodecInfoVector2 codecs = _ep->codecEnum2();
+            for (size_t i = 0; i < codecs.size(); i++) {
+                std::string cid = codecs[i].codecId;   // e.g. "PCMU/8000/1"
+                std::string fam = cid.substr(0, cid.find('/'));
+                std::transform(fam.begin(), fam.end(), fam.begin(),
+                               [](unsigned char c){ return (char)std::toupper(c); });
+                pj_uint8_t prio = 0;
+                if      (fam == "PCMU") prio = 255;
+                else if (fam == "PCMA") prio = 254;
+                else if (fam == "G722") prio = 200;
+                _ep->codecSetPriority(codecs[i].codecId, prio);
+            }
+        } catch (...) {}
+
+        [self configureAudioSessionCategory];
+        _isStarted = YES;
+        return YES;
+    } catch (Error &err) {
+        NSString *msg = VCStr(err.info());
+        if (_ep) { try { _ep->libDestroy(); } catch (...) {} delete _ep; _ep = nullptr; }
+        if (_logWriter) { delete _logWriter; _logWriter = nullptr; }
+        if (error) *error = VCMakeError(err.status, msg);
+        return NO;
+    }
+}
+
+- (void)stop {
+    if (!_isStarted) return;
+    try { if (_ep) _ep->hangupAllCalls(); } catch (...) {}
+    for (auto &kv : _calls) { delete kv.second; }
+    _calls.clear();
+    for (auto &kv : _accounts) {
+        try { kv.second->setRegistration(false); } catch (...) {}
+        delete kv.second;
+    }
+    _accounts.clear();
+    try { if (_ep) { _ep->libDestroy(); delete _ep; _ep = nullptr; } } catch (...) { _ep = nullptr; }
+    if (_logWriter) { delete _logWriter; _logWriter = nullptr; }
+    [self deactivateAudioSessionIfIdle];
+    _isStarted = NO;
+}
+
+#pragma mark Accounts
+
+- (int)registerAccountWithConfig:(NSDictionary *)cfg error:(NSError **)error {
+    if (!_isStarted) { if (error) *error = VCMakeError(-1, @"VoipCloud.init() must succeed first"); return -1; }
+    NSString *uri       = cfg[@"uri"];
+    NSString *registrar = cfg[@"registrar"];
+    NSString *username  = cfg[@"username"];
+    NSString *password  = cfg[@"password"];
+    if (![uri isKindOfClass:[NSString class]] || ![registrar isKindOfClass:[NSString class]] ||
+        ![username isKindOfClass:[NSString class]] || ![password isKindOfClass:[NSString class]]) {
+        if (error) *error = VCMakeError(-1, @"uri, registrar, username, password are required");
+        return -1;
+    }
+    try {
+        AccountConfig acfg;
+        acfg.idUri = std::string(uri.UTF8String);
+        acfg.regConfig.registrarUri = std::string(registrar.UTF8String);
+
+        // Outbound proxy (Kamailio). Route EVERY SIP request — including
+        // in-dialog re-INVITE / BYE — through the proxy so a NAT'd client's
+        // teardown/unhold doesn't go straight to the peer's private address and
+        // get lost (peer stuck on MOH after unhold, call never ends).
+        NSString *proxy = cfg[@"proxy"];
+        if ([proxy isKindOfClass:[NSString class]] && proxy.length) {
+            acfg.sipConfig.proxies.push_back(std::string(proxy.UTF8String));
+        }
+
+        // NAT survival — keep the registration binding alive behind NAT so
+        // inbound INVITEs still reach the device (matches Android).
+        acfg.natConfig.contactRewriteUse = 1;
+        acfg.natConfig.viaRewriteUse = 1;
+        acfg.natConfig.udpKaIntervalSec = 20;
+        acfg.regConfig.timeoutSec = 120;
+        acfg.regConfig.firstRetryIntervalSec = 5;
+        acfg.regConfig.retryIntervalSec = 30;
+
+        // STUN for MEDIA only: without it the SDP offer carries the LAN IP
+        // (c=192.168.x) and the far end sends RTP to an unroutable address →
+        // no 2-way audio. Falls back to the host addr if STUN is unreachable.
+        // SIP keeps rport/contactRewrite — do NOT STUN it (would disturb
+        // REGISTER). STUN server itself is set at endpoint level (stunServer).
+        acfg.natConfig.mediaStunUse = PJSUA_STUN_RETRY_ON_FAILURE;
+        acfg.natConfig.sipStunUse   = PJSUA_STUN_USE_DISABLED;
+
+        AuthCredInfo cred("digest", "*", std::string(username.UTF8String), 0,
+                          std::string(password.UTF8String));
+        acfg.sipConfig.authCreds.push_back(cred);
+
+        // Pin REGISTER + INVITE + in-dialog re-INVITE/BYE to the SAME transport
+        // (socket/port) so the NAT binding is stable across hold/unhold. Without
+        // this PJSIP may auto-pick a different transport per request. Falls back
+        // to auto-select if the requested transport failed to create (-1).
+        NSString *transport = cfg[@"transport"];
+        int pinnedTransportId = -1;
+        if ([transport isEqualToString:@"TLS"])      pinnedTransportId = _tlsTransportId;
+        else if ([transport isEqualToString:@"TCP"]) pinnedTransportId = _tcpTransportId;
+        else if ([transport isEqualToString:@"UDP"]) pinnedTransportId = _udpTransportId;
+        if (pinnedTransportId >= 0) acfg.sipConfig.transportId = pinnedTransportId;
+
+        // No session timers on the device — the VoIP server owns session
+        // refresh. With them on, the device (refresher) proposes Session-Expires
+        // and periodically sends a chatty UPDATE after ACK.
+        acfg.callConfig.timerUse = PJSUA_SIP_TIMER_INACTIVE;
+
+        // SRTP is opt-in per account. A plain-UDP trunk with srtp='disabled'
+        // must NOT offer a=crypto (an optional-SRTP offer breaks media on some
+        // PBX/rtpengine setups → one-way / no audio on outgoing). Default
+        // DISABLED when the account doesn't ask for it.
+        NSString *srtp = cfg[@"srtp"];
+        pjmedia_srtp_use srtpUse = PJMEDIA_SRTP_DISABLED;
+        if ([srtp isEqualToString:@"mandatory"])     srtpUse = PJMEDIA_SRTP_MANDATORY;
+        else if ([srtp isEqualToString:@"optional"]) srtpUse = PJMEDIA_SRTP_OPTIONAL;
+        acfg.mediaConfig.srtpUse = srtpUse;
+        acfg.mediaConfig.srtpSecureSignaling = 0;
+
+        VCAccount *acc = new VCAccount();
+        acc->owner = self;
+        acc->create(acfg);
+        int id = acc->getId();
+        if (id < 0) { delete acc; if (error) *error = VCMakeError(-1, @"Account returned invalid id"); return -1; }
+        acc->cachedId = id;
+        _accounts[id] = acc;
+        return id;
+    } catch (Error &err) {
+        if (error) *error = VCMakeError(err.status, VCStr(err.info()));
+        return -1;
+    }
+}
+
+- (BOOL)unregisterAccount:(int)accountId error:(NSError **)error {
+    auto it = _accounts.find(accountId);
+    if (it == _accounts.end()) return YES; // idempotent
+    VCAccount *acc = it->second;
+    _accounts.erase(it);
+    try { acc->setRegistration(false); } catch (...) {}
+    delete acc;
+    return YES;
+}
+
+#pragma mark Calls
+
+- (int)makeCallFromAccount:(int)accountId toUri:(NSString *)uri error:(NSError **)error {
+    if (!_isStarted) { if (error) *error = VCMakeError(-1, @"VoipCloud.init() must succeed first"); return -1; }
+    auto it = _accounts.find(accountId);
+    if (it == _accounts.end()) {
+        if (error) *error = VCMakeError(-1, [NSString stringWithFormat:@"Unknown accountId %d. Call register() first.", accountId]);
+        return -1;
+    }
+    try {
+        VCCall *call = new VCCall(*it->second);
+        call->owner = self;
+        CallOpParam prm(true);
+        prm.opt.audioCount = 1;
+        prm.opt.videoCount = 0;   // audio-only: no stray video m-line in the offer
+        call->makeCall(std::string(uri.UTF8String), prm);
+        int cid = call->getId();
+        call->cachedId = cid;
+        [self storeCall:call withId:cid];
+        [self activateAudioSession];
+        return cid;
+    } catch (Error &err) {
+        if (error) *error = VCMakeError(err.status, VCStr(err.info()));
+        return -1;
+    }
+}
+
+- (BOOL)answerCall:(int)callId error:(NSError **)error {
+    VCCall *call = [self callForId:callId];
+    if (!call) { if (error) *error = VCMakeError(-1, [NSString stringWithFormat:@"Unknown callId %d", callId]); return NO; }
+    try {
+        CallOpParam op; op.statusCode = PJSIP_SC_OK;
+        call->answer(op);
+        [self activateAudioSession];
+        return YES;
+    } catch (Error &err) { if (error) *error = VCMakeError(err.status, VCStr(err.info())); return NO; }
+}
+
+- (BOOL)hangupCall:(int)callId mode:(NSString *)mode error:(NSError **)error {
+    VCCall *call = [self callForId:callId];
+    if (!call) return YES; // already gone — treat as success (matches Android)
+    try {
+        CallOpParam op(true);
+        if ([mode isEqualToString:@"busy"])        op.statusCode = PJSIP_SC_BUSY_HERE;
+        else if ([mode isEqualToString:@"cancel"]) op.statusCode = PJSIP_SC_REQUEST_TERMINATED;
+        call->hangup(op);
+        return YES;
+    } catch (Error &err) { if (error) *error = VCMakeError(err.status, VCStr(err.info())); return NO; }
+}
+
+- (BOOL)hangupAllCallsWithError:(NSError **)error {
+    try {
+        if (_ep && _isStarted) _ep->hangupAllCalls();
+        return YES;
+    } catch (Error &err) { if (error) *error = VCMakeError(err.status, VCStr(err.info())); return NO; }
+}
+
+- (BOOL)holdCall:(int)callId error:(NSError **)error {
+    VCCall *call = [self callForId:callId];
+    if (!call) { if (error) *error = VCMakeError(-1, [NSString stringWithFormat:@"Unknown callId %d", callId]); return NO; }
+    try {
+        CallOpParam prm(true);
+        prm.opt.audioCount = 1;
+        prm.opt.videoCount = 0;   // audio-only re-INVITE
+        call->setHold(prm);
+        return YES;
+    }
+    catch (Error &err) { if (error) *error = VCMakeError(err.status, VCStr(err.info())); return NO; }
+}
+
+- (BOOL)unholdCall:(int)callId error:(NSError **)error {
+    VCCall *call = [self callForId:callId];
+    if (!call) { if (error) *error = VCMakeError(-1, [NSString stringWithFormat:@"Unknown callId %d", callId]); return NO; }
+    try {
+        CallOpParam prm(true);
+        prm.opt.flag |= PJSUA_CALL_UNHOLD;
+        prm.opt.audioCount = 1;
+        prm.opt.videoCount = 0;   // audio-only re-INVITE
+        call->reinvite(prm);
+        return YES;
+    } catch (Error &err) { if (error) *error = VCMakeError(err.status, VCStr(err.info())); return NO; }
+}
+
+- (BOOL)muteCall:(int)callId on:(BOOL)on error:(NSError **)error {
+    VCCall *call = [self callForId:callId];
+    if (!call) { if (error) *error = VCMakeError(-1, [NSString stringWithFormat:@"Unknown callId %d", callId]); return NO; }
+    call->setMuted(on ? true : false);
+    return YES;
+}
+
+- (BOOL)sendDtmf:(int)callId digits:(NSString *)digits error:(NSError **)error {
+    VCCall *call = [self callForId:callId];
+    if (!call) { if (error) *error = VCMakeError(-1, [NSString stringWithFormat:@"Unknown callId %d", callId]); return NO; }
+    try {
+        CallSendDtmfParam p;
+        p.digits = std::string(digits.UTF8String);
+        call->sendDtmf(p);
+        return YES;
+    } catch (Error &err) { if (error) *error = VCMakeError(err.status, VCStr(err.info())); return NO; }
+}
+
+- (BOOL)transferCall:(int)callId toUri:(NSString *)uri error:(NSError **)error {
+    VCCall *call = [self callForId:callId];
+    if (!call) { if (error) *error = VCMakeError(-1, [NSString stringWithFormat:@"Unknown callId %d", callId]); return NO; }
+    try { CallOpParam prm(true); call->xfer(std::string(uri.UTF8String), prm); return YES; }
+    catch (Error &err) { if (error) *error = VCMakeError(err.status, VCStr(err.info())); return NO; }
+}
+
+- (BOOL)reconnectCallAudio:(int)callId error:(NSError **)error {
+    VCCall *call = [self callForId:callId];
+    if (!call) { if (error) *error = VCMakeError(-1, [NSString stringWithFormat:@"Unknown callId %d", callId]); return NO; }
+    call->reconnectAudioMedia();
+    return YES;
+}
+
+#pragma mark Call map
+
+- (void)storeCall:(VCCall *)call withId:(int)cid { _calls[cid] = call; }
+- (VCCall *)callForId:(int)cid {
+    auto it = _calls.find(cid);
+    return it != _calls.end() ? it->second : nullptr;
+}
+- (void)removeCallId:(int)cid {
+    auto it = _calls.find(cid);
+    if (it != _calls.end()) { delete it->second; _calls.erase(it); }
+    if (_calls.empty()) [self deactivateAudioSessionIfIdle];
+}
+
+#pragma mark Audio session
+
+- (void)configureAudioSessionCategory {
+    AVAudioSession *s = [AVAudioSession sharedInstance];
+    NSError *e = nil;
+    [s setCategory:AVAudioSessionCategoryPlayAndRecord
+              mode:AVAudioSessionModeVoiceChat
+           options:AVAudioSessionCategoryOptionAllowBluetooth
+             error:&e];
+    if (@available(iOS 7.0, *)) {
+        [[AVAudioSession sharedInstance] requestRecordPermission:^(BOOL granted) { (void)granted; }];
+    }
+}
+
+- (void)activateAudioSession {
+    NSError *e = nil;
+    [[AVAudioSession sharedInstance] setActive:YES error:&e];
+}
+
+- (void)deactivateAudioSessionIfIdle {
+    if (!_calls.empty()) return;
+    NSError *e = nil;
+    [[AVAudioSession sharedInstance]
+        setActive:NO
+      withOptions:AVAudioSessionSetActiveOptionNotifyOthersOnDeactivation
+            error:&e];
+}
+
+#pragma mark Emit
+
+- (void)emitEvent:(NSString *)name body:(NSDictionary *)body {
+    id<VoipCloudEngineDelegate> d = self.delegate;
+    if (!d) return;
+    dispatch_async(dispatch_get_main_queue(), ^{
+        [d voipEngineEmitEvent:name body:body];
+    });
+}
+
+@end

package/lib/typescript/types.d.ts

@@ -31,6 +31,20 @@ export interface AccountConfig {
      * the two in sync to avoid surprises.
      */
     transport: Transport;
+    /**
+     * Outbound proxy URI, e.g. "sip:proxy.example.com:5060;lr".  When set,
+     * every SIP request — including in-dialog re-INVITE / BYE — is routed
+     * through this proxy (`proxies.push_back`).  Required for in-dialog SIP
+     * to survive NAT: without a proxy Route a NAT'd client sends its BYE /
+     * unhold re-INVITE straight to the peer's private address and it is lost.
+     */
+    proxy?: string;
+    /**
+     * SRTP media policy.  Defaults to 'disabled' when omitted so a plain-UDP
+     * trunk never offers a=crypto (an optional-SRTP offer breaks media on some
+     * PBX / rtpengine setups → one-way / no audio).
+     */
+    srtp?: 'disabled' | 'optional' | 'mandatory';
 }
 export interface RegistrationStateEvent {
     accountId: number;