feat: update negotiateSdp and WebRtcArgs (#3371)

- update negotiateSdp - update HttpAllArgs and alias - update onRtcConfigure - define setWebRtcArgs, handle set_webrtc_cands and setLocalIp --------- Co-authored-by: xiongziliang <771730766@qq.com> Co-authored-by: KkemChen <kkemchen@qq.com>
2026-06-12 19:24:22 +08:00 · 2024-03-23 11:46:30 -03:00
parent 2e2823d4cf
commit 029813402d
12 changed files with 171 additions and 219 deletions
--- a/webrtc/WebRtcEchoTest.h
+++ b/webrtc/WebRtcEchoTest.h
@@ -27,7 +27,6 @@ protected:
    void onRtp(const char *buf, size_t len, uint64_t stamp_ms) override;
    void onRtcp(const char *buf, size_t len) override;

-    void onRecvRtp(MediaTrack &track, const std::string &rid, RtpPacket::Ptr rtp) override {};
    void onBeforeEncryptRtp(const char *buf, int &len, void *ctx) override {};
    void onBeforeEncryptRtcp(const char *buf, int &len, void *ctx) override {};

--- a/webrtc/WebRtcPlayer.cpp
+++ b/webrtc/WebRtcPlayer.cpp
@@ -17,9 +17,8 @@ namespace mediakit {

 WebRtcPlayer::Ptr WebRtcPlayer::create(const EventPoller::Ptr &poller,
                                       const RtspMediaSource::Ptr &src,
-                                       const MediaInfo &info,
-                                       bool preferred_tcp) {
-    WebRtcPlayer::Ptr ret(new WebRtcPlayer(poller, src, info, preferred_tcp), [](WebRtcPlayer *ptr) {
+                                       const MediaInfo &info) {
+    WebRtcPlayer::Ptr ret(new WebRtcPlayer(poller, src, info), [](WebRtcPlayer *ptr) {
        ptr->onDestory();
        delete ptr;
    });
@@ -29,8 +28,7 @@ WebRtcPlayer::Ptr WebRtcPlayer::create(const EventPoller::Ptr &poller,

 WebRtcPlayer::WebRtcPlayer(const EventPoller::Ptr &poller,
                           const RtspMediaSource::Ptr &src,
-                           const MediaInfo &info,
-                           bool preferred_tcp) : WebRtcTransportImp(poller,preferred_tcp) {
+                           const MediaInfo &info) : WebRtcTransportImp(poller) {
    _media_info = info;
    _play_src = src;
    CHECK(src);
--- a/webrtc/WebRtcPlayer.h
+++ b/webrtc/WebRtcPlayer.h
@@ -19,7 +19,7 @@ namespace mediakit {
 class WebRtcPlayer : public WebRtcTransportImp {
 public:
    using Ptr = std::shared_ptr<WebRtcPlayer>;
-    static Ptr create(const EventPoller::Ptr &poller, const RtspMediaSource::Ptr &src, const MediaInfo &info, bool preferred_tcp = false);
+    static Ptr create(const EventPoller::Ptr &poller, const RtspMediaSource::Ptr &src, const MediaInfo &info);
    MediaInfo getMediaInfo() { return _media_info; }

 protected:
@@ -27,10 +27,9 @@ protected:
    void onStartWebRTC() override;
    void onDestory() override;
    void onRtcConfigure(RtcConfigure &configure) const override;
-    void onRecvRtp(MediaTrack &track, const std::string &rid, RtpPacket::Ptr rtp) override {};

 private:
-    WebRtcPlayer(const EventPoller::Ptr &poller, const RtspMediaSource::Ptr &src, const MediaInfo &info, bool preferred_tcp);
+    WebRtcPlayer(const EventPoller::Ptr &poller, const RtspMediaSource::Ptr &src, const MediaInfo &info);

 private:
    //媒体相关元数据
--- a/webrtc/WebRtcPusher.cpp
+++ b/webrtc/WebRtcPusher.cpp
@@ -20,9 +20,8 @@ WebRtcPusher::Ptr WebRtcPusher::create(const EventPoller::Ptr &poller,
                                       const RtspMediaSource::Ptr &src,
                                       const std::shared_ptr<void> &ownership,
                                       const MediaInfo &info,
-                                       const ProtocolOption &option,
-                                       bool preferred_tcp) {
-    WebRtcPusher::Ptr ret(new WebRtcPusher(poller, src, ownership, info, option,preferred_tcp), [](WebRtcPusher *ptr) {
+                                       const ProtocolOption &option) {
+    WebRtcPusher::Ptr ret(new WebRtcPusher(poller, src, ownership, info, option), [](WebRtcPusher *ptr) {
        ptr->onDestory();
        delete ptr;
    });
@@ -34,8 +33,7 @@ WebRtcPusher::WebRtcPusher(const EventPoller::Ptr &poller,
                           const RtspMediaSource::Ptr &src,
                           const std::shared_ptr<void> &ownership,
                           const MediaInfo &info,
-                           const ProtocolOption &option,
-                           bool preferred_tcp) : WebRtcTransportImp(poller,preferred_tcp) {
+                           const ProtocolOption &option) : WebRtcTransportImp(poller) {
    _media_info = info;
    _push_src = src;
    _push_src_ownership = ownership;
--- a/webrtc/WebRtcPusher.h
+++ b/webrtc/WebRtcPusher.h
@@ -20,8 +20,7 @@ class WebRtcPusher : public WebRtcTransportImp, public MediaSourceEvent {
 public:
    using Ptr = std::shared_ptr<WebRtcPusher>;
    static Ptr create(const EventPoller::Ptr &poller, const RtspMediaSource::Ptr &src,
-                      const std::shared_ptr<void> &ownership, const MediaInfo &info, const ProtocolOption &option, bool preferred_tcp = false);
-
+                      const std::shared_ptr<void> &ownership, const MediaInfo &info, const ProtocolOption &option);

 protected:
    ///////WebRtcTransportImp override///////
@@ -53,7 +52,7 @@ protected:

 private:
    WebRtcPusher(const EventPoller::Ptr &poller, const RtspMediaSource::Ptr &src,
-                 const std::shared_ptr<void> &ownership, const MediaInfo &info, const ProtocolOption &option, bool preferred_tcp);
+                 const std::shared_ptr<void> &ownership, const MediaInfo &info, const ProtocolOption &option);

 private:
    bool _simulcast = false;
--- a/webrtc/WebRtcTransport.cpp
+++ b/webrtc/WebRtcTransport.cpp
@@ -378,6 +378,12 @@ void WebRtcTransport::setRemoteDtlsFingerprint(const RtcSession &remote) {
 }

 void WebRtcTransport::onRtcConfigure(RtcConfigure &configure) const {
+    SdpAttrFingerprint fingerprint;
+    fingerprint.algorithm = _offer_sdp->media[0].fingerprint.algorithm;
+    fingerprint.hash = getFingerprint(fingerprint.algorithm, _dtls_transport);
+    configure.setDefaultSetting(
+            _ice_server->GetUsernameFragment(), _ice_server->GetPassword(), RtpDirection::sendrecv, fingerprint);
+
    // 开启remb后关闭twcc，因为开启twcc后remb无效
    GET_CONFIG(size_t, remb_bit_rate, Rtc::kRembBitRate);
    configure.enableTWCC(!remb_bit_rate);
@@ -407,12 +413,7 @@ std::string WebRtcTransport::getAnswerSdp(const string &offer) {
        setRemoteDtlsFingerprint(*_offer_sdp);

        //// sdp 配置 ////
-        SdpAttrFingerprint fingerprint;
-        fingerprint.algorithm = _offer_sdp->media[0].fingerprint.algorithm;
-        fingerprint.hash = getFingerprint(fingerprint.algorithm, _dtls_transport);
        RtcConfigure configure;
-        configure.setDefaultSetting(
-            _ice_server->GetUsernameFragment(), _ice_server->GetPassword(), RtpDirection::sendrecv, fingerprint);
        onRtcConfigure(configure);

        //// 生成answer sdp ////
@@ -431,10 +432,6 @@ static bool isDtls(char *buf) {
    return ((*buf > 19) && (*buf < 64));
 }

-static string getPeerAddress(RTC::TransportTuple *tuple) {
-    return tuple->get_peer_ip();
-}
-
 void WebRtcTransport::inputSockData(char *buf, int len, RTC::TransportTuple *tuple) {
    if (RTC::StunPacket::IsStun((const uint8_t *)buf, len)) {
        std::unique_ptr<RTC::StunPacket> packet(RTC::StunPacket::Parse((const uint8_t *)buf, len));
@@ -451,7 +448,7 @@ void WebRtcTransport::inputSockData(char *buf, int len, RTC::TransportTuple *tup
    }
    if (isRtp(buf, len)) {
        if (!_srtp_session_recv) {
-            WarnL << "received rtp packet when dtls not completed from:" << getPeerAddress(tuple);
+            WarnL << "received rtp packet when dtls not completed from:" << tuple->get_peer_ip();
            return;
        }
        if (_srtp_session_recv->DecryptSrtp((uint8_t *)buf, &len)) {
@@ -461,7 +458,7 @@ void WebRtcTransport::inputSockData(char *buf, int len, RTC::TransportTuple *tup
    }
    if (isRtcp(buf, len)) {
        if (!_srtp_session_recv) {
-            WarnL << "received rtcp packet when dtls not completed from:" << getPeerAddress(tuple);
+            WarnL << "received rtcp packet when dtls not completed from:" << tuple->get_peer_ip();
            return;
        }
        if (_srtp_session_recv->DecryptSrtcp((uint8_t *)buf, &len)) {
@@ -533,8 +530,7 @@ void WebRtcTransportImp::OnDtlsTransportApplicationDataReceived(const RTC::DtlsT
 #endif
 }

-WebRtcTransportImp::WebRtcTransportImp(const EventPoller::Ptr &poller,bool preferred_tcp)
-    : WebRtcTransport(poller), _preferred_tcp(preferred_tcp) {
+WebRtcTransportImp::WebRtcTransportImp(const EventPoller::Ptr &poller) : WebRtcTransport(poller) {
    InfoL << getIdentifier();
 }

@@ -674,7 +670,7 @@ void WebRtcTransportImp::onCheckAnswer(RtcSession &sdp) {
    });
    for (auto &m : sdp.media) {
        m.addr.reset();
-        m.addr.address = extern_ips.empty() ? _localIp.empty() ? SockUtil::get_local_ip() : _localIp : extern_ips[0];
+        m.addr.address = extern_ips.empty() ? _local_ip.empty() ? SockUtil::get_local_ip() : _local_ip : extern_ips[0];
        m.rtcp_addr.reset();
        m.rtcp_addr.address = m.addr.address;

@@ -769,7 +765,7 @@ void WebRtcTransportImp::onRtcConfigure(RtcConfigure &configure) const {
        return ret;
    });
    if (extern_ips.empty()) {
-        std::string local_ip = _localIp.empty() ? SockUtil::get_local_ip() : _localIp;
+        std::string local_ip = _local_ip.empty() ? SockUtil::get_local_ip() : _local_ip;
        if (local_udp_port) { configure.addCandidate(*makeIceCandidate(local_ip, local_udp_port, 120, "udp")); }
        if (local_tcp_port) { configure.addCandidate(*makeIceCandidate(local_ip, local_tcp_port, _preferred_tcp ? 125 : 115, "tcp")); }
    } else {
@@ -783,12 +779,16 @@ void WebRtcTransportImp::onRtcConfigure(RtcConfigure &configure) const {
    }
 }

-void WebRtcTransportImp::setIceCandidate(vector<SdpAttrCandidate> cands) {
-    _cands = std::move(cands);
+void WebRtcTransportImp::setPreferredTcp(bool flag) {
+    _preferred_tcp = flag;
 }

-void WebRtcTransportImp::setLocalIp(const std::string &localIp) {
-    _localIp = localIp;
+void WebRtcTransportImp::setLocalIp(std::string local_ip) {
+    _local_ip = std::move(local_ip);
+}
+
+void WebRtcTransportImp::setIceCandidate(vector<SdpAttrCandidate> cands) {
+    _cands = std::move(cands);
 }

 ///////////////////////////////////////////////////////////////////
@@ -1278,21 +1278,14 @@ void WebRtcPluginManager::registerPlugin(const string &type, Plugin cb) {
    _map_creator[type] = std::move(cb);
 }

-std::string exchangeSdp(const WebRtcInterface &exchanger, const std::string& offer) {
-    return const_cast<WebRtcInterface &>(exchanger).getAnswerSdp(offer);
-}
-
-void setLocalIp(const WebRtcInterface& exchanger, const std::string& localIp) {
-    return const_cast<WebRtcInterface &>(exchanger).setLocalIp(localIp);
-}

 void WebRtcPluginManager::setListener(Listener cb) {
    lock_guard<mutex> lck(_mtx_creator);
    _listener = std::move(cb);
 }

-void WebRtcPluginManager::getAnswerSdp(Session &sender, const string &type, const WebRtcArgs &args, const onCreateRtc &cb_in) {
-    onCreateRtc cb;
+void WebRtcPluginManager::negotiateSdp(Session &sender, const string &type, const WebRtcArgs &args, const onCreateWebRtc &cb_in) {
+    onCreateWebRtc cb;
    lock_guard<mutex> lck(_mtx_creator);
    if (_listener) {
        auto listener = _listener;
@@ -1308,21 +1301,19 @@ void WebRtcPluginManager::getAnswerSdp(Session &sender, const string &type, cons

    auto it = _map_creator.find(type);
    if (it == _map_creator.end()) {
-        cb(WebRtcException(SockException(Err_other, "the type can not supported")));
+        cb_in(WebRtcException(SockException(Err_other, "the type can not supported")));
        return;
    }
    it->second(sender, args, cb);
 }

-void echo_plugin(Session &sender, const WebRtcArgs &args, const WebRtcPluginManager::onCreateRtc &cb) {
+void echo_plugin(Session &sender, const WebRtcArgs &args, const onCreateWebRtc &cb) {
    cb(*WebRtcEchoTest::create(EventPollerPool::Instance().getPoller()));
 }

-void push_plugin(Session &sender, const WebRtcArgs &args, const WebRtcPluginManager::onCreateRtc &cb) {
+void push_plugin(Session &sender, const WebRtcArgs &args, const onCreateWebRtc &cb) {
    MediaInfo info(args["url"]);
-    bool preferred_tcp = args["preferred_tcp"];
-
-    Broadcast::PublishAuthInvoker invoker = [cb, info, preferred_tcp](const string &err, const ProtocolOption &option) mutable {
+    Broadcast::PublishAuthInvoker invoker = [cb, info](const string &err, const ProtocolOption &option) mutable {
        if (!err.empty()) {
            cb(WebRtcException(SockException(Err_other, err)));
            return;
@@ -1361,7 +1352,7 @@ void push_plugin(Session &sender, const WebRtcArgs &args, const WebRtcPluginMana
            push_src_ownership = push_src->getOwnership();
            push_src->setProtocolOption(option);
        }
-        auto rtc = WebRtcPusher::create(EventPollerPool::Instance().getPoller(), push_src, push_src_ownership, info, option, preferred_tcp);
+        auto rtc = WebRtcPusher::create(EventPollerPool::Instance().getPoller(), push_src, push_src_ownership, info, option);
        push_src->setListener(rtc);
        cb(*rtc);
    };
@@ -1374,12 +1365,10 @@ void push_plugin(Session &sender, const WebRtcArgs &args, const WebRtcPluginMana
    }
 }

-void play_plugin(Session &sender, const WebRtcArgs &args, const WebRtcPluginManager::onCreateRtc &cb) {
+void play_plugin(Session &sender, const WebRtcArgs &args, const onCreateWebRtc &cb) {
    MediaInfo info(args["url"]);
-    bool preferred_tcp = args["preferred_tcp"];
-
    auto session_ptr = static_pointer_cast<Session>(sender.shared_from_this());
-    Broadcast::AuthInvoker invoker = [cb, info, session_ptr, preferred_tcp](const string &err) mutable {
+    Broadcast::AuthInvoker invoker = [cb, info, session_ptr](const string &err) mutable {
        if (!err.empty()) {
            cb(WebRtcException(SockException(Err_other, err)));
            return;
@@ -1395,7 +1384,7 @@ void play_plugin(Session &sender, const WebRtcArgs &args, const WebRtcPluginMana
            }
            // 还原成rtc，目的是为了hook时识别哪种播放协议
            info.schema = "rtc";
-            auto rtc = WebRtcPlayer::create(EventPollerPool::Instance().getPoller(), src, info, preferred_tcp);
+            auto rtc = WebRtcPlayer::create(EventPollerPool::Instance().getPoller(), src, info);
            cb(*rtc);
        });
    };
@@ -1408,39 +1397,63 @@ void play_plugin(Session &sender, const WebRtcArgs &args, const WebRtcPluginMana
    }
 }

-static void set_webrtc_cands(const WebRtcArgs &args, const WebRtcInterface &rtc) {
-    vector<SdpAttrCandidate> cands;
+static void setWebRtcArgs(const WebRtcArgs &args, WebRtcInterface &rtc) {
    {
-        auto cand_str = trim(args["cand_udp"]);
-        auto ip_port = toolkit::split(cand_str, ":");
-        if (ip_port.size() == 2) {
+        static auto is_vaild_ip = [](const std::string &ip) -> bool {
+            int a, b, c, d;
+            return sscanf(ip.c_str(), "%d.%d.%d.%d", &a, &b, &c, &d) == 4;
+        };
+        std::string host = args["Host"];
+        if (!host.empty()) {
+            auto local_ip = host.substr(0, host.find(':'));
+            if (!is_vaild_ip(local_ip) || local_ip == "127.0.0.1") {
+                local_ip = "";
+            }
+            rtc.setLocalIp(std::move(local_ip));
+        }
+    }
+
+    bool preferred_tcp = args["preferred_tcp"];
+    {
+        rtc.setPreferredTcp(preferred_tcp);
+    }
+
+    {
+        vector<SdpAttrCandidate> cands;
+        {
+            auto cand_str = trim(args["cand_udp"]);
+            auto ip_port = toolkit::split(cand_str, ":");
+            if (ip_port.size() == 2) {
+                // udp优先
+                auto ice_cand = makeIceCandidate(ip_port[0], atoi(ip_port[1].data()), preferred_tcp ? 100 : 120, "udp");
+                cands.emplace_back(std::move(*ice_cand));
+            }
+        }
+        {
+            auto cand_str = trim(args["cand_tcp"]);
+            auto ip_port = toolkit::split(cand_str, ":");
+            if (ip_port.size() == 2) {
+                // tcp模式
+                auto ice_cand = makeIceCandidate(ip_port[0], atoi(ip_port[1].data()), preferred_tcp ? 120 : 100, "tcp");
+                cands.emplace_back(std::move(*ice_cand));
+            }
+        }
+        if (!cands.empty()) {
            // udp优先
-            auto ice_cand = makeIceCandidate(ip_port[0], atoi(ip_port[1].data()), 120, "udp");
-            cands.emplace_back(std::move(*ice_cand));
+            rtc.setIceCandidate(std::move(cands));
        }
    }
-    {
-        auto cand_str = trim(args["cand_tcp"]);
-        auto ip_port = toolkit::split(cand_str, ":");
-        if (ip_port.size() == 2) {
-            // tcp模式
-            auto ice_cand = makeIceCandidate(ip_port[0], atoi(ip_port[1].data()), 100, "tcp");
-            cands.emplace_back(std::move(*ice_cand));
-        }
-    }
-    if (!cands.empty()) {
-        // udp优先
-        const_cast<WebRtcInterface &>(rtc).setIceCandidate(std::move(cands));
-    }
 }

 static onceToken s_rtc_auto_register([]() {
+#if !defined (NDEBUG)
+    // debug模式才开启echo插件
    WebRtcPluginManager::Instance().registerPlugin("echo", echo_plugin);
+#endif
    WebRtcPluginManager::Instance().registerPlugin("push", push_plugin);
    WebRtcPluginManager::Instance().registerPlugin("play", play_plugin);
-
    WebRtcPluginManager::Instance().setListener([](Session &sender, const std::string &type, const WebRtcArgs &args, const WebRtcInterface &rtc) {
-        set_webrtc_cands(args, rtc);
+        setWebRtcArgs(args, const_cast<WebRtcInterface&>(rtc));
    });
 });

--- a/webrtc/WebRtcTransport.h
+++ b/webrtc/WebRtcTransport.h
@@ -35,6 +35,8 @@ extern const std::string kTcpPort;
 extern const std::string kTimeOutSec;
 }//namespace RTC

+class WebRtcArgs;
+
 class WebRtcInterface {
 public:
    virtual ~WebRtcInterface() = default;
@@ -42,13 +44,10 @@ public:
    virtual const std::string& getIdentifier() const = 0;
    virtual const std::string& deleteRandStr() const { static std::string s_null; return s_null; }
    virtual void setIceCandidate(std::vector<SdpAttrCandidate> cands) {}
-    virtual void setLocalIp(const std::string &localIp) {}
+    virtual void setLocalIp(std::string localIp) {}
+    virtual void setPreferredTcp(bool flag) {}
 };

-std::string exchangeSdp(const WebRtcInterface &exchanger, const std::string& offer);
-
-void setLocalIp(const WebRtcInterface &exchanger, const std::string &localIp);
-
 class WebRtcException : public WebRtcInterface {
 public:
    WebRtcException(const SockException &ex) : _ex(ex) {};
@@ -88,7 +87,7 @@ public:
     * @param offer offer sdp
     * @return answer sdp
     */
-    std::string getAnswerSdp(const std::string &offer) override;
+    std::string getAnswerSdp(const std::string &offer) override final;

    /**
     * 获取对象唯一id
@@ -252,14 +251,16 @@ public:
    void onSendRtp(const RtpPacket::Ptr &rtp, bool flush, bool rtx = false);

    void createRtpChannel(const std::string &rid, uint32_t ssrc, MediaTrack &track);
-    void setIceCandidate(std::vector<SdpAttrCandidate> cands) override;
    void removeTuple(RTC::TransportTuple* tuple);
    void safeShutdown(const SockException &ex);

-    void setLocalIp(const std::string &localIp) override;
+    void setPreferredTcp(bool flag) override;
+    void setLocalIp(std::string local_ip) override;
+    void setIceCandidate(std::vector<SdpAttrCandidate> cands) override;
+
 protected:
    void OnIceServerSelectedTuple(const RTC::IceServer *iceServer, RTC::TransportTuple *tuple) override;
-    WebRtcTransportImp(const EventPoller::Ptr &poller,bool preferred_tcp = false);
+    WebRtcTransportImp(const EventPoller::Ptr &poller);
    void OnDtlsTransportApplicationDataReceived(const RTC::DtlsTransport *dtlsTransport, const uint8_t *data, size_t len) override;
    void onStartWebRTC() override;
    void onSendSockData(Buffer::Ptr buf, bool flush = true, RTC::TransportTuple *tuple = nullptr) override;
@@ -273,7 +274,7 @@ protected:
    void onCreate() override;
    void onDestory() override;
    void onShutdown(const SockException &ex) override;
-    virtual void onRecvRtp(MediaTrack &track, const std::string &rid, RtpPacket::Ptr rtp) = 0;
+    virtual void onRecvRtp(MediaTrack &track, const std::string &rid, RtpPacket::Ptr rtp) {}
    void updateTicker();
    float getLossRate(TrackType type);
    void onRtcpBye() override;
@@ -289,7 +290,7 @@ private:
    void onCheckAnswer(RtcSession &sdp);

 private:
-    bool _preferred_tcp;
+    bool _preferred_tcp = false;
    uint16_t _rtx_seq[2] = {0, 0};
    //用掉的总流量
    uint64_t _bytes_usage = 0;
@@ -310,8 +311,8 @@ private:
    //根据接收rtp的pt获取相关信息
    std::unordered_map<uint8_t/*pt*/, std::unique_ptr<WrappedMediaTrack>> _pt_to_track;
    std::vector<SdpAttrCandidate> _cands;
-    //源访问的hostip
-    std::string _localIp;
+    //http访问时的host ip
+    std::string _local_ip;
 };

 class WebRtcTransportManager {
@@ -333,21 +334,20 @@ private:
 class WebRtcArgs : public std::enable_shared_from_this<WebRtcArgs> {
 public:
    virtual ~WebRtcArgs() = default;
-
    virtual variant operator[](const std::string &key) const = 0;
 };

+using onCreateWebRtc = std::function<void(const WebRtcInterface &rtc)>;
 class WebRtcPluginManager {
 public:
-    using onCreateRtc = std::function<void(const WebRtcInterface &rtc)>;
-    using Plugin = std::function<void(Session &sender, const WebRtcArgs &args, const onCreateRtc &cb)>;
+    using Plugin = std::function<void(Session &sender, const WebRtcArgs &args, const onCreateWebRtc &cb)>;
    using Listener = std::function<void(Session &sender, const std::string &type, const WebRtcArgs &args, const WebRtcInterface &rtc)>;

    static WebRtcPluginManager &Instance();

    void registerPlugin(const std::string &type, Plugin cb);
-    void getAnswerSdp(Session &sender, const std::string &type, const WebRtcArgs &args, const onCreateRtc &cb);
    void setListener(Listener cb);
+    void negotiateSdp(Session &sender, const std::string &type, const WebRtcArgs &args, const onCreateWebRtc &cb);

 private:
    WebRtcPluginManager() = default;