How to create a datachannel using libdatachannel in Android JNI

[TryRevilo]

I've been trying to set up a DataChannel using libdatachannel, but the connection breaks as soon as it gets set up.

It's an Android WebRTC project with parts of it being itegrated via JNI, DataChannels for instance.

The JNI setup looks as follows :

static {
    System.loadLibrary("My-Lib-WebRTC");
}

public native void initWebRTC();  

Here's the output whenever I run the Android app on ws://192.168.215.220 with a user ID local_user_id:

Server listening on 192.168.215.220:8000
WS  /local_user_id
Client local_user_id << {"description":"v=0\r\no=rtc 3789351977 0 IN IP4 127.0.0.1\r\ns=-\r\nt=0 0\r\na=group:BUNDLE 0\r\na=msid-semantic:WMS *\r\na=setup:actpass\r\na=ice-ufrag:9x6r\r\na=ice-pwd:JUE9x5b5ngOlfdO/gdawjl\r\na=ice-options:ice2,trickle\r\na=fingerprint:sha-256 78:0A:DA:00:09:5D:7C:61:9D:9C:B7:90:1B:77:73:29:53:85:10:34:09:AA:3A:0C:77:82:F4:CB:60:33:4F:40\r\nm=application 9 UDP/DTLS/SCTP webrtc-datachannel\r\nc=IN IP4 0.0.0.0\r\na=mid:0\r\na=sendrecv\r\na=sctp-port:5000\r\na=max-message-size:262144\r\n","id":"remote_user_id","type":"offer"}
Client remote_user_id not found
Client local_user_id << {"candidate":"a=candidate:1 1 UDP 2122317823 192.168.0.30 55988 typ host","id":"remote_user_id","mid":"0","type":"candidate"}
Client remote_user_id not found
Client local_user_id << {"candidate":"a=candidate:2 1 UDP 2122317567 192.168.215.128 55988 typ host","id":"remote_user_id","mid":"0","type":"candidate"}
Client remote_user_id not found
Client local_user_id disconnected

Here's the output of ./client-benchmark -d 300 -w ws://192.168.215.220 :

STUN server is stun:stun.l.google.com:19302
The local ID is remote_user_id
WebSocket URL is ws://192.168.215.220:8000/remote_user_id
Waiting for signaling to be connected...
2022-11-18 08:26:13.978 INFO  [8182] [rtc::impl::TcpTransport::attempt@242] TCP connected
2022-11-18 08:26:13.979 INFO  [8182] [rtc::impl::WsTransport::incoming@132] WebSocket client-side open
WebSocket connected, signaling ready
Enter a remote ID to send an offer:
local_user_id
Offering to local_user_id
Creating DataChannel with label "DC-1"
2022-11-18 08:26:21.139 INFO  [8177] [rtc::impl::IceTransport::IceTransport@114] Using STUN server "stun.l.google.com:19302"
2022-11-18 08:26:21.140 INFO  [8177] [rtc::impl::PeerConnection::changeSignalingState@1172] Changed signaling state to have-local-offer
2022-11-18 08:26:21.140 INFO  [8177] [rtc::impl::PeerConnection::changeGatheringState@1159] Changed gathering state to in-progress
Gathering State: in-progress
2022-11-18 08:26:21.191 INFO  [8177] [rtc::impl::IceTransport::LogCallback@352] juice: Changing state to gathering
2022-11-18 08:26:21.191 INFO  [8177] [rtc::impl::IceTransport::LogCallback@352] juice: Changing state to connecting
2022-11-18 08:26:21.191 INFO  [8177] [rtc::impl::PeerConnection::changeState@1141] Changed state to connecting
State: connecting
Benchmark will run for 300 seconds
#1
      DC-1 Received: 0 KB/s   Sent: 0 KB/s   BufferSize: 0
     TOTAL Received: 0 KB/s   Sent: 0 KB/s

Initialize my Node Server :

Server listening on 192.168.215.220:8000
WS /local_user_id
Client local_user_id << {"description":"v=0\r\no=rtc 3789351977 0 IN IP4 127.0.0.1\r\ns=-\r\nt=0 0\r\na=group:BUNDLE 0\r\na=msid-semantic:WMS *\r\na=setup:actpass\r\na=ice-ufrag:9x6r\r\na=ice-pwd:JUE9x5b5ngOlfdO/gdawjl\r\na=ice-options:ice2,trickle\r\na=fingerprint:sha-256 78:0A:DA:00:09:5D:7C:61:9D:9C:B7:90:1B:77:73:29:53:85:10:34:09:AA:3A:0C:77:82:F4:CB:60:33:4F:40\r\nm=application 9 UDP/DTLS/SCTP webrtc-datachannel\r\nc=IN IP4 0.0.0.0\r\na=mid:0\r\na=sendrecv\r\na=sctp-port:5000\r\na=max-message-size:262144\r\n","id":"remote_user_id","type":"offer"}
Client remote_user_id not found
Client local_user_id << {"candidate":"a=candidate:1 1 UDP 2122317823 192.168.0.30 55988 typ host","id":"remote_user_id","mid":"0","type":"candidate"}
Client remote_user_id not found
Client local_user_id << {"candidate":"a=candidate:2 1 UDP 2122317567 192.168.215.128 55988 typ host","id":"remote_user_id","mid":"0","type":"candidate"}
Client remote_user_id not found
Client local_user_id disconnected
WS /remote_user_id
Client remote_user_id << {"description":"v=0\r\no=rtc 1214504962 0 IN IP4 127.0.0.1\r\ns=-\r\nt=0 0\r\na=group:BUNDLE 0\r\na=msid-semantic:WMS *\r\na=setup:actpass\r\na=ice-ufrag:fZhe\r\na=ice-pwd:41wQzd7P5ecBNTRW/25AE4\r\na=ice-options:ice2,trickle\r\na=fingerprint:sha-256 9E:AB:BF:22:BF:0E:2A:88:F6:23:32:EA:FF:EB:10:F8:22:73:07:29:64:1A:E0:FD:9B:AD:9B:3E:FC:90:EE:8E\r\nm=application 9 UDP/DTLS/SCTP webrtc-datachannel\r\nc=IN IP4 0.0.0.0\r\na=mid:0\r\na=sendrecv\r\na=sctp-port:5000\r\na=max-message-size:262144\r\n","id":"local_user_id","type":"offer"}
Client local_user_id not found
Client remote_user_id << {"candidate":"a=candidate:1 1 UDP 2122317823 192.168.215.220 40791 typ host","id":"local_user_id","mid":"0","type":"candidate"}
Client local_user_id not found
Client remote_user_id << {"candidate":"a=candidate:2 1 UDP 1686109951 102.140.244.151 40791 typ srflx raddr 0.0.0.0 rport 0","id":"local_user_id","mid":"0","type":"candidate"}
Client local_user_id not found

As you can see the android app connects and disconnects immediately.

How can I get this to work?

Thank you all in advance.

Heres the libdatachannel implementation :

#include <variant>
#include <string>
#include <iostream>

#include <jni.h>
#include <android/log.h>

#include <rtc/rtc.hpp>

#include <nlohmann/json.hpp>

#include <algorithm>
#include <future>
#include <memory>
#include <random>
#include <stdexcept>
#include <thread>
#include <unordered_map>

using namespace std::chrono_literals;
using std::shared_ptr;
using std::weak_ptr;

template<class T>
weak_ptr<T> make_weak_ptr(shared_ptr<T> ptr) { return ptr; }

using nlohmann::json;

std::string localId;
std::unordered_map<std::string, shared_ptr<rtc::PeerConnection>> peerConnectionMap;
std::unordered_map<std::string, shared_ptr<rtc::DataChannel>> dataChannelMap;

shared_ptr<rtc::PeerConnection> createPeerConnection(const rtc::Configuration &config,
                                                     weak_ptr<rtc::WebSocket> wws, std::string id);

std::string randomId(size_t length);

int initWebRTC() try {
    rtc::InitLogger(rtc::LogLevel::Info);

    rtc::Configuration config;
    std::string stunServer = "stun.l.google.com";

    stunServer += stunServer + ":" + std::to_string(19302);

    __android_log_print(ANDROID_LOG_INFO, "MyApp", "STUN server is  %s\n", stunServer.c_str());

    config.iceServers.emplace_back(stunServer);

    localId = "local_user_id";

    __android_log_print(ANDROID_LOG_INFO, "MyApp", "The local ID is %s\n", localId.c_str());

    auto ws = std::make_shared<rtc::WebSocket>();

    std::promise<void> wsPromise;
    auto wsFuture = wsPromise.get_future();

    ws->onOpen([&wsPromise]() {
        __android_log_print(ANDROID_LOG_INFO, "MyApp", "WebSocket connected, signaling ready\n");

        wsPromise.set_value();
    });

    ws->onError([&wsPromise](std::string s) {
        __android_log_print(ANDROID_LOG_INFO, "MyApp", "WebSocket error : %s\n", s.c_str());

        wsPromise.set_exception(std::make_exception_ptr(std::runtime_error(s)));
    });

    ws->onClosed([]() { std::cout << "WebSocket closed" << std::endl; });

    ws->onMessage([&config, wws = make_weak_ptr(ws)](auto data) {
        // data holds either std::string or rtc::binary
        if (!std::holds_alternative<std::string>(data))
            return;

        json message = json::parse(std::get<std::string>(data));

        auto it = message.find("id");
        if (it == message.end())
            return;

        auto id = it->get<std::string>();

        it = message.find("type");
        if (it == message.end())
            return;

        auto type = it->get<std::string>();

        shared_ptr<rtc::PeerConnection> pc;
        if (auto jt = peerConnectionMap.find(id); jt != peerConnectionMap.end()) {
            pc = jt->second;
        } else if (type == "offer") {
            __android_log_print(ANDROID_LOG_INFO, "MyApp", "Answering to %s\n", id.c_str());

            pc = createPeerConnection(config, wws, id);
        } else {
            return;
        }

        if (type == "offer" || type == "answer") {
            auto sdp = message["description"].get<std::string>();
            pc->setRemoteDescription(rtc::Description(sdp, type));
        } else if (type == "candidate") {
            auto sdp = message["candidate"].get<std::string>();
            auto mid = message["mid"].get<std::string>();
            pc->addRemoteCandidate(rtc::Candidate(sdp, mid));
        }
    });

    const std::string wsPrefix = "";
    const std::string url =
            wsPrefix + "ws://192.168.215.220" + ":" + std::to_string(8000) + "/" + localId;

    __android_log_print(ANDROID_LOG_INFO, "MyApp", "WebSocket URL is %s\n", url.c_str());

    ws->open(url);

    __android_log_print(ANDROID_LOG_INFO, "MyApp", "Waiting for signaling to be connected...\n");

    wsFuture.get();

    std::string targetId = "remote_user_id";

    if (targetId.empty())
        return 0;

    if (targetId == localId) {
        __android_log_print(ANDROID_LOG_INFO, "MyApp",
                            "Invalid remote ID (This is the local ID)\n");
        return 0;
    }

    __android_log_print(ANDROID_LOG_INFO, "MyApp", "Offering to %s\n", targetId.c_str());

    auto pc = createPeerConnection(config, ws, targetId);

    // We are the offerer, so create a data channel to initiate the process
    const std::string label = "test";

    __android_log_print(ANDROID_LOG_INFO, "MyApp", "Creating DataChannel with label %s\n",
                        label.c_str());

    auto dc = pc->createDataChannel(label);

    dc->onOpen([targetId, wdc = make_weak_ptr(dc)]() {
        __android_log_print(ANDROID_LOG_INFO, "MyApp", "DataChannel from %s\n", targetId.c_str());

        if (auto dc = wdc.lock())
            dc->send("Hello from " + localId);
    });

    dc->onClosed([targetId]() { std::cout << "DataChannel from " << targetId << " closed" << std::endl; });

    dc->onMessage([targetId, wdc = make_weak_ptr(dc)](auto data) {
        // data holds either std::string or rtc::binary
        if (std::holds_alternative<std::string>(data))
            __android_log_print(ANDROID_LOG_INFO, "MyApp", "Message from  %s : >>> %s\n",
                                targetId.c_str(), std::get<std::string>(data).c_str());
        else
            __android_log_print(ANDROID_LOG_INFO, "MyApp",
                                "Binary message from %s ::: received size : %d\n", targetId.c_str(),
                                std::get<rtc::binary>(data).size());
    });

    dataChannelMap.emplace(targetId, dc);

    __android_log_print(ANDROID_LOG_INFO, "MyApp", "Cleaning up...");

    dataChannelMap.clear();
    peerConnectionMap.clear();

    return 0;

} catch (const std::exception &e) {
    __android_log_print(ANDROID_LOG_INFO, "MyApp", "Error: %s\n", e.what());

    dataChannelMap.clear();
    peerConnectionMap.clear();
    return -1;
}

// Create and setup a PeerConnection
shared_ptr<rtc::PeerConnection> createPeerConnection(const rtc::Configuration &config,
                                                     weak_ptr<rtc::WebSocket> wws, std::string id) {
    auto pc = std::make_shared<rtc::PeerConnection>(config);

    pc->onStateChange(
            [](rtc::PeerConnection::State state) { std::cout << "State: " << state << std::endl; });

    pc->onGatheringStateChange([](rtc::PeerConnection::GatheringState state) {
        __android_log_print(ANDROID_LOG_INFO, "MyApp", "Gathering State: \n", state);
    });

    pc->onLocalDescription([wws, id](rtc::Description description) {
        json message = {{"id",          id},
                        {"type",        description.typeString()},
                        {"description", std::string(description)}};

        if (auto ws = wws.lock())
            ws->send(message.dump());
    });

    pc->onLocalCandidate([wws, id](rtc::Candidate candidate) {
        json message = {{"id",        id},
                        {"type",      "candidate"},
                        {"candidate", std::string(candidate)},
                        {"mid",       candidate.mid()}};

        if (auto ws = wws.lock())
            ws->send(message.dump());
    });

    pc->onDataChannel([id](shared_ptr<rtc::DataChannel> dc) {
        __android_log_print(ANDROID_LOG_INFO, "MyApp",
                            "DataChannel from %s received with label %s\n", id.c_str(),
                            dc->label().c_str());

        dc->onOpen([wdc = make_weak_ptr(dc)]() {
            if (auto dc = wdc.lock())
                dc->send("Hello from " + localId);
        });

        dc->onClosed([id]() { std::cout << "DataChannel from " << id << " closed" << std::endl; });

        dc->onMessage([id](auto data) {
            // data holds either std::string or rtc::binary
            if (std::holds_alternative<std::string>(data))
                __android_log_print(ANDROID_LOG_INFO, "MyApp", "Message from  %s\n", id.c_str());
            else
                __android_log_print(ANDROID_LOG_INFO, "MyApp",
                                    "Message from  %s received, size= %d\n",
                                    id.c_str(), std::get<rtc::binary>(data).size());
        });

        dataChannelMap.emplace(id, dc);
    });

    peerConnectionMap.emplace(id, pc);
    return pc;
};

// Helper function to generate a random ID
std::string randomId(size_t length) {
    static const std::string characters(
            "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz");
    std::string id(length, '0');
    std::default_random_engine rng(std::random_device{}());
    std::uniform_int_distribution<int> dist(0, int(characters.size() - 1));
    std::generate(id.begin(), id.end(), [&]() { return characters.at(dist(rng)); });
    return id;
}

[paullouisageneau]

I think there are two issues here:

• Your initWebRTC() function sets up the connection then clears everything before returning, as a result the connection is immediately destroyed
• In your example both clients attempt to offer a WebRTC, while one must offer while the other must be already connected to the signaling and answer