init

android/sdk/.classpath

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8/"/>
+	<classpathentry kind="con" path="org.eclipse.buildship.core.gradleclasspathcontainer"/>
+	<classpathentry kind="output" path="bin/default"/>
+</classpath>

android/sdk/.project

@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>sdk</name>
+	<comment>Project sdk created by Buildship.</comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.buildship.core.gradleprojectbuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+		<nature>org.eclipse.buildship.core.gradleprojectnature</nature>
+	</natures>
+</projectDescription>

android/sdk/.settings/org.eclipse.buildship.core.prefs

@@ -0,0 +1,2 @@
+connection.project.dir=..
+eclipse.preferences.version=1

android/sdk/build.gradle

@@ -0,0 +1,319 @@
+apply plugin: 'com.android.library'
+apply plugin: 'maven-publish'
+
+android {
+    compileSdkVersion rootProject.ext.compileSdkVersion
+    ndkVersion rootProject.ext.ndkVersion
+
+    defaultConfig {
+        minSdkVersion rootProject.ext.minSdkVersion
+        targetSdkVersion rootProject.ext.targetSdkVersion
+        buildConfigField "String", "SDK_VERSION", "\"$sdkVersion\""
+    }
+
+    buildTypes {
+        debug {
+            buildConfigField "boolean", "LIBRE_BUILD", "${rootProject.ext.libreBuild}"
+            buildConfigField "boolean", "GOOGLE_SERVICES_ENABLED", "${rootProject.ext.googleServicesEnabled}"
+        }
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+            buildConfigField "boolean", "LIBRE_BUILD", "${rootProject.ext.libreBuild}"
+            buildConfigField "boolean", "GOOGLE_SERVICES_ENABLED", "${rootProject.ext.googleServicesEnabled}"
+        }
+    }
+
+    sourceSets {
+        main {
+            java {
+                exclude "test/"
+            }
+        }
+    }
+    namespace 'org.jitsi.meet.sdk'
+}
+
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation 'androidx.appcompat:appcompat:1.4.1'
+    implementation 'androidx.fragment:fragment:1.4.1'
+    implementation 'androidx.localbroadcastmanager:localbroadcastmanager:1.0.0'
+    implementation 'androidx.swiperefreshlayout:swiperefreshlayout:1.1.0'
+
+    api "com.facebook.react:react-android:$rootProject.ext.rnVersion"
+    api "com.facebook.react:hermes-android:$rootProject.ext.rnVersion"
+
+    implementation 'com.dropbox.core:dropbox-core-sdk:4.0.1'
+    implementation 'com.jakewharton.timber:timber:5.0.1'
+    implementation 'com.squareup.duktape:duktape-android:1.3.0'
+    implementation 'com.google.code.gson:gson:2.8.6'
+    implementation 'androidx.startup:startup-runtime:1.1.0'
+    implementation 'com.google.j2objc:j2objc-annotations:3.0.0'
+
+    // Only add these packages if we are NOT doing a LIBRE_BUILD
+    if (!rootProject.ext.libreBuild) {
+        implementation project(':react-native-amplitude')
+        implementation project(':react-native-giphy')
+        implementation(project(':react-native-google-signin')) {
+            exclude group: 'com.google.android.gms'
+            exclude group: 'androidx'
+        }
+    }
+
+    implementation project(':react-native-async-storage')
+    implementation project(':react-native-background-timer')
+    implementation project(':react-native-calendar-events')
+    implementation project(':react-native-community_clipboard')
+    implementation project(':react-native-community_netinfo')
+    implementation project(':react-native-default-preference')
+    implementation(project(':react-native-device-info')) {
+        exclude group: 'com.google.firebase'
+        exclude group: 'com.google.android.gms'
+        exclude group: 'com.android.installreferrer'
+    }
+    implementation project(':react-native-gesture-handler')
+    implementation project(':react-native-get-random-values')
+    implementation project(':react-native-immersive-mode')
+    implementation project(':react-native-keep-awake')
+    implementation project(':react-native-orientation-locker')
+    implementation project(':react-native-pager-view')
+    implementation project(':react-native-performance')
+    implementation project(':react-native-safe-area-context')
+    implementation project(':react-native-screens')
+    implementation project(':react-native-slider')
+    implementation project(':react-native-sound')
+    implementation project(':react-native-splash-view')
+    implementation project(':react-native-svg')
+    implementation project(':react-native-video')
+    implementation project(':react-native-webview')
+
+    // Use `api` here so consumers can use WebRTCModuleOptions.
+    api project(':react-native-webrtc')
+
+    testImplementation 'junit:junit:4.12'
+}
+
+
+// Here we bundle all assets, resources and React files. We cannot use the
+// react.gradle file provided by react-native because it's designed to be used
+// in an application (it taps into applicationVariants, but the SDK is a library
+// so we need libraryVariants instead).
+android.libraryVariants.all { def variant ->
+    // Create variant and target names
+    def targetName = variant.name.capitalize()
+    def targetPath = variant.dirName
+
+    // React js bundle directories
+    def jsBundleDir = file("$buildDir/generated/assets/react/${targetPath}")
+    def resourcesDir = file("$buildDir/generated/res/react/${targetPath}")
+
+    def jsBundleFile = file("$jsBundleDir/index.android.bundle")
+
+    def currentBundleTask = tasks.create(
+            name: "bundle${targetName}JsAndAssets",
+            type: Exec) {
+        group = "react"
+        description = "bundle JS and assets for ${targetName}."
+
+        // Create dirs if they are not there (e.g. the "clean" task just ran)
+        doFirst {
+            jsBundleDir.deleteDir()
+            jsBundleDir.mkdirs()
+            resourcesDir.deleteDir()
+            resourcesDir.mkdirs()
+        }
+
+        // Set up inputs and outputs so gradle can cache the result
+        def reactRoot = file("${projectDir}/../../")
+        inputs.files fileTree(dir: reactRoot, excludes: ["android/**", "ios/**"])
+        outputs.dir jsBundleDir
+        outputs.dir resourcesDir
+
+        // Set up the call to the react-native cli
+        workingDir reactRoot
+
+        // Set up dev mode
+        def devEnabled = !targetName.toLowerCase().contains("release")
+
+        // Run the bundler
+        // Use full path to node to avoid PATH issues in Gradle
+        def nodePath = System.getenv('NVM_BIN') ? "${System.getenv('NVM_BIN')}/node" : "node"
+
+        // Debug: Print the node path and environment
+        println "Using node path: ${nodePath}"
+        println "NVM_BIN: ${System.getenv('NVM_BIN')}"
+        println "Working directory: ${reactRoot}"
+
+        commandLine(
+                nodePath,
+                "node_modules/react-native/scripts/bundle.js",
+                "--platform", "android",
+                "--dev", "${devEnabled}",
+                "--reset-cache",
+                "--entry-file", "index.android.js",
+                "--bundle-output", jsBundleFile,
+                "--assets-dest", resourcesDir)
+
+        // Disable bundling on dev builds
+        enabled !devEnabled
+    }
+
+    // GRADLE REQUIREMENTS (Gradle 8.7+ / AGP 8.5.0+):
+    
+    // This task requires explicit dependencies on resource tasks from all React Native modules
+    // due to Gradle's strict validation of task dependencies.
+
+    // Without these dependencies,
+    // builds will fail with errors like:
+    // "Task ':sdk:bundleReleaseJsAndAssets' uses the output of task ':react-native-amplitude:packageReleaseResources'
+    // without declaring a dependency on it."
+
+    // The automatic dependency resolution below ensures all required resource tasks are properly
+    // declared as dependencies before this task executes.
+
+    if (variant.name.toLowerCase().contains("release")) {
+        rootProject.subprojects.each { subproject ->
+            if (
+                subproject.name.startsWith("react-native-") ||
+                subproject.name.startsWith("@react-native-") ||
+                subproject.name.startsWith("@giphy/")
+            ) {
+                [
+                    "packageReleaseResources",
+                    "generateReleaseResValues",
+                    "generateReleaseResources",
+                    "generateReleaseBuildConfig",
+                    "processReleaseManifest",
+                    "writeReleaseAarMetadata",
+                    "generateReleaseRFile",
+                    "compileReleaseLibraryResources",
+                    "compileReleaseJavaWithJavac",
+                    "javaPreCompileRelease",
+                    "bundleLibCompileToJarRelease",
+                    "exportReleaseConsumerProguardFiles",
+                    "mergeReleaseGeneratedProguardFiles",
+                    "mergeReleaseJniLibFolders",
+                    "mergeReleaseShaders",
+                    "packageReleaseAssets",
+                    "processReleaseJavaRes",
+                    "prepareReleaseArtProfile",
+                    "copyReleaseJniLibsProjectOnly",
+                    "extractDeepLinksRelease",
+                    "createFullJarRelease",
+                    "generateReleaseLintModel",
+                    "writeReleaseLintModelMetadata",
+                    "generateReleaseLintVitalModel",
+                    "lintVitalAnalyzeRelease",
+                    "lintReportRelease",
+                    "lintAnalyzeRelease",
+                    "lintReportDebug",
+                    "lintAnalyzeDebug"
+                ].each { taskName ->
+                    if (subproject.tasks.findByName(taskName)) {
+                        currentBundleTask.dependsOn(subproject.tasks.named(taskName))
+                    }
+                }
+
+                // Also depend on the main build task to ensure all sub-tasks are completed
+                if (subproject.tasks.findByName("build")) {
+                    currentBundleTask.dependsOn(subproject.tasks.named("build"))
+                }
+            }
+        }
+    }
+
+    currentBundleTask.ext.generatedResFolders = files(resourcesDir).builtBy(currentBundleTask)
+    currentBundleTask.ext.generatedAssetsFolders = files(jsBundleDir).builtBy(currentBundleTask)
+    variant.registerGeneratedResFolders(currentBundleTask.generatedResFolders)
+
+    def mergeAssetsTask = variant.mergeAssetsProvider.get()
+    def mergeResourcesTask = variant.mergeResourcesProvider.get()
+
+    mergeAssetsTask.dependsOn(currentBundleTask)
+    mergeResourcesTask.dependsOn(currentBundleTask)
+
+    mergeAssetsTask.doLast {
+        def assetsDir = mergeAssetsTask.outputDir.get()
+
+        // Bundle sounds
+        //
+        copy {
+            from("${projectDir}/../../sounds")
+            include("*.wav")
+            include("*.mp3")
+            into("${assetsDir}/sounds")
+        }
+
+        // Copy React assets
+        //
+        if (currentBundleTask.enabled) {
+            copy {
+                from(jsBundleFile)
+                into(assetsDir)
+            }
+        }
+    }
+
+    mergeResourcesTask.doLast {
+        // Copy React resources
+        //
+        if (currentBundleTask.enabled) {
+            copy {
+                from(resourcesDir)
+                into(mergeResourcesTask.outputDir.get())
+            }
+        }
+    }
+}
+
+
+publishing {
+    publications {
+        aarArchive(MavenPublication) {
+            groupId 'org.jitsi.react'
+            artifactId 'jitsi-meet-sdk'
+            version System.env.OVERRIDE_SDK_VERSION ?: project.sdkVersion
+
+            artifact("${project.buildDir}/outputs/aar/${project.name}-release.aar") {
+                extension "aar"
+            }
+            pom.withXml {
+                def pomXml = asNode()
+                pomXml.appendNode('name', 'jitsi-meet-sdk')
+                pomXml.appendNode('description', 'Jitsi Meet SDK for Android')
+                def dependencies = pomXml.appendNode('dependencies')
+                configurations.getByName('releaseCompileClasspath').getResolvedConfiguration().getFirstLevelModuleDependencies().each {
+                    // The (third-party) React Native modules that we depend on
+                    // are in source code form and do not have groupId. That is
+                    // why we have a dedicated groupId for them. But the other
+                    // dependencies come through Maven and, consequently, have
+                    // groupId.
+                    def groupId = it.moduleGroup
+                    def artifactId = it.moduleName
+
+                    if (artifactId.startsWith('react-native-')) {
+                        groupId = rootProject.ext.moduleGroupId
+                    }
+
+                    def dependency = dependencies.appendNode('dependency')
+                    dependency.appendNode('groupId', groupId)
+                    dependency.appendNode('artifactId', artifactId)
+                    dependency.appendNode('version', it.moduleVersion)
+                }
+            }
+        }
+
+    }
+    repositories {
+        maven {
+            url rootProject.ext.mavenRepo
+            if (!rootProject.ext.mavenRepo.startsWith("file")) {
+                credentials {
+                    username rootProject.ext.mavenUser
+                    password rootProject.ext.mavenPassword
+                }
+            }
+        }
+    }
+}

android/sdk/src/debug/AndroidManifest.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+    <uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW"/>
+
+    <application android:usesCleartextTraffic="true">
+        <activity android:name="com.facebook.react.devsupport.DevSettingsActivity" android:exported="false"/>
+    </application>
+</manifest>

android/sdk/src/main/AndroidManifest.xml

@@ -0,0 +1,72 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools">
+    <!-- XXX ACCESS_NETWORK_STATE is required by WebRTC. -->
+    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+    <uses-permission android:name="android.permission.BLUETOOTH" />
+    <uses-permission android:name="android.permission.CAMERA" />
+    <uses-permission android:name="android.permission.INTERNET" />
+    <uses-permission android:name="android.permission.MANAGE_OWN_CALLS" />
+    <uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS" />
+    <uses-permission android:name="android.permission.RECORD_AUDIO" />
+    <uses-permission android:name="android.permission.WAKE_LOCK" />
+    <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_MICROPHONE" />
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_MEDIA_PLAYBACK" />
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_MEDIA_PROJECTION" />
+    <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
+
+    <uses-feature
+        android:glEsVersion="0x00020000"
+        android:required="true" />
+    <uses-feature
+        android:name="android.hardware.camera"
+        android:required="false" />
+    <uses-feature
+        android:name="android.hardware.camera.autofocus"
+        android:required="false" />
+
+    <application
+        android:allowBackup="true"
+        android:label="@string/app_name"
+        android:supportsRtl="true">
+        <activity
+            android:name=".JitsiMeetActivity"
+            android:configChanges="keyboard|keyboardHidden|orientation|screenLayout|screenSize|smallestScreenSize|uiMode"
+            android:launchMode="singleTask"
+            android:theme="@style/JitsiMeetActivityStyle"
+            android:resizeableActivity="true"
+            android:supportsPictureInPicture="true"
+            android:windowSoftInputMode="adjustResize"/>
+
+        <service
+            android:name=".ConnectionService"
+            android:permission="android.permission.BIND_TELECOM_CONNECTION_SERVICE"
+            android:exported="true">
+            <intent-filter>
+                <action android:name="android.telecom.ConnectionService" />
+            </intent-filter>
+        </service>
+
+        <service
+            android:name="org.jitsi.meet.sdk.JitsiMeetOngoingConferenceService"
+            android:foregroundServiceType="mediaPlayback|microphone" />
+
+        <provider
+            android:name="com.reactnativecommunity.webview.RNCWebViewFileProvider"
+            android:authorities="${applicationId}.fileprovider"
+            android:enabled="false"
+            tools:replace="android:authorities">
+        </provider>
+        <provider
+            android:name="androidx.startup.InitializationProvider"
+            android:authorities="${applicationId}.androidx-startup"
+            android:exported="false">
+            <meta-data  android:name="org.jitsi.meet.sdk.JitsiInitializer"
+                android:value="androidx.startup" />
+        </provider>
+
+    </application>
+
+</manifest>

android/sdk/src/main/java/org/jitsi/meet/sdk/AndroidSettingsModule.java

@@ -0,0 +1,56 @@
+/**
+ * Adapted from
+ * {@link https://github.com/Aleksandern/react-native-android-settings-library}.
+ */
+
+package org.jitsi.meet.sdk;
+
+import android.content.ActivityNotFoundException;
+import android.content.Context;
+import android.content.Intent;
+import android.net.Uri;
+import android.provider.Settings;
+
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.module.annotations.ReactModule;
+
+@ReactModule(name = AndroidSettingsModule.NAME)
+class AndroidSettingsModule
+    extends ReactContextBaseJavaModule {
+
+    public static final String NAME = "AndroidSettings";
+
+    public AndroidSettingsModule(ReactApplicationContext reactContext) {
+        super(reactContext);
+    }
+
+    @Override
+    public String getName() {
+        return NAME;
+    }
+
+    @ReactMethod
+    public void open(Promise promise) {
+        Context context = getReactApplicationContext();
+        Intent intent = new Intent();
+
+        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+        intent.setAction(Settings.ACTION_APPLICATION_DETAILS_SETTINGS);
+        intent.setData(
+            Uri.fromParts("package", context.getPackageName(), null));
+
+        try {
+            context.startActivity(intent);
+        } catch (ActivityNotFoundException e) {
+            // Some devices may give an error here.
+            // https://developer.android.com/reference/android/provider/Settings.html#ACTION_APPLICATION_DETAILS_SETTINGS
+            promise.reject(e);
+            return;
+        }
+
+        promise.resolve(null);
+    }
+}

android/sdk/src/main/java/org/jitsi/meet/sdk/AppInfoModule.java

@@ -0,0 +1,150 @@
+/*
+ * Copyright @ 2017-present 8x8, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jitsi.meet.sdk;
+
+import android.content.Context;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.PackageInfo;
+import android.content.pm.PackageManager;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.module.annotations.ReactModule;
+
+import java.lang.reflect.Field;
+import java.util.HashMap;
+import java.util.Map;
+
+@ReactModule(name = AppInfoModule.NAME)
+class AppInfoModule
+    extends ReactContextBaseJavaModule {
+
+    private static final String BUILD_CONFIG = "org.jitsi.meet.sdk.BuildConfig";
+    public static final String NAME = "AppInfo";
+    public static final boolean GOOGLE_SERVICES_ENABLED = getGoogleServicesEnabled();
+    public static final boolean LIBRE_BUILD = getLibreBuild();
+    public static final String SDK_VERSION = getSdkVersion();
+
+    public AppInfoModule(ReactApplicationContext reactContext) {
+        super(reactContext);
+    }
+
+    /**
+     * Gets a {@code Map} of constants this module exports to JS. Supports JSON
+     * types.
+     *
+     * @return a {@link Map} of constants this module exports to JS
+     */
+    @Override
+    public Map<String, Object> getConstants() {
+        Context context = getReactApplicationContext();
+        PackageManager packageManager = context.getPackageManager();
+        ApplicationInfo applicationInfo;
+        PackageInfo packageInfo;
+
+        try {
+             String packageName = context.getPackageName();
+
+             applicationInfo
+                 = packageManager.getApplicationInfo(packageName, 0);
+             packageInfo = packageManager.getPackageInfo(packageName, 0);
+        } catch (PackageManager.NameNotFoundException e) {
+             applicationInfo = null;
+             packageInfo = null;
+        }
+
+        Map<String, Object> constants = new HashMap<>();
+
+        constants.put(
+            "buildNumber",
+            packageInfo == null ? "" : String.valueOf(packageInfo.versionCode));
+        constants.put(
+            "name",
+            applicationInfo == null
+                ? ""
+                : packageManager.getApplicationLabel(applicationInfo));
+        constants.put(
+            "version",
+            packageInfo == null ? "" : packageInfo.versionName);
+        constants.put("sdkVersion", SDK_VERSION);
+        constants.put("LIBRE_BUILD", LIBRE_BUILD);
+        constants.put("GOOGLE_SERVICES_ENABLED", GOOGLE_SERVICES_ENABLED);
+
+        return constants;
+    }
+
+    @Override
+    public String getName() {
+        return NAME;
+    }
+
+    /**
+     * Checks if libre google services object is null based on build configuration.
+     */
+    private static boolean getGoogleServicesEnabled() {
+        Object googleServicesEnabled = getBuildConfigValue("GOOGLE_SERVICES_ENABLED");
+
+        if (googleServicesEnabled !=null) {
+            return (Boolean) googleServicesEnabled;
+        }
+
+        return false;
+    }
+
+    /**
+     * Checks if libre build field is null based on build configuration.
+     */
+    private static boolean getLibreBuild() {
+        Object libreBuild = getBuildConfigValue("LIBRE_BUILD");
+
+        if (libreBuild !=null) {
+            return (Boolean) libreBuild;
+        }
+
+        return false;
+    }
+
+    /**
+     * Gets the SDK version.
+     */
+    private static String getSdkVersion() {
+        Object sdkVersion = getBuildConfigValue("SDK_VERSION");
+
+        if (sdkVersion !=null) {
+            return (String) sdkVersion;
+        }
+
+        return "";
+    }
+
+    /**
+     * Gets build config value of a certain field.
+     *
+     * @param fieldName Field from build config.
+     */
+    private static Object getBuildConfigValue(String fieldName) {
+        try {
+            Class<?> c = Class.forName(BUILD_CONFIG);
+            Field f  = c.getDeclaredField(fieldName);
+            f.setAccessible(true);
+            return f.get(null);
+        } catch (Exception e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+}

android/sdk/src/main/java/org/jitsi/meet/sdk/AudioDeviceHandlerConnectionService.java

@@ -0,0 +1,185 @@
+/*
+ * Copyright @ 2017-present 8x8, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jitsi.meet.sdk;
+
+import android.content.Context;
+import android.media.AudioManager;
+import android.telecom.CallAudioState;
+import androidx.annotation.RequiresApi;
+
+import com.facebook.react.bridge.ReactContext;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import org.jitsi.meet.sdk.log.JitsiMeetLogger;
+
+
+/**
+ * {@link AudioModeModule.AudioDeviceHandlerInterface} module implementing device handling for
+ * Android versions >= O when ConnectionService is enabled.
+ */
+class AudioDeviceHandlerConnectionService implements
+        AudioModeModule.AudioDeviceHandlerInterface,
+        RNConnectionService.CallAudioStateListener {
+
+    private final static String TAG = AudioDeviceHandlerConnectionService.class.getSimpleName();
+
+    /**
+     * {@link AudioManager} instance used to interact with the Android audio subsystem.
+     */
+    private AudioManager audioManager;
+
+    /**
+     * Reference to the main {@code AudioModeModule}.
+     */
+    private AudioModeModule module;
+
+    private RNConnectionService rcs;
+
+    /**
+     * Converts any of the "DEVICE_" constants into the corresponding
+     * {@link android.telecom.CallAudioState} "ROUTE_" number.
+     *
+     * @param audioDevice one of the "DEVICE_" constants.
+     * @return a route number {@link android.telecom.CallAudioState#ROUTE_EARPIECE} if
+     * no match is found.
+     */
+    private static int audioDeviceToRouteInt(String audioDevice) {
+        if (audioDevice == null) {
+            return CallAudioState.ROUTE_SPEAKER;
+        }
+        switch (audioDevice) {
+            case AudioModeModule.DEVICE_BLUETOOTH:
+                return CallAudioState.ROUTE_BLUETOOTH;
+            case AudioModeModule.DEVICE_EARPIECE:
+                return CallAudioState.ROUTE_EARPIECE;
+            case AudioModeModule.DEVICE_HEADPHONES:
+                return CallAudioState.ROUTE_WIRED_HEADSET;
+            case AudioModeModule.DEVICE_SPEAKER:
+                return CallAudioState.ROUTE_SPEAKER;
+            default:
+                JitsiMeetLogger.e(TAG + " Unsupported device name: " + audioDevice);
+                return CallAudioState.ROUTE_SPEAKER;
+        }
+    }
+
+    /**
+     * Populates given route mask into the "DEVICE_" list.
+     *
+     * @param supportedRouteMask an integer coming from
+     * {@link android.telecom.CallAudioState#getSupportedRouteMask()}.
+     * @return a list of device names.
+     */
+    private static Set<String> routesToDeviceNames(int supportedRouteMask) {
+        Set<String> devices = new HashSet<>();
+        if ((supportedRouteMask & CallAudioState.ROUTE_EARPIECE) == CallAudioState.ROUTE_EARPIECE) {
+            devices.add(AudioModeModule.DEVICE_EARPIECE);
+        }
+        if ((supportedRouteMask & CallAudioState.ROUTE_BLUETOOTH) == CallAudioState.ROUTE_BLUETOOTH) {
+            devices.add(AudioModeModule.DEVICE_BLUETOOTH);
+        }
+        if ((supportedRouteMask & CallAudioState.ROUTE_SPEAKER) == CallAudioState.ROUTE_SPEAKER) {
+            devices.add(AudioModeModule.DEVICE_SPEAKER);
+        }
+        if ((supportedRouteMask & CallAudioState.ROUTE_WIRED_HEADSET) == CallAudioState.ROUTE_WIRED_HEADSET) {
+            devices.add(AudioModeModule.DEVICE_HEADPHONES);
+        }
+        return devices;
+    }
+
+    /**
+     * Used to store the most recently reported audio devices.
+     * Makes it easier to compare for a change, because the devices are stored
+     * as a mask in the {@link android.telecom.CallAudioState}. The mask is populated into
+     * the {@code availableDevices} on each update.
+     */
+    private int supportedRouteMask = -1;
+
+    public AudioDeviceHandlerConnectionService(AudioManager audioManager) {
+        this.audioManager = audioManager;
+    }
+
+    @Override
+    public void onCallAudioStateChange(final CallAudioState state) {
+        module.runInAudioThread(new Runnable() {
+            @Override
+            public void run() {
+                boolean audioRouteChanged
+                    = audioDeviceToRouteInt(module.getSelectedDevice()) != state.getRoute();
+                int newSupportedRoutes = state.getSupportedRouteMask();
+                boolean audioDevicesChanged = supportedRouteMask != newSupportedRoutes;
+                if (audioDevicesChanged) {
+                    supportedRouteMask = newSupportedRoutes;
+                    Set<String> devices = routesToDeviceNames(supportedRouteMask);
+                    module.replaceDevices(devices);
+                    JitsiMeetLogger.i(TAG + " Available audio devices: " + devices.toString());
+                }
+
+                if (audioRouteChanged || audioDevicesChanged) {
+                    module.resetSelectedDevice();
+                    module.updateAudioRoute();
+                }
+            }
+        });
+    }
+
+    @Override
+    public void start(AudioModeModule audioModeModule) {
+        JitsiMeetLogger.i("Using " + TAG + " as the audio device handler");
+
+        module = audioModeModule;
+        rcs = module.getContext().getNativeModule(RNConnectionService.class);
+
+        if (rcs != null) {
+            rcs.setCallAudioStateListener(this);
+        } else {
+            JitsiMeetLogger.w(TAG + " Couldn't set call audio state listener, module is null");
+        }
+    }
+
+    @Override
+    public void stop() {
+        if (rcs != null) {
+            rcs.setCallAudioStateListener(null);
+            rcs = null;
+        } else {
+            JitsiMeetLogger.w(TAG + " Couldn't set call audio state listener, module is null");
+        }
+    }
+
+    public void setAudioRoute(String audioDevice) {
+        int newAudioRoute = audioDeviceToRouteInt(audioDevice);
+
+        RNConnectionService.setAudioRoute(newAudioRoute);
+    }
+
+    @Override
+    public boolean setMode(int mode) {
+        if (mode != AudioModeModule.DEFAULT) {
+            // This shouldn't be needed when using ConnectionService, but some devices have been
+            // observed not doing it.
+            try {
+                audioManager.setMicrophoneMute(false);
+            } catch (Throwable tr) {
+                JitsiMeetLogger.w(tr, TAG + " Failed to unmute the microphone");
+            }
+        }
+
+        return true;
+    }
+}

android/sdk/src/main/java/org/jitsi/meet/sdk/AudioDeviceHandlerGeneric.java

@@ -0,0 +1,248 @@
+/*
+ * Copyright @ 2017-present 8x8, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jitsi.meet.sdk;
+
+import android.media.AudioAttributes;
+import android.media.AudioDeviceInfo;
+import android.media.AudioFocusRequest;
+import android.media.AudioManager;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import org.jitsi.meet.sdk.log.JitsiMeetLogger;
+
+
+/**
+ * {@link AudioModeModule.AudioDeviceHandlerInterface} module implementing device handling for
+ * all post-M Android versions. This handler can be used on any Android versions >= M, but by
+ * default it's only used on versions < O, since versions >= O use ConnectionService, but it
+ * can be disabled.
+ */
+class AudioDeviceHandlerGeneric implements
+        AudioModeModule.AudioDeviceHandlerInterface,
+        AudioManager.OnAudioFocusChangeListener {
+
+    private final static String TAG = AudioDeviceHandlerGeneric.class.getSimpleName();
+
+    /**
+     * Reference to the main {@code AudioModeModule}.
+     */
+    private AudioModeModule module;
+
+    /**
+     * Constant defining a Hearing Aid. Only available on API level >= 28.
+     * The value of: AudioDeviceInfo.TYPE_HEARING_AID
+     */
+    private static final int TYPE_HEARING_AID = 23;
+
+    /**
+     * Constant defining a USB headset. Only available on API level >= 26.
+     * The value of: AudioDeviceInfo.TYPE_USB_HEADSET
+     */
+    private static final int TYPE_USB_HEADSET = 22;
+
+    /**
+     * Indicator that we have lost audio focus.
+     */
+    private boolean audioFocusLost = false;
+
+    /**
+     * {@link AudioManager} instance used to interact with the Android audio
+     * subsystem.
+     */
+    private AudioManager audioManager;
+
+    /**
+     * {@link Runnable} for running audio device detection in the audio thread.
+     * This is only used on Android >= M.
+     */
+    private final Runnable onAudioDeviceChangeRunner = new Runnable() {
+        @Override
+        public void run() {
+            Set<String> devices = new HashSet<>();
+            AudioDeviceInfo[] deviceInfos = audioManager.getDevices(AudioManager.GET_DEVICES_ALL);
+
+            for (AudioDeviceInfo info: deviceInfos) {
+                switch (info.getType()) {
+                    case AudioDeviceInfo.TYPE_BLUETOOTH_SCO:
+                        devices.add(AudioModeModule.DEVICE_BLUETOOTH);
+                        break;
+                    case AudioDeviceInfo.TYPE_BUILTIN_EARPIECE:
+                        devices.add(AudioModeModule.DEVICE_EARPIECE);
+                        break;
+                    case AudioDeviceInfo.TYPE_BUILTIN_SPEAKER:
+                    case AudioDeviceInfo.TYPE_HDMI:
+                        devices.add(AudioModeModule.DEVICE_SPEAKER);
+                        break;
+                    case AudioDeviceInfo.TYPE_WIRED_HEADPHONES:
+                    case AudioDeviceInfo.TYPE_WIRED_HEADSET:
+                    case TYPE_HEARING_AID:
+                    case TYPE_USB_HEADSET:
+                        devices.add(AudioModeModule.DEVICE_HEADPHONES);
+                        break;
+                }
+            }
+
+            module.replaceDevices(devices);
+
+            JitsiMeetLogger.i(TAG + " Available audio devices: " + devices.toString());
+
+            module.updateAudioRoute();
+        }
+    };
+
+    private final android.media.AudioDeviceCallback audioDeviceCallback =
+        new android.media.AudioDeviceCallback() {
+            @Override
+            public void onAudioDevicesAdded(
+                AudioDeviceInfo[] addedDevices) {
+                JitsiMeetLogger.d(TAG + " Audio devices added");
+                onAudioDeviceChange();
+            }
+
+            @Override
+            public void onAudioDevicesRemoved(
+                AudioDeviceInfo[] removedDevices) {
+                JitsiMeetLogger.d(TAG + " Audio devices removed");
+                onAudioDeviceChange();
+            }
+        };
+
+    public AudioDeviceHandlerGeneric(AudioManager audioManager) {
+        this.audioManager = audioManager;
+    }
+
+    /**
+     * Helper method to trigger an audio route update when devices change. It
+     * makes sure the operation is performed on the audio thread.
+     */
+    private void onAudioDeviceChange() {
+        module.runInAudioThread(onAudioDeviceChangeRunner);
+    }
+
+    /**
+     * {@link AudioManager.OnAudioFocusChangeListener} interface method. Called
+     * when the audio focus of the system is updated.
+     *
+     * @param focusChange - The type of focus change.
+     */
+    @Override
+    public void onAudioFocusChange(final int focusChange) {
+        module.runInAudioThread(new Runnable() {
+            @Override
+            public void run() {
+                switch (focusChange) {
+                    case AudioManager.AUDIOFOCUS_GAIN: {
+                        JitsiMeetLogger.d(TAG + " Audio focus gained");
+                        // Some other application potentially stole our audio focus
+                        // temporarily. Restore our mode.
+                        if (audioFocusLost) {
+                            module.resetAudioRoute();
+                        }
+                        audioFocusLost = false;
+                        break;
+                    }
+                    case AudioManager.AUDIOFOCUS_LOSS:
+                    case AudioManager.AUDIOFOCUS_LOSS_TRANSIENT:
+                    case AudioManager.AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK: {
+                        JitsiMeetLogger.d(TAG + " Audio focus lost");
+                        audioFocusLost = true;
+                        break;
+                    }
+                }
+            }
+        });
+    }
+
+    /**
+     * Helper method to set the output route to a Bluetooth device.
+     *
+     * @param enabled true if Bluetooth should use used, false otherwise.
+     */
+    private void setBluetoothAudioRoute(boolean enabled) {
+        if (enabled) {
+            audioManager.startBluetoothSco();
+            audioManager.setBluetoothScoOn(true);
+        } else {
+            audioManager.setBluetoothScoOn(false);
+            audioManager.stopBluetoothSco();
+        }
+    }
+
+    @Override
+    public void start(AudioModeModule audioModeModule) {
+        JitsiMeetLogger.i("Using " + TAG + " as the audio device handler");
+
+        module = audioModeModule;
+
+        // Setup runtime device change detection.
+        audioManager.registerAudioDeviceCallback(audioDeviceCallback, null);
+
+        // Do an initial detection.
+        onAudioDeviceChange();
+    }
+
+    @Override
+    public void stop() {
+        audioManager.unregisterAudioDeviceCallback(audioDeviceCallback);
+    }
+
+    @Override
+    public void setAudioRoute(String device) {
+        // Turn speaker on / off
+        audioManager.setSpeakerphoneOn(device.equals(AudioModeModule.DEVICE_SPEAKER));
+
+        // Turn bluetooth on / off
+        setBluetoothAudioRoute(device.equals(AudioModeModule.DEVICE_BLUETOOTH));
+    }
+
+    @Override
+    public boolean setMode(int mode) {
+        if (mode == AudioModeModule.DEFAULT) {
+            audioFocusLost = false;
+            audioManager.setMode(AudioManager.MODE_NORMAL);
+            audioManager.abandonAudioFocus(this);
+            audioManager.setSpeakerphoneOn(false);
+            setBluetoothAudioRoute(false);
+
+            return true;
+        }
+
+        audioManager.setMode(AudioManager.MODE_IN_COMMUNICATION);
+        audioManager.setMicrophoneMute(false);
+
+        int gotFocus = audioManager.requestAudioFocus(new AudioFocusRequest.Builder(AudioManager.AUDIOFOCUS_GAIN)
+            .setAudioAttributes(
+                new AudioAttributes.Builder()
+                    .setUsage(AudioAttributes.USAGE_VOICE_COMMUNICATION)
+                    .setContentType(AudioAttributes.CONTENT_TYPE_SPEECH)
+                    .build()
+            )
+            .setAcceptsDelayedFocusGain(true)
+            .setOnAudioFocusChangeListener(this)
+            .build()
+        );
+
+        if (gotFocus == AudioManager.AUDIOFOCUS_REQUEST_FAILED) {
+            JitsiMeetLogger.w(TAG + " Audio focus request failed");
+            return false;
+        }
+
+        return true;
+    }
+}

android/sdk/src/main/java/org/jitsi/meet/sdk/AudioModeModule.java

@@ -0,0 +1,529 @@
+/*
+ * Copyright @ 2017-present 8x8, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jitsi.meet.sdk;
+
+import android.annotation.SuppressLint;
+import android.app.Activity;
+import android.content.Context;
+import android.media.AudioManager;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.WritableArray;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.module.annotations.ReactModule;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+
+
+import org.jitsi.meet.sdk.log.JitsiMeetLogger;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+/**
+ * Module implementing a simple API to select the appropriate audio device for a
+ * conference call.
+ *
+ * Audio calls should use {@code AudioModeModule.AUDIO_CALL}, which uses the
+ * builtin earpiece, wired headset or bluetooth headset. The builtin earpiece is
+ * the default audio device.
+ *
+ * Video calls should should use {@code AudioModeModule.VIDEO_CALL}, which uses
+ * the builtin speaker, earpiece, wired headset or bluetooth headset. The
+ * builtin speaker is the default audio device.
+ *
+ * Before a call has started and after it has ended the
+ * {@code AudioModeModule.DEFAULT} mode should be used.
+ */
+@ReactModule(name = AudioModeModule.NAME)
+class AudioModeModule extends ReactContextBaseJavaModule {
+    public static final String NAME = "AudioMode";
+
+    /**
+     * Constants representing the audio mode.
+     * - DEFAULT: Used before and after every call. It represents the default
+     *   audio routing scheme.
+     * - AUDIO_CALL: Used for audio only calls. It will use the earpiece by
+     *   default, unless a wired or Bluetooth headset is connected.
+     * - VIDEO_CALL: Used for video calls. It will use the speaker by default,
+     *   unless a wired or Bluetooth headset is connected.
+     */
+    static final int DEFAULT    = 0;
+    static final int AUDIO_CALL = 1;
+    static final int VIDEO_CALL = 2;
+
+    /**
+     * The {@code Log} tag {@code AudioModeModule} is to log messages with.
+     */
+    static final String TAG = NAME;
+
+    /**
+     * Whether or not the ConnectionService is used for selecting audio devices.
+     */
+    private static boolean useConnectionService_ = true;
+
+    static boolean useConnectionService() {
+        return useConnectionService_;
+    }
+
+    /**
+     * {@link AudioManager} instance used to interact with the Android audio
+     * subsystem.
+     */
+    private AudioManager audioManager;
+
+    private AudioDeviceHandlerInterface audioDeviceHandler;
+
+    /**
+     * {@link ExecutorService} for running all audio operations on a dedicated
+     * thread.
+     */
+    private static final ExecutorService executor = Executors.newSingleThreadExecutor();
+
+    /**
+     * Audio mode currently in use.
+     */
+    private int mode = -1;
+
+    /**
+     * Audio device types.
+     */
+    static final String DEVICE_BLUETOOTH  = "BLUETOOTH";
+    static final String DEVICE_EARPIECE   = "EARPIECE";
+    static final String DEVICE_HEADPHONES = "HEADPHONES";
+    static final String DEVICE_SPEAKER    = "SPEAKER";
+
+    /**
+     * Device change event.
+     */
+    private static final String DEVICE_CHANGE_EVENT = "org.jitsi.meet:features/audio-mode#devices-update";
+
+    /**
+     * List of currently available audio devices.
+     */
+    private Set<String> availableDevices = new HashSet<>();
+
+    /**
+     * Currently selected device.
+     */
+    private String selectedDevice;
+
+    /**
+     * User selected device. When null the default is used depending on the
+     * mode.
+     */
+    private String userSelectedDevice;
+
+    /**
+     * Whether or not audio is disabled.
+     */
+    private boolean audioDisabled;
+
+    /**
+     * Initializes a new module instance. There shall be a single instance of
+     * this module throughout the lifetime of the application.
+     *
+     * @param reactContext the {@link ReactApplicationContext} where this module
+     * is created.
+     */
+    public AudioModeModule(ReactApplicationContext reactContext) {
+        super(reactContext);
+
+        audioManager = (AudioManager)reactContext.getSystemService(Context.AUDIO_SERVICE);
+    }
+
+    @ReactMethod
+    public void addListener(String eventName) {
+        // Keep: Required for RN built in Event Emitter Calls.
+    }
+
+    @ReactMethod
+    public void removeListeners(Integer count) {
+        // Keep: Required for RN built in Event Emitter Calls.
+    }
+
+    /**
+     * Gets a mapping with the constants this module is exporting.
+     *
+     * @return a {@link Map} mapping the constants to be exported with their
+     * values.
+     */
+    @Override
+    public Map<String, Object> getConstants() {
+        Map<String, Object> constants = new HashMap<>();
+
+        constants.put("DEVICE_CHANGE_EVENT", DEVICE_CHANGE_EVENT);
+        constants.put("AUDIO_CALL", AUDIO_CALL);
+        constants.put("DEFAULT", DEFAULT);
+        constants.put("VIDEO_CALL", VIDEO_CALL);
+
+        return constants;
+    }
+
+    /**
+     * Notifies JS land that the devices list has changed.
+     */
+    private void notifyDevicesChanged() {
+        runInAudioThread(new Runnable() {
+            @Override
+            public void run() {
+                WritableArray data = Arguments.createArray();
+                final boolean hasHeadphones = availableDevices.contains(DEVICE_HEADPHONES);
+                for (String device : availableDevices) {
+                    if (hasHeadphones && device.equals(DEVICE_EARPIECE)) {
+                        // Skip earpiece when headphones are plugged in.
+                        continue;
+                    }
+                    WritableMap deviceInfo = Arguments.createMap();
+                    deviceInfo.putString("type", device);
+                    deviceInfo.putBoolean("selected", device.equals(selectedDevice));
+                    data.pushMap(deviceInfo);
+                }
+                getContext().getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class).emit(DEVICE_CHANGE_EVENT, data);
+                JitsiMeetLogger.i(TAG + " Updating audio device list");
+            }
+        });
+    }
+
+    /**
+     * Gets the name for this module to be used in the React Native bridge.
+     *
+     * @return a string with the module name.
+     */
+    @Override
+    public String getName() {
+        return NAME;
+    }
+
+    public ReactContext getContext(){
+        return this.getReactApplicationContext();
+    }
+
+    /**
+     * Initializes the audio device handler module. This function is called *after* all Catalyst
+     * modules have been created, and that's why we use it, because {@link AudioDeviceHandlerConnectionService}
+     * needs access to another Catalyst module, so doing this in the constructor would be too early.
+     */
+    @Override
+    public void initialize() {
+        runInAudioThread(new Runnable() {
+            @Override
+            public void run() {
+                setAudioDeviceHandler();
+            }
+        });
+    }
+
+    private void setAudioDeviceHandler() {
+        if (audioDeviceHandler != null) {
+            audioDeviceHandler.stop();
+        }
+
+        audioDeviceHandler = null;
+
+        if (audioDisabled) {
+            return;
+        }
+
+        if (useConnectionService()) {
+            audioDeviceHandler = new AudioDeviceHandlerConnectionService(audioManager);
+        } else {
+            audioDeviceHandler = new AudioDeviceHandlerGeneric(audioManager);
+        }
+
+        audioDeviceHandler.start(this);
+    }
+
+    /**
+     * Helper function to run operations on a dedicated thread.
+     * @param runnable
+     */
+    void runInAudioThread(Runnable runnable) {
+        executor.execute(runnable);
+    }
+
+    /**
+     * Sets the user selected audio device as the active audio device.
+     *
+     * @param device the desired device which will become active.
+     */
+    @ReactMethod
+    public void setAudioDevice(final String device) {
+        runInAudioThread(new Runnable() {
+            @Override
+            public void run() {
+                if (!availableDevices.contains(device)) {
+                    JitsiMeetLogger.w(TAG + " Audio device not available: " + device);
+                    userSelectedDevice = null;
+                    return;
+                }
+
+                if (mode != -1) {
+                    JitsiMeetLogger.i(TAG + " User selected device set to: " + device);
+                    userSelectedDevice = device;
+                    updateAudioRoute(mode, false);
+                }
+            }
+        });
+    }
+
+    @ReactMethod
+    public void setDisabled(final boolean disabled, final Promise promise) {
+        if (audioDisabled == disabled) {
+            promise.resolve(null);
+            return;
+        }
+
+        JitsiMeetLogger.i(TAG + "  audio disabled: " + disabled);
+
+        audioDisabled = disabled;
+        setAudioDeviceHandler();
+
+        if (disabled) {
+            mode = -1;
+            availableDevices.clear();
+            resetSelectedDevice();
+        }
+
+        promise.resolve(null);
+    }
+
+    /**
+     * Public method to set the current audio mode.
+     *
+     * @param mode the desired audio mode.
+     * @param promise a {@link Promise} which will be resolved if the audio mode
+     * could be updated successfully, and it will be rejected otherwise.
+     */
+    @ReactMethod
+    public void setMode(final int mode, final Promise promise) {
+        if (audioDisabled) {
+            promise.resolve(null);
+            return;
+        }
+
+        if (mode < DEFAULT || mode > VIDEO_CALL) {
+            promise.reject("setMode", "Invalid audio mode " + mode);
+            return;
+        }
+
+        Activity currentActivity = getCurrentActivity();
+        if (currentActivity != null) {
+            if (mode == DEFAULT) {
+                currentActivity.setVolumeControlStream(AudioManager.USE_DEFAULT_STREAM_TYPE);
+            } else {
+                currentActivity.setVolumeControlStream(AudioManager.STREAM_VOICE_CALL);
+            }
+        }
+
+        runInAudioThread(new Runnable() {
+            @Override
+            public void run() {
+                boolean success;
+
+                try {
+                    success = updateAudioRoute(mode, false);
+                } catch (Throwable e) {
+                    success = false;
+                    JitsiMeetLogger.e(e, TAG + " Failed to update audio route for mode: " + mode);
+                }
+                if (success) {
+                    AudioModeModule.this.mode = mode;
+                    promise.resolve(null);
+                } else {
+                    promise.reject("setMode", "Failed to set audio mode to " + mode);
+                }
+            }
+        });
+    }
+
+    /**
+     * Sets whether ConnectionService should be used (if available) for setting the audio mode
+     * or not.
+     *
+     * @param use Boolean indicator of where it should be used or not.
+     */
+    @ReactMethod
+    public void setUseConnectionService(final boolean use) {
+        runInAudioThread(new Runnable() {
+            @Override
+            public void run() {
+                useConnectionService_ = use;
+                setAudioDeviceHandler();
+            }
+        });
+    }
+
+    /**
+     * Updates the audio route for the given mode.
+     *
+     * @param mode the audio mode to be used when computing the audio route.
+     * @return {@code true} if the audio route was updated successfully;
+     * {@code false}, otherwise.
+     */
+    private boolean updateAudioRoute(int mode, boolean force) {
+        JitsiMeetLogger.i(TAG + " Update audio route for mode: " + mode);
+
+        if (!audioDeviceHandler.setMode(mode)) {
+            return false;
+        }
+
+        if (mode == DEFAULT) {
+            selectedDevice = null;
+            userSelectedDevice = null;
+
+            notifyDevicesChanged();
+            return true;
+        }
+
+        boolean bluetoothAvailable = availableDevices.contains(DEVICE_BLUETOOTH);
+        boolean headsetAvailable = availableDevices.contains(DEVICE_HEADPHONES);
+
+        // Pick the desired device based on what's available and the mode.
+        String audioDevice;
+        if (bluetoothAvailable) {
+            audioDevice = DEVICE_BLUETOOTH;
+        } else if (headsetAvailable) {
+            audioDevice = DEVICE_HEADPHONES;
+        } else {
+            audioDevice = DEVICE_SPEAKER;
+        }
+
+        // Consider the user's selection
+        if (userSelectedDevice != null && availableDevices.contains(userSelectedDevice)) {
+            audioDevice = userSelectedDevice;
+        }
+
+        // If the previously selected device and the current default one
+        // match, do nothing.
+        if (!force && selectedDevice != null && selectedDevice.equals(audioDevice)) {
+            return true;
+        }
+
+        selectedDevice = audioDevice;
+        JitsiMeetLogger.i(TAG + " Selected audio device: " + audioDevice);
+
+        audioDeviceHandler.setAudioRoute(audioDevice);
+
+        notifyDevicesChanged();
+        return true;
+    }
+
+    /**
+     * Gets the currently selected audio device.
+     *
+     * @return The selected audio device.
+     */
+    String getSelectedDevice() {
+        return selectedDevice;
+    }
+
+    /**
+     * Resets the current device selection.
+     */
+    void resetSelectedDevice() {
+        selectedDevice = null;
+        userSelectedDevice = null;
+    }
+
+    /**
+     * Adds a new device to the list of available devices.
+     *
+     * @param device The new device.
+     */
+    void addDevice(String device) {
+        availableDevices.add(device);
+        resetSelectedDevice();
+    }
+
+    /**
+     * Removes a device from the list of available devices.
+     *
+     * @param device The old device to the removed.
+     */
+    void removeDevice(String device) {
+        availableDevices.remove(device);
+        resetSelectedDevice();
+    }
+
+    /**
+     * Replaces the current list of available devices with a new one.
+     *
+     * @param devices The new devices list.
+     */
+    void replaceDevices(Set<String> devices) {
+        availableDevices = devices;
+        resetSelectedDevice();
+    }
+
+    /**
+     * Re-sets the current audio route. Needed when devices changes have happened.
+     */
+    void updateAudioRoute() {
+        if (mode != -1) {
+            updateAudioRoute(mode, false);
+        }
+    }
+
+    /**
+     * Re-sets the current audio route. Needed when focus is lost and regained.
+     */
+    void resetAudioRoute() {
+        if (mode != -1) {
+            updateAudioRoute(mode, true);
+        }
+    }
+
+    /**
+     * Interface for the modules implementing the actual audio device management.
+     */
+    interface AudioDeviceHandlerInterface {
+        /**
+         * Start detecting audio device changes.
+         * @param audioModeModule Reference to the main {@link AudioModeModule}.
+         */
+        void start(AudioModeModule audioModeModule);
+
+        /**
+         * Stop audio device detection.
+         */
+        void stop();
+
+        /**
+         * Set the appropriate route for the given audio device.
+         *
+         * @param device Audio device for which the route must be set.
+         */
+        void setAudioRoute(String device);
+
+        /**
+         * Set the given audio mode.
+         *
+         * @param mode The new audio mode to be used.
+         * @return Whether the operation was successful or not.
+         */
+        boolean setMode(int mode);
+    }
+}

android/sdk/src/main/java/org/jitsi/meet/sdk/BroadcastAction.java

@@ -0,0 +1,66 @@
+package org.jitsi.meet.sdk;
+
+import android.content.Intent;
+import android.os.Bundle;
+
+/**
+ * Wraps the name and extra data for events that were broadcasted locally.
+ */
+public class BroadcastAction {
+    private static final String TAG = BroadcastAction.class.getSimpleName();
+
+    private final Type type;
+    private final Bundle data;
+
+    public BroadcastAction(Intent intent) {
+        this.type = Type.buildTypeFromAction(intent.getAction());
+        this.data = intent.getExtras();
+    }
+
+    public Type getType() {
+        return this.type;
+    }
+
+    public Bundle getData() {
+        return this.data;
+    }
+
+    enum Type {
+        SET_AUDIO_MUTED("org.jitsi.meet.SET_AUDIO_MUTED"),
+        HANG_UP("org.jitsi.meet.HANG_UP"),
+        SEND_ENDPOINT_TEXT_MESSAGE("org.jitsi.meet.SEND_ENDPOINT_TEXT_MESSAGE"),
+        TOGGLE_SCREEN_SHARE("org.jitsi.meet.TOGGLE_SCREEN_SHARE"),
+        RETRIEVE_PARTICIPANTS_INFO("org.jitsi.meet.RETRIEVE_PARTICIPANTS_INFO"),
+        OPEN_CHAT("org.jitsi.meet.OPEN_CHAT"),
+        CLOSE_CHAT("org.jitsi.meet.CLOSE_CHAT"),
+        SEND_CHAT_MESSAGE("org.jitsi.meet.SEND_CHAT_MESSAGE"),
+        SET_VIDEO_MUTED("org.jitsi.meet.SET_VIDEO_MUTED"),
+        SET_CLOSED_CAPTIONS_ENABLED("org.jitsi.meet.SET_CLOSED_CAPTIONS_ENABLED"),
+        TOGGLE_CAMERA("org.jitsi.meet.TOGGLE_CAMERA"),
+        SHOW_NOTIFICATION("org.jitsi.meet.SHOW_NOTIFICATION"),
+        HIDE_NOTIFICATION("org.jitsi.meet.HIDE_NOTIFICATION"),
+        START_RECORDING("org.jitsi.meet.START_RECORDING"),
+        STOP_RECORDING("org.jitsi.meet.STOP_RECORDING"),
+        OVERWRITE_CONFIG("org.jitsi.meet.OVERWRITE_CONFIG"),
+        SEND_CAMERA_FACING_MODE_MESSAGE("org.jitsi.meet.SEND_CAMERA_FACING_MODE_MESSAGE");
+
+        private final String action;
+
+        Type(String action) {
+            this.action = action;
+        }
+
+        public String getAction() {
+            return action;
+        }
+
+        private static Type buildTypeFromAction(String action) {
+            for (Type type : Type.values()) {
+                if (type.action.equalsIgnoreCase(action)) {
+                    return type;
+                }
+            }
+            return null;
+        }
+    }
+}

android/sdk/src/main/java/org/jitsi/meet/sdk/BroadcastEmitter.java

@@ -0,0 +1,30 @@
+package org.jitsi.meet.sdk;
+
+import android.content.Context;
+import android.content.Intent;
+
+import androidx.localbroadcastmanager.content.LocalBroadcastManager;
+
+import com.facebook.react.bridge.ReadableMap;
+
+/**
+ * Class used to emit events through the LocalBroadcastManager, called when events
+ * from JS occurred. Takes an action name from JS, builds and broadcasts the {@link BroadcastEvent}
+ */
+public class BroadcastEmitter {
+    private final LocalBroadcastManager localBroadcastManager;
+
+    public BroadcastEmitter(Context context) {
+        localBroadcastManager = LocalBroadcastManager.getInstance(context);
+    }
+
+    public void sendBroadcast(String name, ReadableMap data) {
+        BroadcastEvent event = new BroadcastEvent(name, data);
+
+        Intent intent = event.buildIntent();
+
+        if (intent != null) {
+            localBroadcastManager.sendBroadcast(intent);
+        }
+    }
+}

android/sdk/src/main/java/org/jitsi/meet/sdk/BroadcastEvent.java

@@ -0,0 +1,182 @@
+package org.jitsi.meet.sdk;
+
+import android.content.Intent;
+import android.os.Bundle;
+
+import com.facebook.react.bridge.ReadableMap;
+
+import org.jitsi.meet.sdk.log.JitsiMeetLogger;
+
+import java.util.HashMap;
+
+/**
+ * Wraps the name and extra data for the events that occur on the JS side and are
+ * to be broadcasted.
+ */
+public class BroadcastEvent {
+
+    private static final String TAG = BroadcastEvent.class.getSimpleName();
+
+    private final Type type;
+    private final HashMap<String, Object> data;
+
+    public BroadcastEvent(String name, ReadableMap data) {
+        this.type = Type.buildTypeFromName(name);
+        this.data = data.toHashMap();
+    }
+
+    public BroadcastEvent(Intent intent) {
+        this.type = Type.buildTypeFromAction(intent.getAction());
+        this.data = buildDataFromBundle(intent.getExtras());
+    }
+
+    public Type getType() {
+        return this.type;
+    }
+
+    public HashMap<String, Object> getData() {
+        return this.data;
+    }
+
+    public Intent buildIntent() {
+        if (type != null && type.action != null) {
+            Intent intent = new Intent(type.action);
+
+            for (String key : this.data.keySet()) {
+                try {
+                    intent.putExtra(key, this.data.get(key).toString());
+                } catch (Exception e) {
+                    JitsiMeetLogger.w(TAG + " invalid extra data in event", e);
+                }
+            }
+
+            return intent;
+        }
+
+        return null;
+    }
+
+    private static HashMap<String, Object> buildDataFromBundle(Bundle bundle) {
+        if (bundle != null) {
+            try {
+                HashMap<String, Object> map = new HashMap<>();
+
+                for (String key : bundle.keySet()) {
+                    map.put(key, bundle.get(key));
+                }
+
+                return map;
+            } catch (Exception e) {
+                JitsiMeetLogger.w(TAG + " invalid extra data", e);
+            }
+        }
+
+        return null;
+    }
+
+    public enum Type {
+        CONFERENCE_BLURRED("org.jitsi.meet.CONFERENCE_BLURRED"),
+        CONFERENCE_FOCUSED("org.jitsi.meet.CONFERENCE_FOCUSED"),
+        CONFERENCE_JOINED("org.jitsi.meet.CONFERENCE_JOINED"),
+        CONFERENCE_TERMINATED("org.jitsi.meet.CONFERENCE_TERMINATED"),
+        CONFERENCE_WILL_JOIN("org.jitsi.meet.CONFERENCE_WILL_JOIN"),
+        AUDIO_MUTED_CHANGED("org.jitsi.meet.AUDIO_MUTED_CHANGED"),
+        PARTICIPANT_JOINED("org.jitsi.meet.PARTICIPANT_JOINED"),
+        PARTICIPANT_LEFT("org.jitsi.meet.PARTICIPANT_LEFT"),
+        ENDPOINT_TEXT_MESSAGE_RECEIVED("org.jitsi.meet.ENDPOINT_TEXT_MESSAGE_RECEIVED"),
+        SCREEN_SHARE_TOGGLED("org.jitsi.meet.SCREEN_SHARE_TOGGLED"),
+        PARTICIPANTS_INFO_RETRIEVED("org.jitsi.meet.PARTICIPANTS_INFO_RETRIEVED"),
+        CHAT_MESSAGE_RECEIVED("org.jitsi.meet.CHAT_MESSAGE_RECEIVED"),
+        CHAT_TOGGLED("org.jitsi.meet.CHAT_TOGGLED"),
+        VIDEO_MUTED_CHANGED("org.jitsi.meet.VIDEO_MUTED_CHANGED"),
+        READY_TO_CLOSE("org.jitsi.meet.READY_TO_CLOSE"),
+        TRANSCRIPTION_CHUNK_RECEIVED("org.jitsi.meet.TRANSCRIPTION_CHUNK_RECEIVED"),
+        CUSTOM_BUTTON_PRESSED("org.jitsi.meet.CUSTOM_BUTTON_PRESSED"),
+        CONFERENCE_UNIQUE_ID_SET("org.jitsi.meet.CONFERENCE_UNIQUE_ID_SET"),
+        RECORDING_STATUS_CHANGED("org.jitsi.meet.RECORDING_STATUS_CHANGED");
+
+        private static final String CONFERENCE_BLURRED_NAME = "CONFERENCE_BLURRED";
+        private static final String CONFERENCE_FOCUSED_NAME = "CONFERENCE_FOCUSED";
+        private static final String CONFERENCE_WILL_JOIN_NAME = "CONFERENCE_WILL_JOIN";
+        private static final String CONFERENCE_JOINED_NAME = "CONFERENCE_JOINED";
+        private static final String CONFERENCE_TERMINATED_NAME = "CONFERENCE_TERMINATED";
+        private static final String AUDIO_MUTED_CHANGED_NAME = "AUDIO_MUTED_CHANGED";
+        private static final String PARTICIPANT_JOINED_NAME = "PARTICIPANT_JOINED";
+        private static final String PARTICIPANT_LEFT_NAME = "PARTICIPANT_LEFT";
+        private static final String ENDPOINT_TEXT_MESSAGE_RECEIVED_NAME = "ENDPOINT_TEXT_MESSAGE_RECEIVED";
+        private static final String SCREEN_SHARE_TOGGLED_NAME = "SCREEN_SHARE_TOGGLED";
+        private static final String PARTICIPANTS_INFO_RETRIEVED_NAME = "PARTICIPANTS_INFO_RETRIEVED";
+        private static final String CHAT_MESSAGE_RECEIVED_NAME = "CHAT_MESSAGE_RECEIVED";
+        private static final String CHAT_TOGGLED_NAME = "CHAT_TOGGLED";
+        private static final String VIDEO_MUTED_CHANGED_NAME = "VIDEO_MUTED_CHANGED";
+        private static final String READY_TO_CLOSE_NAME = "READY_TO_CLOSE";
+        private static final String TRANSCRIPTION_CHUNK_RECEIVED_NAME = "TRANSCRIPTION_CHUNK_RECEIVED";
+        private static final String CUSTOM_BUTTON_PRESSED_NAME = "CUSTOM_BUTTON_PRESSED";
+        private static final String CONFERENCE_UNIQUE_ID_SET_NAME = "CONFERENCE_UNIQUE_ID_SET";
+        private static final String RECORDING_STATUS_CHANGED_NAME = "RECORDING_STATUS_CHANGED";
+
+        private final String action;
+
+        Type(String action) {
+            this.action = action;
+        }
+
+        public String getAction() {
+            return action;
+        }
+
+        private static Type buildTypeFromAction(String action) {
+            for (Type type : Type.values()) {
+                if (type.action.equalsIgnoreCase(action)) {
+                    return type;
+                }
+            }
+            return null;
+        }
+
+        private static Type buildTypeFromName(String name) {
+            switch (name) {
+                case CONFERENCE_BLURRED_NAME:
+                    return CONFERENCE_BLURRED;
+                case CONFERENCE_FOCUSED_NAME:
+                    return CONFERENCE_FOCUSED;
+                case CONFERENCE_WILL_JOIN_NAME:
+                    return CONFERENCE_WILL_JOIN;
+                case CONFERENCE_JOINED_NAME:
+                    return CONFERENCE_JOINED;
+                case CONFERENCE_TERMINATED_NAME:
+                    return CONFERENCE_TERMINATED;
+                case AUDIO_MUTED_CHANGED_NAME:
+                    return AUDIO_MUTED_CHANGED;
+                case PARTICIPANT_JOINED_NAME:
+                    return PARTICIPANT_JOINED;
+                case PARTICIPANT_LEFT_NAME:
+                    return PARTICIPANT_LEFT;
+                case ENDPOINT_TEXT_MESSAGE_RECEIVED_NAME:
+                    return ENDPOINT_TEXT_MESSAGE_RECEIVED;
+                case SCREEN_SHARE_TOGGLED_NAME:
+                    return SCREEN_SHARE_TOGGLED;
+                case PARTICIPANTS_INFO_RETRIEVED_NAME:
+                    return PARTICIPANTS_INFO_RETRIEVED;
+                case CHAT_MESSAGE_RECEIVED_NAME:
+                    return CHAT_MESSAGE_RECEIVED;
+                case CHAT_TOGGLED_NAME:
+                    return CHAT_TOGGLED;
+                case VIDEO_MUTED_CHANGED_NAME:
+                    return VIDEO_MUTED_CHANGED;
+                case READY_TO_CLOSE_NAME:
+                    return READY_TO_CLOSE;
+                case TRANSCRIPTION_CHUNK_RECEIVED_NAME:
+                    return TRANSCRIPTION_CHUNK_RECEIVED;
+                case CUSTOM_BUTTON_PRESSED_NAME:
+                    return CUSTOM_BUTTON_PRESSED;
+                case CONFERENCE_UNIQUE_ID_SET_NAME:
+                    return CONFERENCE_UNIQUE_ID_SET;
+                case RECORDING_STATUS_CHANGED_NAME:
+                    return RECORDING_STATUS_CHANGED;
+            }
+
+            return null;
+        }
+    }
+}

android/sdk/src/main/java/org/jitsi/meet/sdk/BroadcastIntentHelper.java

@@ -0,0 +1,157 @@
+package org.jitsi.meet.sdk;
+
+import android.content.Intent;
+import android.os.Bundle;
+
+public class BroadcastIntentHelper {
+    public static Intent buildSetAudioMutedIntent(boolean muted) {
+        Intent intent = new Intent(BroadcastAction.Type.SET_AUDIO_MUTED.getAction());
+        intent.putExtra("muted", muted);
+
+        return intent;
+    }
+
+    public static Intent buildHangUpIntent() {
+        return new Intent(BroadcastAction.Type.HANG_UP.getAction());
+    }
+
+    public static Intent buildSendEndpointTextMessageIntent(String to, String message) {
+        Intent intent = new Intent(BroadcastAction.Type.SEND_ENDPOINT_TEXT_MESSAGE.getAction());
+        intent.putExtra("to", to);
+        intent.putExtra("message", message);
+
+        return intent;
+    }
+
+    public static Intent buildToggleScreenShareIntent(boolean enabled) {
+        Intent intent = new Intent(BroadcastAction.Type.TOGGLE_SCREEN_SHARE.getAction());
+        intent.putExtra("enabled", enabled);
+
+        return intent;
+    }
+
+    public static Intent buildOpenChatIntent(String participantId) {
+        Intent intent = new Intent(BroadcastAction.Type.OPEN_CHAT.getAction());
+        intent.putExtra("to", participantId);
+
+        return intent;
+    }
+
+    public static Intent buildCloseChatIntent() {
+        return new Intent(BroadcastAction.Type.CLOSE_CHAT.getAction());
+    }
+
+    public static Intent buildSendChatMessageIntent(String participantId, String message) {
+        Intent intent = new Intent(BroadcastAction.Type.SEND_CHAT_MESSAGE.getAction());
+        intent.putExtra("to", participantId);
+        intent.putExtra("message", message);
+
+        return intent;
+    }
+
+    public static Intent buildSetVideoMutedIntent(boolean muted) {
+        Intent intent = new Intent(BroadcastAction.Type.SET_VIDEO_MUTED.getAction());
+        intent.putExtra("muted", muted);
+
+        return intent;
+    }
+
+    public static Intent buildSetClosedCaptionsEnabledIntent(boolean enabled) {
+        Intent intent = new Intent(BroadcastAction.Type.SET_CLOSED_CAPTIONS_ENABLED.getAction());
+        intent.putExtra("enabled", enabled);
+
+        return intent;
+    }
+
+    public static Intent buildRetrieveParticipantsInfo(String requestId) {
+        Intent intent = new Intent(BroadcastAction.Type.RETRIEVE_PARTICIPANTS_INFO.getAction());
+        intent.putExtra("requestId", requestId);
+
+        return intent;
+    }
+
+    public static Intent buildToggleCameraIntent() {
+        return new Intent(BroadcastAction.Type.TOGGLE_CAMERA.getAction());
+    }
+
+    public static Intent buildShowNotificationIntent(
+        String appearance, String description, String timeout, String title, String uid) {
+        Intent intent = new Intent(BroadcastAction.Type.SHOW_NOTIFICATION.getAction());
+        intent.putExtra("appearance", appearance);
+        intent.putExtra("description", description);
+        intent.putExtra("timeout", timeout);
+        intent.putExtra("title", title);
+        intent.putExtra("uid", uid);
+
+        return intent;
+    }
+
+    public static Intent buildHideNotificationIntent(String uid) {
+        Intent intent = new Intent(BroadcastAction.Type.HIDE_NOTIFICATION.getAction());
+        intent.putExtra("uid", uid);
+
+        return intent;
+    }
+
+    public enum RecordingMode {
+        FILE("file"),
+        STREAM("stream");
+
+        private final String mode;
+
+        RecordingMode(String mode) {
+            this.mode = mode;
+        }
+
+        public String getMode() {
+            return mode;
+        }
+    }
+
+    public static Intent buildStartRecordingIntent(
+        RecordingMode mode,
+        String dropboxToken,
+        boolean shouldShare,
+        String rtmpStreamKey,
+        String rtmpBroadcastID,
+        String youtubeStreamKey,
+        String youtubeBroadcastID,
+        Bundle extraMetadata,
+        boolean transcription) {
+        Intent intent = new Intent(BroadcastAction.Type.START_RECORDING.getAction());
+        intent.putExtra("mode", mode.getMode());
+        intent.putExtra("dropboxToken", dropboxToken);
+        intent.putExtra("shouldShare", shouldShare);
+        intent.putExtra("rtmpStreamKey", rtmpStreamKey);
+        intent.putExtra("rtmpBroadcastID", rtmpBroadcastID);
+        intent.putExtra("youtubeStreamKey", youtubeStreamKey);
+        intent.putExtra("youtubeBroadcastID", youtubeBroadcastID);
+        intent.putExtra("extraMetadata", extraMetadata);
+        intent.putExtra("transcription", transcription);
+
+        return intent;
+    }
+
+    public static Intent buildStopRecordingIntent(RecordingMode mode, boolean transcription) {
+        Intent intent = new Intent(BroadcastAction.Type.STOP_RECORDING.getAction());
+        intent.putExtra("mode", mode.getMode());
+        intent.putExtra("transcription", transcription);
+
+        return intent;
+    }
+
+    public static Intent buildOverwriteConfigIntent(Bundle config) {
+        Intent intent = new Intent(BroadcastAction.Type.OVERWRITE_CONFIG.getAction());
+        intent.putExtra("config", config);
+
+        return intent;
+    }
+
+    public static Intent buildSendCameraFacingModeMessageIntent(String to, String facingMode) {
+        Intent intent = new Intent(BroadcastAction.Type.SEND_CAMERA_FACING_MODE_MESSAGE.getAction());
+        intent.putExtra("to", to);
+        intent.putExtra("facingMode", facingMode);
+
+        return intent;
+    }
+}

android/sdk/src/main/java/org/jitsi/meet/sdk/BroadcastReceiver.java

@@ -0,0 +1,44 @@
+package org.jitsi.meet.sdk;
+
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.os.Bundle;
+
+import com.facebook.react.bridge.Arguments;
+
+import androidx.localbroadcastmanager.content.LocalBroadcastManager;
+
+/**
+ * Listens for {@link BroadcastAction}s on LocalBroadcastManager. When one occurs,
+ * it emits it to JS.
+ */
+public class BroadcastReceiver extends android.content.BroadcastReceiver {
+
+    public BroadcastReceiver(Context context) {
+        LocalBroadcastManager localBroadcastManager = LocalBroadcastManager.getInstance(context);
+
+        IntentFilter intentFilter = new IntentFilter();
+
+        for (BroadcastAction.Type type : BroadcastAction.Type.values()) {
+            intentFilter.addAction(type.getAction());
+        }
+
+        localBroadcastManager.registerReceiver(this, intentFilter);
+    }
+
+    @Override
+    public void onReceive(Context context, Intent intent) {
+        BroadcastAction action = new BroadcastAction(intent);
+        String actionName = action.getType().getAction();
+        Bundle data = action.getData();
+            
+        // For actions without data bundle (like hangup), we create an empty map
+        // instead of attempting to convert a null bundle to avoid crashes.
+        if (data != null) {
+            ReactInstanceManagerHolder.emitEvent(actionName, Arguments.fromBundle(data));
+        } else {
+            ReactInstanceManagerHolder.emitEvent(actionName, Arguments.createMap());
+        }
+    }
+}

android/sdk/src/main/java/org/jitsi/meet/sdk/ConnectionService.java

@@ -0,0 +1,452 @@
+package org.jitsi.meet.sdk;
+
+import android.content.ComponentName;
+import android.content.Context;
+import android.net.Uri;
+import android.os.Build;
+import android.os.Bundle;
+import android.telecom.CallAudioState;
+import android.telecom.Connection;
+import android.telecom.ConnectionRequest;
+import android.telecom.DisconnectCause;
+import android.telecom.PhoneAccount;
+import android.telecom.PhoneAccountHandle;
+import android.telecom.TelecomManager;
+import android.telecom.VideoProfile;
+
+import androidx.annotation.RequiresApi;
+
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableNativeMap;
+
+import org.jitsi.meet.sdk.log.JitsiMeetLogger;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+
+/**
+ * Jitsi Meet implementation of {@link ConnectionService}. At the time of this
+ * writing it implements only the outgoing call scenario.
+ *
+ * NOTE the class needs to be public, but is not part of the SDK API and should
+ * never be used directly.
+ *
+ * @author Pawel Domas
+ */
+public class ConnectionService extends android.telecom.ConnectionService {
+
+    /**
+     * Tag used for logging.
+     */
+    static final String TAG = "JitsiConnectionService";
+
+    /**
+     * The extra added to the {@link ConnectionImpl} and
+     * {@link ConnectionRequest} which stores the {@link PhoneAccountHandle}
+     * created for the call.
+     */
+    static final String EXTRA_PHONE_ACCOUNT_HANDLE
+        = "org.jitsi.meet.sdk.connection_service.PHONE_ACCOUNT_HANDLE";
+
+    /**
+     * Connections mapped by call UUID.
+     */
+    static private final Map<String, ConnectionImpl> connections
+            = new HashMap<>();
+
+    /**
+     * The start call Promises mapped by call UUID.
+     */
+    static private final HashMap<String, Promise> startCallPromises
+            = new HashMap<>();
+
+    /**
+     * Aborts all ongoing connections. This is a last resort mechanism which forces all resources to
+     * be freed on the system in case of fatal error.
+     */
+    static void abortConnections() {
+        for (ConnectionImpl connection: getConnections()) {
+            connection.onAbort();
+        }
+    }
+
+    /**
+     * Adds {@link ConnectionImpl} to the list.
+     *
+     * @param connection - {@link ConnectionImpl}
+     */
+    static void addConnection(ConnectionImpl connection) {
+        connections.put(connection.getCallUUID(), connection);
+    }
+
+    /**
+     * Returns all {@link ConnectionImpl} instances held in this list.
+     *
+     * @return a list of {@link ConnectionImpl}.
+     */
+    static List<ConnectionImpl> getConnections() {
+        return new ArrayList<>(connections.values());
+    }
+
+    /**
+     * @return {@code true} if running a Samsung device.
+     */
+    static boolean isSamsungDevice() {
+        return android.os.Build.MANUFACTURER.toLowerCase().contains("samsung");
+    }
+
+    /**
+     * Registers a start call promise.
+     *
+     * @param uuid - the call UUID to which the start call promise belongs to.
+     * @param promise - the Promise instance to be stored for later use.
+     */
+    static void registerStartCallPromise(String uuid, Promise promise) {
+        startCallPromises.put(uuid, promise);
+    }
+
+    /**
+     * Removes {@link ConnectionImpl} from the list.
+     *
+     * @param connection - {@link ConnectionImpl}
+     */
+    static void removeConnection(ConnectionImpl connection) {
+        connections.remove(connection.getCallUUID());
+    }
+
+    /**
+     * Used to adjusts the connection's state to
+     * {@link android.telecom.Connection#STATE_ACTIVE}.
+     *
+     * @param callUUID the call UUID which identifies the connection.
+     * @return Whether the connection was set as active or not.
+     */
+    static boolean setConnectionActive(String callUUID) {
+        ConnectionImpl connection = connections.get(callUUID);
+
+        if (connection != null) {
+            connection.setActive();
+            return true;
+        } else {
+            JitsiMeetLogger.w("%s setConnectionActive - no connection for UUID: %s", TAG, callUUID);
+            return false;
+        }
+    }
+
+    /**
+     * Used to adjusts the connection's state to
+     * {@link android.telecom.Connection#STATE_DISCONNECTED}.
+     *
+     * @param callUUID the call UUID which identifies the connection.
+     * @param cause disconnection reason.
+     */
+    static void setConnectionDisconnected(String callUUID, DisconnectCause cause) {
+        ConnectionImpl connection = connections.get(callUUID);
+
+        if (connection != null) {
+            if (isSamsungDevice()) {
+                // Required to release the audio focus correctly.
+                connection.setOnHold();
+                // Prevents from including in the native phone calls history
+                connection.setConnectionProperties(
+                    Connection.PROPERTY_SELF_MANAGED
+                        | Connection.PROPERTY_IS_EXTERNAL_CALL);
+            }
+            // Note that the connection is not removed from the list here, but
+            // in ConnectionImpl's state changed callback. It's a safer
+            // approach, because in case the app would crash on the JavaScript
+            // side the calls would be cleaned up by the system they would still
+            // be removed from the ConnectionList.
+            connection.setDisconnected(cause);
+            connection.destroy();
+        } else {
+            JitsiMeetLogger.e(TAG + " endCall no connection for UUID: " + callUUID);
+        }
+    }
+
+    /**
+     * Unregisters a start call promise. Must be called after the Promise is
+     * rejected or resolved.
+     *
+     * @param uuid the call UUID which identifies the call to which the promise
+     *        belongs to.
+     * @return the unregistered Promise instance or <tt>null</tt> if there
+     *         wasn't any for the given call UUID.
+     */
+    static Promise unregisterStartCallPromise(String uuid) {
+        return startCallPromises.remove(uuid);
+    }
+
+    /**
+     * Used to adjusts the call's state.
+     *
+     * @param callUUID the call UUID which identifies the connection.
+     * @param callState a map which carries the properties to be modified. See
+     *        "KEY_*" constants in {@link ConnectionImpl} for the list of keys.
+     */
+    static void updateCall(String callUUID, ReadableMap callState) {
+        ConnectionImpl connection = connections.get(callUUID);
+
+        if (connection != null) {
+            if (callState.hasKey(ConnectionImpl.KEY_HAS_VIDEO)) {
+                boolean hasVideo
+                        = callState.getBoolean(ConnectionImpl.KEY_HAS_VIDEO);
+
+                JitsiMeetLogger.i(" %s updateCall: %s hasVideo: %s", TAG, callUUID, hasVideo);
+                connection.setVideoState(
+                        hasVideo
+                                ? VideoProfile.STATE_BIDIRECTIONAL
+                                : VideoProfile.STATE_AUDIO_ONLY);
+            }
+        } else {
+            JitsiMeetLogger.e(TAG + " updateCall no connection for UUID: " + callUUID);
+        }
+    }
+
+    @Override
+    public Connection onCreateOutgoingConnection(
+            PhoneAccountHandle accountHandle, ConnectionRequest request) {
+        ConnectionImpl connection = new ConnectionImpl();
+
+        connection.setConnectionProperties(Connection.PROPERTY_SELF_MANAGED);
+        connection.setAddress(
+            request.getAddress(),
+            TelecomManager.PRESENTATION_UNKNOWN);
+        connection.setExtras(request.getExtras());
+
+        connection.setAudioModeIsVoip(true);
+
+        // NOTE there's a time gap between the placeCall and this callback when
+        // things could get out of sync, but they are put back in sync once
+        // the startCall Promise is resolved below. That's because on
+        // the JavaScript side there's a logic to sync up in .then() callback.
+        connection.setVideoState(request.getVideoState());
+
+        Bundle moreExtras = new Bundle();
+
+        moreExtras.putParcelable(
+            EXTRA_PHONE_ACCOUNT_HANDLE,
+            Objects.requireNonNull(request.getAccountHandle(), "accountHandle"));
+        connection.putExtras(moreExtras);
+
+        addConnection(connection);
+
+        Promise startCallPromise
+            = unregisterStartCallPromise(connection.getCallUUID());
+
+        if (startCallPromise != null) {
+            JitsiMeetLogger.d(TAG + " onCreateOutgoingConnection " + connection.getCallUUID());
+            startCallPromise.resolve(null);
+        } else {
+            JitsiMeetLogger.e(
+                TAG + " onCreateOutgoingConnection: no start call Promise for " + connection.getCallUUID());
+        }
+
+        return connection;
+    }
+
+    @Override
+    public Connection onCreateIncomingConnection(
+            PhoneAccountHandle accountHandle, ConnectionRequest request) {
+        throw new RuntimeException("Not implemented");
+    }
+
+    @Override
+    public void onCreateIncomingConnectionFailed(
+            PhoneAccountHandle accountHandle, ConnectionRequest request) {
+        throw new RuntimeException("Not implemented");
+    }
+
+    @Override
+    public void onCreateOutgoingConnectionFailed(
+            PhoneAccountHandle accountHandle, ConnectionRequest request) {
+        PhoneAccountHandle theAccountHandle = request.getAccountHandle();
+        String callUUID = theAccountHandle.getId();
+
+        JitsiMeetLogger.e(TAG + " onCreateOutgoingConnectionFailed " + callUUID);
+
+        if (callUUID != null) {
+            Promise startCallPromise = unregisterStartCallPromise(callUUID);
+
+            if (startCallPromise != null) {
+                startCallPromise.reject(
+                        "CREATE_OUTGOING_CALL_FAILED",
+                        "The request has been denied by the system");
+            } else {
+                JitsiMeetLogger.e(TAG + " startCallFailed - no start call Promise for UUID: " + callUUID);
+            }
+        } else {
+            JitsiMeetLogger.e(TAG + " onCreateOutgoingConnectionFailed - no call UUID");
+        }
+
+        unregisterPhoneAccount(theAccountHandle);
+    }
+
+    private void unregisterPhoneAccount(PhoneAccountHandle phoneAccountHandle) {
+        TelecomManager telecom = getSystemService(TelecomManager.class);
+        if (telecom != null) {
+            if (phoneAccountHandle != null) {
+                telecom.unregisterPhoneAccount(phoneAccountHandle);
+            } else {
+                JitsiMeetLogger.e(TAG + " unregisterPhoneAccount - account handle is null");
+            }
+        } else {
+            JitsiMeetLogger.e(TAG + " unregisterPhoneAccount - telecom is null");
+        }
+    }
+
+    /**
+     * Registers new {@link PhoneAccountHandle}.
+     *
+     * @param context the current Android context.
+     * @param address the phone account's address. At the time of this writing
+     *        it's the call handle passed from the Java Script side.
+     * @param callUUID the call's UUID for which the account is to be created.
+     *        It will be used as the account's id.
+     * @return {@link PhoneAccountHandle} described by the given arguments.
+     */
+    static PhoneAccountHandle registerPhoneAccount(
+            Context context, Uri address, String callUUID) {
+        PhoneAccountHandle phoneAccountHandle
+            = new PhoneAccountHandle(
+                    new ComponentName(context, ConnectionService.class),
+                    callUUID);
+
+        PhoneAccount.Builder builder
+            = PhoneAccount.builder(phoneAccountHandle, address.toString())
+                .setAddress(address)
+                .setCapabilities(PhoneAccount.CAPABILITY_SELF_MANAGED |
+                        PhoneAccount.CAPABILITY_VIDEO_CALLING |
+                        PhoneAccount.CAPABILITY_SUPPORTS_VIDEO_CALLING)
+                .addSupportedUriScheme(PhoneAccount.SCHEME_SIP);
+
+        PhoneAccount account = builder.build();
+
+        TelecomManager telecomManager
+            = context.getSystemService(TelecomManager.class);
+        telecomManager.registerPhoneAccount(account);
+
+        return phoneAccountHandle;
+    }
+
+    /**
+     * Connection implementation for Jitsi Meet's {@link ConnectionService}.
+     *
+     * @author Pawel Domas
+     */
+    class ConnectionImpl extends Connection {
+
+        /**
+         * The constant which defines the key for the "has video" property.
+         * The key is used in the map which carries the call's state passed as
+         * the argument of the {@link RNConnectionService#updateCall} method.
+         */
+        static final String KEY_HAS_VIDEO = "hasVideo";
+
+        /**
+         * Called when system wants to disconnect the call.
+         *
+         * {@inheritDoc}
+         */
+        @Override
+        public void onDisconnect() {
+            JitsiMeetLogger.i(TAG + " onDisconnect " + getCallUUID());
+            WritableNativeMap data = new WritableNativeMap();
+            data.putString("callUUID", getCallUUID());
+            RNConnectionService.getInstance().emitEvent(
+                    "org.jitsi.meet:features/connection_service#disconnect",
+                    data);
+            // The JavaScript side will not go back to the native with
+            // 'endCall', so the Connection must be removed immediately.
+            setConnectionDisconnected(
+                    getCallUUID(),
+                    new DisconnectCause(DisconnectCause.LOCAL));
+        }
+
+        /**
+         * Called when system wants to abort the call.
+         *
+         * {@inheritDoc}
+         */
+        @Override
+        public void onAbort() {
+            JitsiMeetLogger.i(TAG + " onAbort " + getCallUUID());
+            WritableNativeMap data = new WritableNativeMap();
+            data.putString("callUUID", getCallUUID());
+            RNConnectionService.getInstance().emitEvent(
+                    "org.jitsi.meet:features/connection_service#abort",
+                    data);
+            // The JavaScript side will not go back to the native with
+            // 'endCall', so the Connection must be removed immediately.
+            setConnectionDisconnected(
+                    getCallUUID(),
+                    new DisconnectCause(DisconnectCause.CANCELED));
+        }
+
+        @Override
+        public void onHold() {
+            // What ?! Android will still call this method even if we do not add
+            // the HOLD capability, so do the same thing as on abort.
+            // TODO implement HOLD
+            JitsiMeetLogger.w(TAG + " onHold %s - HOLD is not supported, aborting the call...", getCallUUID());
+            this.onAbort();
+        }
+
+        /**
+         * Called when there's change to the call audio state. Either by
+         * the system after the connection is initialized or in response to
+         * {@link #setAudioRoute(int)}.
+         *
+         * @param state the new {@link CallAudioState}
+         */
+        @Override
+        public void onCallAudioStateChanged(CallAudioState state) {
+            JitsiMeetLogger.d(TAG + " onCallAudioStateChanged: " + state);
+            RNConnectionService module = RNConnectionService.getInstance();
+            if (module != null) {
+                module.onCallAudioStateChange(state);
+            }
+        }
+
+        /**
+         * Unregisters the account when the call is disconnected.
+         *
+         * @param state - the new connection's state.
+         */
+        @Override
+        public void onStateChanged(int state) {
+            JitsiMeetLogger.d(
+                "%s onStateChanged: %s %s", TAG, Connection.stateToString(state), getCallUUID());
+
+            if (state == STATE_DISCONNECTED) {
+                removeConnection(this);
+                unregisterPhoneAccount(getPhoneAccountHandle());
+            }
+        }
+
+        /**
+         * Retrieves the UUID of the call associated with this connection.
+         *
+         * @return call UUID
+         */
+        String getCallUUID() {
+            return getPhoneAccountHandle().getId();
+        }
+
+        private PhoneAccountHandle getPhoneAccountHandle() {
+            return getExtras().getParcelable(
+                    ConnectionService.EXTRA_PHONE_ACCOUNT_HANDLE);
+        }
+
+        @Override
+        public String toString() {
+            return String.format(
+                    "ConnectionImpl[address=%s, uuid=%s]@%d",
+                    getAddress(), getCallUUID(), hashCode());
+        }
+    }
+}

android/sdk/src/main/java/org/jitsi/meet/sdk/DefaultHardwareBackBtnHandlerImpl.java

@@ -0,0 +1,65 @@
+/*
+ * Copyright @ 2019-present 8x8, Inc.
+ * Copyright @ 2017-2018 Atlassian Pty Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jitsi.meet.sdk;
+
+import android.app.Activity;
+
+import com.facebook.react.modules.core.DefaultHardwareBackBtnHandler;
+
+/**
+ * Defines the default behavior of {@code JitsiMeetFragment} and
+ * {@code JitsiMeetView} upon invoking the back button if no
+ * {@code JitsiMeetView} handles the invocation. For example, a
+ * {@code JitsiMeetView} may (1) handle the invocation of the back button
+ * during a conference by leaving the conference and (2) not handle the
+ * invocation when not in a conference.
+ */
+class DefaultHardwareBackBtnHandlerImpl implements DefaultHardwareBackBtnHandler {
+
+    /**
+     * The {@code Activity} to which the default handling of the back button
+     * is being provided by this instance.
+     */
+    private final Activity activity;
+
+    /**
+     * Initializes a new {@code DefaultHardwareBackBtnHandlerImpl} instance to
+     * provide the default handling of the back button to a specific
+     * {@code Activity}.
+     *
+     * @param activity the {@code Activity} to which the new instance is to
+     * provide the default behavior of the back button
+     */
+    public DefaultHardwareBackBtnHandlerImpl(Activity activity) {
+        this.activity = activity;
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * Finishes the associated {@code Activity}.
+     */
+    @Override
+    public void invokeDefaultOnBackPressed() {
+        // Technically, we'd like to invoke Activity#onBackPressed().
+        // Practically, it's not possible. Fortunately, the documentation of
+        // Activity#onBackPressed() specifies that "[t]he default implementation
+        // simply finishes the current activity,"
+        activity.finish();
+    }
+}

android/sdk/src/main/java/org/jitsi/meet/sdk/DropboxModule.java

@@ -0,0 +1,204 @@
+package org.jitsi.meet.sdk;
+
+import android.content.Context;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.PackageInfo;
+import android.content.pm.PackageManager;
+import android.text.TextUtils;
+
+import com.dropbox.core.DbxException;
+import com.dropbox.core.DbxRequestConfig;
+import com.dropbox.core.android.Auth;
+import com.dropbox.core.oauth.DbxCredential;
+import com.dropbox.core.v2.DbxClientV2;
+import com.dropbox.core.v2.users.FullAccount;
+import com.dropbox.core.v2.users.SpaceAllocation;
+import com.dropbox.core.v2.users.SpaceUsage;
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.LifecycleEventListener;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.module.annotations.ReactModule;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Implements the react-native module for the dropbox integration.
+ */
+@ReactModule(name = DropboxModule.NAME)
+class DropboxModule
+        extends ReactContextBaseJavaModule
+        implements LifecycleEventListener {
+
+    public static final String NAME = "Dropbox";
+
+    private String appKey;
+
+    private String clientId;
+
+    private final boolean isEnabled;
+
+    private Promise promise;
+
+    public DropboxModule(ReactApplicationContext reactContext) {
+        super(reactContext);
+
+        String pkg = reactContext.getApplicationContext().getPackageName();
+        int resId = reactContext.getResources()
+            .getIdentifier("dropbox_app_key", "string", pkg);
+        appKey
+            = reactContext.getString(resId);
+        isEnabled = !TextUtils.isEmpty(appKey);
+
+        clientId = generateClientId();
+
+        reactContext.addLifecycleEventListener(this);
+    }
+
+    /**
+     * Executes the dropbox auth flow.
+     *
+     * @param promise The promise used to return the result of the auth flow.
+     */
+    @ReactMethod
+    public void authorize(final Promise promise) {
+        if (isEnabled) {
+            Auth.startOAuth2PKCE(this.getCurrentActivity(), appKey, DbxRequestConfig.newBuilder(clientId).build());
+            this.promise = promise;
+        } else {
+            promise.reject(
+                new Exception("Dropbox integration isn't configured."));
+        }
+    }
+
+    /**
+     * Generate a client identifier for the dropbox sdk.
+     *
+     * @returns a client identifier for the dropbox sdk.
+     * @see {https://dropbox.github.io/dropbox-sdk-java/api-docs/v3.0.x/com/dropbox/core/DbxRequestConfig.html#getClientIdentifier--}
+     */
+    private String generateClientId() {
+        Context context = getReactApplicationContext();
+        PackageManager packageManager = context.getPackageManager();
+        ApplicationInfo applicationInfo = null;
+        PackageInfo packageInfo = null;
+
+        try {
+            String packageName = context.getPackageName();
+
+            applicationInfo = packageManager.getApplicationInfo(packageName, 0);
+            packageInfo = packageManager.getPackageInfo(packageName, 0);
+        } catch (PackageManager.NameNotFoundException e) {
+        }
+
+        String applicationLabel
+            = applicationInfo == null
+                ? "JitsiMeet"
+                : packageManager.getApplicationLabel(applicationInfo).toString()
+                    .replaceAll("\\s", "");
+        String version = packageInfo == null ? "dev" : packageInfo.versionName;
+
+        return applicationLabel + "/" + version;
+    }
+
+    @Override
+    public Map<String, Object> getConstants() {
+        Map<String, Object> constants = new HashMap<>();
+
+        constants.put("ENABLED", isEnabled);
+
+        return constants;
+    }
+
+    /**
+     * Resolves the current user dropbox display name.
+     *
+     * @param token A dropbox access token.
+     * @param promise The promise used to return the result of the auth flow.
+     */
+    @ReactMethod
+    public void getDisplayName(final String token, final Promise promise) {
+        DbxRequestConfig config = DbxRequestConfig.newBuilder(clientId).build();
+        DbxClientV2 client = new DbxClientV2(config, token);
+
+        // Get current account info
+        try {
+            FullAccount account = client.users().getCurrentAccount();
+
+            promise.resolve(account.getName().getDisplayName());
+        } catch (DbxException e) {
+            promise.reject(e);
+        }
+    }
+
+    @Override
+    public String getName() {
+        return NAME;
+    }
+
+    /**
+     * Resolves the current user space usage.
+     *
+     * @param token A dropbox access token.
+     * @param promise The promise used to return the result of the auth flow.
+     */
+    @ReactMethod
+    public void getSpaceUsage(final String token, final Promise promise) {
+        DbxRequestConfig config = DbxRequestConfig.newBuilder(clientId).build();
+        DbxClientV2 client = new DbxClientV2(config, token);
+
+        try {
+            SpaceUsage spaceUsage = client.users().getSpaceUsage();
+            WritableMap map = Arguments.createMap();
+
+            map.putString("used", String.valueOf(spaceUsage.getUsed()));
+
+            SpaceAllocation allocation = spaceUsage.getAllocation();
+            long allocated = 0;
+
+            if (allocation.isIndividual()) {
+                allocated += allocation.getIndividualValue().getAllocated();
+            }
+            if (allocation.isTeam()) {
+                allocated += allocation.getTeamValue().getAllocated();
+            }
+            map.putString("allocated", String.valueOf(allocated));
+
+            promise.resolve(map);
+        } catch (DbxException e) {
+            promise.reject(e);
+        }
+    }
+
+    @Override
+    public void onHostDestroy() {}
+
+    @Override
+    public void onHostPause() {}
+
+    @Override
+    public void onHostResume() {
+        DbxCredential credential = Auth.getDbxCredential();
+
+        if (this.promise != null ) {
+            if (credential != null) {
+                WritableMap result = Arguments.createMap();
+                result.putString("token", credential.getAccessToken());
+                result.putString("rToken", credential.getRefreshToken());
+                result.putDouble("expireDate", credential.getExpiresAt());
+
+                this.promise.resolve(result);
+                this.promise = null;
+            } else {
+                this.promise.reject("Invalid dropbox credentials");
+            }
+
+            this.promise = null;
+        }
+
+    }
+}

android/sdk/src/main/java/org/jitsi/meet/sdk/ExternalAPIModule.java

@@ -0,0 +1,126 @@
+/*
+ * Copyright @ 2017-present 8x8, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jitsi.meet.sdk;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.module.annotations.ReactModule;
+
+import org.jitsi.meet.sdk.log.JitsiMeetLogger;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Module implementing an API for sending events from JavaScript to native code.
+ */
+@ReactModule(name = ExternalAPIModule.NAME)
+class ExternalAPIModule extends ReactContextBaseJavaModule {
+
+    public static final String NAME = "ExternalAPI";
+
+    private static final String TAG = NAME;
+
+    private final BroadcastEmitter broadcastEmitter;
+    private final BroadcastReceiver broadcastReceiver;
+
+    /**
+     * Initializes a new module instance. There shall be a single instance of
+     * this module throughout the lifetime of the app.
+     *
+     * @param reactContext the {@link ReactApplicationContext} where this module
+     * is created.
+     */
+    public ExternalAPIModule(ReactApplicationContext reactContext) {
+        super(reactContext);
+
+        broadcastEmitter = new BroadcastEmitter(reactContext);
+        broadcastReceiver = new BroadcastReceiver(reactContext);
+
+        ParticipantsService.init(reactContext);
+    }
+
+    @ReactMethod
+    public void addListener(String eventName) {
+        // Keep: Required for RN built in Event Emitter Calls.
+    }
+
+    @ReactMethod
+    public void removeListeners(Integer count) {
+        // Keep: Required for RN built in Event Emitter Calls.
+    }
+
+    /**
+     * Gets the name of this module to be used in the React Native bridge.
+     *
+     * @return The name of this module to be used in the React Native bridge.
+     */
+    @Override
+    public String getName() {
+        return NAME;
+    }
+
+    /**
+     * Gets a mapping with the constants this module is exporting.
+     *
+     * @return a {@link Map} mapping the constants to be exported with their
+     * values.
+     */
+    @Override
+    public Map<String, Object> getConstants() {
+        Map<String, Object> constants = new HashMap<>();
+
+        constants.put("SET_AUDIO_MUTED", BroadcastAction.Type.SET_AUDIO_MUTED.getAction());
+        constants.put("HANG_UP", BroadcastAction.Type.HANG_UP.getAction());
+        constants.put("SEND_ENDPOINT_TEXT_MESSAGE", BroadcastAction.Type.SEND_ENDPOINT_TEXT_MESSAGE.getAction());
+        constants.put("TOGGLE_SCREEN_SHARE", BroadcastAction.Type.TOGGLE_SCREEN_SHARE.getAction());
+        constants.put("RETRIEVE_PARTICIPANTS_INFO", BroadcastAction.Type.RETRIEVE_PARTICIPANTS_INFO.getAction());
+        constants.put("OPEN_CHAT", BroadcastAction.Type.OPEN_CHAT.getAction());
+        constants.put("CLOSE_CHAT", BroadcastAction.Type.CLOSE_CHAT.getAction());
+        constants.put("SEND_CHAT_MESSAGE", BroadcastAction.Type.SEND_CHAT_MESSAGE.getAction());
+        constants.put("SET_VIDEO_MUTED", BroadcastAction.Type.SET_VIDEO_MUTED.getAction());
+        constants.put("SET_CLOSED_CAPTIONS_ENABLED", BroadcastAction.Type.SET_CLOSED_CAPTIONS_ENABLED.getAction());
+        constants.put("TOGGLE_CAMERA", BroadcastAction.Type.TOGGLE_CAMERA.getAction());
+        constants.put("SHOW_NOTIFICATION", BroadcastAction.Type.SHOW_NOTIFICATION.getAction());
+        constants.put("HIDE_NOTIFICATION", BroadcastAction.Type.HIDE_NOTIFICATION.getAction());
+        constants.put("START_RECORDING", BroadcastAction.Type.START_RECORDING.getAction());
+        constants.put("STOP_RECORDING", BroadcastAction.Type.STOP_RECORDING.getAction());
+        constants.put("OVERWRITE_CONFIG", BroadcastAction.Type.OVERWRITE_CONFIG.getAction());
+        constants.put("SEND_CAMERA_FACING_MODE_MESSAGE", BroadcastAction.Type.SEND_CAMERA_FACING_MODE_MESSAGE.getAction());
+
+        return constants;
+    }
+
+    /**
+     * Dispatches an event that occurred on the JavaScript side of the SDK to
+     * the native side.
+     *
+     * @param name The name of the event.
+     * @param data The details/specifics of the event to send determined
+     * by/associated with the specified {@code name}.
+     */
+    @ReactMethod
+    public void sendEvent(String name, ReadableMap data) {
+        // Keep track of the current ongoing conference.
+        OngoingConferenceTracker.getInstance().onExternalAPIEvent(name, data);
+
+        JitsiMeetLogger.d(TAG + " Sending event: " + name + " with data: " + data);
+        broadcastEmitter.sendBroadcast(name, data);
+    }
+}

android/sdk/src/main/java/org/jitsi/meet/sdk/JavaScriptSandboxModule.java

@@ -0,0 +1,57 @@
+/*
+ * Copyright @ 2019-present 8x8, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jitsi.meet.sdk;
+
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.module.annotations.ReactModule;
+import com.squareup.duktape.Duktape;
+
+@ReactModule(name = JavaScriptSandboxModule.NAME)
+class JavaScriptSandboxModule extends ReactContextBaseJavaModule {
+    public static final String NAME = "JavaScriptSandbox";
+
+    public JavaScriptSandboxModule(ReactApplicationContext reactContext) {
+        super(reactContext);
+    }
+
+    /**
+     * Evaluates the given code in a Duktape VM.
+     * @param code - The code that needs to evaluated.
+     * @param promise - Resolved with the output in case of success or rejected with an exception
+     *                in case of failure.
+     */
+    @ReactMethod
+    public void evaluate(String code, Promise promise) {
+        Duktape vm = Duktape.create();
+        try {
+            Object res = vm.evaluate(code);
+            promise.resolve(res.toString());
+        } catch (Throwable tr) {
+            promise.reject(tr);
+        } finally {
+            vm.close();
+        }
+    }
+
+    @Override
+    public String getName() {
+        return NAME;
+    }
+}

android/sdk/src/main/java/org/jitsi/meet/sdk/JitsiInitializer.java

@@ -0,0 +1,64 @@
+/*
+ * Copyright @ 2021-present 8x8, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.jitsi.meet.sdk;
+
+import android.app.Application;
+import android.content.Context;
+import android.util.Log;
+
+import androidx.annotation.NonNull;
+import androidx.startup.Initializer;
+
+import com.facebook.soloader.SoLoader;
+import com.facebook.react.soloader.OpenSourceMergedSoMapping;
+import org.wonday.orientation.OrientationActivityLifecycle;
+
+import java.io.IOException;
+import java.util.Collections;
+import java.util.List;
+
+public class JitsiInitializer implements Initializer<Boolean> {
+
+    @NonNull
+    @Override
+    public Boolean create(@NonNull Context context) {
+        Log.d(this.getClass().getCanonicalName(), "create");
+
+        try {
+            SoLoader.init(context, OpenSourceMergedSoMapping.INSTANCE);
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+
+        // Register our uncaught exception handler.
+        JitsiMeetUncaughtExceptionHandler.register();
+
+        // Register activity lifecycle handler for the orientation locker module.
+        ((Application) context).registerActivityLifecycleCallbacks(OrientationActivityLifecycle.getInstance());
+
+        // Initialize ReactInstanceManager during application startup
+        // This ensures it's ready before any Activity onCreate is called
+        ReactInstanceManagerHolder.initReactInstanceManager((Application) context);
+
+        return true;
+    }
+
+    @NonNull
+    @Override
+    public List<Class<? extends Initializer<?>>> dependencies() {
+        return Collections.emptyList();
+    }
+}

android/sdk/src/main/java/org/jitsi/meet/sdk/JitsiMeet.java

@@ -0,0 +1,100 @@
+/*
+ * Copyright @ 2017-present 8x8, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.jitsi.meet.sdk;
+
+import android.app.Activity;
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.os.Bundle;
+
+import com.facebook.react.ReactInstanceManager;
+
+import com.splashview.SplashView;
+import org.jitsi.meet.sdk.log.JitsiMeetLogger;
+
+public class JitsiMeet {
+
+    /**
+     * Default {@link JitsiMeetConferenceOptions} which will be used for all conferences. When
+     * joining a conference these options will be merged with the ones passed to
+     * {@link JitsiMeetView} join().
+     */
+    private static JitsiMeetConferenceOptions defaultConferenceOptions;
+
+    public static JitsiMeetConferenceOptions getDefaultConferenceOptions() {
+        return defaultConferenceOptions;
+    }
+
+    public static void setDefaultConferenceOptions(JitsiMeetConferenceOptions options) {
+        if (options != null && options.getRoom() != null) {
+            throw new RuntimeException("'room' must be null in the default conference options");
+        }
+        defaultConferenceOptions = options;
+    }
+
+    /**
+     * Returns the current conference URL as a string.
+     *
+     * @return the current conference URL.
+     */
+    public static String getCurrentConference() {
+        return OngoingConferenceTracker.getInstance().getCurrentConference();
+    }
+
+    /**
+     * Helper to get the default conference options as a {@link Bundle}.
+     *
+     * @return a {@link Bundle} with the default conference options.
+     */
+    static Bundle getDefaultProps() {
+        if (defaultConferenceOptions != null) {
+            return defaultConferenceOptions.asProps();
+        }
+
+        return new Bundle();
+    }
+
+    /**
+     * Used in development mode. It displays the React Native development menu.
+     */
+    public static void showDevOptions() {
+        ReactInstanceManager reactInstanceManager
+            = ReactInstanceManagerHolder.getReactInstanceManager();
+
+        if (reactInstanceManager != null) {
+            reactInstanceManager.showDevOptionsDialog();
+        }
+    }
+
+    public static boolean isCrashReportingDisabled(Context context) {
+        SharedPreferences preferences = context.getSharedPreferences("jitsi-default-preferences", Context.MODE_PRIVATE);
+        String value = preferences.getString("isCrashReportingDisabled", "");
+        return Boolean.parseBoolean(value);
+    }
+
+    /**
+     * Helper method to show the SplashScreen.
+     *
+     * @param activity - The activity on which to show the SplashScreen {@link Activity}.
+     */
+    public static void showSplashScreen(Activity activity) {
+        try {
+            SplashView.INSTANCE.showSplashView(activity);
+        } catch (Exception e) {
+            JitsiMeetLogger.e(e, "Failed to show splash screen");
+        }
+    }
+}

android/sdk/src/main/java/org/jitsi/meet/sdk/JitsiMeetActivity.java

@@ -0,0 +1,417 @@
+/*
+ * Copyright @ 2019-present 8x8, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jitsi.meet.sdk;
+
+import android.annotation.SuppressLint;
+import android.app.Activity;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.content.res.Configuration;
+import android.net.Uri;
+import android.os.Bundle;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.Window;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.appcompat.app.AppCompatActivity;
+import androidx.core.view.ViewCompat;
+import androidx.core.view.WindowInsetsCompat;
+import androidx.localbroadcastmanager.content.LocalBroadcastManager;
+
+import com.facebook.react.modules.core.PermissionListener;
+
+import org.jitsi.meet.sdk.log.JitsiMeetLogger;
+
+import java.util.HashMap;
+
+/**
+ * A base activity for SDK users to embed.  It contains all the required wiring
+ * between the {@code JitsiMeetView} and the Activity lifecycle methods.
+ *
+ * In this activity we use a single {@code JitsiMeetView} instance. This
+ * instance gives us access to a view which displays the welcome page and the
+ * conference itself. All lifecycle methods associated with this Activity are
+ * hooked to the React Native subsystem via proxy calls through the
+ * {@code JitsiMeetActivityDelegate} static methods.
+ */
+public class JitsiMeetActivity extends AppCompatActivity
+    implements JitsiMeetActivityInterface {
+
+    protected static final String TAG = JitsiMeetActivity.class.getSimpleName();
+
+    private static final String ACTION_JITSI_MEET_CONFERENCE = "org.jitsi.meet.CONFERENCE";
+    private static final String JITSI_MEET_CONFERENCE_OPTIONS = "JitsiMeetConferenceOptions";
+
+    private boolean isReadyToClose;
+
+    private final BroadcastReceiver broadcastReceiver = new BroadcastReceiver() {
+        @Override
+        public void onReceive(Context context, Intent intent) {
+            onBroadcastReceived(intent);
+        }
+    };
+
+    /**
+     * Instance of the {@link JitsiMeetView} which this activity will display.
+     */
+    private JitsiMeetView jitsiView;
+
+    // Helpers for starting the activity
+    //
+
+    public static void launch(Context context, JitsiMeetConferenceOptions options) {
+        Intent intent = new Intent(context, JitsiMeetActivity.class);
+        intent.setAction(ACTION_JITSI_MEET_CONFERENCE);
+        intent.putExtra(JITSI_MEET_CONFERENCE_OPTIONS, options);
+        if (!(context instanceof Activity)) {
+            intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+        }
+        context.startActivity(intent);
+    }
+
+    public static void launch(Context context, String url) {
+        JitsiMeetConferenceOptions options
+            = new JitsiMeetConferenceOptions.Builder().setRoom(url).build();
+        launch(context, options);
+    }
+
+    public static void addTopBottomInsets(@NonNull Window w, @NonNull View v) {
+        if (android.os.Build.VERSION.SDK_INT < android.os.Build.VERSION_CODES.VANILLA_ICE_CREAM) return;
+
+        View decorView = w.getDecorView();
+
+        decorView.post(() -> {
+            WindowInsetsCompat insets = ViewCompat.getRootWindowInsets(decorView);
+            if (insets != null) {
+                ViewGroup.MarginLayoutParams params = (ViewGroup.MarginLayoutParams) v.getLayoutParams();
+                params.topMargin = insets.getInsets(WindowInsetsCompat.Type.systemBars()).top;
+                params.bottomMargin = insets.getInsets(WindowInsetsCompat.Type.systemBars()).bottom;
+                v.setLayoutParams(params);
+
+                decorView.setOnApplyWindowInsetsListener((view, windowInsets) -> {
+                    view.setBackgroundColor(JitsiMeetView.BACKGROUND_COLOR);
+
+                    return windowInsets;
+                });
+            }
+        });
+    }
+
+    // Overrides
+    //
+
+    @Override
+    public void onConfigurationChanged(Configuration newConfig) {
+        super.onConfigurationChanged(newConfig);
+        Intent intent = new Intent("onConfigurationChanged");
+        intent.putExtra("newConfig", newConfig);
+        this.sendBroadcast(intent);
+    }
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        // ReactInstanceManager is now initialized by JitsiInitializer during application startup
+        // Just call onHostResume since the manager is already ready
+        JitsiMeetActivityDelegate.onHostResume(this);
+
+        setContentView(R.layout.activity_jitsi_meet);
+        addTopBottomInsets(getWindow(),findViewById(android.R.id.content));
+        this.jitsiView = findViewById(R.id.jitsiView);
+
+        registerForBroadcastMessages();
+
+        if (!extraInitialize()) {
+            initialize();
+        }
+    }
+
+    @Override
+    public void onResume() {
+        super.onResume();
+        JitsiMeetActivityDelegate.onHostResume(this);
+    }
+
+    @Override
+    public void onStop() {
+        JitsiMeetActivityDelegate.onHostPause(this);
+        super.onStop();
+    }
+
+    @Override
+    public void onDestroy() {
+        JitsiMeetLogger.i("onDestroy()");
+
+        // Here we are trying to handle the following corner case: an application using the SDK
+        // is using this Activity for displaying meetings, but there is another "main" Activity
+        // with other content. If this Activity is "swiped out" from the recent list we will get
+        // Activity#onDestroy() called without warning. At this point we can try to leave the
+        // current meeting, but when our view is detached from React the JS <-> Native bridge won't
+        // be operational so the external API won't be able to notify the native side that the
+        // conference terminated. Thus, try our best to clean up.
+        if (!isReadyToClose) {
+            JitsiMeetLogger.i("onDestroy(): leaving...");
+            leave();
+        }
+
+        this.jitsiView = null;
+
+        if (AudioModeModule.useConnectionService()) {
+            ConnectionService.abortConnections();
+        }
+        JitsiMeetOngoingConferenceService.abort(this);
+
+        LocalBroadcastManager.getInstance(this).unregisterReceiver(broadcastReceiver);
+
+        JitsiMeetActivityDelegate.onHostDestroy(this);
+
+        super.onDestroy();
+    }
+
+    @Override
+    public void finish() {
+        if (!isReadyToClose) {
+            JitsiMeetLogger.i("finish(): leaving...");
+            leave();
+        }
+
+        JitsiMeetLogger.i("finish(): finishing...");
+        super.finish();
+    }
+
+    // Helper methods
+    //
+
+    protected JitsiMeetView getJitsiView() {
+        return jitsiView;
+    }
+
+    public void join(@Nullable String url) {
+        JitsiMeetConferenceOptions options
+            = new JitsiMeetConferenceOptions.Builder()
+            .setRoom(url)
+            .build();
+        join(options);
+    }
+
+    public void join(JitsiMeetConferenceOptions options) {
+        if (this.jitsiView != null) {
+            this.jitsiView.join(options);
+        } else {
+            JitsiMeetLogger.w("Cannot join, view is null");
+        }
+    }
+
+    protected void leave() {
+        if (this.jitsiView != null) {
+            this.jitsiView.abort();
+        } else {
+            JitsiMeetLogger.w("Cannot leave, view is null");
+        }
+    }
+
+    private @Nullable
+    JitsiMeetConferenceOptions getConferenceOptions(Intent intent) {
+        String action = intent.getAction();
+
+        if (Intent.ACTION_VIEW.equals(action)) {
+            Uri uri = intent.getData();
+            if (uri != null) {
+                return new JitsiMeetConferenceOptions.Builder().setRoom(uri.toString()).build();
+            }
+        } else if (ACTION_JITSI_MEET_CONFERENCE.equals(action)) {
+            return intent.getParcelableExtra(JITSI_MEET_CONFERENCE_OPTIONS);
+        }
+
+        return null;
+    }
+
+    /**
+     * Helper function called during activity initialization. If {@code true} is returned, the
+     * initialization is delayed and the {@link JitsiMeetActivity#initialize()} method is not
+     * called. In this case, it's up to the subclass to call the initialize method when ready.
+     * <p>
+     * This is mainly required so we do some extra initialization in the Jitsi Meet app.
+     *
+     * @return {@code true} if the initialization will be delayed, {@code false} otherwise.
+     */
+    protected boolean extraInitialize() {
+        return false;
+    }
+
+    protected void initialize() {
+        // Join the room specified by the URL the app was launched with.
+        // Joining without the room option displays the welcome page.
+        join(getConferenceOptions(getIntent()));
+    }
+
+    protected void onConferenceJoined(HashMap<String, Object> extraData) {
+        JitsiMeetLogger.i("Conference joined: " + extraData);
+        // Launch the service for the ongoing notification.
+        JitsiMeetOngoingConferenceService.launch(this, extraData);
+    }
+
+    protected void onConferenceTerminated(HashMap<String, Object> extraData) {
+        JitsiMeetLogger.i("Conference terminated: " + extraData);
+    }
+
+    protected void onConferenceWillJoin(HashMap<String, Object> extraData) {
+        JitsiMeetLogger.i("Conference will join: " + extraData);
+    }
+
+    protected void onParticipantJoined(HashMap<String, Object> extraData) {
+        try {
+            JitsiMeetLogger.i("Participant joined: ", extraData);
+        } catch (Exception e) {
+            JitsiMeetLogger.w("Invalid participant joined extraData", e);
+        }
+    }
+
+    protected void onParticipantLeft(HashMap<String, Object> extraData) {
+        try {
+            JitsiMeetLogger.i("Participant left: ", extraData);
+        } catch (Exception e) {
+            JitsiMeetLogger.w("Invalid participant left extraData", e);
+        }
+    }
+
+    protected void onReadyToClose() {
+        JitsiMeetLogger.i("SDK is ready to close");
+        isReadyToClose = true;
+        finish();
+    }
+
+//    protected void onTranscriptionChunkReceived(HashMap<String, Object> extraData) {
+//        JitsiMeetLogger.i("Transcription chunk received: " + extraData);
+//    }
+
+//    protected void onCustomButtonPressed(HashMap<String, Object> extraData) {
+//         JitsiMeetLogger.i("Custom button pressed: " + extraData);
+//     }
+
+//     protected void onConferenceUniqueIdSet(HashMap<String, Object> extraData) {
+//         JitsiMeetLogger.i("Conference unique id set: " + extraData);
+//     }
+
+//     protected void onRecordingStatusChanged(HashMap<String, Object> extraData) {
+//       JitsiMeetLogger.i("Recording status changed: " + extraData);
+//     }
+
+    // Activity lifecycle methods
+    //
+
+    @Override
+    public void onActivityResult(int requestCode, int resultCode, Intent data) {
+        super.onActivityResult(requestCode, resultCode, data);
+
+        JitsiMeetActivityDelegate.onActivityResult(this, requestCode, resultCode, data);
+    }
+
+    @Override
+    public void onBackPressed() {
+        JitsiMeetActivityDelegate.onBackPressed();
+    }
+
+    @Override
+    public void onNewIntent(Intent intent) {
+        super.onNewIntent(intent);
+
+        JitsiMeetConferenceOptions options;
+
+        if ((options = getConferenceOptions(intent)) != null) {
+            join(options);
+            return;
+        }
+
+        JitsiMeetActivityDelegate.onNewIntent(intent);
+    }
+
+    @Override
+    protected void onUserLeaveHint() {
+        if (this.jitsiView != null) {
+            this.jitsiView.enterPictureInPicture();
+        }
+    }
+
+    // JitsiMeetActivityInterface
+    //
+
+    @Override
+    public void requestPermissions(String[] permissions, int requestCode, PermissionListener listener) {
+        JitsiMeetActivityDelegate.requestPermissions(this, permissions, requestCode, listener);
+    }
+
+    @SuppressLint("MissingSuperCall")
+    @Override
+    public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
+        JitsiMeetActivityDelegate.onRequestPermissionsResult(requestCode, permissions, grantResults);
+    }
+
+    private void registerForBroadcastMessages() {
+        IntentFilter intentFilter = new IntentFilter();
+
+        for (BroadcastEvent.Type type : BroadcastEvent.Type.values()) {
+            intentFilter.addAction(type.getAction());
+        }
+
+        LocalBroadcastManager.getInstance(this).registerReceiver(broadcastReceiver, intentFilter);
+    }
+
+    private void onBroadcastReceived(Intent intent) {
+        if (intent != null) {
+            BroadcastEvent event = new BroadcastEvent(intent);
+
+            switch (event.getType()) {
+                case CONFERENCE_JOINED:
+                    onConferenceJoined(event.getData());
+                    break;
+                case CONFERENCE_WILL_JOIN:
+                    onConferenceWillJoin(event.getData());
+                    break;
+                case CONFERENCE_TERMINATED:
+                    onConferenceTerminated(event.getData());
+                    break;
+                case PARTICIPANT_JOINED:
+                    onParticipantJoined(event.getData());
+                    break;
+                case PARTICIPANT_LEFT:
+                    onParticipantLeft(event.getData());
+                    break;
+                case READY_TO_CLOSE:
+                    onReadyToClose();
+                    break;
+                // case TRANSCRIPTION_CHUNK_RECEIVED:
+                //    onTranscriptionChunkReceived(event.getData());
+                //    break;
+                // case CUSTOM_BUTTON_PRESSED:
+                //    onCustomButtonPressed(event.getData());
+                //    break;
+                // case CONFERENCE_UNIQUE_ID_SET:
+                //     onConferenceUniqueIdSet(event.getData());
+                //     break;
+                // case RECORDING_STATUS_CHANGED:
+                //     onRecordingStatusChanged(event.getData());
+                //     break;
+            }
+        }
+    }
+}

android/sdk/src/main/java/org/jitsi/meet/sdk/JitsiMeetActivityDelegate.java

@@ -0,0 +1,197 @@
+/*
+ * Copyright @ 2018-present 8x8, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jitsi.meet.sdk;
+
+import android.app.Activity;
+import android.content.Intent;
+
+import com.facebook.react.ReactInstanceManager;
+import com.facebook.react.bridge.Callback;
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.modules.core.PermissionListener;
+
+import org.jitsi.meet.sdk.log.JitsiMeetLogger;
+
+/**
+ * Helper class to encapsulate the work which needs to be done on
+ * {@link Activity} lifecycle methods in order for the React side to be aware of
+ * it.
+ */
+public class JitsiMeetActivityDelegate {
+    /**
+     * Needed for making sure this class working with the "PermissionsAndroid"
+     * React Native module.
+     */
+    private static PermissionListener permissionListener;
+    private static Callback permissionsCallback;
+
+    /**
+     * Tells whether or not the permissions request is currently in progress.
+     *
+     * @return {@code true} if the permissions are being requested or {@code false} otherwise.
+     */
+    static boolean arePermissionsBeingRequested() {
+        return permissionListener != null;
+    }
+
+    /**
+     * {@link Activity} lifecycle method which should be called from
+     * {@code Activity#onActivityResult} so we are notified about results of external intents
+     * started/finished.
+     *
+     * @param activity {@code Activity} activity from where the result comes from.
+     * @param requestCode {@code int} code of the request.
+     * @param resultCode {@code int} code of the result.
+     * @param data {@code Intent} the intent of the activity.
+     */
+    public static void onActivityResult(
+            Activity activity,
+            int requestCode,
+            int resultCode,
+            Intent data) {
+        ReactInstanceManager reactInstanceManager
+                = ReactInstanceManagerHolder.getReactInstanceManager();
+
+        if (reactInstanceManager != null) {
+            reactInstanceManager.onActivityResult(activity, requestCode, resultCode, data);
+        }
+    }
+
+    /**
+     * {@link Activity} lifecycle method which should be called from
+     * {@link Activity#onBackPressed} so we can do the required internal
+     * processing.
+     *
+     * @return {@code true} if the back-press was processed; {@code false},
+     * otherwise. If {@code false}, the application should call the
+     * {@code super}'s implementation.
+     */
+    public static void onBackPressed() {
+        ReactInstanceManager reactInstanceManager
+            = ReactInstanceManagerHolder.getReactInstanceManager();
+
+        if (reactInstanceManager != null) {
+            reactInstanceManager.onBackPressed();
+        }
+    }
+
+    /**
+     * {@link Activity} lifecycle method which should be called from
+     * {@code Activity#onDestroy} so we can do the required internal
+     * processing.
+     *
+     * @param activity {@code Activity} being destroyed.
+     */
+    public static void onHostDestroy(Activity activity) {
+        ReactInstanceManager reactInstanceManager
+            = ReactInstanceManagerHolder.getReactInstanceManager();
+
+        if (reactInstanceManager != null) {
+            reactInstanceManager.onHostDestroy(activity);
+        }
+    }
+
+    /**
+     * {@link Activity} lifecycle method which should be called from
+     * {@code Activity#onPause} so we can do the required internal processing.
+     *
+     * @param activity {@code Activity} being paused.
+     */
+    public static void onHostPause(Activity activity) {
+        ReactInstanceManager reactInstanceManager
+            = ReactInstanceManagerHolder.getReactInstanceManager();
+
+        if (reactInstanceManager != null) {
+            try {
+                reactInstanceManager.onHostPause(activity);
+            } catch (AssertionError e) {
+                // There seems to be a problem in RN when resuming an Activity when
+                // rotation is involved and the planets align. There doesn't seem to
+                // be a proper solution, but since the activity is going away anyway,
+                // we'll YOLO-ignore the exception and hope fo the best.
+                // Ref: https://github.com/facebook/react-native/search?q=Pausing+an+activity+that+is+not+the+current+activity%2C+this+is+incorrect%21&type=issues
+                JitsiMeetLogger.e(e, "Error running onHostPause, ignoring");
+            }
+        }
+    }
+
+    /**
+     * {@link Activity} lifecycle method which should be called from
+     * {@code Activity#onResume} so we can do the required internal processing.
+     *
+     * @param activity {@code Activity} being resumed.
+     */
+    public static void onHostResume(Activity activity) {
+        ReactInstanceManager reactInstanceManager
+            = ReactInstanceManagerHolder.getReactInstanceManager();
+
+        if (reactInstanceManager != null) {
+            reactInstanceManager.onHostResume(activity, new DefaultHardwareBackBtnHandlerImpl(activity));
+        }
+
+        if (permissionsCallback != null) {
+            permissionsCallback.invoke();
+            permissionsCallback = null;
+        }
+    }
+
+    /**
+     * {@link Activity} lifecycle method which should be called from
+     * {@code Activity#onNewIntent} so we can do the required internal
+     * processing. Note that this is only needed if the activity's "launchMode"
+     * was set to "singleTask". This is required for deep linking to work once
+     * the application is already running.
+     *
+     * @param intent {@code Intent} instance which was received.
+     */
+    public static void onNewIntent(Intent intent) {
+        ReactInstanceManager reactInstanceManager
+            = ReactInstanceManagerHolder.getReactInstanceManager();
+
+        if (reactInstanceManager != null) {
+            reactInstanceManager.onNewIntent(intent);
+        }
+    }
+
+    public static void onRequestPermissionsResult(
+            final int requestCode, final String[] permissions, final int[] grantResults) {
+        permissionsCallback = new Callback() {
+            @Override
+            public void invoke(Object... args) {
+                if (permissionListener != null
+                        && permissionListener.onRequestPermissionsResult(requestCode, permissions, grantResults)) {
+                    permissionListener = null;
+                }
+            }
+        };
+    }
+
+    public static void requestPermissions(Activity activity, String[] permissions, int requestCode, PermissionListener listener) {
+        permissionListener = listener;
+
+        // The RN Permissions module calls this in a non-UI thread. What we observe is a crash in ViewGroup.dispatchCancelPendingInputEvents,
+        // which is called on the calling (ie, non-UI) thread. This doesn't look very safe, so try to avoid a crash by pretending the permission
+        // was denied.
+
+        try {
+            activity.requestPermissions(permissions, requestCode);
+        } catch (Exception e) {
+            JitsiMeetLogger.e(e, "Error requesting permissions");
+            onRequestPermissionsResult(requestCode, permissions, new int[0]);
+        }
+    }
+}

android/sdk/src/main/java/org/jitsi/meet/sdk/JitsiMeetActivityInterface.java

@@ -0,0 +1,15 @@
+package org.jitsi.meet.sdk;
+
+import androidx.core.app.ActivityCompat;
+
+import com.facebook.react.modules.core.PermissionAwareActivity;
+
+/**
+ * This interface serves as the umbrella interface that applications not using
+ * {@code JitsiMeetFragment} must implement in order to ensure full
+ * functionality.
+ */
+public interface JitsiMeetActivityInterface
+    extends ActivityCompat.OnRequestPermissionsResultCallback,
+            PermissionAwareActivity {
+}

android/sdk/src/main/java/org/jitsi/meet/sdk/JitsiMeetConferenceOptions.java

@@ -0,0 +1,332 @@
+/*
+ * Copyright @ 2019-present 8x8, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jitsi.meet.sdk;
+
+import android.os.Bundle;
+import android.os.Parcel;
+import android.os.Parcelable;
+
+import java.net.URL;
+import java.util.ArrayList;
+
+
+/**
+ * This class represents the options when joining a Jitsi Meet conference. The user can create an
+ * instance by using {@link JitsiMeetConferenceOptions.Builder} and setting the desired options
+ * there.
+ *
+ * The resulting {@link JitsiMeetConferenceOptions} object is immutable and represents how the
+ * conference will be joined.
+ */
+public class JitsiMeetConferenceOptions implements Parcelable {
+    /**
+     * Server where the conference should take place.
+     */
+    private URL serverURL;
+    /**
+     * Room name.
+     */
+    private String room;
+    /**
+     * JWT token used for authentication.
+     */
+    private String token;
+
+    /**
+     * Config. See: https://github.com/jitsi/jitsi-meet/blob/master/config.js
+     */
+    private Bundle config;
+
+    /**
+     * Feature flags. See: https://github.com/jitsi/jitsi-meet/blob/master/react/features/base/flags/constants.js
+     */
+    private Bundle featureFlags;
+
+    /**
+     * USer information, to be used when no token is specified.
+     */
+    private JitsiMeetUserInfo userInfo;
+
+    public URL getServerURL() {
+        return serverURL;
+    }
+
+    public String getRoom() {
+        return room;
+    }
+
+    public String getToken() {
+        return token;
+    }
+
+    public Bundle getFeatureFlags() {
+        return featureFlags;
+    }
+
+    public JitsiMeetUserInfo getUserInfo() {
+        return userInfo;
+    }
+
+    /**
+     * Class used to build the immutable {@link JitsiMeetConferenceOptions} object.
+     */
+    public static class Builder {
+        private URL serverURL;
+        private String room;
+        private String token;
+
+        private Bundle config;
+        private Bundle featureFlags;
+
+        private JitsiMeetUserInfo userInfo;
+
+        public Builder() {
+            config = new Bundle();
+            featureFlags = new Bundle();
+        }
+
+        /**\
+         * Sets the server URL.
+         * @param url - {@link URL} of the server where the conference should take place.
+         * @return - The {@link Builder} object itself so the method calls can be chained.
+         */
+        public Builder setServerURL(URL url) {
+            this.serverURL = url;
+
+            return this;
+        }
+
+        /**
+         * Sets the room where the conference will take place.
+         * @param room - Name of the room.
+         * @return - The {@link Builder} object itself so the method calls can be chained.
+         */
+        public Builder setRoom(String room) {
+            this.room = room;
+
+            return this;
+        }
+
+        /**
+         * Sets the conference subject.
+         * @param subject - Subject for the conference.
+         * @return - The {@link Builder} object itself so the method calls can be chained.
+         */
+        public Builder setSubject(String subject) {
+            setConfigOverride("subject", subject);
+
+            return this;
+        }
+
+        /**
+         * Sets the JWT token to be used for authentication when joining a conference.
+         * @param token - The JWT token to be used for authentication.
+         * @return - The {@link Builder} object itself so the method calls can be chained.
+         */
+        public Builder setToken(String token) {
+            this.token = token;
+
+            return this;
+        }
+
+        /**
+         * Indicates the conference will be joined with the microphone muted.
+         * @param audioMuted - Muted indication.
+         * @return - The {@link Builder} object itself so the method calls can be chained.
+         */
+        public Builder setAudioMuted(boolean audioMuted) {
+            setConfigOverride("startWithAudioMuted", audioMuted);
+
+            return this;
+        }
+
+        /**
+         * Indicates the conference will be joined in audio-only mode. In this mode no video is
+         * sent or received.
+         * @param audioOnly - Audio-mode indicator.
+         * @return - The {@link Builder} object itself so the method calls can be chained.
+         */
+        public Builder setAudioOnly(boolean audioOnly) {
+            setConfigOverride("startAudioOnly", audioOnly);
+
+            return this;
+        }
+        /**
+         * Indicates the conference will be joined with the camera muted.
+         * @param videoMuted - Muted indication.
+         * @return - The {@link Builder} object itself so the method calls can be chained.
+         */
+        public Builder setVideoMuted(boolean videoMuted) {
+            setConfigOverride("startWithVideoMuted", videoMuted);
+
+            return this;
+        }
+
+        public Builder setFeatureFlag(String flag, boolean value) {
+            this.featureFlags.putBoolean(flag, value);
+
+            return this;
+        }
+
+        public Builder setFeatureFlag(String flag, String value) {
+            this.featureFlags.putString(flag, value);
+
+            return this;
+        }
+
+        public Builder setFeatureFlag(String flag, int value) {
+            this.featureFlags.putInt(flag, value);
+
+            return this;
+        }
+
+        public Builder setUserInfo(JitsiMeetUserInfo userInfo) {
+            this.userInfo = userInfo;
+
+            return this;
+        }
+
+        public Builder setConfigOverride(String config, String value) {
+            this.config.putString(config, value);
+
+            return this;
+        }
+
+        public Builder setConfigOverride(String config, int value) {
+            this.config.putInt(config, value);
+
+            return this;
+        }
+
+        public Builder setConfigOverride(String config, boolean value) {
+            this.config.putBoolean(config, value);
+
+            return this;
+        }
+
+        public Builder setConfigOverride(String config, Bundle bundle) {
+            this.config.putBundle(config, bundle);
+
+            return this;
+        }
+
+        public Builder setConfigOverride(String config, String[] list) {
+            this.config.putStringArray(config, list);
+
+            return this;
+        }
+
+        public Builder setConfigOverride(String config, ArrayList<Bundle> arrayList) {
+            this.config.putParcelableArrayList(config, arrayList);
+
+            return this;
+        }
+
+        /**
+         * Builds the immutable {@link JitsiMeetConferenceOptions} object with the configuration
+         * that this {@link Builder} instance specified.
+         * @return - The built {@link JitsiMeetConferenceOptions} object.
+         */
+        public JitsiMeetConferenceOptions build() {
+            JitsiMeetConferenceOptions options = new JitsiMeetConferenceOptions();
+
+            options.serverURL = this.serverURL;
+            options.room = this.room;
+            options.token = this.token;
+            options.config = this.config;
+            options.featureFlags = this.featureFlags;
+            options.userInfo = this.userInfo;
+
+            return options;
+        }
+    }
+
+    private JitsiMeetConferenceOptions() {
+    }
+
+    private JitsiMeetConferenceOptions(Parcel in) {
+        serverURL = (URL) in.readSerializable();
+        room = in.readString();
+        token = in.readString();
+        config = in.readBundle();
+        featureFlags = in.readBundle();
+        userInfo = new JitsiMeetUserInfo(in.readBundle());
+    }
+
+    Bundle asProps() {
+        Bundle props = new Bundle();
+
+        props.putBundle("flags", featureFlags);
+
+        Bundle urlProps = new Bundle();
+
+        // The room is fully qualified
+        if (room != null && room.contains("://")) {
+            urlProps.putString("url", room);
+        } else {
+            if (serverURL != null) {
+                urlProps.putString("serverURL", serverURL.toString());
+            }
+            if (room != null) {
+                urlProps.putString("room", room);
+            }
+        }
+
+        if (token != null) {
+            urlProps.putString("jwt", token);
+        }
+
+        if (userInfo != null) {
+            props.putBundle("userInfo", userInfo.asBundle());
+        }
+
+        urlProps.putBundle("config", config);
+        props.putBundle("url", urlProps);
+
+        return props;
+    }
+
+    // Parcelable interface
+    //
+
+    public static final Creator<JitsiMeetConferenceOptions> CREATOR = new Creator<JitsiMeetConferenceOptions>() {
+        @Override
+        public JitsiMeetConferenceOptions createFromParcel(Parcel in) {
+            return new JitsiMeetConferenceOptions(in);
+        }
+
+        @Override
+        public JitsiMeetConferenceOptions[] newArray(int size) {
+            return new JitsiMeetConferenceOptions[size];
+        }
+    };
+
+    @Override
+    public void writeToParcel(Parcel dest, int flags) {
+        dest.writeSerializable(serverURL);
+        dest.writeString(room);
+        dest.writeString(token);
+        dest.writeBundle(config);
+        dest.writeBundle(featureFlags);
+        dest.writeBundle(userInfo != null ? userInfo.asBundle() : new Bundle());
+    }
+
+    @Override
+    public int describeContents() {
+        return 0;
+    }
+}

android/sdk/src/main/java/org/jitsi/meet/sdk/JitsiMeetOngoingConferenceService.java

@@ -0,0 +1,310 @@
+/*
+ * Copyright @ 2019-present 8x8, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jitsi.meet.sdk;
+
+import static android.Manifest.permission.POST_NOTIFICATIONS;
+import static android.Manifest.permission.RECORD_AUDIO;
+
+import android.app.Activity;
+import android.app.Notification;
+import android.app.NotificationManager;
+import android.app.Service;
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.content.pm.PackageManager;
+import android.content.pm.ServiceInfo;
+import android.os.Build;
+import android.os.Bundle;
+import android.os.IBinder;
+
+import androidx.localbroadcastmanager.content.LocalBroadcastManager;
+
+import com.facebook.react.modules.core.PermissionListener;
+
+import org.jitsi.meet.sdk.log.JitsiMeetLogger;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Random;
+
+/**
+ * This class implements an Android {@link Service}, a foreground one specifically, and it's
+ * responsible for presenting an ongoing notification when a conference is in progress.
+ * The service will help keep the app running while in the background.
+ *
+ * See: https://developer.android.com/guide/components/services
+ */
+public class JitsiMeetOngoingConferenceService extends Service implements OngoingConferenceTracker.OngoingConferenceListener {
+    private static final String TAG = JitsiMeetOngoingConferenceService.class.getSimpleName();
+    private static final String ACTIVITY_DATA_KEY = "activityDataKey";
+    private static final String EXTRA_DATA_KEY = "extraDataKey";
+    private static final String EXTRA_DATA_BUNDLE_KEY = "extraDataBundleKey";
+    private static final String IS_AUDIO_MUTED_KEY = "isAudioMuted";
+
+    private static final int PERMISSIONS_REQUEST_CODE = (int) (Math.random() * Short.MAX_VALUE);
+
+    private final BroadcastReceiver broadcastReceiver = new BroadcastReceiver();
+
+    private boolean isAudioMuted;
+    private Class tapBackActivity;
+
+    static final int NOTIFICATION_ID = new Random().nextInt(99999) + 10000;
+
+    private static void doLaunch(Context context, HashMap<String, Object> extraData) {
+        Activity activity = (Activity) context;
+
+        OngoingNotification.createNotificationChannel(activity);
+
+        Intent intent = new Intent(context, JitsiMeetOngoingConferenceService.class);
+
+        Bundle extraDataBundle = new Bundle();
+        extraDataBundle.putSerializable(EXTRA_DATA_KEY, extraData);
+
+        intent.putExtra(EXTRA_DATA_BUNDLE_KEY, extraDataBundle);
+        intent.putExtra(ACTIVITY_DATA_KEY, activity.getClass().getCanonicalName());
+
+        ComponentName componentName;
+
+        try {
+            componentName = context.startForegroundService(intent);
+        } catch (RuntimeException e) {
+            // Avoid crashing due to ForegroundServiceStartNotAllowedException (API level 31).
+            // See: https://developer.android.com/guide/components/foreground-services#background-start-restrictions
+            JitsiMeetLogger.w(TAG + " Ongoing conference service not started", e);
+            return;
+        }
+
+        if (componentName == null) {
+            JitsiMeetLogger.w(TAG + " Ongoing conference service not started");
+        }
+    }
+
+
+    public static void launch(Context context, HashMap<String, Object> extraData) {
+        List<String> permissionsList = new ArrayList<>();
+
+        PermissionListener listener = new PermissionListener() {
+            @Override
+            public boolean onRequestPermissionsResult(int i, String[] strings, int[] results) {
+                int counter = 0;
+
+                if (results.length > 0) {
+                    for (int result : results) {
+                        if (result == PackageManager.PERMISSION_GRANTED) {
+                            counter++;
+                        }
+                    }
+
+                    if (counter == results.length){
+                        doLaunch(context, extraData);
+                        JitsiMeetLogger.w(TAG + " Service launched, permissions were granted");
+                    } else {
+                        JitsiMeetLogger.w(TAG + " Couldn't launch service, permissions were not granted");
+                    }
+                }
+
+                return true;
+            }
+        };
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+            permissionsList.add(POST_NOTIFICATIONS);
+            permissionsList.add(RECORD_AUDIO);
+        }
+
+        String[] permissionsArray = new String[ permissionsList.size() ];
+        permissionsArray = permissionsList.toArray( permissionsArray );
+
+        if (permissionsArray.length > 0) {
+            JitsiMeetActivityDelegate.requestPermissions(
+                (Activity) context,
+                permissionsArray,
+                PERMISSIONS_REQUEST_CODE,
+                listener
+            );
+        } else {
+            doLaunch(context, extraData);
+            JitsiMeetLogger.w(TAG + " Service launched");
+        }
+    }
+
+    public static void abort(Context context) {
+        Intent intent = new Intent(context, JitsiMeetOngoingConferenceService.class);
+        context.stopService(intent);
+    }
+
+    @Override
+    public void onCreate() {
+        super.onCreate();
+
+        Notification notification = OngoingNotification.buildOngoingConferenceNotification(isAudioMuted, this, tapBackActivity);
+        if (notification == null) {
+            stopSelf();
+            JitsiMeetLogger.w(TAG + " Couldn't start service, notification is null");
+        } else {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+                startForeground(NOTIFICATION_ID, notification, ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PLAYBACK | ServiceInfo.FOREGROUND_SERVICE_TYPE_MICROPHONE);
+            } else if (Build.VERSION.SDK_INT == Build.VERSION_CODES.Q) {
+                startForeground(NOTIFICATION_ID, notification, ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PLAYBACK);
+            } else {
+                startForeground(NOTIFICATION_ID, notification);
+            }
+        }
+
+        OngoingConferenceTracker.getInstance().addListener(this);
+
+        IntentFilter intentFilter = new IntentFilter();
+        intentFilter.addAction(BroadcastEvent.Type.AUDIO_MUTED_CHANGED.getAction());
+        LocalBroadcastManager.getInstance(getApplicationContext()).registerReceiver(broadcastReceiver, intentFilter);
+    }
+
+    @Override
+    public void onDestroy() {
+        OngoingConferenceTracker.getInstance().removeListener(this);
+        LocalBroadcastManager.getInstance(getApplicationContext()).unregisterReceiver(broadcastReceiver);
+
+        super.onDestroy();
+    }
+
+    @Override
+    public IBinder onBind(Intent intent) {
+        return null;
+    }
+
+    @Override
+    public int onStartCommand(Intent intent, int flags, int startId) {
+        final String actionName = intent.getAction();
+        final Action action = Action.fromName(actionName);
+
+        if (action != Action.HANGUP) {
+            Boolean isAudioMuted = tryParseIsAudioMuted(intent);
+
+            if (isAudioMuted != null) {
+                this.isAudioMuted = Boolean.parseBoolean(intent.getStringExtra("muted"));
+            }
+
+            if (tapBackActivity == null) {
+                String targetActivityName = intent.getExtras().getString(ACTIVITY_DATA_KEY);
+                Class<? extends Activity> targetActivity = null;
+                try {
+                    targetActivity = Class.forName(targetActivityName).asSubclass(Activity.class);
+                    tapBackActivity = targetActivity;
+                } catch (ClassNotFoundException e) {
+                    JitsiMeetLogger.w(TAG + " Could not find target Activity: " + targetActivityName);
+                }
+            }
+
+            Notification notification = OngoingNotification.buildOngoingConferenceNotification(this.isAudioMuted, this, tapBackActivity);
+            if (notification == null) {
+                stopSelf();
+                JitsiMeetLogger.w(TAG + " Couldn't start service, notification is null");
+            } else {
+                NotificationManager notificationManager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
+                notificationManager.notify(NOTIFICATION_ID, notification);
+            }
+        }
+
+        // When starting the service, there is no action passed in the intent
+        if (action != null) {
+            switch (action) {
+                case UNMUTE:
+                case MUTE:
+                    Intent muteBroadcastIntent = BroadcastIntentHelper.buildSetAudioMutedIntent(action == Action.MUTE);
+                    LocalBroadcastManager.getInstance(getApplicationContext()).sendBroadcast(muteBroadcastIntent);
+                    break;
+                case HANGUP:
+                    JitsiMeetLogger.i(TAG + " Hangup requested");
+
+                    Intent hangupBroadcastIntent = BroadcastIntentHelper.buildHangUpIntent();
+                    LocalBroadcastManager.getInstance(getApplicationContext()).sendBroadcast(hangupBroadcastIntent);
+
+                    stopSelf();
+                    break;
+                default:
+                    JitsiMeetLogger.w(TAG + " Unknown action received: " + action);
+                    break;
+            }
+        }
+
+        return START_NOT_STICKY;
+    }
+
+    @Override
+    public void onCurrentConferenceChanged(String conferenceUrl) {
+        if (conferenceUrl == null) {
+            stopSelf();
+            OngoingNotification.resetStartingtime();
+            JitsiMeetLogger.i(TAG + "Service stopped");
+        }
+    }
+
+    public enum Action {
+        HANGUP(TAG + ":HANGUP"),
+        MUTE(TAG + ":MUTE"),
+        UNMUTE(TAG + ":UNMUTE");
+
+        private final String name;
+
+        Action(String name) {
+            this.name = name;
+        }
+
+        public static Action fromName(String name) {
+            for (Action action : Action.values()) {
+                if (action.name.equalsIgnoreCase(name)) {
+                    return action;
+                }
+            }
+            return null;
+        }
+
+        public String getName() {
+            return name;
+        }
+    }
+
+    private Boolean tryParseIsAudioMuted(Intent intent) {
+        try {
+            HashMap<String, Object> extraData = (HashMap<String, Object>) intent.getBundleExtra(EXTRA_DATA_BUNDLE_KEY).getSerializable(EXTRA_DATA_KEY);
+            return Boolean.parseBoolean((String) extraData.get(IS_AUDIO_MUTED_KEY));
+        } catch (Exception ignored) {
+        }
+        return null;
+    }
+
+    private class BroadcastReceiver extends android.content.BroadcastReceiver {
+
+        @Override
+        public void onReceive(Context context, Intent intent) {
+            Class tapBackActivity = JitsiMeetOngoingConferenceService.this.tapBackActivity;
+            isAudioMuted = Boolean.parseBoolean(intent.getStringExtra("muted"));
+            Notification notification = OngoingNotification.buildOngoingConferenceNotification(isAudioMuted, context, tapBackActivity);
+            if (notification == null) {
+                stopSelf();
+                JitsiMeetLogger.w(TAG + " Couldn't update service, notification is null");
+            } else {
+                NotificationManager notificationManager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
+                notificationManager.notify(NOTIFICATION_ID, notification);
+
+                JitsiMeetLogger.i(TAG + " audio muted changed");
+            }
+        }
+    }
+}

android/sdk/src/main/java/org/jitsi/meet/sdk/JitsiMeetUncaughtExceptionHandler.java

@@ -0,0 +1,51 @@
+/*
+ * Copyright @ 2018-present 8x8, Inc.
+ * Copyright @ 2017-2018 Atlassian Pty Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jitsi.meet.sdk;
+
+import org.jitsi.meet.sdk.log.JitsiMeetLogger;
+
+class JitsiMeetUncaughtExceptionHandler implements Thread.UncaughtExceptionHandler {
+    private final Thread.UncaughtExceptionHandler defaultUncaughtExceptionHandler;
+
+    public static void register() {
+        Thread.UncaughtExceptionHandler defaultUncaughtExceptionHandler = Thread.getDefaultUncaughtExceptionHandler();
+
+        JitsiMeetUncaughtExceptionHandler uncaughtExceptionHandler
+            = new JitsiMeetUncaughtExceptionHandler(defaultUncaughtExceptionHandler);
+
+        Thread.setDefaultUncaughtExceptionHandler(uncaughtExceptionHandler);
+    }
+
+    private JitsiMeetUncaughtExceptionHandler(Thread.UncaughtExceptionHandler defaultUncaughtExceptionHandler) {
+        this.defaultUncaughtExceptionHandler = defaultUncaughtExceptionHandler;
+    }
+
+    @Override
+    public void uncaughtException(Thread t, Throwable e) {
+        JitsiMeetLogger.e(e, this.getClass().getSimpleName() + " FATAL ERROR");
+
+        // Abort all ConnectionService ongoing calls
+        if (AudioModeModule.useConnectionService()) {
+            ConnectionService.abortConnections();
+        }
+
+        if (defaultUncaughtExceptionHandler != null) {
+            defaultUncaughtExceptionHandler.uncaughtException(t, e);
+        }
+    }
+}

android/sdk/src/main/java/org/jitsi/meet/sdk/JitsiMeetUserInfo.java

@@ -0,0 +1,107 @@
+/*
+ * Copyright @ 2019-present 8x8, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jitsi.meet.sdk;
+
+import android.os.Bundle;
+
+import java.net.MalformedURLException;
+import java.net.URL;
+
+/**
+ * This class represents user information to be passed to {@link JitsiMeetConferenceOptions} for
+ * identifying a user.
+ */
+public class JitsiMeetUserInfo {
+    /**
+     * User's display name.
+     */
+    private String displayName;
+
+    /**
+     * User's email address.
+     */
+    private String email;
+
+    /**
+     * User's avatar URL.
+     */
+    private URL avatar;
+
+    public JitsiMeetUserInfo() {}
+
+    public JitsiMeetUserInfo(Bundle b) {
+        super();
+
+        if (b.containsKey("displayName")) {
+            displayName = b.getString("displayName");
+        }
+
+        if (b.containsKey("email")) {
+            email = b.getString("email");
+        }
+
+        if (b.containsKey("avatarURL")) {
+            String avatarURL = b.getString("avatarURL");
+            try {
+                avatar = new URL(avatarURL);
+            } catch (MalformedURLException e) {
+            }
+        }
+    }
+
+    public String getDisplayName() {
+        return displayName;
+    }
+
+    public void setDisplayName(String displayName) {
+        this.displayName = displayName;
+    }
+
+    public String getEmail() {
+        return email;
+    }
+
+    public void setEmail(String email) {
+        this.email = email;
+    }
+
+    public URL getAvatar() {
+        return avatar;
+    }
+
+    public void setAvatar(URL avatar) {
+        this.avatar = avatar;
+    }
+
+    Bundle asBundle() {
+        Bundle b = new Bundle();
+
+        if (displayName != null) {
+            b.putString("displayName", displayName);
+        }
+
+        if (email != null) {
+            b.putString("email", email);
+        }
+
+        if (avatar != null) {
+            b.putString("avatarURL", avatar.toString());
+        }
+
+        return b;
+    }
+}

android/sdk/src/main/java/org/jitsi/meet/sdk/JitsiMeetView.java

@@ -0,0 +1,229 @@
+/*
+ * Copyright @ 2017-present 8x8, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jitsi.meet.sdk;
+
+import android.app.Activity;
+import android.app.Application;
+import android.content.Context;
+import android.os.Bundle;
+import android.util.AttributeSet;
+import android.widget.FrameLayout;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.facebook.react.ReactRootView;
+
+import org.jitsi.meet.sdk.log.JitsiMeetLogger;
+
+
+public class JitsiMeetView extends FrameLayout {
+
+    /**
+     * Background color. Should match the background color set in JS.
+     */
+    public static final int BACKGROUND_COLOR = 0xFF040404;
+
+    /**
+     * React Native root view.
+     */
+    private ReactRootView reactRootView;
+
+    /**
+     * Helper method to recursively merge 2 {@link Bundle} objects representing React Native props.
+     *
+     * @param a - The first {@link Bundle}.
+     * @param b - The second {@link Bundle}.
+     * @return The merged {@link Bundle} object.
+     */
+    private static Bundle mergeProps(@Nullable Bundle a, @Nullable Bundle b) {
+        Bundle result = new Bundle();
+
+        if (a == null) {
+            if (b != null) {
+                result.putAll(b);
+            }
+
+            return result;
+        }
+
+        if (b == null) {
+            result.putAll(a);
+
+            return result;
+        }
+
+        // Start by putting all of a in the result.
+        result.putAll(a);
+
+        // Iterate over each key in b and override if appropriate.
+        for (String key : b.keySet()) {
+            Object bValue = b.get(key);
+            Object aValue = a.get(key);
+            String valueType = bValue.getClass().getSimpleName();
+
+            if (valueType.contentEquals("Boolean")) {
+                result.putBoolean(key, (Boolean)bValue);
+            } else if (valueType.contentEquals("String")) {
+                result.putString(key, (String)bValue);
+            } else if (valueType.contentEquals("Integer")) {
+                result.putInt(key, (int)bValue);
+            } else if (valueType.contentEquals("Bundle")) {
+                result.putBundle(key, mergeProps((Bundle)aValue, (Bundle)bValue));
+            } else {
+                throw new RuntimeException("Unsupported type: " + valueType);
+            }
+        }
+
+        return result;
+    }
+
+    public JitsiMeetView(@NonNull Context context) {
+        super(context);
+        initialize(context);
+    }
+
+    public JitsiMeetView(Context context, AttributeSet attrs) {
+        super(context, attrs);
+        initialize(context);
+    }
+
+    public JitsiMeetView(Context context, AttributeSet attrs, int defStyle) {
+        super(context, attrs, defStyle);
+        initialize(context);
+    }
+
+    /**
+     * Releases the React resources (specifically the {@link ReactRootView})
+     * associated with this view.
+     *
+     * MUST be called when the {@link Activity} holding this view is destroyed,
+     * typically in the {@code onDestroy} method.
+     */
+    public void dispose() {
+        if (reactRootView != null) {
+            removeView(reactRootView);
+            reactRootView.unmountReactApplication();
+            reactRootView = null;
+        }
+    }
+
+    /**
+     * Enters Picture-In-Picture mode, if possible. This method is designed to
+     * be called from the {@code Activity.onUserLeaveHint} method.
+     *
+     * This is currently not mandatory, but if used will provide automatic
+     * handling of the picture in picture mode when user minimizes the app. It
+     * will be probably the most useful in case the app is using the welcome
+     * page.
+     */
+    public void enterPictureInPicture() {
+        PictureInPictureModule pipModule
+            = ReactInstanceManagerHolder.getNativeModule(
+                PictureInPictureModule.class);
+        if (pipModule != null
+                && pipModule.isPictureInPictureSupported()
+                && !JitsiMeetActivityDelegate.arePermissionsBeingRequested()) {
+            try {
+                pipModule.enterPictureInPicture();
+            } catch (RuntimeException re) {
+                JitsiMeetLogger.e(re, "Failed to enter PiP mode");
+            }
+        }
+    }
+
+    /**
+     * Joins the conference specified by the given {@link JitsiMeetConferenceOptions}. If there is
+     * already an active conference, it will be left and the new one will be joined.
+     * @param options - Description of what conference must be joined and what options will be used
+     *                when doing so.
+     */
+    public void join(@Nullable JitsiMeetConferenceOptions options) {
+        setProps(options != null ? options.asProps() : new Bundle());
+    }
+
+    /**
+     * Internal method which aborts running RN by passing empty props.
+     * This is only meant to be used from the enclosing Activity's onDestroy.
+     */
+    public void abort() {
+        setProps(new Bundle());
+    }
+
+    /**
+     * Creates the {@code ReactRootView} for the given app name with the given
+     * props. Once created it's set as the view of this {@code FrameLayout}.
+     *
+     * @param appName - The name of the "app" (in React Native terms) to load.
+     * @param props - The React Component props to pass to the app.
+     */
+    private void createReactRootView(String appName, @Nullable Bundle props) {
+        if (props == null) {
+            props = new Bundle();
+        }
+
+        if (reactRootView == null) {
+            reactRootView = new ReactRootView(getContext());
+            reactRootView.startReactApplication(
+                ReactInstanceManagerHolder.getReactInstanceManager(),
+                appName,
+                props);
+            reactRootView.setBackgroundColor(BACKGROUND_COLOR);
+            addView(reactRootView);
+        } else {
+            reactRootView.setAppProperties(props);
+        }
+    }
+
+    private void initialize(@NonNull Context context) {
+        // Check if the parent Activity implements JitsiMeetActivityInterface,
+        // otherwise things may go wrong.
+        if (!(context instanceof JitsiMeetActivityInterface)) {
+            throw new RuntimeException("Enclosing Activity must implement JitsiMeetActivityInterface");
+        }
+
+        setBackgroundColor(BACKGROUND_COLOR);
+    }
+
+    /**
+     * Helper method to set the React Native props.
+     * @param newProps - New props to be set on the React Native view.
+     */
+    private void setProps(@NonNull Bundle newProps) {
+        // Merge the default options with the newly provided ones.
+        Bundle props = mergeProps(JitsiMeet.getDefaultProps(), newProps);
+
+        // XXX The setProps() method is supposed to be imperative i.e.
+        // a second invocation with one and the same URL is expected to join
+        // the respective conference again if the first invocation was followed
+        // by leaving the conference. However, React and, respectively,
+        // appProperties/initialProperties are declarative expressions i.e. one
+        // and the same URL will not trigger an automatic re-render in the
+        // JavaScript source code. The workaround implemented below introduces
+        // "imperativeness" in React Component props by defining a unique value
+        // per setProps() invocation.
+        props.putLong("timestamp", System.currentTimeMillis());
+
+        createReactRootView("App", props);
+    }
+
+    @Override
+    protected void onDetachedFromWindow() {
+        dispose();
+        super.onDetachedFromWindow();
+    }
+}

android/sdk/src/main/java/org/jitsi/meet/sdk/JitsiVideoDecoderFactory.java

@@ -0,0 +1,84 @@
+package org.jitsi.meet.sdk;
+
+/*
+ *  Copyright 2017 The WebRTC project authors. All Rights Reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+import android.media.MediaCodecInfo;
+import androidx.annotation.Nullable;
+
+import com.oney.WebRTCModule.webrtcutils.SoftwareVideoDecoderFactoryProxy;
+
+import org.webrtc.EglBase;
+import org.webrtc.HardwareVideoDecoderFactory;
+import org.webrtc.JitsiPlatformVideoDecoderFactory;
+import org.webrtc.Predicate;
+import org.webrtc.VideoCodecInfo;
+import org.webrtc.VideoDecoder;
+import org.webrtc.VideoDecoderFactory;
+import org.webrtc.VideoDecoderFallback;
+
+import java.util.Arrays;
+import java.util.LinkedHashSet;
+
+/**
+ * Custom decoder factory which uses HW decoders and falls back to SW.
+ */
+public class JitsiVideoDecoderFactory implements VideoDecoderFactory {
+    private final VideoDecoderFactory hardwareVideoDecoderFactory;
+    private final VideoDecoderFactory softwareVideoDecoderFactory = new SoftwareVideoDecoderFactoryProxy();
+    private final VideoDecoderFactory platformSoftwareVideoDecoderFactory;
+
+    /**
+     * Predicate to filter out the AV1 hardware decoder, as we've seen decoding issues with it.
+     */
+    private static final String GOOGLE_AV1_DECODER = "c2.google.av1";
+    private static final Predicate<MediaCodecInfo> hwCodecPredicate = arg -> {
+        // Filter out the Google AV1 codec.
+        return !arg.getName().startsWith(GOOGLE_AV1_DECODER);
+    };
+    private static final Predicate<MediaCodecInfo> swCodecPredicate = arg -> {
+        // Noop, just making sure we can customize it easily if needed.
+        return true;
+    };
+
+    /**
+     * Create decoder factory using default hardware decoder factory.
+     */
+    public JitsiVideoDecoderFactory(@Nullable EglBase.Context eglContext) {
+        this.hardwareVideoDecoderFactory = new HardwareVideoDecoderFactory(eglContext, hwCodecPredicate);
+        this.platformSoftwareVideoDecoderFactory = new JitsiPlatformVideoDecoderFactory(eglContext, swCodecPredicate);
+    }
+
+    @Override
+    public @Nullable VideoDecoder createDecoder(VideoCodecInfo codecType) {
+        VideoDecoder softwareDecoder = softwareVideoDecoderFactory.createDecoder(codecType);
+        final VideoDecoder hardwareDecoder = hardwareVideoDecoderFactory.createDecoder(codecType);
+        if (softwareDecoder == null) {
+            softwareDecoder = platformSoftwareVideoDecoderFactory.createDecoder(codecType);
+        }
+        if (hardwareDecoder != null && softwareDecoder != null) {
+            // Both hardware and software supported, wrap it in a software fallback
+            return new VideoDecoderFallback(
+                /* fallback= */ softwareDecoder, /* primary= */ hardwareDecoder);
+        }
+        return hardwareDecoder != null ? hardwareDecoder : softwareDecoder;
+    }
+
+    @Override
+    public VideoCodecInfo[] getSupportedCodecs() {
+        LinkedHashSet<VideoCodecInfo> supportedCodecInfos = new LinkedHashSet<>();
+
+        supportedCodecInfos.addAll(Arrays.asList(softwareVideoDecoderFactory.getSupportedCodecs()));
+        supportedCodecInfos.addAll(Arrays.asList(hardwareVideoDecoderFactory.getSupportedCodecs()));
+        supportedCodecInfos.addAll(Arrays.asList(platformSoftwareVideoDecoderFactory.getSupportedCodecs()));
+
+        return supportedCodecInfos.toArray(new VideoCodecInfo[supportedCodecInfos.size()]);
+    }
+}

android/sdk/src/main/java/org/jitsi/meet/sdk/JitsiVideoEncoderFactory.java

@@ -0,0 +1,16 @@
+package org.jitsi.meet.sdk;
+
+import androidx.annotation.Nullable;
+
+import com.oney.WebRTCModule.webrtcutils.H264AndSoftwareVideoEncoderFactory;
+
+import org.webrtc.EglBase;
+
+/**
+ * Custom encoder factory which uses HW for H.264 and SW for everything else.
+ */
+public class JitsiVideoEncoderFactory extends H264AndSoftwareVideoEncoderFactory {
+    public JitsiVideoEncoderFactory(@Nullable EglBase.Context eglContext) {
+        super(eglContext);
+    }
+}

android/sdk/src/main/java/org/jitsi/meet/sdk/LocaleDetector.java

@@ -0,0 +1,58 @@
+/*
+ * Copyright @ 2018-present 8x8, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+ * Based on https://github.com/DylanVann/react-native-locale-detector
+ */
+
+package org.jitsi.meet.sdk;
+
+import android.content.Context;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Module which provides information about the system locale.
+ */
+class LocaleDetector extends ReactContextBaseJavaModule {
+
+    public LocaleDetector(ReactApplicationContext reactContext) {
+        super(reactContext);
+    }
+
+    /**
+     * Gets a {@code Map} of constants this module exports to JS. Supports JSON
+     * types.
+     *
+     * @return a {@link Map} of constants this module exports to JS
+     */
+    @Override
+    public Map<String, Object> getConstants() {
+        Context context = getReactApplicationContext();
+        HashMap<String,Object> constants = new HashMap<>();
+        constants.put("locale", context.getResources().getConfiguration().locale.toLanguageTag());
+        return constants;
+    }
+
+    @Override
+    public String getName() {
+        return "LocaleDetector";
+    }
+}

android/sdk/src/main/java/org/jitsi/meet/sdk/LogBridgeModule.java

@@ -0,0 +1,73 @@
+/*
+ * Copyright @ 2019-present 8x8, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jitsi.meet.sdk;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.module.annotations.ReactModule;
+
+import org.jitsi.meet.sdk.log.JitsiMeetLogger;
+
+import javax.annotation.Nonnull;
+
+/**
+ * Module implementing a "bridge" between the JS loggers and the native one.
+ */
+@ReactModule(name = LogBridgeModule.NAME)
+class LogBridgeModule extends ReactContextBaseJavaModule {
+    public static final String NAME = "LogBridge";
+
+    public LogBridgeModule(@Nonnull ReactApplicationContext reactContext) {
+        super(reactContext);
+    }
+
+    @Override
+    public String getName() {
+        return NAME;
+    }
+
+    @ReactMethod
+    public void trace(final String message) {
+        JitsiMeetLogger.v(message);
+    }
+
+    @ReactMethod
+    public void debug(final String message) {
+        JitsiMeetLogger.d(message);
+    }
+
+    @ReactMethod
+    public void info(final String message) {
+        JitsiMeetLogger.i(message);
+    }
+
+    @ReactMethod
+    public void log(final String message) {
+        JitsiMeetLogger.i(message);
+    }
+
+    @ReactMethod
+    public void warn(final String message) {
+        JitsiMeetLogger.w(message);
+    }
+
+    @ReactMethod
+    public void error(final String message) {
+        JitsiMeetLogger.e(message);
+    }
+}

android/sdk/src/main/java/org/jitsi/meet/sdk/OngoingConferenceTracker.java

@@ -0,0 +1,99 @@
+/*
+ * Copyright @ 2019-present 8x8, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jitsi.meet.sdk;
+
+import com.facebook.react.bridge.ReadableMap;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
+
+
+/**
+ * Helper class to keep track of what the current conference is.
+ */
+class OngoingConferenceTracker {
+    private static final OngoingConferenceTracker instance = new OngoingConferenceTracker();
+
+    private static final String CONFERENCE_WILL_JOIN = "CONFERENCE_WILL_JOIN";
+    private static final String CONFERENCE_TERMINATED = "CONFERENCE_TERMINATED";
+
+    private final Collection<OngoingConferenceListener> listeners =
+        Collections.synchronizedSet(new HashSet<OngoingConferenceListener>());
+    private String currentConference;
+
+    public OngoingConferenceTracker() {
+    }
+
+    public static OngoingConferenceTracker getInstance() {
+        return instance;
+    }
+
+    /**
+     * Gets the current active conference URL.
+     *
+     * @return - The current conference URL as a String.
+     */
+    synchronized String getCurrentConference() {
+        return currentConference;
+    }
+
+    synchronized void onExternalAPIEvent(String name, ReadableMap data) {
+        if (!data.hasKey("url")) {
+            return;
+        }
+
+        String url = data.getString("url");
+        if (url == null) {
+            return;
+        }
+
+        switch(name) {
+            case CONFERENCE_WILL_JOIN:
+                currentConference = url;
+                updateListeners();
+                break;
+
+            case CONFERENCE_TERMINATED:
+                if (url.equals(currentConference)) {
+                    currentConference = null;
+                    updateListeners();
+                }
+                break;
+        }
+    }
+
+    void addListener(OngoingConferenceListener listener) {
+        listeners.add(listener);
+    }
+
+    void removeListener(OngoingConferenceListener listener) {
+        listeners.remove(listener);
+    }
+
+    private void updateListeners() {
+        synchronized (listeners) {
+            for (OngoingConferenceListener listener : listeners) {
+                listener.onCurrentConferenceChanged(currentConference);
+            }
+        }
+    }
+
+    public interface OngoingConferenceListener {
+        void onCurrentConferenceChanged(String conferenceUrl);
+    }
+}

android/sdk/src/main/java/org/jitsi/meet/sdk/OngoingNotification.java

@@ -0,0 +1,124 @@
+/*
+ * Copyright @ 2019-present 8x8, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jitsi.meet.sdk;
+
+import org.jitsi.meet.sdk.log.JitsiMeetLogger;
+
+import android.app.Activity;
+import android.app.NotificationChannel;
+import android.app.NotificationManager;
+import android.app.Notification;
+import android.app.PendingIntent;
+import android.content.Context;
+import android.content.Intent;
+
+import androidx.annotation.StringRes;
+import androidx.core.app.NotificationCompat;
+
+
+/**
+ * Helper class for creating the ongoing notification which is used with
+ * {@link JitsiMeetOngoingConferenceService}. It allows the user to easily get back to the app
+ * and to hangup from within the notification itself.
+ */
+class OngoingNotification {
+    private static final String TAG = OngoingNotification.class.getSimpleName();
+
+    private static long startingTime = 0;
+
+    static final String ONGOING_CONFERENCE_CHANNEL_ID = "JitsiOngoingConferenceChannel";
+
+    static void createNotificationChannel(Activity context) {
+        if (context == null) {
+            JitsiMeetLogger.w(TAG + " Cannot create notification channel: no current context");
+            return;
+        }
+
+        NotificationManager notificationManager
+            = (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
+
+        NotificationChannel channel
+            = notificationManager.getNotificationChannel(ONGOING_CONFERENCE_CHANNEL_ID);
+
+        if (channel != null) {
+            // The channel was already created, no need to do it again.
+            return;
+        }
+
+        channel = new NotificationChannel(ONGOING_CONFERENCE_CHANNEL_ID, context.getString(R.string.ongoing_notification_channel_name), NotificationManager.IMPORTANCE_DEFAULT);
+        channel.enableLights(false);
+        channel.enableVibration(false);
+        channel.setShowBadge(false);
+
+        notificationManager.createNotificationChannel(channel);
+    }
+
+    static Notification buildOngoingConferenceNotification(Boolean isMuted, Context context, Class tapBackActivity) {
+        if (context == null) {
+            JitsiMeetLogger.w(TAG + " Cannot create notification: no current context");
+            return null;
+        }
+
+        Intent notificationIntent = new Intent(context, tapBackActivity == null ? context.getClass() : tapBackActivity);
+        PendingIntent pendingIntent = PendingIntent.getActivity(context, 0, notificationIntent, PendingIntent.FLAG_IMMUTABLE);
+
+        NotificationCompat.Builder builder = new NotificationCompat.Builder(context, ONGOING_CONFERENCE_CHANNEL_ID);
+
+        if (startingTime == 0) {
+            startingTime = System.currentTimeMillis();
+        }
+
+        builder
+            .setCategory(NotificationCompat.CATEGORY_CALL)
+            .setContentTitle(context.getString(R.string.ongoing_notification_title))
+            .setContentText(context.getString(R.string.ongoing_notification_text))
+            .setPriority(NotificationCompat.PRIORITY_DEFAULT)
+            .setContentIntent(pendingIntent)
+            .setOngoing(true)
+            .setWhen(startingTime)
+            .setUsesChronometer(true)
+            .setAutoCancel(false)
+            .setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
+            .setOnlyAlertOnce(true)
+            .setSmallIcon(context.getResources().getIdentifier("ic_notification", "drawable", context.getPackageName()));
+
+        NotificationCompat.Action hangupAction = createAction(context, JitsiMeetOngoingConferenceService.Action.HANGUP, R.string.ongoing_notification_action_hang_up);
+
+        JitsiMeetOngoingConferenceService.Action toggleAudioAction = isMuted
+            ? JitsiMeetOngoingConferenceService.Action.UNMUTE : JitsiMeetOngoingConferenceService.Action.MUTE;
+        int toggleAudioTitle = isMuted ? R.string.ongoing_notification_action_unmute : R.string.ongoing_notification_action_mute;
+        NotificationCompat.Action audioAction = createAction(context, toggleAudioAction, toggleAudioTitle);
+
+        builder.addAction(hangupAction);
+        builder.addAction(audioAction);
+
+        return builder.build();
+    }
+
+    static void resetStartingtime() {
+        startingTime = 0;
+    }
+
+    private static NotificationCompat.Action createAction(Context context, JitsiMeetOngoingConferenceService.Action action, @StringRes int titleId) {
+        Intent intent = new Intent(context, JitsiMeetOngoingConferenceService.class);
+        intent.setAction(action.getName());
+        PendingIntent pendingIntent
+            = PendingIntent.getService(context, 0, intent, PendingIntent.FLAG_IMMUTABLE);
+        String title = context.getString(titleId);
+        return new NotificationCompat.Action(0, title, pendingIntent);
+    }
+}

android/sdk/src/main/java/org/jitsi/meet/sdk/ParticipantInfo.java

@@ -0,0 +1,27 @@
+package org.jitsi.meet.sdk;
+
+import com.google.gson.annotations.SerializedName;
+
+public class ParticipantInfo {
+
+    @SerializedName("participantId")
+    public String id;
+
+    @SerializedName("displayName")
+    public String displayName;
+
+    @SerializedName("avatarUrl")
+    public String avatarUrl;
+
+    @SerializedName("email")
+    public String email;
+
+    @SerializedName("name")
+    public String name;
+
+    @SerializedName("isLocal")
+    public boolean isLocal;
+
+    @SerializedName("role")
+    public String role;
+}

android/sdk/src/main/java/org/jitsi/meet/sdk/ParticipantsService.java

@@ -0,0 +1,90 @@
+package org.jitsi.meet.sdk;
+
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+
+import androidx.localbroadcastmanager.content.LocalBroadcastManager;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.WritableMap;
+import com.google.gson.Gson;
+import com.google.gson.reflect.TypeToken;
+
+import org.jitsi.meet.sdk.log.JitsiMeetLogger;
+
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+
+import javax.annotation.Nullable;
+
+public class ParticipantsService extends android.content.BroadcastReceiver {
+
+    private static final String TAG = ParticipantsService.class.getSimpleName();
+    private static final String REQUEST_ID = "requestId";
+
+    private final Map<String, WeakReference<ParticipantsInfoCallback>> participantsInfoCallbackMap = new HashMap<>();
+
+    private static ParticipantsService instance;
+
+    @Nullable
+    public static ParticipantsService getInstance() {
+        return instance;
+    }
+
+    private ParticipantsService(Context context) {
+        LocalBroadcastManager localBroadcastManager = LocalBroadcastManager.getInstance(context);
+
+        IntentFilter intentFilter = new IntentFilter();
+        intentFilter.addAction(BroadcastEvent.Type.PARTICIPANTS_INFO_RETRIEVED.getAction());
+        localBroadcastManager.registerReceiver(this, intentFilter);
+    }
+
+    static void init(Context context) {
+        instance = new ParticipantsService(context);
+    }
+
+    public void retrieveParticipantsInfo(ParticipantsInfoCallback participantsInfoCallback) {
+        String callbackKey = UUID.randomUUID().toString();
+        this.participantsInfoCallbackMap.put(callbackKey, new WeakReference<>(participantsInfoCallback));
+
+        String actionName = BroadcastAction.Type.RETRIEVE_PARTICIPANTS_INFO.getAction();
+        WritableMap data = Arguments.createMap();
+        data.putString(REQUEST_ID, callbackKey);
+        ReactInstanceManagerHolder.emitEvent(actionName, data);
+    }
+
+    @Override
+    public void onReceive(Context context, Intent intent) {
+        BroadcastEvent event = new BroadcastEvent(intent);
+
+        switch (event.getType()) {
+            case PARTICIPANTS_INFO_RETRIEVED:
+                try {
+                    List<ParticipantInfo> participantInfoList = new Gson().fromJson(
+                        event.getData().get("participantsInfo").toString(),
+                        new TypeToken<ArrayList<ParticipantInfo>>() {
+                        }.getType());
+
+                    ParticipantsInfoCallback participantsInfoCallback = this.participantsInfoCallbackMap.get(event.getData().get(REQUEST_ID).toString()).get();
+
+                    if (participantsInfoCallback != null) {
+                        participantsInfoCallback.onReceived(participantInfoList);
+                        this.participantsInfoCallbackMap.remove(participantsInfoCallback);
+                    }
+                } catch (Exception e) {
+                    JitsiMeetLogger.w(TAG + "error parsing participantsList", e);
+                }
+
+                break;
+        }
+    }
+
+    public interface ParticipantsInfoCallback {
+        void onReceived(List<ParticipantInfo> participantInfoList);
+    }
+}

android/sdk/src/main/java/org/jitsi/meet/sdk/PictureInPictureModule.java

@@ -0,0 +1,145 @@
+/*
+ * Copyright @ 2017-present 8x8, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jitsi.meet.sdk;
+
+import android.annotation.TargetApi;
+import android.app.Activity;
+import android.app.ActivityManager;
+import android.app.PictureInPictureParams;
+import android.util.Rational;
+
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.module.annotations.ReactModule;
+
+import org.jitsi.meet.sdk.log.JitsiMeetLogger;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import static android.content.Context.ACTIVITY_SERVICE;
+
+@ReactModule(name = PictureInPictureModule.NAME)
+class PictureInPictureModule extends ReactContextBaseJavaModule {
+
+    public static final String NAME = "PictureInPicture";
+    private static final String TAG = NAME;
+
+    private static boolean isSupported;
+    private boolean isEnabled;
+
+    public PictureInPictureModule(ReactApplicationContext reactContext) {
+        super(reactContext);
+
+        ActivityManager am = (ActivityManager) reactContext.getSystemService(ACTIVITY_SERVICE);
+
+        // Android Go devices don't support PiP. There doesn't seem to be a better way to detect it than
+        // to use ActivityManager.isLowRamDevice().
+        // https://stackoverflow.com/questions/58340558/how-to-detect-android-go
+        isSupported = !am.isLowRamDevice();
+    }
+
+    /**
+     * Gets a {@code Map} of constants this module exports to JS. Supports JSON
+     * types.
+     *
+     * @return a {@link Map} of constants this module exports to JS
+     */
+    @Override
+    public Map<String, Object> getConstants() {
+        Map<String, Object> constants = new HashMap<>();
+        constants.put("SUPPORTED", isSupported);
+        return constants;
+    }
+
+    /**
+     * Enters Picture-in-Picture (mode) for the current {@link Activity}.
+     * Supported on Android API >= 26 (Oreo) only.
+     *
+     * @throws IllegalStateException if {@link #isPictureInPictureSupported()}
+     * returns {@code false} or if {@link #getCurrentActivity()} returns
+     * {@code null}.
+     * @throws RuntimeException if
+     * {@link Activity#enterPictureInPictureMode(PictureInPictureParams)} fails.
+     * That method can also throw a {@link RuntimeException} in various cases,
+     * including when the activity is not visible (paused or stopped), if the
+     * screen is locked or if the user has an activity pinned.
+     */
+    public void enterPictureInPicture() {
+        if (!isEnabled) {
+            return;
+        }
+
+        if (!isSupported) {
+            throw new IllegalStateException("Picture-in-Picture not supported");
+        }
+
+        Activity currentActivity = getCurrentActivity();
+
+        if (currentActivity == null) {
+            throw new IllegalStateException("No current Activity!");
+        }
+
+        JitsiMeetLogger.i(TAG + " Entering Picture-in-Picture");
+
+        PictureInPictureParams.Builder builder
+            = new PictureInPictureParams.Builder()
+                .setAspectRatio(new Rational(1, 1));
+
+        // https://developer.android.com/reference/android/app/Activity.html#enterPictureInPictureMode(android.app.PictureInPictureParams)
+        //
+        // The system may disallow entering picture-in-picture in various cases,
+        // including when the activity is not visible, if the screen is locked
+        // or if the user has an activity pinned.
+        if (!currentActivity.enterPictureInPictureMode(builder.build())) {
+            throw new RuntimeException("Failed to enter Picture-in-Picture");
+        }
+    }
+
+    /**
+     * Enters Picture-in-Picture (mode) for the current {@link Activity}.
+     * Supported on Android API >= 26 (Oreo) only.
+     *
+     * @param promise a {@code Promise} which will resolve with a {@code null}
+     * value upon success, and an {@link Exception} otherwise.
+     */
+    @ReactMethod
+    public void enterPictureInPicture(Promise promise) {
+        try {
+            enterPictureInPicture();
+            promise.resolve(null);
+        } catch (RuntimeException re) {
+            promise.reject(re);
+        }
+    }
+
+    @ReactMethod
+    public void setPictureInPictureEnabled(Boolean enabled) {
+        this.isEnabled = enabled;
+    }
+
+    public boolean isPictureInPictureSupported() {
+        return isSupported;
+    }
+
+    @Override
+    public String getName() {
+        return NAME;
+    }
+}

android/sdk/src/main/java/org/jitsi/meet/sdk/ProximityModule.java

@@ -0,0 +1,107 @@
+/*
+ * Copyright @ 2017-present 8x8, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jitsi.meet.sdk;
+
+import android.content.Context;
+import android.os.PowerManager;
+import android.os.PowerManager.WakeLock;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.UiThreadUtil;
+import com.facebook.react.module.annotations.ReactModule;
+
+/**
+ * Module implementing a simple API to enable a proximity sensor-controlled
+ * wake lock. When the lock is held, if the proximity sensor detects a nearby
+ * object it will dim the screen and disable touch controls. The functionality
+ * is used with the conference audio-only mode.
+ */
+@ReactModule(name = ProximityModule.NAME)
+class ProximityModule extends ReactContextBaseJavaModule {
+
+    public static final String NAME = "Proximity";
+
+    /**
+     * {@link WakeLock} instance.
+     */
+    private final WakeLock wakeLock;
+
+    /**
+     * Initializes a new module instance. There shall be a single instance of
+     * this module throughout the lifetime of the application.
+     *
+     * @param reactContext The {@link ReactApplicationContext} where this module
+     * is created.
+     */
+    public ProximityModule(ReactApplicationContext reactContext) {
+        super(reactContext);
+
+        WakeLock wakeLock;
+        PowerManager powerManager
+            = (PowerManager)
+                reactContext.getSystemService(Context.POWER_SERVICE);
+
+        try {
+            wakeLock
+                = powerManager.newWakeLock(
+                        PowerManager.PROXIMITY_SCREEN_OFF_WAKE_LOCK,
+                        "jitsi:"+NAME);
+        } catch (Throwable ignored) {
+            wakeLock = null;
+        }
+
+        this.wakeLock = wakeLock;
+    }
+
+    /**
+     * Gets the name of this module to be used in the React Native bridge.
+     *
+     * @return The name of this module to be used in the React Native bridge.
+     */
+    @Override
+    public String getName() {
+        return NAME;
+    }
+
+    /**
+     * Acquires / releases the proximity sensor wake lock.
+     *
+     * @param enabled {@code true} to enable the proximity sensor; otherwise,
+     * {@code false}.
+     */
+    @ReactMethod
+    public void setEnabled(final boolean enabled) {
+        if (wakeLock == null) {
+            return;
+        }
+
+        UiThreadUtil.runOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                if (enabled) {
+                    if (!wakeLock.isHeld()) {
+                        wakeLock.acquire();
+                    }
+                } else if (wakeLock.isHeld()) {
+                    wakeLock.release();
+                }
+            }
+        });
+    }
+}

android/sdk/src/main/java/org/jitsi/meet/sdk/RNConnectionService.java

@@ -0,0 +1,255 @@
+package org.jitsi.meet.sdk;
+
+import android.annotation.SuppressLint;
+import android.content.Context;
+import android.net.Uri;
+import android.os.Bundle;
+import android.telecom.DisconnectCause;
+import android.telecom.PhoneAccount;
+import android.telecom.PhoneAccountHandle;
+import android.telecom.TelecomManager;
+import android.telecom.VideoProfile;
+
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.module.annotations.ReactModule;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+
+import org.jitsi.meet.sdk.log.JitsiMeetLogger;
+
+/**
+ * The react-native side of Jitsi Meet's {@link ConnectionService}. Exposes
+ * the Java Script API.
+ *
+ * @author Pawel Domas
+ */
+@ReactModule(name = RNConnectionService.NAME)
+class RNConnectionService extends ReactContextBaseJavaModule {
+
+    public static final String NAME = "ConnectionService";
+
+    private static final String TAG = ConnectionService.TAG;
+
+    private static RNConnectionService sRNConnectionServiceInstance;
+    /**
+     * Handler for dealing with call state changes. We are acting as a proxy between ConnectionService
+     * and other modules such as {@link AudioModeModule}.
+     */
+    private CallAudioStateListener callAudioStateListener;
+
+    /**
+     * Sets the audio route on all existing {@link android.telecom.Connection}s
+     *
+     * @param audioRoute the new audio route to be set. See
+     * {@link android.telecom.CallAudioState} constants prefixed with "ROUTE_".
+     */
+    static void setAudioRoute(int audioRoute) {
+        for (ConnectionService.ConnectionImpl c
+                : ConnectionService.getConnections()) {
+            c.setAudioRoute(audioRoute);
+        }
+    }
+
+    RNConnectionService(ReactApplicationContext reactContext) {
+        super(reactContext);
+        sRNConnectionServiceInstance = this;
+    }
+
+    static RNConnectionService getInstance() {
+        return sRNConnectionServiceInstance;
+    }
+
+    @ReactMethod
+    public void addListener(String eventName) {
+        // Keep: Required for RN built in Event Emitter Calls.
+    }
+
+    @ReactMethod
+    public void removeListeners(Integer count) {
+        // Keep: Required for RN built in Event Emitter Calls.
+    }
+
+    /**
+     * Starts a new outgoing call.
+     *
+     * @param callUUID - unique call identifier assigned by Jitsi Meet to
+     *        a conference call.
+     * @param handle - a call handle which by default is Jitsi Meet room's URL.
+     * @param hasVideo - whether or not user starts with the video turned on.
+     * @param promise - the Promise instance passed by the React-native bridge,
+     *        so that this method returns a Promise on the JS side.
+     *
+     * NOTE regarding the "missingPermission" suppress - SecurityException will
+     * be handled as part of the Exception try catch block and the Promise will
+     * be rejected.
+     */
+    @SuppressLint("MissingPermission")
+    @ReactMethod
+    public void startCall(
+            String callUUID,
+            String handle,
+            boolean hasVideo,
+            Promise promise) {
+        JitsiMeetLogger.d("%s startCall UUID=%s, h=%s, v=%s",
+                            TAG,
+                            callUUID,
+                            handle,
+                            hasVideo);
+
+        ReactApplicationContext ctx = getReactApplicationContext();
+
+        Uri address = Uri.fromParts(PhoneAccount.SCHEME_SIP, handle, null);
+        PhoneAccountHandle accountHandle;
+
+        try {
+            accountHandle
+                = ConnectionService.registerPhoneAccount(getReactApplicationContext(), address, callUUID);
+        } catch (Throwable tr) {
+            JitsiMeetLogger.e(tr, TAG + " error in startCall");
+
+            promise.reject(tr);
+            return;
+        }
+
+        Bundle extras = new Bundle();
+        extras.putParcelable(
+                TelecomManager.EXTRA_PHONE_ACCOUNT_HANDLE,
+                accountHandle);
+        extras.putInt(
+            TelecomManager.EXTRA_START_CALL_WITH_VIDEO_STATE,
+            hasVideo
+                ? VideoProfile.STATE_BIDIRECTIONAL
+                : VideoProfile.STATE_AUDIO_ONLY);
+
+        ConnectionService.registerStartCallPromise(callUUID, promise);
+
+        TelecomManager tm = null;
+
+        try {
+            tm = (TelecomManager) ctx.getSystemService(Context.TELECOM_SERVICE);
+            tm.placeCall(address, extras);
+        } catch (Throwable tr) {
+            JitsiMeetLogger.e(tr, TAG + " error in startCall");
+            if (tm != null) {
+                try {
+                    tm.unregisterPhoneAccount(accountHandle);
+                } catch (Throwable tr1) {
+                    // UnsupportedOperationException: System does not support feature android.software.connectionservice
+                    // was observed here. Ignore.
+                }
+            }
+            ConnectionService.unregisterStartCallPromise(callUUID);
+            promise.reject(tr);
+        }
+    }
+
+    /**
+     * Called by the JS side of things to mark the call as failed.
+     *
+     * @param callUUID - the call's UUID.
+     */
+    @ReactMethod
+    public void reportCallFailed(String callUUID) {
+        JitsiMeetLogger.d(TAG + " reportCallFailed " + callUUID);
+        ConnectionService.setConnectionDisconnected(
+                callUUID,
+                new DisconnectCause(DisconnectCause.ERROR));
+    }
+
+    /**
+     * Called by the JS side of things to mark the call as disconnected.
+     *
+     * @param callUUID - the call's UUID.
+     */
+    @ReactMethod
+    public void endCall(String callUUID) {
+        JitsiMeetLogger.d(TAG + " endCall " + callUUID);
+        ConnectionService.setConnectionDisconnected(
+                callUUID,
+                new DisconnectCause(DisconnectCause.LOCAL));
+    }
+
+    /**
+     * Called by the JS side of things to mark the call as active.
+     *
+     * @param callUUID - the call's UUID.
+     */
+    @ReactMethod
+    public void reportConnectedOutgoingCall(String callUUID, Promise promise) {
+        JitsiMeetLogger.d(TAG + " reportConnectedOutgoingCall " + callUUID);
+        if (ConnectionService.setConnectionActive(callUUID)) {
+            promise.resolve(null);
+        } else {
+            promise.reject("CONNECTION_NOT_FOUND_ERROR", "Connection wasn't found.");
+        }
+    }
+
+    @Override
+    public String getName() {
+        return NAME;
+    }
+
+    /**
+     * Called by the JS side to update the call's state.
+     *
+     * @param callUUID - the call's UUID.
+     * @param callState - the map which carries info about the current call's
+     * state. See static fields in {@link ConnectionService.ConnectionImpl}
+     * prefixed with "KEY_" for the values supported by the Android
+     * implementation.
+     */
+    @ReactMethod
+    public void updateCall(String callUUID, ReadableMap callState) {
+        ConnectionService.updateCall(callUUID, callState);
+    }
+
+    public CallAudioStateListener getCallAudioStateListener() {
+        return callAudioStateListener;
+    }
+
+    public void setCallAudioStateListener(CallAudioStateListener callAudioStateListener) {
+        this.callAudioStateListener = callAudioStateListener;
+    }
+
+    /**
+     * Handler for call state changes. {@code ConnectionServiceImpl} will call this handler when the
+     * call audio state changes.
+     *
+     * @param callAudioState The current call's audio state.
+     */
+    void onCallAudioStateChange(android.telecom.CallAudioState callAudioState) {
+        if (callAudioStateListener != null) {
+            callAudioStateListener.onCallAudioStateChange(callAudioState);
+        }
+    }
+
+    interface CallAudioStateListener {
+        void onCallAudioStateChange(android.telecom.CallAudioState callAudioState);
+    }
+
+    /**
+     * Helper function to send an event to JavaScript.
+     *
+     * @param eventName {@code String} containing the event name.
+     * @param data {@code Object} optional ancillary data for the event.
+     */
+    void emitEvent(
+        String eventName,
+        @Nullable Object data) {
+        ReactContext reactContext = getReactApplicationContext();
+
+        if (reactContext != null) {
+            reactContext
+                .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+                .emit(eventName, data);
+        }
+    }
+}

android/sdk/src/main/java/org/jitsi/meet/sdk/ReactInstanceManagerHolder.java

@@ -0,0 +1,245 @@
+/*
+ * Copyright @ 2017-present 8x8, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jitsi.meet.sdk;
+
+import android.annotation.SuppressLint;
+import android.app.Activity;
+import android.app.Application;
+
+import androidx.annotation.Nullable;
+
+import com.facebook.hermes.reactexecutor.HermesExecutorFactory;
+import com.facebook.react.ReactInstanceManager;
+import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.common.LifecycleState;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+import com.facebook.react.uimanager.ViewManager;
+import com.oney.WebRTCModule.EglUtils;
+import com.oney.WebRTCModule.WebRTCModuleOptions;
+
+import org.jitsi.meet.sdk.log.JitsiMeetLogger;
+import org.webrtc.EglBase;
+
+import java.lang.reflect.Constructor;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+class ReactInstanceManagerHolder {
+    private static final String TAG = ReactInstanceManagerHolder.class.getSimpleName();
+
+    /**
+     * FIXME (from linter): Do not place Android context classes in static
+     * fields (static reference to ReactInstanceManager which has field
+     * mApplicationContext pointing to Context); this is a memory leak (and
+     * also breaks Instant Run).
+     *
+     * React Native bridge. The instance manager allows embedding applications
+     * to create multiple root views off the same JavaScript bundle.
+     */
+    private static ReactInstanceManager reactInstanceManager;
+
+    private static List<NativeModule> createNativeModules(ReactApplicationContext reactContext) {
+        List<NativeModule> nativeModules
+            = new ArrayList<>(Arrays.<NativeModule>asList(
+                new AndroidSettingsModule(reactContext),
+                new AppInfoModule(reactContext),
+                new AudioModeModule(reactContext),
+                new DropboxModule(reactContext),
+                new ExternalAPIModule(reactContext),
+                new JavaScriptSandboxModule(reactContext),
+                new LocaleDetector(reactContext),
+                new LogBridgeModule(reactContext),
+                new PictureInPictureModule(reactContext),
+                new ProximityModule(reactContext),
+                new org.jitsi.meet.sdk.net.NAT64AddrInfoModule(reactContext)));
+
+        if (AudioModeModule.useConnectionService()) {
+            nativeModules.add(new RNConnectionService(reactContext));
+        }
+
+        return nativeModules;
+    }
+
+    private static List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
+        return Collections.emptyList();
+    }
+
+    static List<ReactPackage> getReactNativePackages() {
+        List<ReactPackage> packages
+            = new ArrayList<>(Arrays.asList(
+            new com.reactnativecommunity.asyncstorage.AsyncStoragePackage(),
+            new com.ocetnik.timer.BackgroundTimerPackage(),
+            new com.calendarevents.RNCalendarEventsPackage(),
+            new com.sayem.keepawake.KCKeepAwakePackage(),
+            new com.facebook.react.shell.MainReactPackage(),
+            new com.reactnativecommunity.clipboard.ClipboardPackage(),
+            new com.reactnativecommunity.netinfo.NetInfoPackage(),
+            new com.reactnativepagerview.PagerViewPackage(),
+            new com.oblador.performance.PerformancePackage(),
+            new com.reactnativecommunity.slider.ReactSliderPackage(),
+            new com.brentvatne.react.ReactVideoPackage(),
+            new com.reactnativecommunity.webview.RNCWebViewPackage(),
+            new com.kevinresol.react_native_default_preference.RNDefaultPreferencePackage(),
+            new com.learnium.RNDeviceInfo.RNDeviceInfo(),
+            new com.oney.WebRTCModule.WebRTCModulePackage(),
+            new com.swmansion.gesturehandler.RNGestureHandlerPackage(),
+            new org.linusu.RNGetRandomValuesPackage(),
+            new com.rnimmersivemode.RNImmersiveModePackage(),
+            new com.swmansion.rnscreens.RNScreensPackage(),
+            new com.zmxv.RNSound.RNSoundPackage(),
+            new com.th3rdwave.safeareacontext.SafeAreaContextPackage(),
+            new com.horcrux.svg.SvgPackage(),
+            new org.wonday.orientation.OrientationPackage(),
+            new com.splashview.SplashViewPackage(),
+            new ReactPackageAdapter() {
+                @Override
+                public List<NativeModule> createNativeModules(ReactApplicationContext reactContext) {
+                    return ReactInstanceManagerHolder.createNativeModules(reactContext);
+                }
+                @Override
+                public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
+                    return ReactInstanceManagerHolder.createViewManagers(reactContext);
+                }
+            }));
+
+        // AmplitudeReactNativePackage
+        try {
+            Class<?> amplitudePackageClass = Class.forName("com.amplitude.reactnative.AmplitudeReactNativePackage");
+            Constructor<?> constructor = amplitudePackageClass.getConstructor();
+            packages.add((ReactPackage)constructor.newInstance());
+        } catch (Exception e) {
+            // Ignore any error, the module is not compiled when LIBRE_BUILD is enabled.
+            JitsiMeetLogger.d(TAG, "Not loading AmplitudeReactNativePackage");
+        }
+
+        // GiphyReactNativeSdkPackage
+        try {
+            Class<?> giphyPackageClass = Class.forName("com.giphyreactnativesdk.RTNGiphySdkPackage");
+            Constructor<?> constructor = giphyPackageClass.getConstructor();
+            packages.add((ReactPackage)constructor.newInstance());
+        } catch (Exception e) {
+            // Ignore any error, the module is not compiled when LIBRE_BUILD is enabled.
+            JitsiMeetLogger.d(TAG, "Not loading GiphyReactNativeSdkPackage");
+        }
+
+        // RNGoogleSignInPackage
+        try {
+            Class<?> googlePackageClass = Class.forName("com.reactnativegooglesignin.RNGoogleSigninPackage");
+            Constructor<?> constructor = googlePackageClass.getConstructor();
+            packages.add((ReactPackage)constructor.newInstance());
+        } catch (Exception e) {
+            // Ignore any error, the module is not compiled when LIBRE_BUILD is enabled.
+            JitsiMeetLogger.d(TAG, "Not loading RNGoogleSignInPackage");
+        }
+
+        return packages;
+    }
+
+    /**
+     * Helper function to send an event to JavaScript.
+     *
+     * @param eventName {@code String} containing the event name.
+     * @param data {@code Object} optional ancillary data for the event.
+     */
+    static void emitEvent(
+            String eventName,
+            @Nullable Object data) {
+        ReactInstanceManager reactInstanceManager
+            = ReactInstanceManagerHolder.getReactInstanceManager();
+
+        if (reactInstanceManager != null) {
+            @SuppressLint("VisibleForTests") ReactContext reactContext
+                = reactInstanceManager.getCurrentReactContext();
+
+            if (reactContext != null) {
+                reactContext
+                    .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+                    .emit(eventName, data);
+            }
+        }
+    }
+
+    /**
+     * Finds a native React module for given class.
+     *
+     * @param nativeModuleClass the native module's class for which an instance
+     * is to be retrieved from the {@link #reactInstanceManager}.
+     * @param <T> the module's type.
+     * @return {@link NativeModule} instance for given interface type or
+     * {@code null} if no instance for this interface is available, or if
+     * {@link #reactInstanceManager} has not been initialized yet.
+     */
+    static <T extends NativeModule> T getNativeModule(
+            Class<T> nativeModuleClass) {
+        @SuppressLint("VisibleForTests") ReactContext reactContext
+            = reactInstanceManager != null
+                ? reactInstanceManager.getCurrentReactContext() : null;
+
+        return reactContext != null
+                ? reactContext.getNativeModule(nativeModuleClass) : null;
+    }
+
+    static ReactInstanceManager getReactInstanceManager() {
+        return reactInstanceManager;
+    }
+
+    /**
+     * Internal method to initialize the React Native instance manager. We
+     * create a single instance in order to load the JavaScript bundle a single
+     * time. All {@code ReactRootView} instances will be tied to the one and
+     * only {@code ReactInstanceManager}.
+     *
+     * @param app {@code Application}
+     */
+    static void initReactInstanceManager(Application app) {
+        if (reactInstanceManager != null) {
+            return;
+        }
+
+        // Initialize the WebRTC module options.
+        WebRTCModuleOptions options = WebRTCModuleOptions.getInstance();
+        options.enableMediaProjectionService = true;
+        if (options.videoDecoderFactory == null || options.videoEncoderFactory == null) {
+            EglBase.Context eglContext = EglUtils.getRootEglBaseContext();
+            if (options.videoDecoderFactory == null) {
+                options.videoDecoderFactory = new JitsiVideoDecoderFactory(eglContext);
+            }
+            if (options.videoEncoderFactory == null) {
+                options.videoEncoderFactory = new JitsiVideoEncoderFactory(eglContext);
+            }
+        }
+
+        JitsiMeetLogger.d(TAG, "initializing RN");
+
+        reactInstanceManager
+            = ReactInstanceManager.builder()
+                .setApplication(app)
+                .setCurrentActivity(null)
+                .setBundleAssetName("index.android.bundle")
+                .setJSMainModulePath("index.android")
+                .setJavaScriptExecutorFactory(new HermesExecutorFactory())
+                .addPackages(getReactNativePackages())
+                .setUseDeveloperSupport(BuildConfig.DEBUG)
+                .setInitialLifecycleState(LifecycleState.BEFORE_CREATE)
+                .build();
+    }
+}

android/sdk/src/main/java/org/jitsi/meet/sdk/ReactPackageAdapter.java

@@ -0,0 +1,41 @@
+/*
+ * Copyright @ 2017-present Atlassian Pty Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jitsi.meet.sdk;
+
+import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.uimanager.ViewManager;
+
+import java.util.Collections;
+import java.util.List;
+
+class ReactPackageAdapter
+    implements ReactPackage {
+
+    @Override
+    public List<NativeModule> createNativeModules(
+            ReactApplicationContext reactContext) {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public List<ViewManager> createViewManagers(
+            ReactApplicationContext reactContext) {
+        return Collections.emptyList();
+    }
+}

android/sdk/src/main/java/org/jitsi/meet/sdk/log/JitsiMeetBaseLogHandler.java

@@ -0,0 +1,49 @@
+/*
+ * Copyright @ 2019-present 8x8, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jitsi.meet.sdk.log;
+
+import android.util.Log;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.text.MessageFormat;
+
+import timber.log.Timber;
+
+/**
+ * Base class for all custom log handlers. Implementations must inherit from this class and
+ * implement a `doLog` method which does the actual logging, in addition with a `getTag` method
+ * with which to tag all logs coming into this logger.
+ *
+ * See {@link JitsiMeetDefaultLogHandler} for an example.
+ */
+public abstract class JitsiMeetBaseLogHandler extends Timber.Tree {
+    @Override
+    protected void log(int priority, @Nullable String tag, @NotNull String msg, @Nullable Throwable t) {
+        String errmsg = Log.getStackTraceString(t);
+        if (errmsg.isEmpty()) {
+            doLog(priority, getDefaultTag(), msg);
+        } else {
+            doLog(priority, getDefaultTag(), MessageFormat.format("{0}\n{1}", msg, errmsg));
+        }
+    }
+
+    protected abstract void doLog(int priority, @NotNull String tag, @NotNull String msg);
+
+    protected abstract String getDefaultTag();
+}

android/sdk/src/main/java/org/jitsi/meet/sdk/log/JitsiMeetDefaultLogHandler.java

@@ -0,0 +1,39 @@
+/*
+ * Copyright @ 2019-present 8x8, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jitsi.meet.sdk.log;
+
+import android.util.Log;
+
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Default implementation of a {@link JitsiMeetBaseLogHandler}. This is the main SDK logger, which
+ * logs using the Android util.Log module.
+ */
+public class JitsiMeetDefaultLogHandler extends JitsiMeetBaseLogHandler {
+    private static final String TAG = "JitsiMeetSDK";
+
+    @Override
+    protected void doLog(int priority, @NotNull String tag, @NotNull String msg) {
+        Log.println(priority, tag, msg);
+    }
+
+    @Override
+    protected String getDefaultTag() {
+        return TAG;
+    }
+}

android/sdk/src/main/java/org/jitsi/meet/sdk/log/JitsiMeetLogger.java

@@ -0,0 +1,107 @@
+/*
+ * Copyright @ 2019-present 8x8, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jitsi.meet.sdk.log;
+
+import timber.log.Timber;
+
+public class JitsiMeetLogger {
+    static {
+        addHandler(new JitsiMeetDefaultLogHandler());
+    }
+
+    public static void addHandler(JitsiMeetBaseLogHandler handler) {
+        if (!Timber.forest().contains(handler)) {
+            try {
+                Timber.plant(handler);
+            } catch (Throwable t) {
+                Timber.w(t, "Couldn't add log handler");
+            }
+
+        }
+    }
+
+    public static void removeHandler(JitsiMeetBaseLogHandler handler) {
+        if (Timber.forest().contains(handler)) {
+            try {
+                Timber.uproot(handler);
+            } catch (Throwable t) {
+                Timber.w(t, "Couldn't remove log handler");
+            }
+        }
+    }
+
+    public static void v(String message, Object... args) {
+        Timber.v(message, args);
+    }
+
+    public static void v(Throwable t, String message, Object... args) {
+        Timber.v(t, message, args);
+    }
+
+    public static void v(Throwable t) {
+        Timber.v(t);
+    }
+
+    public static void d(String message, Object... args) {
+        Timber.d(message, args);
+    }
+
+    public static void d(Throwable t, String message, Object... args) {
+        Timber.d(t, message, args);
+    }
+
+    public static void d(Throwable t) {
+        Timber.d(t);
+    }
+
+    public static void i(String message, Object... args) {
+        Timber.i(message, args);
+    }
+
+    public static void i(Throwable t, String message, Object... args) {
+        Timber.i(t, message, args);
+    }
+
+    public static void i(Throwable t) {
+        Timber.i(t);
+    }
+
+    public static void w(String message, Object... args) {
+        Timber.w(message, args);
+    }
+
+    public static void w(Throwable t, String message, Object... args) {
+        Timber.w(t, message, args);
+    }
+
+    public static void w(Throwable t) {
+        Timber.w(t);
+    }
+
+    public static void e(String message, Object... args) {
+        Timber.e(message, args);
+    }
+
+    public static void e(Throwable t, String message, Object... args) {
+        Timber.e(t, message, args);
+    }
+
+    public static void e(Throwable t) {
+        Timber.e(t);
+    }
+
+}

android/sdk/src/main/java/org/jitsi/meet/sdk/net/NAT64AddrInfo.java

@@ -0,0 +1,238 @@
+/*
+ * Copyright @ 2018-present Atlassian Pty Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.jitsi.meet.sdk.net;
+
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+
+/**
+ * Constructs IPv6 addresses for IPv4 addresses in the NAT64 environment.
+ *
+ * NAT64 translates IPv4 to IPv6 addresses by adding "well known" prefix and
+ * suffix configured by the administrator. Those are figured out by discovering
+ * both IPv6 and IPv4 addresses of a host and then trying to find a place where
+ * the IPv4 address fits into the format described here:
+ * https://tools.ietf.org/html/rfc6052#section-2.2
+ */
+public class NAT64AddrInfo {
+    /**
+     * Coverts bytes array to upper case HEX string.
+     *
+     * @param bytes an array of bytes to be converted
+     * @return ex. "010AFF" for an array of {1, 10, 255}.
+     */
+    static String bytesToHexString(byte[] bytes) {
+        StringBuilder hexStr = new StringBuilder();
+
+        for (byte b : bytes) {
+            hexStr.append(String.format("%02X", b));
+        }
+
+        return hexStr.toString();
+    }
+
+    /**
+     * Tries to discover the NAT64 prefix/suffix based on the IPv4 and IPv6
+     * addresses resolved for given {@code host}.
+     *
+     * @param host the host for which the code will try to discover IPv4 and
+     * IPv6 addresses which then will be used to figure out the NAT64 prefix.
+     * @return {@link NAT64AddrInfo} instance if the NAT64 prefix/suffix was
+     * successfully discovered or {@code null} if it failed for any reason.
+     * @throws UnknownHostException thrown by {@link InetAddress#getAllByName}.
+     */
+    public static NAT64AddrInfo discover(String host)
+            throws UnknownHostException {
+        InetAddress ipv4 = null;
+        InetAddress ipv6 = null;
+
+        for(InetAddress addr : InetAddress.getAllByName(host)) {
+            byte[] bytes = addr.getAddress();
+
+            if (bytes.length == 4) {
+                ipv4 = addr;
+            } else if (bytes.length == 16) {
+                ipv6 = addr;
+            }
+        }
+
+        if (ipv4 != null && ipv6 != null) {
+            return figureOutNAT64AddrInfo(ipv4.getAddress(), ipv6.getAddress());
+        }
+
+        return null;
+    }
+
+    /**
+     * Based on IPv4 and IPv6 addresses of the same host, the method will make
+     * an attempt to figure out what are the NAT64 prefix and suffix.
+     *
+     * @param ipv4AddrBytes the IPv4 address of the same host in NAT64 network,
+     * as returned by {@link InetAddress#getAddress()}.
+     * @param ipv6AddrBytes the IPv6 address of the same host in NAT64 network,
+     * as returned by {@link InetAddress#getAddress()}.
+     * @return {@link NAT64AddrInfo} instance which contains the prefix/suffix
+     * of the current NAT64 network or {@code null} if the prefix could not be
+     * found.
+     */
+    static NAT64AddrInfo figureOutNAT64AddrInfo(
+            byte[] ipv4AddrBytes,
+            byte[] ipv6AddrBytes) {
+        String ipv6Str = bytesToHexString(ipv6AddrBytes);
+        String ipv4Str = bytesToHexString(ipv4AddrBytes);
+
+        // NAT64 address format:
+        // +--+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
+        // |PL| 0-------------32--40--48--56--64--72--80--88--96--104---------|
+        // +--+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
+        // |32|     prefix    |v4(32)         | u | suffix                    |
+        // +--+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
+        // |40|     prefix        |v4(24)     | u |(8)| suffix                |
+        // +--+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
+        // |48|     prefix            |v4(16) | u | (16)  | suffix            |
+        // +--+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
+        // |56|     prefix                |(8)| u |  v4(24)   | suffix        |
+        // +--+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
+        // |64|     prefix                    | u |   v4(32)      | suffix    |
+        // +--+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
+        // |96|     prefix                                    |    v4(32)     |
+        // +--+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
+        int prefixLength = 96;
+        int suffixLength = 0;
+        String prefix = null;
+        String suffix = null;
+
+        if (ipv4Str.equalsIgnoreCase(ipv6Str.substring(prefixLength / 4))) {
+            prefix = ipv6Str.substring(0, prefixLength / 4);
+        } else {
+            // Cut out the 'u' octet
+            ipv6Str = ipv6Str.substring(0, 16) + ipv6Str.substring(18);
+
+            for (prefixLength = 64, suffixLength = 6; prefixLength >= 32; ) {
+                if (ipv4Str.equalsIgnoreCase(
+                        ipv6Str.substring(
+                                prefixLength / 4, prefixLength / 4 + 8))) {
+                    prefix = ipv6Str.substring(0, prefixLength / 4);
+                    suffix = ipv6Str.substring(ipv6Str.length() - suffixLength);
+                    break;
+                }
+
+                prefixLength -= 8;
+                suffixLength += 2;
+            }
+        }
+
+        return prefix != null ? new NAT64AddrInfo(prefix, suffix) : null;
+    }
+
+    /**
+     * An overload for {@link #hexStringToIPv6String(StringBuilder)}.
+     *
+     * @param hexStr a hex representation of IPv6 address bytes.
+     * @return an IPv6 address string.
+     */
+    static String hexStringToIPv6String(String hexStr) {
+        return hexStringToIPv6String(new StringBuilder(hexStr));
+    }
+
+    /**
+     * Converts from HEX representation of IPv6 address bytes into IPv6 address
+     * string which includes the ':' signs.
+     *
+     * @param str a hex representation of IPv6 address bytes.
+     * @return eg. FE80:CD00:0000:0CDA:1357:0000:212F:749C
+     */
+    static String hexStringToIPv6String(StringBuilder str) {
+        for (int i = 32 - 4; i > 0; i -= 4) {
+            str.insert(i, ":");
+        }
+
+        return str.toString().toUpperCase();
+    }
+
+    /**
+     * Parses an IPv4 address string and returns it's byte array representation.
+     *
+     * @param ipv4Address eg. '192.168.3.23'
+     * @return byte representation of given IPv4 address string.
+     * @throws IllegalArgumentException if the address is not in valid format.
+     */
+    static byte[] ipv4AddressStringToBytes(String ipv4Address) {
+        InetAddress address;
+
+        try {
+            address = InetAddress.getByName(ipv4Address);
+        } catch (UnknownHostException e) {
+            throw new IllegalArgumentException(
+                    "Invalid IP address: " + ipv4Address, e);
+        }
+
+        byte[] bytes = address.getAddress();
+
+        if (bytes.length != 4) {
+            throw new IllegalArgumentException(
+                    "Not an IPv4 address: " + ipv4Address);
+        }
+
+        return bytes;
+    }
+
+    /**
+     * The NAT64 prefix added to construct IPv6 from an IPv4 address.
+     */
+    private final String prefix;
+
+    /**
+     * The NAT64 suffix (if any) used to construct IPv6 from an IPv4 address.
+     */
+    private final String suffix;
+
+    /**
+     * Creates new instance of {@link NAT64AddrInfo}.
+     *
+     * @param prefix the NAT64 prefix.
+     * @param suffix the NAT64 suffix.
+     */
+    private NAT64AddrInfo(String prefix, String suffix) {
+        this.prefix = prefix;
+        this.suffix = suffix;
+    }
+
+    /**
+     * Based on the NAT64 prefix and suffix will create an IPv6 representation
+     * of the given IPv4 address.
+     *
+     * @param ipv4Address eg. '192.34.2.3'
+     * @return IPv6 address string eg. FE80:CD00:0000:0CDA:1357:0000:212F:749C
+     * @throws IllegalArgumentException if given string is not a valid IPv4
+     * address.
+     */
+    public String getIPv6Address(String ipv4Address) {
+        byte[] ipv4AddressBytes = ipv4AddressStringToBytes(ipv4Address);
+        StringBuilder newIPv6Str = new StringBuilder();
+
+        newIPv6Str.append(prefix);
+        newIPv6Str.append(bytesToHexString(ipv4AddressBytes));
+
+        if (suffix != null) {
+            // Insert the 'u' octet.
+            newIPv6Str.insert(16, "00");
+            newIPv6Str.append(suffix);
+        }
+
+        return hexStringToIPv6String(newIPv6Str);
+    }
+}

android/sdk/src/main/java/org/jitsi/meet/sdk/net/NAT64AddrInfoModule.java

@@ -0,0 +1,123 @@
+/*
+ * Copyright @ 2018-present Atlassian Pty Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.jitsi.meet.sdk.net;
+
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.module.annotations.ReactModule;
+
+import org.jitsi.meet.sdk.log.JitsiMeetLogger;
+
+import java.net.UnknownHostException;
+
+/**
+ * This module exposes the functionality of creating an IPv6 representation
+ * of IPv4 addresses in NAT64 environment.
+ *
+ * See[1] and [2] for more info on what NAT64 is.
+ * [1]: https://tools.ietf.org/html/rfc6146
+ * [2]: https://tools.ietf.org/html/rfc6052
+ */
+@ReactModule(name = NAT64AddrInfoModule.NAME)
+public class NAT64AddrInfoModule
+    extends ReactContextBaseJavaModule {
+
+    public final static String NAME = "NAT64AddrInfo";
+
+    /**
+     * The host for which the module wil try to resolve both IPv4 and IPv6
+     * addresses in order to figure out the NAT64 prefix.
+     */
+    private final static String HOST = "ipv4only.arpa";
+
+    /**
+     * How long is the {@link NAT64AddrInfo} instance valid.
+     */
+    private final static long INFO_LIFETIME = 60 * 1000;
+
+    /**
+     * The {@code Log} tag {@code NAT64AddrInfoModule} is to log messages with.
+     */
+    private final static String TAG = NAME;
+
+    /**
+     * The {@link NAT64AddrInfo} instance which holds NAT64 prefix/suffix.
+     */
+    private NAT64AddrInfo info;
+
+    /**
+     * When {@link #info} was created.
+     */
+    private long infoTimestamp;
+
+    /**
+     * Creates new {@link NAT64AddrInfoModule}.
+     *
+     * @param reactContext the react context to be used by the new module
+     * instance.
+     */
+    public NAT64AddrInfoModule(ReactApplicationContext reactContext) {
+        super(reactContext);
+    }
+
+    /**
+     * Tries to obtain IPv6 address for given IPv4 address in NAT64 environment.
+     *
+     * @param ipv4Address IPv4 address string.
+     * @param promise a {@link Promise} which will be resolved either with IPv6
+     * address for given IPv4 address or with {@code null} if no
+     * {@link NAT64AddrInfo} was resolved for the current network. Will be
+     * rejected if given {@code ipv4Address} is not a valid IPv4 address.
+     */
+    @ReactMethod
+    public void getIPv6Address(String ipv4Address, final Promise promise) {
+        // Reset if cached for too long.
+        if (System.currentTimeMillis() - infoTimestamp > INFO_LIFETIME) {
+            info = null;
+        }
+
+        if (info == null) {
+            String host = HOST;
+
+            try {
+                info = NAT64AddrInfo.discover(host);
+            } catch (UnknownHostException e) {
+                JitsiMeetLogger.e(e, TAG + " NAT64AddrInfo.discover: " + host);
+            }
+            infoTimestamp = System.currentTimeMillis();
+        }
+
+        String result;
+
+        try {
+            result = info == null ? null : info.getIPv6Address(ipv4Address);
+        } catch (IllegalArgumentException exc) {
+            JitsiMeetLogger.e(exc, TAG + " Failed to get IPv6 address for: " + ipv4Address);
+
+            // We don't want to reject. It's not a big deal if there's no IPv6
+            // address resolved.
+            result = null;
+        }
+        promise.resolve(result);
+    }
+
+    @Override
+    public String getName() {
+        return NAME;
+    }
+}

android/sdk/src/main/java/org/webrtc/JitsiPlatformVideoDecoderFactory.java

@@ -0,0 +1,40 @@
+/*
+ *  Copyright 2018 The WebRTC project authors. All Rights Reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+package org.webrtc;
+
+import android.media.MediaCodecInfo;
+import androidx.annotation.Nullable;
+
+/** Factory for Android platform software VideoDecoders. */
+public class JitsiPlatformVideoDecoderFactory extends MediaCodecVideoDecoderFactory {
+    /**
+     * Default allowed predicate.
+     */
+    private static final Predicate<MediaCodecInfo> defaultAllowedPredicate =
+        codecInfo -> {
+            // We only want to use the platform software codecs.
+            return MediaCodecUtils.isSoftwareOnly(codecInfo);
+        };
+
+    /**
+     * Creates a PlatformSoftwareVideoDecoderFactory that supports surface texture rendering.
+     *
+     * @param sharedContext The textures generated will be accessible from this context. May be null,
+     *                      this disables texture support.
+     */
+    public JitsiPlatformVideoDecoderFactory(@Nullable EglBase.Context sharedContext) {
+        super(sharedContext, defaultAllowedPredicate);
+    }
+
+    public JitsiPlatformVideoDecoderFactory(@Nullable EglBase.Context sharedContext, @Nullable Predicate<MediaCodecInfo> codecAllowedPredicate) {
+        super(sharedContext, codecAllowedPredicate == null ? defaultAllowedPredicate : codecAllowedPredicate.and(defaultAllowedPredicate));
+    }
+}

android/sdk/src/main/res/layout/activity_jitsi_meet.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="utf-8"?>
+<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:id="@+id/jitsi_layout"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    tools:context=".JitsiMeetActivity">
+
+    <org.jitsi.meet.sdk.JitsiMeetView
+        android:id="@+id/jitsiView"
+        android:layout_width="match_parent"
+        android:layout_height="match_parent" />
+</FrameLayout>

android/sdk/src/main/res/values-ru/strings.xml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="ongoing_notification_title">Текущая встреча</string>
+    <string name="ongoing_notification_text">Нажмите, чтобы вернуться к встрече.</string>
+    <string name="ongoing_notification_action_hang_up">Отключиться</string>
+    <string name="ongoing_notification_action_mute">Отключить звук</string>
+    <string name="ongoing_notification_action_unmute">Включить звук</string>
+    <string name="ongoing_notification_channel_name">Ongoing Conference Notifications</string>
+</resources>

android/sdk/src/main/res/values/strings.xml

@@ -0,0 +1,12 @@
+<resources>
+    <string name="app_name">Jitsi Meet SDK</string>
+    <string name="dropbox_app_key"></string>
+    <string name="media_projection_notification_title">Media projection</string>
+    <string name="media_projection_notification_text">You are currently sharing your screen.</string>
+    <string name="ongoing_notification_title">Ongoing meeting</string>
+    <string name="ongoing_notification_text">You are currently in a meeting. Tap to return to it.</string>
+    <string name="ongoing_notification_action_hang_up">Hang up</string>
+    <string name="ongoing_notification_action_mute">Mute</string>
+    <string name="ongoing_notification_action_unmute">Unmute</string>
+    <string name="ongoing_notification_channel_name">Ongoing Conference Notifications</string>
+</resources>

android/sdk/src/main/res/values/styles.xml

@@ -0,0 +1,3 @@
+<resources>
+    <style name="JitsiMeetActivityStyle" parent="Theme.AppCompat.Light.NoActionBar"/>
+</resources>

android/sdk/src/test/java/org/jitsi/meet/sdk/net/NAT64AddrInfoTest.java

@@ -0,0 +1,150 @@
+/*
+ * Copyright @ 2017-present Atlassian Pty Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.jitsi.meet.sdk.net;
+
+import org.junit.Test;
+
+import java.math.BigInteger;
+import java.net.UnknownHostException;
+
+import static org.junit.Assert.*;
+
+/**
+ * Tests for {@link NAT64AddrInfo} class.
+ */
+public class NAT64AddrInfoTest {
+    /**
+     * Test case for the 96 prefix length.
+     */
+    @Test
+    public void test96Prefix() {
+        testPrefixSuffix(
+                "260777000000000400000000", "", "203.0.113.1", "23.17.23.3");
+    }
+
+    /**
+     * Test case for the 64 prefix length.
+     */
+    @Test
+    public void test64Prefix() {
+        String prefix = "1FF2A227B3AAF3D2";
+        String suffix = "BB87C8";
+
+        testPrefixSuffix(prefix, suffix, "48.46.87.34", "23.87.145.4");
+    }
+
+    /**
+     * Test case for the 56 prefix length.
+     */
+    @Test
+    public void test56Prefix() {
+        String prefix = "1FF2A227B3AAF3";
+        String suffix = "A2BB87C8";
+
+        testPrefixSuffix(prefix, suffix, "34.72.234.255", "1.235.3.65");
+    }
+
+    /**
+     * Test case for the 48 prefix length.
+     */
+    @Test
+    public void test48Prefix() {
+        String prefix = "1FF2A227B3AA";
+        String suffix = "72A2BB87C8";
+
+        testPrefixSuffix(prefix, suffix, "97.54.3.23", "77.49.0.33");
+    }
+
+    /**
+     * Test case for the 40 prefix length.
+     */
+    @Test
+    public void test40Prefix() {
+        String prefix = "1FF2A227B3";
+        String suffix = "D972A2BB87C8";
+
+        testPrefixSuffix(prefix, suffix, "10.23.56.121", "97.65.32.21");
+    }
+
+    /**
+     * Test case for the 32 prefix length.
+     */
+    @Test
+    public void test32Prefix()
+        throws UnknownHostException {
+        String prefix = "1FF2A227";
+        String suffix = "20D972A2BB87C8";
+
+        testPrefixSuffix(prefix, suffix, "162.63.65.189", "135.222.84.206");
+    }
+
+    private static String buildIPv6Addr(
+            String prefix, String suffix, String ipv4Hex) {
+        String ipv6Str = prefix + ipv4Hex + suffix;
+
+        if (suffix.length() > 0) {
+            ipv6Str = new StringBuilder(ipv6Str).insert(16, "00").toString();
+        }
+
+        return ipv6Str;
+    }
+
+    private void testPrefixSuffix(
+            String prefix, String suffix, String ipv4, String otherIPv4) {
+        byte[] ipv4Bytes = NAT64AddrInfo.ipv4AddressStringToBytes(ipv4);
+        String ipv4String = NAT64AddrInfo.bytesToHexString(ipv4Bytes);
+        String ipv6Str = buildIPv6Addr(prefix, suffix, ipv4String);
+
+        BigInteger ipv6Address = new BigInteger(ipv6Str, 16);
+
+        NAT64AddrInfo nat64AddrInfo
+            = NAT64AddrInfo.figureOutNAT64AddrInfo(
+                    ipv4Bytes, ipv6Address.toByteArray());
+
+        assertNotNull("Failed to figure out NAT64 info", nat64AddrInfo);
+
+        String newIPv6 = nat64AddrInfo.getIPv6Address(ipv4);
+
+        assertEquals(
+                NAT64AddrInfo.hexStringToIPv6String(ipv6Address.toString(16)),
+                newIPv6);
+
+        byte[] ipv4Addr2 = NAT64AddrInfo.ipv4AddressStringToBytes(otherIPv4);
+        String ipv4Addr2Hex = NAT64AddrInfo.bytesToHexString(ipv4Addr2);
+
+        newIPv6 = nat64AddrInfo.getIPv6Address(otherIPv4);
+
+        assertEquals(
+                NAT64AddrInfo.hexStringToIPv6String(
+                        buildIPv6Addr(prefix, suffix, ipv4Addr2Hex)),
+                newIPv6);
+    }
+
+    @Test
+    public void testInvalidIPv4Format() {
+        testInvalidIPv4Format("256.1.2.3");
+        testInvalidIPv4Format("FE80:CD00:0000:0CDA:1357:0000:212F:749C");
+    }
+
+    private void testInvalidIPv4Format(String ipv4Str) {
+        try {
+            NAT64AddrInfo.ipv4AddressStringToBytes(ipv4Str);
+            fail("Did not throw IllegalArgumentException");
+        } catch (IllegalArgumentException exc) {
+            /* OK */
+        }
+    }
+}