Android Video SDK

The EnableX Android SDK (EnxRtcAndroid) is a native Android library that integrates real-time audio and video into your Android app. It communicates directly with EnableX signalling and media servers, and delivers session notifications to your application through a structured Observer / Callback pattern — the Android equivalent of web event listeners.

Before integrating the SDK, ensure the following are ready on your server:

1. App Credentials — app_id and app_key from the EnableX Portal. Keep these on your server only — never embed in the APK.
2. A Room — created via the Video API. Store the room_id.
3. A Token — generated server-side via Create Token API for each participant before they join.

The Android SDK is distributed as two .aar archive files — the EnableX SDK itself and a bundled WebRTC library. Both must be included in your project.

  Download Android SDK v3.1.0 ⇩  Download WebRTC Library

Android SDK v3.1.0 — Released July 7, 2026  |  WebRTC Library — Released July 24, 2025

Method 1 — Add .aar files to libs/

Extract both ZIP archives to get the .aar files, then copy them into your app module's libs/ folder and update your app-level build file:

// app/build.gradle.kts
dependencies {
    implementation(fileTree(mapOf("dir" to "libs", "include" to listOf("*.aar"))))
    implementation("io.socket:socket.io-client:2.1.2") {
        exclude(group = "org.json", module = "json")
    }
    implementation("android.arch.lifecycle:extensions:1.1.1")
}

// app/build.gradle
dependencies {
    implementation fileTree(dir: "libs", include: ["*.aar"])
    implementation('io.socket:socket.io-client:2.1.2') {
        exclude group: 'org.json', module: 'json'
    }
    implementation 'android.arch.lifecycle:extensions:1.1.1'
}

Method 2 — Separate module (Recommended)

This approach isolates the SDK files cleanly and works better with multi-module projects.

1. Create a new directory in your project root, e.g. enx-sdk/. Place both .aar files inside it.
2. Create a build file in that directory:

// enx-sdk/build.gradle.kts
configurations.maybeCreate("default")
artifacts.add("default", file("EnxRtcAndroid-release_3.1.0.aar"))
artifacts.add("default", file("libWebRtc.aar"))

// enx-sdk/build.gradle
configurations.maybeCreate('default')
artifacts.add('default', file('EnxRtcAndroid-release_3.1.0.aar'))
artifacts.add('default', file('libWebRtc.aar'))

3. Register the module in your root settings file:

// settings.gradle.kts
include(":enx-sdk")

// settings.gradle
include ':enx-sdk'

4. Add it as a dependency in your app's build file:

// app/build.gradle.kts
dependencies {
    implementation(project(":enx-sdk"))
}

// app/build.gradle
implementation project(":enx-sdk", configuration: "default")

AndroidManifest.xml — Permissions & Features

Add the following to your AndroidManifest.xml. Camera and microphone are required for audio/video; the remaining entries support networking, storage, and Bluetooth audio devices.

<!-- Permissions -->
<uses-permission android:name="android.permission.CAMERA"/>
<uses-permission android:name="android.permission.RECORD_AUDIO"/>
<uses-permission android:name="android.permission.INTERNET"/>
<uses-permission android:name="android.permission.ACCESS_WIFI_STATE"/>
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>
<uses-permission android:name="android.permission.CHANGE_NETWORK_STATE"/>
<uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS"/>
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
<uses-permission android:name="android.permission.BLUETOOTH"/>
<uses-permission android:name="android.permission.BLUETOOTH_ADMIN"/>

<!-- Hardware features -->
<uses-feature android:name="android.hardware.camera"/>
<uses-feature android:name="android.hardware.camera.autofocus"/>
<uses-feature android:glEsVersion="0x00020000" android:required="true"/>

Observers — The Android Callback Pattern

In the Android SDK, all asynchronous notifications arrive through Observers. These are Java interfaces your Activity or Fragment implements. When something happens in the session — a stream is published, recording starts, a user joins — the SDK calls the corresponding method on the registered observer.

There are two levels of observers:

Core Observers (registered in the constructor)

The two primary observers are passed when you create the EnxRoom instance. They handle the most common room and stream events:

// Your Activity implements EnxRoomObserver and EnxStreamObserver
class MainActivity : AppCompatActivity(), EnxRoomObserver, EnxStreamObserver {

    override fun onRoomConnected(enxRoom: EnxRoom?, roomMetaData: JSONObject?) {
        this.room = enxRoom
        localStream?.let { enxRoom?.publish(it) }
    }

    override fun onRoomError(jsonObject: JSONObject?) {
        val code = jsonObject?.optInt("result")
    }

    override fun onStreamAdded(stream: EnxStream?) {
        stream?.let { room?.subscribe(it) }
    }

    override fun onSubscribedStream(enxStream: EnxStream?) {
        enxStream?.attachRenderer(remoteVideoView)
    }
}

// Your Activity implements EnxRoomObserver and EnxStreamObserver
public class VideoActivity extends AppCompatActivity
        implements EnxRoomObserver, EnxStreamObserver {

    private EnxRoom room;

    void initRoom() {
        room = new EnxRoom(
            this,   // EnxRoomObserver  — receives room-level callbacks
            this    // EnxStreamObserver — receives stream-level callbacks
        );
        room.init(this); // pass the Activity context
    }

    // Called when your client successfully connects to the room
    @Override
    public void onRoomConnected(EnxRoom room, JSONObject roomMetaData) {
        Log.d("ENX", "Room connected: " + roomMetaData);
    }

    // Called when a new remote stream is available
    @Override
    public void onStreamAdded(EnxStream stream) {
        room.subscribe(stream); // subscribe to receive it
    }
}

Feature Observers (registered via setters)

Specialised features use dedicated observer interfaces that you register via setter methods — always before calling the feature method:

// Recording
room.setRecordingObserver(this)
room.startRecord()

// Hard mute
room.setMuteRoomObserver(this)
room.hardMute()

// Floor access (Lecture Mode)
room.setChairControlObserver(this)
room.requestFloor()

// File sharing
room.setFileShareObserver(this)
room.sendFiles(files, options)

// Active talker list (custom view mode)
room.setActiveTalkerListObserver(this)
// or for predefined RecyclerView mode:
room.setActiveTalkerViewObserver(this)

// Recording
room.setRecordingObserver(this);
room.startRecord();

// Hard mute
room.setMuteRoomObserver(this);
room.hardMute();

// Floor access (Lecture Mode)
room.setChairControlObserver(this);
room.requestFloor();

// File sharing
room.setFileShareObserver(this);
room.sendFiles(files, options);

// Active talker list (custom view mode)
room.setActiveTalkerListObserver(this);
// or for predefined RecyclerView mode:
room.setActiveTalkerViewObserver(this);

Callback Naming Convention

All callbacks follow predictable naming that tells you who receives them:

• Callbacks starting with onACK or onYourAction (e.g., onStartRecordingEvent, onPublishedStream) — delivered only to the user who triggered the action.
• Callbacks like onRoomRecordingOn, onUserConnected, onStreamAdded — delivered to all participants in the room.

Key Room Attributes

When an SDK method fails, the error is returned as a JSONObject through the callback. Note that Android uses errorCode — not result — as the primary error field:

{
  "errorCode": 5013,
  "msg": "Failed to publish stream",
  "desc": "Optional extended description of the error"
}

The Android SDK documentation is organized into focused topic pages. Each page covers a feature area with method signatures, observer setup, callback descriptions, and Java code examples.