Using libjingle for Real-time Communication: Setting Up and Using libjingle for Real-Time Voice and Video Communication

What is libjingle?

libjingle is a C++ library. Although it has some components written in other languages, its core is written in C++ and mainly handles the most difficult tasks of RTC, like signaling, media processing, or NAT traversal. This is why performance-critical apps that require fine-grained control over the RTC process often depend on libjingle.

Originally, libjingle was developed by Google to allow for video and voice calls in Google Talk, which is one of its first VoIP and instant messaging services. The library offers the necessary functionalities to create smooth, direct connections between users without the need for a central server. For example, it uses protocols like XMPP (Extensible Messaging and Presence Protocol) for signaling and ICE (Interactive Connectivity Establishment) for managing connections.

When technology evolved, Google integrated libjingle’s core features, especially those related to signaling and peer connection, into a broader framework called WebRTC. While libjingle is no longer actively maintained as a separate entity, its code and concepts are integral parts of WebRTC, laying the foundation for today’s RTC solutions.

How Does libjingle Work?

To better understand libjingle, it’s essential to learn about its key features and how these features work together to establish seamless calls and data exchange. Let’s take a look:

1. Signaling via XMPP or Custom Protocols

Before transmitting any media, devices need to find each other, agree upon a communication protocol, and exchange session details. This is what we call a “signaling process.”

libjingle supports signaling between two devices through protocols. XMPP is a widely used protocol that sends connection requests and manages presence updates. Further, developers can implement custom signaling methods to exchange session description protocol (SDP) information, including supported codecs, media types, and other parameters.

2. NAT Traversal Using STUN/TURN/ICE

In P2P communication, devices need to create a direct connection for efficient data exchange and calls. However, many devices sit behind routers or firewalls that leverage Network Address Translation (NAT) to assign unique IP addresses. For this reason, two devices behind different NATs can’t easily connect, consequently blocking direct P2P connections. To address this problem, libjingle uses:

STUN (Session Traversal Utilities for NAT) to determine a device’s public IP address and see whether it can connect directly with another device.
TURN (Traversal Using Relays around NAT) to pass on data through an external server when a direct connection fails.
ICE (Interactive Connectivity Establishment) to test different network paths and find the best way to connect two devices.

3. Stream Voice and Video Data

When devices are connected, they need to negotiate the media codecs and formats. To process real-time video and voice streaming, libjingle encodes and compresses media data to decrease bandwidth usage. Then, it uses RTP (Real-time Transport Protocol) to transfer media streams (audio and video) between devices.

4. Manage Connection Stability and Security

libjingle keeps communication between devices stable by managing network conditions. This means it can adjust audio and video quality based on network conditions to keep connections stable. It’s especially beneficial when your users have a slow internet connection. Accordingly, libjingle can adapt to ensure clear video or voice calls without requiring additional plugins or complex configurations.

Further, it offers RTCP (Real-time Transport Control Protocol) to send feedback on the quality of the media stream. This allows devices to manage packet loss and jitter to prevent call disruptions. Meanwhile, the library supports data encryption to safeguard user privacy and avoid unauthorized access.

Setting Up libjingle for Development

It’s crucial to restate that libjingle is no longer supported and recommended for new real-time communication projects. Instead, WebRTC is preferred and has become a standard in RTC development. Therefore, this section is primarily for educational purposes, which helps you understand the evolution of RTC technology. In other words, we don’t encourage you to use libjingle for a production application.

1. Prerequisites

Prior to libjingle installation, you need to prepare your development environment and set up essential dependencies.

Development Environment Setup

libjingle can be installed on Windows, macOS, and Linux. However, each operating system requires different tools and commands to implement setup.

Windows

Install Visual Studio (for Windows) or a compatible C++ IDE.
Download and set up Git to clone the repository.

macOS

Download and set up Xcode from the App Store. This involves installing the Xcode Command Line Tools, which are crucial to compile and develop the app.
Install Homebrew, which is macOS’s package manager, to set up dependencies effectively.

Linux (Ubuntu/Debian)

Install Git and Make. While Git is used to replicate the libjingle repository from the WebRTC source to your local machine, Make helps compile the library after setting up dependencies. To implement installation, use the following command:

sudo apt-get update

sudo apt-get install git make

Prepare other tools to develop dependencies, like build-essential, libssl-dev, or pkg-config.

Required Dependencies

To create and run libjingle, you need the following dependencies:

C++ Compiler: You need to install and configure a compatible C++ compiler for your development environment. On Windows, Visual Studio is a common option, combined with other C++ development tools. Meanwhile, macOS requires Xcode with preinstalled Clang. If you work on Linux, install GCC (GNU Compiler Collection) with the command:

sudo apt-get install build-essential.

Build Systems: Installing build systems like GN (Generate Ninja) and Ninja helps you create build files efficiently, even for large codebases.

WebRTC Dependencies: libjingle depends on WebRTC for real-time communication. Accordingly, you need to set up WebRTC’s core dependencies. Search for specific instructions to install WebRTC on its official GitHub repository or use prebuilt WebRTC binaries to save time and avoid complexities. Prebuilt WebRTC Binaries by Ben Greenier is typically used.

Protocol Buffers (protobuf): protobuf helps serialize structured data. Follow the detailed instructions in the Protocol Buffers GitHub repository to install it. If you work on macOS or Linux, use the following commands to install protobuf:

sudo apt-get install protobuf-compiler # Linux (Ubuntu/Debian)

brew install protobuf # macOS (using Homebrew)

STUN/TURN Servers: To process NAT traversal, you need STUN and TURN servers. Some popular options include Google STUN Server, Mozilla STUN Server, and Coturn (the most common open-source TURN server). Otherwise, you can install your own.

2. Installing libjingle

To install and run libjingle, you can follow these steps. However, please remember that these steps are general instructions. The specific commands and directory structures can vary depending on the exact libjingle version you’re working on.

Step 1: Clone the libjingle repository (if available)

First, you need to replicate the libjingle repository (if you can find a still-accessible one) using Git from Google’s source. Open a terminal and run the following command:

git clone https://some.accessible.libjingle.repo.url/libjingle.git # Hypothetical URL

Step 2: Install the required dependencies

When you already have the repository, it’s time to install all the essential dependencies we listed above. The process may vary depending on your environment.

On Windows: The installation process for Windows can include many steps, typically setting up Visual Studio, GN/Ninja, and WebRTC dependencies. You should consult the WebRTC documentation or official libjingle (if available) to access Windows-specific instructions.

On macOS/Linux: After cloning the repository, you need to navigate to the libjingle directory and set up the essential dependencies by running the appropriate setup script (if available) for your operating system. If no script is provided, you must manually install these dependencies (e.g., WebRTC dependencies or protobuf).

Step 3: Build the library

Once you set up the development environment and all the required dependencies, the next step is to create libjingle from the source code. This includes compiling the source files and linking them with the essential dependencies to create the final libraries for use in real-time communication apps.

In this step, you first navigate to the libjingle source directory with the following command:

cd path/to/libjingle

Note: Replace path/to/libjingle with the actual directory where you already replicated the repository.

Next, compile the library with build systems like GN, Ninja, or GYP (an older version of libjingle). When the build is finished, you should check the output directory for the compiled binaries. In doing so, search for files like static libraries (.a or .lib files) or shared libraries (.dll for Windows and .so for macOS/Linux)

Step 4: Test the build

To ensure your build is successful, we advise you to run a sample libjingle test program with the following script:

./out/Default/peerconnection_server

If you see logs stating that the peer connection server is running, it means your build is successful. In other words, you correctly compiled libjingle and this library is ready for incorporation into your real-time communication apps.

Troubleshooting and Debugging libjingle Applications

In this section, we’ll also offer a conceptual overview of common issues and debugging approaches that are related to libjingle apps. Even when libjingle isn’t a separate entity yet a crucial part of WebRTC, understanding problems relevant to libjingle is still essential. This is especially beneficial if you use libjingle in WebRTC-based applications.

1. Connection Failures

When this problem occurs, you may notice that devices fail to connect with each other, calls often drop, or signaling messages are not correctly exchanged.

Possible causes can be issues with the signaling server, NAT traversal failures, incorrect network configurations, and restrictive firewalls. By identifying the exact culprit behind connection failures, you can implement appropriate troubleshooting strategies like verifying the signaling server logs or inspecting ICE candidate fathering.

2. Poor Audio/Video Quality

When this problem happens, your devices might confront choppy and laggy media streams. The reasons behind this may vary. Limited bandwidth, hardware limitations, codec mismatch, and network congestion can impact the quality of video calls or data exchange.

Once you’ve identified the precise cause, you can implement proper troubleshooting techniques. They can involve estimating bandwidth to adapt the media stream, checking hardware (e.g., camera or microphone), testing whether compatible codecs are used, and more.

3. ICE Candidate Gathering

This problem occurs when devices are unlikely to gather ICE candidates, which are crucial to creating a connection. The reasons behind this issue can come from network restrictions (e.g., firewalls blocking access), incorrect configuration, and STUN/TURN server problems. When you identify the correct cause, you can implement suitable troubleshooting measures like testing STUN/TURN connectivity or inspecting ICE candidate logs.

Using debugging tools and logs for libjingle apps

In addition to troubleshooting strategies and techniques, you should combine the use of tools to debug libjingle applications.

Logging: Both libjingle and WebRTC provide built-in logging capabilities to diagnose problems. You can enable verbose logging to identify connection failures, media performance, and ICE candidate gathering.

WebRTC Internals: If you’re using libjingle in a WebRTC-based app, leverage Chrome’s webrtc-internals tool for debugging. To enable this tool, open Chrome and navigate to chrome://webrtc-internals/. Then, you can spot any dropped packets or high jitter values that impact call quality, as well as verify bandwidth usage, ICE candidate exchanges, and connection states.

Network Monitoring Tools: Use tools like Wireshark to inspect network traffic, signaling messages, and media streams.

Future of libjingle in Real-time Communication

As we confirm throughout this article, libjingle is no longer maintained and supported as a standalone technology. Therefore, it’s clear that this library has no future in modern real-time communication projects.

While some legacy systems can still leverage libjingle, most modern apps have switched to WebRTC because of its better performance and active support. Developers also consider transitioning their old projects built with libjingle to WebRTC if they want to maintain these projects with feature improvements.

WebRTC: A Perfect Alternative for libjingle

WebRTC is a W3C framework that offers an all-inclusive set of APIs to develop real-time communication apps in web browsers and other platforms. Look at the following table to understand why WebRTC is preferred over libjingle:

Feature	libjingle	WebRTC
Platform Support	Limited (Desktop)	Cross-platform (Web, Mobile, Desktop)
Media Handling	Basic	Optimized with VP8/VP9, Opus
NAT Traversal	STUN/TURN	Advanced ICE/STUN/TURN
Security	Limited encryption	End-to-end encryption, DTLS-SRTP
Scalability	Less optimized	Supports SFUs and MCUs for large-scale apps
Integration	Needs custom signaling	Works with modern signaling frameworks
Maintenance	Unsupported	Actively maintained

When to Use libjingle Instead of WebRTC

So, does this mean learning about libjingle is meaningless? We would say not exactly. As Google moved it to WebRTC, which integrates the core functionalities of libjingle, understanding this library will lay the groundwork for learning about some parts of WebRTC. Further, there are still some cases where developers still consider libjingle. This is when you want to maintain legacy apps that were initially built with libjingle or non-browser-based apps where WebRTC’s browser dependencies are unnecessary.

How to Transition From libjingle to WebRTC

Switching from libjingle to WebRTC is a daunting process. It often requires rewriting significant portions of your app’s communication logic. As libjingle depends on external signaling, you need to re-architect how signaling works in your app to leverage the signaling mechanisms offered by WebRTC. Further, you need to adapt the media handling to the WebRTC APIs.

Conclusion

After this article, we expect you to better understand what libjingle is and how it works for real-time communication applications. Although it’s now no longer supported and maintained, its core functionalities still prove useful in WebRTC-based apps. For more interesting articles about VoIP technologies, subscribe to our blog now and follow us on Facebook, X, and LinkedIn!