Repository files navigation

Getting Started

This repository involves aStep by Step Guide to Compile and Build WebRTC Library for Android based on WebRTC Native Stack. As we all know, Android Programs run intoDalvik Virtual Machine. Native Development tool (NDK) allows users to execute some of the program using native code languages such asC/C++.

I have made this document pretty straight forward for those who are using WebRTC for the first time or for those who are still struggling to get most out of it. To get more details of WebRTC you have to look into this reference:

• Android_Realtime_Communication_Using_WebRTC.

ForAudioProcessing in Android, I will recommend you to must visit these references:

• Android-Audio-Processing-Using-WebRTC
• Android-Native-Development-For-WebRTC

• Prebuilt Libraries

• Prerequisite Software

• Major Steps

• Explanation of Steps

  • Getting the Code

  • Dependencies and Branch Selection

  • Compilation and Building

    • Using AAR Build Tools

    • Using Manual Compilation

• Usage of Library

  • Manually Include Packages(*.aar)

  • Publish to Maven Repository

• Compilation Issues

• Conclusion

The easiest way to get started is using theofficial prebuilt libraries available at JCenter. These libraries are compiled from the tip-of-tree and are meant for development purposes only.

On Android Studio 3+ add to your dependencies:

implementation 'org.webrtc:google-webrtc:1.0.+'

So, I will must suggest to use any ofLinux-Environment etc (Ubuntu) for Android Development. When you have setup your Linux-Environment, then make sure of these important things before hand:

• Hard-Disk Space around30-50GB (Minimum20GB)
• RAM4-8GB (Enough)
• Internet With GoodMBs

Currently, The only supported distros are:

Ubuntu 14.04 LTS (trusty with EoL April 2022)Ubuntu 16.04 LTS (xenial with EoL April 2024)Ubuntu 18.04 LTS (bionic with EoL April 2028)Ubuntu 19.04 (disco)Ubuntu 19.10 (eoan)Debian 8 (jessie) or later

If you go for latest Linux Environment available i.e. (Ubuntu 20.01) , It might not install most of the dependencies to build the library.

Before to start with WebRTC Native Stack, open your terminal, first install these modules, using the following Commands:

 - sudo add-apt-repository ppa:openjdk-r/ppa - sudo apt-get install openjdk-8-jdk - sudo apt-get install pkg-config - sudo apt-get update

Most of the developers prefer, Inline commands as follows:

  sudo add-apt-repository ppa:openjdk-r/ppa && sudo apt-get install openjdk-8-jdk && sudo apt-get install pkg-config && sudo apt-get update

These are the only11-Steps which are basically the cream of WebRTC Native Development:

• To Get the Code
• To Compile and Build Library

I have explained about each step below in this document. To get basic understanding of these given steps seeExplanation of Steps and then start with these following steps one by one.

    1- git clone https://chromium.googlesource.com/chromium/tools/depot_tools.git        2- export PATH="$PATH:${HOME}/depot_tools"        3- mkdir webrtc_android        3.1- cd webrtc_android        4- fetch --nohooks webrtc_android            5- gclient sync        6- cd src/        7- ./build/install-build-deps.sh        8- git branch -r        9- git checkout origin/master        # To check you're in origin/master branch    10- git branch        11- tools_webrtc/android/build_aar.py

If you perform all of the above steps in an RDP (Remote Desktop Protocol) of AWS with30-50 CPU Cores and with the speed of internet around4-5 GBPs, then all of the above process might take around5-6 minutes. Hurry!!!

Now, if you look in thewebrtc_android/src/ directory, It turns out that you will end up with the compilation and building oflibwebrtc.aar.

The above mentioned11-Steps involve these three procedures to deal with:

This procedure involves Steps fromStep-1 toStep-5, to get the native code of WebRTC from Google Git, there is always a need

• To install the Chromium Depot Tools

Chromium and Chromium OS use a package of scripts calleddepot_tools to manage checkouts and code reviews.Thedepot_tools package includes custom git binary, ninja build tools, gclient, gn, ninja, gcl, git-cl, repo, and others.

It is very easy to get these tools. Just take your first step by cloning the repository with this command:

    1- git clone https://chromium.googlesource.com/chromium/tools/depot_tools.git

Now, its time to add path intoPATH Environment Variables, so that the binaries/dependencies must be included in the repository. In this way, these binaries would be available in the current terminal:

    2- export PATH="$PATH:${HOME}/depot_tools"

If you close the current instance of Linux-terminal, then before starting any step (except step-1), you have to repeat this step to get working binaries in that instance. To get more detailed intuition, you can visitGet Chromium Depot Tools

After this make a new directory and go into that directory using these commands:

    3-   mkdir webrtc_android    3.1- cd webrtc_android

This is the directory, where all of your WebRTC Native Stack will be cloned and synced. Now, here comes the twogiant steps of this getting code procedure which are:

• Fetch command is used to get the a regular WebRTC Native Source Code with the Android-specific parts added.
• Gclient Sync command is used to update your checkout for underlying source code i.e WebRTC Native Code.

Make sure your current directory iswebrtc_android/:

    4- fetch --nohooks webrtc_android    5- gclient sync

Thegclient sync command will pull all dependencies of the Chromium src checkout. You will need to run this any time you update the main src checkout, including when you switch branches.

Try to avoid any kind of interruption as these processes may take enough time based on Machine Specs and Internet Speed because these processes require the android build chain tools for which;

After these steps, you will end up with Updated and Synced WebRTC Native Code.

To install all required dependencies for linux, a script is provided forUbuntu, which is unfortunately only available after your firstgclient sync:

Make sure your current directory iswebrtc_android/src/

    6- cd src/    7- ./build/install-build-deps.sh

Most of the libraries installed with this script are not needed since WebRTC Developers now build using Debian sysroot images in build/linux, but there are still some tools needed for the build that are installed withinstall-build-deps.sh.These all dependencies are very important to build the Native Source Code.

Here I will explainStep-8,9.Some of the developers recommend to look for particular git branches before Compiling the Native Source Code. To list down all the available WebRTC Checkout Branches use this command:

    8- git branch -r

You can see the available latest branches looks like this as follows:

Now you can checkout to the latest branch which isbranch-heads/m79, using this command:

    9- git checkout branch-heads/m79

But I will must recommend you to checkout with theorigin/master:

    9- git checkout origin/master

This will help you to resolve most ofcompilation issues. To get the details about your current branch you can simply use these commands:

    10- git branch    or    10- git status

There are two ways to compile the WebRTC Native Stack for Android to build the library i.e.libwebrtc.aar. You can use these following methods such as:

This is the most beautiful process. It would compile the source code for all supported CPU types such as

• arm64-v8a,
• armeabi-v7a,
• x86,
• x86_64

and at the end package all thesenative libraries and.jar library into*.aar file.

Make sure your current working directory iswebrtc_android/src/ of your workspace. Then run:

    11- tools_webrtc/android/build_aar.py

This process will take some time based on your machine specs and internet speed, so here we go:

Now, if you look in thewebrtc_android/src/ directory, It turns out that you will end up with the compilation and building oflibwebrtc.aar.

This process will manually compile the source code for each particular CPU type. Manual Compiling involves these two steps:

This step will compile library for both Debug and Release Mode of Development.

Make sure your current working directory iswebrtc_android/src/ of your workspace. Then run:

    11- gn gen out/Debug --args='target_os="android" target_cpu="arm"'    11- gn gen out/Release --args='is_debug=false is_component_build=false rtc_include_tests=false target_os="android" target_cpu="arm"'

You can specify a directory of your own choice instead of out/Debug, to enable managing multiple configurations in parallel.

• To build for ARM64: use target_cpu="arm64"
• To build for 32-bit x86: use target_cpu="x86"
• To build for 64-bit x64: use target_cpu="x64"

For compilation you can simply use these following commands for (out/Debug,out/Release):

     11.1- ninja -C out/Debug     11.1- ninja -C out/Release

The output of the above process will be in theout/Debug orout/Release. Manually compilation of the source code is quite difficult and challenging. As with, manual compilation you also need to package all these libraries into.aar manually which is more time consuming.

The Native*.so file will be in thelib.unstripped/, and the java.jar library will be in thelib.java/ directory.

The Native.so library is un-stripped, you can strip it tominimize file size using strip tools for particular CPU type.Such tools are located in this following Directory:

webrtc_android/src/third_party/android_ndk/toolchains/arm-linux-androideabi-4.9/prebuilt/linux-x86_64/bin/arm-linux-androideabi-strip (for x64 binary .so)

You can use this (.aar) library into your project using:

First kept yourlibwebrtc.aar file into thelibs directory and thenopen Project levelbuild.gradle and includeflatDir such as:

    allprojects {        repositories {            jcenter()            flatDir {                dirs 'libs'            }            google()        }    }

then, open Application Levelbuild.gradle file and add*.aar file such as:

    dependencies {        compile(name:'libwebrtc', ext:'aar')    }

If everything goes well you will see library entry is made in build exploded-aar. Also note that if you are importing a .aar file from another project that has dependencies you'll need to include these in your build.gradle, too.

You can use maven to add*.aar libraries into the existing maven repository using this commands:

    sudo apt-get install maven    mvn install:install-file -Dfile=./google-webrtc-M79.aar -DgroupId=com.aar.app -DartifactId=google-webrtc -Dversion=M79 -Dpackaging=aar -DlocalRepositoryPath=./libwebrtc-android -DcreateChecksum=true

Then you can add repository in the root gradle file followed by adding into your app module.

Some of you guys may try different branch-heads of WebRTC for there development. But I must suggest to use theorigin/master. Because, it turns out that while using different branch heads, you may end up with multiple issues regardingBUILD.gn or inside this classtools_webrtc/android/build_aar.py, which may be an unhealthy experience.

Some kind of the issues are as follows:

And you may end up with same kind of many more issues. But if you have properly carried out the above steps, then hopefully, you won't be catch up with issue regarding Compilation and Building libraries.

Now, If you have already completed your task tostep-7 with the whatever branch let's say in between (branch-heads/60--branch-heads/m79), then you can again select thebranch oforigin/master instead of any otherbranch-heads. To do that try these following steps:

Make sure you're in this directorywebrtc_android/src/:

 - git checkout origin/master # To make sure you're using origin/master - git branch - gclient revert - gclient sync - tools_webrtc/android/build_aar.py

And hopefully, you will have your issues sorted, because currently, you are checking out a branch that is behind theorigin/master and doesn't have all dependencies and modules over there which are necessary to build yourlibwebrtc.aar.

I have tried to get most out of it. Hopefully, If you will follow these steps properly, you will enjoy the development. Again thanks to WebRTC-Developers for such as huge module for pre-processing as well as post-processing of Real-time Communication.

Now you have WebRTC Native Stack go and do some changes in the native stack and re-build the library, and use it either manually or publish it. If you catchup with any kind of issues, feel free to jump into issues and open that one or you can simply use this discussion portal i.eDiscuss-webrtc.This group first verify your post, then display it after a short/long interval, so be relaxed. You're issue gonna be solved one day.