settings: fix loading disableCallIntegration

Samsung devices (of course) seem to stick with the earpiece if we first select
Bluetooth but then set speaker to false. Reverse the order to make everyone
happy.

This only applies to the generic and legacy handlers.

.flowconfig

@@ -2,22 +2,30 @@
 ; We fork some components by platform
 .*/*[.]android.js
 
-; Ignore "BUCK" generated dirs
-<PROJECT_ROOT>/\.buckd/
-
 ; Ignore unexpected extra "@providesModule"
 .*/node_modules/.*/node_modules/fbjs/.*
+node_modules/react-native/Libraries/react-native/React.js
 
 ; Ignore duplicate module providers
 ; For RN Apps installed via npm, "Libraries" folder is inside
 ; "node_modules/react-native" but in the source repo it is in the root
-.*/Libraries/react-native/React.js
+node_modules/react-native/Libraries/react-native/React.js
+
+; Flow doesn't support platforms
+.*/Libraries/Utilities/LoadingView.js
 
 ; Ignore polyfills
-.*/Libraries/polyfills/.*
+node_modules/react-native/Libraries/polyfills/.*
 
-; Ignore metro
-.*/node_modules/metro/.*
+; These should not be required directly
+; require from fbjs/lib instead: require('fbjs/lib/warning')
+node_modules/warning/.*
+
+; Flow doesn't support platforms
+.*/Libraries/Utilities/HMRLoadingView.js
+
+[untyped]
+.*/node_modules/@react-native-community/cli/.*/.*
 
 ; Ignore packages in node_modules which we (i.e. the jitsi-meet project) have
 ; seen to cause errors and we have chosen not to fix.
@@ -40,6 +48,18 @@ emoji=true
 esproposal.optional_chaining=enable
 esproposal.nullish_coalescing=enable
 
+; We (i.e. the jitsi-meet project) are using the haste module system on Web as
+; well, not only on React Native. Unfortunately, Flow does not support .web.js
+; by default. Override Flow's defaults to include .web.js as well. Technically,
+; we have .native.js as well so the choice of .web.js may lead to errors.
+; Practically though, it is a potential future problem that we do not have at
+; the time of this writing.
+module.file_ext=.web.js
+; Flow's defaults:
+module.file_ext=.js
+module.file_ext=.json
+module.file_ext=.ios.js
+
 module.system=haste
 module.system.haste.use_name_reducers=true
 # get basename
@@ -52,8 +72,11 @@ module.system.haste.name_reducers='^\(.*\)\.android$' -> '\1'
 module.system.haste.name_reducers='^\(.*\)\.native$' -> '\1'
 module.system.haste.paths.blacklist=.*/__tests__/.*
 module.system.haste.paths.blacklist=.*/__mocks__/.*
-module.system.haste.paths.blacklist=<PROJECT_ROOT>/node_modules/react-native/Libraries/Animated/src/polyfills/.*
 module.system.haste.paths.whitelist=<PROJECT_ROOT>/node_modules/react-native/Libraries/.*
+module.system.haste.paths.whitelist=<PROJECT_ROOT>/node_modules/react-native/RNTester/.*
+module.system.haste.paths.whitelist=<PROJECT_ROOT>/node_modules/react-native/IntegrationTests/.*
+module.system.haste.paths.blacklist=<PROJECT_ROOT>/node_modules/react-native/Libraries/react-native/react-native-implementation.js
+module.system.haste.paths.blacklist=<PROJECT_ROOT>/node_modules/react-native/Libraries/Animated/src/polyfills/.*
 
 munge_underscores=true
 
@@ -64,22 +87,32 @@ suppress_type=$FlowFixMe
 suppress_type=$FlowFixMeProps
 suppress_type=$FlowFixMeState
 
-suppress_comment=\\(.\\|\n\\)*\\$FlowFixMe\\($\\|[^(]\\|(\\(<VERSION>\\)? *\\(site=[a-z,_]*react_native[a-z,_]*\\)?)\\)
-suppress_comment=\\(.\\|\n\\)*\\$FlowIssue\\((\\(<VERSION>\\)? *\\(site=[a-z,_]*react_native[a-z,_]*\\)?)\\)?:? #[0-9]+
-suppress_comment=\\(.\\|\n\\)*\\$FlowFixedInNextDeploy
+suppress_comment=\\(.\\|\n\\)*\\$FlowFixMe\\($\\|[^(]\\|(\\(<VERSION>\\)? *\\(site=[a-z,_]*react_native\\(_ios\\)?_\\(oss\\|fb\\)[a-z,_]*\\)?)\\)
+suppress_comment=\\(.\\|\n\\)*\\$FlowIssue\\((\\(<VERSION>\\)? *\\(site=[a-z,_]*react_native\\(_ios\\)?_\\(oss\\|fb\\)[a-z,_]*\\)?)\\)?:? #[0-9]+
+
 suppress_comment=\\(.\\|\n\\)*\\$FlowExpectedError
 
-; We (i.e. the jitsi-meet project) are using the haste module system on Web as
-; well, not only on React Native. Unfortunately, Flow does not support .web.js
-; by default. Override Flow's defaults to include .web.js as well. Technically,
-; we have .native.js as well so the choice of .web.js may lead to errors.
-; Practically though, it is a potential future problem that we do not have at
-; the time of this writing.
-module.file_ext=.web.js
-; Flow's defaults:
-module.file_ext=.js
-module.file_ext=.jsx
-module.file_ext=.json
+[lints]
+sketchy-null-number=warn
+sketchy-null-mixed=warn
+sketchy-number=warn
+untyped-type-import=warn
+nonstrict-import=warn
+deprecated-type=warn
+unsafe-getters-setters=warn
+inexact-spread=warn
+unnecessary-invariant=warn
+signature-verification-failure=warn
+deprecated-utility=error
+
+[strict]
+deprecated-type
+nonstrict-import
+sketchy-null
+unclear-type
+unsafe-getters-setters
+untyped-import
+untyped-type-import
 
 [version]
-^0.92.0
+^0.104.0

.github/ISSUE_TEMPLATE/4-security-issues.md

@@ -0,0 +1,11 @@
+---
+name: Security issues
+about: Please email security@jitsi.org
+
+---
+
+We take security very seriously and develop all Jitsi projects to be secure and safe.
+
+If you find (or simply suspect) a security issue in any of the Jitsi projects, please send us an email to security@jitsi.org.
+
+We encourage responsible disclosure for the sake of our users, so please reach out before posting in a public space.

.travis.yml

@@ -1,4 +1,6 @@
-osx_image: xcode10.2
+osx_image: xcode11.1
 language: objective-c
 script:
 - "./ios/travis-ci/build-ipa.sh"
+after_script:
+  - sleep 10

Makefile

@@ -3,6 +3,7 @@ CLEANCSS = ./node_modules/.bin/cleancss
 DEPLOY_DIR = libs
 LIBJITSIMEET_DIR = node_modules/lib-jitsi-meet/
 LIBFLAC_DIR = node_modules/libflacjs/dist/min/
+RNNOISE_WASM_DIR = node_modules/rnnoise-wasm/dist/
 NODE_SASS = ./node_modules/.bin/node-sass
 NPM = npm
 OUTPUT_DIR = .
@@ -20,7 +21,7 @@ compile:
 clean:
 	rm -fr $(BUILD_DIR)
 
-deploy: deploy-init deploy-appbundle deploy-lib-jitsi-meet deploy-libflac deploy-css deploy-local
+deploy: deploy-init deploy-appbundle deploy-rnnoise-binary deploy-lib-jitsi-meet deploy-libflac deploy-css deploy-local
 
 deploy-init:
 	rm -fr $(DEPLOY_DIR)
@@ -45,6 +46,10 @@ deploy-appbundle:
 		$(OUTPUT_DIR)/analytics-ga.js \
 		$(BUILD_DIR)/analytics-ga.min.js \
 		$(BUILD_DIR)/analytics-ga.min.map \
+		$(BUILD_DIR)/video-blur-effect.min.js \
+		$(BUILD_DIR)/video-blur-effect.min.map \
+		$(BUILD_DIR)/rnnoise-processor.min.js \
+		$(BUILD_DIR)/rnnoise-processor.min.map \
 		$(DEPLOY_DIR)
 
 deploy-lib-jitsi-meet:
@@ -61,6 +66,11 @@ deploy-libflac:
 		$(LIBFLAC_DIR)/libflac4-1.3.2.min.js.mem \
 		$(DEPLOY_DIR)
 
+deploy-rnnoise-binary:
+	cp \
+		$(RNNOISE_WASM_DIR)/rnnoise.wasm \
+		$(DEPLOY_DIR)
+
 deploy-css:
 	$(NODE_SASS) $(STYLES_MAIN) $(STYLES_BUNDLE) && \
 	$(CLEANCSS) $(STYLES_BUNDLE) > $(STYLES_DESTINATION) ; \
@@ -69,7 +79,7 @@ deploy-css:
 deploy-local:
 	([ ! -x deploy-local.sh ] || ./deploy-local.sh)
 
-dev: deploy-init deploy-css deploy-lib-jitsi-meet deploy-libflac
+dev: deploy-init deploy-css deploy-rnnoise-binary deploy-lib-jitsi-meet deploy-libflac
 	$(WEBPACK_DEV_SERVER)
 
 source-package:

README.md

@@ -31,82 +31,9 @@ You can get our mobile versions from here:
 * [Android](https://play.google.com/store/apps/details?id=org.jitsi.meet)
 * [iOS](https://itunes.apple.com/us/app/jitsi-meet/id1165103905)
 
-## Building the sources
+## Development
 
-Node.js >= 10 and npm >= 6 are required.
-
-On Debian/Ubuntu systems, the required packages can be installed with:
-```
-sudo apt-get install npm nodejs
-cd jitsi-meet
-npm install
-```
-
-To build the Jitsi Meet application, just type
-```
-make
-```
-
-### Working with the library sources (lib-jitsi-meet)
-
-By default the library is build from its git repository sources. The default dependency path in package.json is :
-```json
-"lib-jitsi-meet": "jitsi/lib-jitsi-meet",
-```
-
-To work with local copy you must change the path to:
-```json
-"lib-jitsi-meet": "file:///Users/name/local-lib-jitsi-meet-copy",
-```
-
-To make the project you must force it to take the sources as 'npm update':
-```
-npm install lib-jitsi-meet --force && make
-```
-
-Or if you are making only changes to the library:
-```
-npm install lib-jitsi-meet --force && make deploy-lib-jitsi-meet
-```
-
-Alternative way is to use [npm link](https://docs.npmjs.com/cli/link).
-It allows to link `lib-jitsi-meet` dependency to local source in few steps:
-
-```bash
-cd lib-jitsi-meet
-
-#### create global symlink for lib-jitsi-meet package
-npm link
-
-cd ../jitsi-meet
-
-#### create symlink from the local node_modules folder to the global lib-jitsi-meet symlink
-npm link lib-jitsi-meet
-```
-
- After changes in local `lib-jitsi-meet` repository, you can rebuild it with `npm run install` and your `jitsi-meet` repository will use that modified library.
-Note: when using node version 4.x, the make file of jitsi-meet do npm update which will delete the link. It is no longer the case with version 6.x.
-
-If you do not want to use local repository anymore you should run
-```bash
-cd jitsi-meet
-npm unlink lib-jitsi-meet
-npm install
-```
-### Running with webpack-dev-server for development
-
-Use it at the CLI, type
-```
-make dev
-```
-
-By default the backend deployment used is `beta.meet.jit.si`. You can point the Jitsi-Meet app at a different backend by using a proxy server. To do this, set the WEBPACK_DEV_SERVER_PROXY_TARGET variable:
-```
-export WEBPACK_DEV_SERVER_PROXY_TARGET=https://your-example-server.com
-make dev
-```
-
-The app should be running at https://localhost:8080/
+For web development see [here](doc/development.md), and for mobile see [here](doc/mobile.md).
 
 ## Contributing
 
@@ -118,7 +45,8 @@ see our [guidelines for contributing](CONTRIBUTING.md).
 Jitsi Meet provides a very flexible way of embedding in external applications by using the [Jitsi Meet API](doc/api.md).
 
 ## Security
-WebRTC does not provide a way of conducting multi-party conversations with end-to-end encryption. 
+
+WebRTC does not (yet) provide a way of conducting multi-party conversations with end-to-end encryption. 
 Unless you consistently compare DTLS fingerprints with your peers vocally, the same goes for one-to-one calls.
 As a result, your stream is encrypted on the network but decrypted on the machine that hosts the bridge when using Jitsi Meet.
 
@@ -130,9 +58,13 @@ Jitsi Meet in terms of security.
 The [meet.jit.si](https://meet.jit.si) service is maintained by the Jitsi team
 at [8x8](https://8x8.com).
 
-## Mobile app
-Jitsi Meet is also available as a React Native app for Android and iOS.
-Instructions on how to build it can be found [here](doc/mobile.md).
+## Security issues
+
+We take security very seriously and develop all Jitsi projects to be secure and safe.
+
+If you find (or simply suspect) a security issue in any of the Jitsi projects, please send us an email to security@jitsi.org.
+
+**We encourage responsible disclosure for the sake of our users, so please reach out before posting in a public space.**
 
 ## Acknowledgements
 

android/README.md

@@ -207,24 +207,6 @@ public class MainActivity extends FragmentActivity implements JitsiMeetActivityI
 
 </details>
 
-Starting with SDK version 1.22, a Glide module must be provided by the host app.
-This makes it possible to use the Glide image processing library from both the
-SDK and the host app itself.
-
-You can use the code in `JitsiGlideModule.java` and adjust the package name.
-When building, add the following code in your `app/build.gradle` file, adjusting
-the Glide version to match the one in https://github.com/jitsi/jitsi-meet/blob/master/android/build.gradle
-
-```
-// Glide
-implementation("com.github.bumptech.glide:glide:${glideVersion}") {
-    exclude group: "com.android.support", module: "glide"
-}
-implementation("com.github.bumptech.glide:annotations:${glideVersion}") {
-    exclude group: "com.android.support", module: "annotations"
-}
-```
-
 ### JitsiMeetActivity
 
 This class encapsulates a high level API in the form of an Android `FragmentActivity`

android/app/.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/app/.project

@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>app</name>
+	<comment>Project app 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/app/.settings/org.eclipse.buildship.core.prefs

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

android/app/build.gradle

@@ -34,8 +34,6 @@ android {
 
     buildTypes {
         debug {
-            minifyEnabled true
-            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules-debug.pro'
             buildConfigField "boolean", "GOOGLE_SERVICES_ENABLED", "${googleServicesEnabled}"
             buildConfigField "boolean", "LIBRE_BUILD", "${rootProject.ext.libreBuild}"
         }
@@ -70,8 +68,8 @@ repositories {
 
 dependencies {
     implementation fileTree(dir: 'libs', include: ['*.jar'])
-    implementation "com.android.support:support-v4:${rootProject.ext.supportLibVersion}"
-    implementation "com.android.support:appcompat-v7:${rootProject.ext.supportLibVersion}"
+    implementation 'androidx.legacy:legacy-support-v4:1.0.0'
+    implementation 'androidx.appcompat:appcompat:1.0.2'
 
     if (!rootProject.ext.libreBuild) {
         implementation 'com.google.android.gms:play-services-auth:16.0.1'
@@ -88,15 +86,6 @@ dependencies {
 
     debugImplementation 'com.squareup.leakcanary:leakcanary-android:1.6.1'
     releaseImplementation 'com.squareup.leakcanary:leakcanary-android-no-op:1.6.1'
-
-    // Glide
-    implementation("com.github.bumptech.glide:glide:${rootProject.ext.glideVersion}") {
-        exclude group: "com.android.support", module: "glide"
-    }
-    implementation("com.github.bumptech.glide:annotations:${rootProject.ext.glideVersion}") {
-        exclude group: "com.android.support", module: "annotations"
-    }
-    annotationProcessor "com.github.bumptech.glide:compiler:${rootProject.ext.glideVersion}"
 }
 
 gradle.projectsEvaluated {

android/app/proguard-rules-debug.pro

@@ -1,5 +0,0 @@
--include proguard-rules.pro
-
-# Disabling obfuscation is useful if you collect stack traces from production crashes
-# (unless you are using a system that supports de-obfuscate the stack traces).
--dontobfuscate

android/app/proguard-rules.pro

@@ -9,13 +9,6 @@
 
 # Add any project specific keep options here:
 
-# If your project uses WebView with JS, uncomment the following
-# and specify the fully qualified class name to the JavaScript interface
-# class:
-#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
-#   public *;
-#}
-
 # React Native
 
 # Keep our interfaces so they can be used by other ProGuard rules.
@@ -60,19 +53,9 @@
 -keep class sun.misc.Unsafe { *; }
 -dontwarn java.nio.file.*
 -dontwarn org.codehaus.mojo.animal_sniffer.IgnoreJRERequirement
+-keep class okio.** { *; }
 -dontwarn okio.**
 
-# FastImage + Glide
-
--keep public class com.dylanvann.fastimage.* {*;}
--keep public class com.dylanvann.fastimage.** {*;}
--keep public class * implements com.bumptech.glide.module.GlideModule
--keep public class * extends com.bumptech.glide.module.AppGlideModule
--keep public enum com.bumptech.glide.load.ImageHeaderParser$** {
-  **[] $VALUES;
-  public *;
-}
-
 # WebRTC
 
 -keep class org.webrtc.** { *; }
@@ -100,3 +83,6 @@
 -dontwarn javax.servlet.**
 
 # ^^^ We added the above when we switched minifyEnabled on.
+
+# Rule to avoid build errors related to SVGs.
+-keep public class com.horcrux.svg.** {*;}

android/app/src/main/java/org/jitsi/meet/JitsiGlideModule.java

@@ -1,16 +0,0 @@
-package org.jitsi.meet;
-
-import com.bumptech.glide.annotation.GlideModule;
-import com.bumptech.glide.module.AppGlideModule;
-
-/**
- * An AppGlideModule needs to be present for image loading events to work in
- * react-native-fast-image. However, if this is defined by the SDK it will cause trouble with
- * apps which are using Glide themselves.
- *
- * In order to avoid the problem, define a Jitsi Glide module here, so applications already using
- * it are not in trouble.
- */
-@GlideModule
-public final class JitsiGlideModule extends AppGlideModule {
-}

android/app/src/main/java/org/jitsi/meet/MainActivity.java

@@ -21,14 +21,13 @@ import android.content.Intent;
 import android.net.Uri;
 import android.os.Build;
 import android.provider.Settings;
-import android.support.annotation.Nullable;
 import android.util.Log;
 import android.view.KeyEvent;
+import androidx.annotation.Nullable;
 
 import org.jitsi.meet.sdk.JitsiMeet;
 import org.jitsi.meet.sdk.JitsiMeetActivity;
 import org.jitsi.meet.sdk.JitsiMeetConferenceOptions;
-import org.jitsi.meet.sdk.JitsiMeetUserInfo;
 
 import java.lang.reflect.Method;
 import java.net.MalformedURLException;

android/app/src/main/res/mipmap-anydpi-v26/ic_launcher.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
+    <background android:drawable="@color/ic_launcher_background"/>
+    <foreground android:drawable="@mipmap/ic_launcher_foreground"/>
+</adaptive-icon>

android/app/src/main/res/mipmap-anydpi-v26/ic_launcher_round.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
+    <background android:drawable="@color/ic_launcher_background"/>
+    <foreground android:drawable="@mipmap/ic_launcher_foreground"/>
+</adaptive-icon>

android/app/src/main/res/values/ic_launcher_background.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <color name="ic_launcher_background">#66A8DD</color>
+</resources>

android/build.gradle

@@ -25,9 +25,10 @@ allprojects {
     repositories {
         google()
         jcenter()
-        // React Native (JS, Obj-C sources, Android binaries) is installed from
-        // npm.
+        // React Native (JS, Obj-C sources, Android binaries) is installed from npm.
         maven { url "$rootDir/../node_modules/react-native/android" }
+        // Android JSC is installed from npm.
+        maven { url("$rootDir/../node_modules/jsc-android/dist") }
     }
 
     // Make sure we use the react-native version in node_modules and not the one
@@ -74,6 +75,13 @@ allprojects {
     def versionQualifierNumber = (int)(((new Date().getTime()/1000) - 1546297200) / 10)
 
     afterEvaluate { project ->
+        if (project.plugins.hasPlugin('android') || project.plugins.hasPlugin('android-library')) {
+            project.android {
+                compileSdkVersion rootProject.ext.compileSdkVersion
+                buildToolsVersion rootProject.ext.buildToolsVersion
+            }
+        }
+
         if (project.name.startsWith('react-native-')) {
             def npmManifest = project.file('../package.json')
             def json = new JsonSlurper().parseText(npmManifest.text)
@@ -83,17 +91,6 @@ allprojects {
 
             project.version = "${json.version}-jitsi-${versionQualifierNumber}"
 
-            project.android {
-                compileSdkVersion rootProject.ext.compileSdkVersion
-                if (rootProject.ext.has('buildToolsVersion')) {
-                    buildToolsVersion rootProject.ext.buildToolsVersion
-                }
-                defaultConfig {
-                    minSdkVersion rootProject.ext.minSdkVersion
-                    targetSdkVersion rootProject.ext.targetSdkVersion
-                }
-            }
-
             task androidSourcesJar(type: Jar) {
                 classifier = 'sources'
                 from android.sourceSets.main.java.source
@@ -164,10 +161,6 @@ ext {
     mavenUser = System.env.MVN_USER ?: ""
     mavenPassword = System.env.MVN_PASSWORD ?: ""
 
-    // Glide
-    excludeAppGlideModule = true
-    glideVersion = "4.7.1"  // keep in sync with react-native-fast-image
-
     // Libre build
     libreBuild = (System.env.LIBRE_BUILD ?: "false").toBoolean()
 }

android/gradle.properties

@@ -17,5 +17,8 @@
 # http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects
 # org.gradle.parallel=true
 
-appVersion=19.2.0
-sdkVersion=2.1.0
+android.useAndroidX=true
+android.enableJetifier=true
+
+appVersion=19.4.0
+sdkVersion=2.4.0

android/scripts/release-sdk.sh

@@ -10,6 +10,7 @@ MVN_HTTP=0
 DEFAULT_SDK_VERSION=$(grep sdkVersion ${THIS_DIR}/../gradle.properties | cut -d"=" -f2)
 SDK_VERSION=${OVERRIDE_SDK_VERSION:-${DEFAULT_SDK_VERSION}}
 RN_VERSION=$(jq -r '.dependencies."react-native"' ${THIS_DIR}/../../package.json)
+JSC_VERSION="r"$(jq -r '.dependencies."jsc-android"' ${THIS_DIR}/../../node_modules/react-native/package.json | cut -d . -f 1 | cut -c 2-)
 DO_GIT_TAG=${GIT_TAG:-0}
 
 if [[ $THE_MVN_REPO == http* ]]; then
@@ -37,14 +38,20 @@ if [[ $MVN_HTTP == 1 ]]; then
         -DgeneratePom=false \
         -DpomFile=react-native-${RN_VERSION}.pom || true
     popd
+    # Push JSC
+    echo "Pushing JSC ${JSC_VERSION} to the Maven repo"
+    pushd ${THIS_DIR}/../../node_modules/jsc-android/dist/org/webkit/android-jsc/${JSC_VERSION}
+    mvn \
+        deploy:deploy-file \
+        -Durl=${MVN_REPO} \
+        -DrepositoryId=${MVN_REPO_ID} \
+        -Dfile=android-jsc-${JSC_VERSION}.aar \
+        -Dpackaging=aar \
+        -DgeneratePom=false \
+        -DpomFile=android-jsc-${JSC_VERSION}.pom || true
+    popd
 else
-    # Check if an SDK with that same version has already been released
-    if [[ -d ${MVN_REPO}/org/jitsi/react/jitsi-meet-sdk/${SDK_VERSION} ]]; then
-        echo "There is already a release with that version in the Maven repo!"
-        exit 1
-    fi
-
-    # First push React Native, if necessary
+    # Push React Native, if necessary
     if [[ ! -d ${MVN_REPO}/com/facebook/react/react-native/${RN_VERSION} ]]; then
         echo "Pushing React Native ${RN_VERSION} to the Maven repo"
         pushd ${THIS_DIR}/../../node_modules/react-native/android/com/facebook/react/react-native/${RN_VERSION}
@@ -57,6 +64,26 @@ else
             -DpomFile=react-native-${RN_VERSION}.pom
         popd
     fi
+
+    # Push JSC, if necessary
+    if [[ ! -d ${MVN_REPO}/org/webkit/android-jsc/${JSC_VERSION} ]]; then
+        echo "Pushing JSC ${JSC_VERSION} to the Maven repo"
+        pushd ${THIS_DIR}/../../node_modules/jsc-android/dist/org/webkit/android-jsc/${JSC_VERSION}
+        mvn \
+            deploy:deploy-file \
+            -Durl=${MVN_REPO} \
+            -Dfile=android-jsc-${JSC_VERSION}.aar \
+            -Dpackaging=aar \
+            -DgeneratePom=false \
+            -DpomFile=android-jsc-${JSC_VERSION}.pom
+        popd
+    fi
+
+    # Check if an SDK with that same version has already been released
+    if [[ -d ${MVN_REPO}/org/jitsi/react/jitsi-meet-sdk/${SDK_VERSION} ]]; then
+        echo "There is already a release with that version in the Maven repo!"
+        exit 1
+    fi
 fi
 
 # Now build and publish the Jitsi Meet SDK and its dependencies

android/scripts/run-packager.sh

@@ -8,13 +8,14 @@ THIS_DIR=$(cd -P "$(dirname "$(readlink "${BASH_SOURCE[0]}" || echo "${BASH_SOUR
 export RCT_METRO_PORT="${RCT_METRO_PORT:=8081}"
 echo "export RCT_METRO_PORT=${RCT_METRO_PORT}" > "${THIS_DIR}/../../node_modules/react-native/scripts/.packager.env"
 
+adb reverse tcp:8081 tcp:8081
+
 if nc -w 5 -z localhost ${RCT_METRO_PORT} ; then
   if ! curl -s "http://localhost:${RCT_METRO_PORT}/status" | grep -q "packager-status:running" ; then
     echo "Port ${RCT_METRO_PORT} already in use, packager is either not running or not running correctly"
     exit 2
   fi
 else
-    adb reverse tcp:8081 tcp:8081
     CMD="${THIS_DIR}/../../node_modules/react-native/scripts/launchPackager.command"
     if [[ `uname` == "Darwin"  ]]; then
         open -g "${CMD}" || echo "Can't start packager automatically"

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

@@ -36,32 +36,34 @@ android {
 dependencies {
     implementation fileTree(dir: 'libs', include: ['*.jar'])
 
-    implementation "com.android.support:support-v4:${rootProject.ext.supportLibVersion}"
-    implementation "com.android.support:appcompat-v7:${rootProject.ext.supportLibVersion}"
+    implementation 'androidx.legacy:legacy-support-v4:1.0.0'
+    implementation 'androidx.appcompat:appcompat:1.0.2'
+    implementation 'androidx.fragment:fragment:1.0.0'
 
     api 'com.facebook.react:react-native:+'
+    implementation 'org.webkit:android-jsc:+'
 
     implementation 'com.dropbox.core:dropbox-core-sdk:3.0.8'
+    implementation 'com.jakewharton.timber:timber:4.7.1'
+    implementation 'com.squareup.duktape:duktape-android:1.3.0'
 
     if (!rootProject.ext.libreBuild) {
         implementation 'com.amplitude:android-sdk:2.14.1'
         implementation(project(":react-native-google-signin")) {
             exclude group: 'com.google.android.gms'
-            exclude group: 'com.android.support'
+            exclude group: 'androidx'
         }
     }
 
     implementation project(':react-native-background-timer')
     implementation project(':react-native-calendar-events')
     implementation project(':react-native-community-async-storage')
-    implementation(project(':react-native-fast-image')) {
-        exclude group: 'com.android.support'
-    }
+    implementation project(':react-native-community_netinfo')
     implementation project(':react-native-immersive')
     implementation project(':react-native-keep-awake')
     implementation project(':react-native-linear-gradient')
     implementation project(':react-native-sound')
-    implementation project(':react-native-vector-icons')
+    implementation project(':react-native-svg')
     implementation project(':react-native-webrtc')
     implementation project(':react-native-webview')
 
@@ -139,19 +141,14 @@ android.libraryVariants.all { def variant ->
     mergeAssetsTask.doLast {
         def assetsDir = mergeAssetsTask.outputDir
 
-        // Bundle fonts
-        //
-        copy {
-            from("${projectDir}/../../fonts/jitsi.ttf")
-            into("${assetsDir}/fonts")
-        }
-
         // Bundle sounds
         //
         copy {
             from("${projectDir}/../../sounds/incomingMessage.wav")
             from("${projectDir}/../../sounds/joined.wav")
             from("${projectDir}/../../sounds/left.wav")
+            from("${projectDir}/../../sounds/liveStreamingOn.mp3")
+            from("${projectDir}/../../sounds/liveStreamingOff.mp3")
             from("${projectDir}/../../sounds/outgoingRinging.wav")
             from("${projectDir}/../../sounds/outgoingStart.wav")
             from("${projectDir}/../../sounds/recordingOn.mp3")

android/sdk/src/main/AndroidManifest.xml

@@ -12,6 +12,7 @@
     <uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW" />
     <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-feature
         android:glEsVersion="0x00020000"
@@ -44,6 +45,8 @@
                 <action android:name="android.telecom.ConnectionService" />
             </intent-filter>
         </service>
+
+        <service android:name="org.jitsi.meet.sdk.JitsiMeetOngoingConferenceService" />
     </application>
 
 </manifest>

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

@@ -24,6 +24,7 @@ import com.facebook.react.bridge.ReadableMap;
 import com.amplitude.api.Amplitude;
 import com.facebook.react.module.annotations.ReactModule;
 
+import org.jitsi.meet.sdk.log.JitsiMeetLogger;
 import org.json.JSONException;
 import org.json.JSONObject;
 
@@ -90,7 +91,7 @@ class AmplitudeModule
             JSONObject eventProps = new JSONObject(eventPropsString);
             Amplitude.getInstance(instanceName).logEvent(eventType, eventProps);
         } catch (JSONException e) {
-            e.printStackTrace();
+            JitsiMeetLogger.e(e, "Error logging event");
         }
     }
 

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

@@ -0,0 +1,165 @@
+/*
+ * 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.Build;
+import android.telecom.CallAudioState;
+import androidx.annotation.RequiresApi;
+
+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.
+ */
+@RequiresApi(Build.VERSION_CODES.O)
+class AudioDeviceHandlerConnectionService implements
+        AudioModeModule.AudioDeviceHandlerInterface,
+        RNConnectionService.CallAudioStateListener {
+
+    private final static String TAG = AudioDeviceHandlerConnectionService.class.getSimpleName();
+
+    /**
+     * Reference to the main {@code AudioModeModule}.
+     */
+    private AudioModeModule module;
+
+    /**
+     * 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_EARPIECE;
+        }
+        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_EARPIECE;
+        }
+    }
+
+    /**
+     * 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() {
+    }
+
+    @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(Context context, AudioModeModule audioModeModule) {
+        JitsiMeetLogger.i("Using " + TAG + " as the audio device handler");
+
+        module = audioModeModule;
+        RNConnectionService rcs = ReactInstanceManagerHolder.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() {
+        RNConnectionService rcs = ReactInstanceManagerHolder.getNativeModule(RNConnectionService.class);
+        if (rcs != null) {
+            rcs.setCallAudioStateListener(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) {
+        return true;
+    }
+}

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

@@ -0,0 +1,231 @@
+/*
+ * 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.AudioDeviceInfo;
+import android.media.AudioManager;
+import android.os.Build;
+import androidx.annotation.RequiresApi;
+
+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.
+ */
+@RequiresApi(Build.VERSION_CODES.M)
+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 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 the main 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:
+                        devices.add(AudioModeModule.DEVICE_SPEAKER);
+                        break;
+                    case AudioDeviceInfo.TYPE_WIRED_HEADPHONES:
+                    case AudioDeviceInfo.TYPE_WIRED_HEADSET:
+                    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() {
+    }
+
+    /**
+     * 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.updateAudioRoute();
+                        }
+                        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(Context context, AudioModeModule audioModeModule) {
+        JitsiMeetLogger.i("Using " + TAG + " as the audio device handler");
+
+        module = audioModeModule;
+        audioManager = (AudioManager)context.getSystemService(Context.AUDIO_SERVICE);
+
+        // 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);
+
+        if (audioManager.requestAudioFocus(this, AudioManager.STREAM_VOICE_CALL, AudioManager.AUDIOFOCUS_GAIN)
+            == AudioManager.AUDIOFOCUS_REQUEST_FAILED) {
+            JitsiMeetLogger.w(TAG + " Audio focus request failed");
+            return false;
+        }
+
+        return true;
+    }
+}

android/sdk/src/main/java/org/jitsi/meet/sdk/AudioDeviceHandlerLegacy.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.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.content.pm.PackageManager;
+import android.media.AudioManager;
+
+import org.jitsi.meet.sdk.log.JitsiMeetLogger;
+
+
+/**
+ * {@link AudioModeModule.AudioDeviceHandlerInterface} module implementing device handling for
+ * legacy (pre-M) Android versions.
+ */
+class AudioDeviceHandlerLegacy implements
+        AudioModeModule.AudioDeviceHandlerInterface,
+        AudioManager.OnAudioFocusChangeListener,
+        BluetoothHeadsetMonitor.Listener {
+
+    private final static String TAG = AudioDeviceHandlerLegacy.class.getSimpleName();
+
+    /**
+     * Reference to the main {@code AudioModeModule}.
+     */
+    private AudioModeModule module;
+
+    /**
+     * 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 BluetoothHeadsetMonitor} for detecting Bluetooth device changes in
+     * old (< M) Android versions.
+     */
+    private BluetoothHeadsetMonitor bluetoothHeadsetMonitor;
+
+    public AudioDeviceHandlerLegacy() {
+    }
+
+    /**
+     * Helper method to trigger an audio route update when Bluetooth devices are
+     * connected / disconnected.
+     */
+    @Override
+    public void onBluetoothDeviceChange(final boolean deviceAvailable) {
+        module.runInAudioThread(new Runnable() {
+            @Override
+            public void run() {
+                if (deviceAvailable) {
+                    module.addDevice(AudioModeModule.DEVICE_BLUETOOTH);
+                } else {
+                    module.removeDevice(AudioModeModule.DEVICE_BLUETOOTH);
+                }
+
+                module.updateAudioRoute();
+            }
+        });
+    }
+
+    /**
+     * Helper method to trigger an audio route update when a headset is plugged
+     * or unplugged.
+     */
+    private void onHeadsetDeviceChange() {
+        module.runInAudioThread(new Runnable() {
+            @Override
+            public void run() {
+                // XXX: isWiredHeadsetOn is not deprecated when used just for
+                // knowing if there is a wired headset connected, regardless of
+                // audio being routed to it.
+                //noinspection deprecation
+                if (audioManager.isWiredHeadsetOn()) {
+                    module.addDevice(AudioModeModule.DEVICE_HEADPHONES);
+                } else {
+                    module.removeDevice(AudioModeModule.DEVICE_HEADPHONES);
+                }
+
+                module.updateAudioRoute();
+            }
+        });
+    }
+
+    /**
+     * {@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.updateAudioRoute();
+                        }
+                        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(Context context, AudioModeModule audioModeModule) {
+        JitsiMeetLogger.i("Using " + TAG + " as the audio device handler");
+
+        module = audioModeModule;
+        audioManager = (AudioManager)context.getSystemService(Context.AUDIO_SERVICE);
+
+        // Setup runtime device change detection.
+        //
+
+        // Detect changes in wired headset connections.
+        IntentFilter wiredHeadSetFilter = new IntentFilter(AudioManager.ACTION_HEADSET_PLUG);
+        BroadcastReceiver wiredHeadsetReceiver = new BroadcastReceiver() {
+            @Override
+            public void onReceive(Context context, Intent intent) {
+                JitsiMeetLogger.d(TAG + " Wired headset added / removed");
+                onHeadsetDeviceChange();
+            }
+        };
+        context.registerReceiver(wiredHeadsetReceiver, wiredHeadSetFilter);
+
+        // Detect Bluetooth device changes.
+        bluetoothHeadsetMonitor = new BluetoothHeadsetMonitor(context, this);
+
+        // On Android < M, detect if we have an earpiece.
+        PackageManager pm = context.getPackageManager();
+        if (pm.hasSystemFeature(PackageManager.FEATURE_TELEPHONY)) {
+            module.addDevice(AudioModeModule.DEVICE_EARPIECE);
+        }
+
+        // Always assume there is a speaker.
+        module.addDevice(AudioModeModule.DEVICE_SPEAKER);
+    }
+
+    @Override
+    public void stop() {
+        bluetoothHeadsetMonitor.stop();
+        bluetoothHeadsetMonitor = null;
+    }
+
+    @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);
+
+        if (audioManager.requestAudioFocus(this, AudioManager.STREAM_VOICE_CALL, AudioManager.AUDIOFOCUS_GAIN)
+                == 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

@@ -1,5 +1,5 @@
 /*
- * Copyright @ 2017-present Atlassian Pty Ltd
+ * 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.
@@ -16,17 +16,8 @@
 
 package org.jitsi.meet.sdk;
 
-import android.annotation.TargetApi;
-import android.content.BroadcastReceiver;
 import android.content.Context;
-import android.content.Intent;
-import android.content.IntentFilter;
-import android.content.pm.PackageManager;
-import android.media.AudioDeviceInfo;
-import android.media.AudioManager;
 import android.os.Build;
-import android.support.annotation.RequiresApi;
-import android.util.Log;
 
 import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.Promise;
@@ -37,6 +28,8 @@ import com.facebook.react.bridge.WritableArray;
 import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.module.annotations.ReactModule;
 
+import org.jitsi.meet.sdk.log.JitsiMeetLogger;
+
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Map;
@@ -60,9 +53,7 @@ import java.util.concurrent.Executors;
  * {@code AudioModeModule.DEFAULT} mode should be used.
  */
 @ReactModule(name = AudioModeModule.NAME)
-class AudioModeModule extends ReactContextBaseJavaModule
-    implements AudioManager.OnAudioFocusChangeListener {
-
+class AudioModeModule extends ReactContextBaseJavaModule {
     public static final String NAME = "AudioMode";
 
     /**
@@ -74,174 +65,33 @@ class AudioModeModule extends ReactContextBaseJavaModule
      * - VIDEO_CALL: Used for video calls. It will use the speaker by default,
      *   unless a wired or Bluetooth headset is connected.
      */
-    private static final int DEFAULT    = 0;
-    private static final int AUDIO_CALL = 1;
-    private static final int VIDEO_CALL = 2;
-
-    /**
-     * Constant defining the action for plugging in a headset. This is used on
-     * our device detection system for API < 23.
-     */
-    private static final String ACTION_HEADSET_PLUG
-        = (Build.VERSION.SDK_INT >= 21)
-            ? AudioManager.ACTION_HEADSET_PLUG
-            : Intent.ACTION_HEADSET_PLUG;
-
-    /**
-     * 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;
+    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;
 
-    /**
-     * 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.
-     */
-    @RequiresApi(api = Build.VERSION_CODES.M)
-    private static int audioDeviceToRouteInt(String audioDevice) {
-        if (audioDevice == null) {
-            return android.telecom.CallAudioState.ROUTE_EARPIECE;
-        }
-        switch (audioDevice) {
-            case DEVICE_BLUETOOTH:
-                return android.telecom.CallAudioState.ROUTE_BLUETOOTH;
-            case DEVICE_EARPIECE:
-                return android.telecom.CallAudioState.ROUTE_EARPIECE;
-            case DEVICE_HEADPHONES:
-                return android.telecom.CallAudioState.ROUTE_WIRED_HEADSET;
-            case DEVICE_SPEAKER:
-                return android.telecom.CallAudioState.ROUTE_SPEAKER;
-            default:
-                Log.e(TAG, "Unsupported device name: " + audioDevice);
-                return android.telecom.CallAudioState.ROUTE_EARPIECE;
-        }
-    }
-
-    /**
-     * 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.
-     */
-    @RequiresApi(api = Build.VERSION_CODES.M)
-    private static Set<String> routesToDeviceNames(int supportedRouteMask) {
-        Set<String> devices = new HashSet<>();
-        if ((supportedRouteMask & android.telecom.CallAudioState.ROUTE_EARPIECE)
-                == android.telecom.CallAudioState.ROUTE_EARPIECE) {
-            devices.add(DEVICE_EARPIECE);
-        }
-        if ((supportedRouteMask & android.telecom.CallAudioState.ROUTE_BLUETOOTH)
-                == android.telecom.CallAudioState.ROUTE_BLUETOOTH) {
-            devices.add(DEVICE_BLUETOOTH);
-        }
-        if ((supportedRouteMask & android.telecom.CallAudioState.ROUTE_SPEAKER)
-                == android.telecom.CallAudioState.ROUTE_SPEAKER) {
-            devices.add(DEVICE_SPEAKER);
-        }
-        if ((supportedRouteMask & android.telecom.CallAudioState.ROUTE_WIRED_HEADSET)
-                == android.telecom.CallAudioState.ROUTE_WIRED_HEADSET) {
-            devices.add(DEVICE_HEADPHONES);
-        }
-        return devices;
-    }
-
     /**
      * Whether or not the ConnectionService is used for selecting audio devices.
      */
+
+    private static final boolean supportsConnectionService = Build.VERSION.SDK_INT >= Build.VERSION_CODES.O;
+    private static boolean useConnectionService_ = supportsConnectionService;
+
     static boolean useConnectionService() {
-        return Build.VERSION.SDK_INT >= Build.VERSION_CODES.O;
+        return supportsConnectionService && useConnectionService_;
     }
 
-    /**
-     * Indicator that we have lost audio focus.
-     */
-    private boolean audioFocusLost = false;
-
-    /**
-     * {@link AudioManager} instance used to interact with the Android audio
-     * subsystem.
-     */
-    private final AudioManager audioManager;
-
-    /**
-     * {@link BluetoothHeadsetMonitor} for detecting Bluetooth device changes in
-     * old (< M) Android versions.
-     */
-    private BluetoothHeadsetMonitor bluetoothHeadsetMonitor;
+    private AudioDeviceHandlerInterface audioDeviceHandler;
 
     /**
      * {@link ExecutorService} for running all audio operations on a dedicated
      * thread.
      */
-    private static final ExecutorService executor
-        = Executors.newSingleThreadExecutor();
-
-    /**
-     * {@link Runnable} for running audio device detection the main thread.
-     * This is only used on Android >= M.
-     */
-    private final Runnable onAudioDeviceChangeRunner = new Runnable() {
-        @TargetApi(Build.VERSION_CODES.M)
-        @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(DEVICE_BLUETOOTH);
-                    break;
-                case AudioDeviceInfo.TYPE_BUILTIN_EARPIECE:
-                    devices.add(DEVICE_EARPIECE);
-                    break;
-                case AudioDeviceInfo.TYPE_BUILTIN_SPEAKER:
-                    devices.add(DEVICE_SPEAKER);
-                    break;
-                case AudioDeviceInfo.TYPE_WIRED_HEADPHONES:
-                case AudioDeviceInfo.TYPE_WIRED_HEADSET:
-                case TYPE_USB_HEADSET:
-                    devices.add(DEVICE_HEADPHONES);
-                    break;
-                }
-            }
-
-            availableDevices = devices;
-            Log.d(TAG, "Available audio devices: " +
-                availableDevices.toString());
-
-            // Reset user selection
-            userSelectedDevice = null;
-
-            if (mode != -1) {
-                updateAudioRoute(mode);
-            }
-        }
-    };
-
-    /**
-     * {@link Runnable} for running update operation on the main thread.
-     */
-    private final Runnable updateAudioRouteRunner
-        = new Runnable() {
-            @Override
-            public void run() {
-                if (mode != -1) {
-                    updateAudioRoute(mode);
-                }
-            }
-        };
+    private static final ExecutorService executor = Executors.newSingleThreadExecutor();
 
     /**
      * Audio mode currently in use.
@@ -251,10 +101,15 @@ class AudioModeModule extends ReactContextBaseJavaModule
     /**
      * Audio device types.
      */
-    private static final String DEVICE_BLUETOOTH  = "BLUETOOTH";
-    private static final String DEVICE_EARPIECE   = "EARPIECE";
-    private static final String DEVICE_HEADPHONES = "HEADPHONES";
-    private static final String DEVICE_SPEAKER    = "SPEAKER";
+    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.
@@ -266,15 +121,6 @@ class AudioModeModule extends ReactContextBaseJavaModule
      */
     private String selectedDevice;
 
-    /**
-     * Used on API >= 26 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 {@link #availableDevices} on each update.
-     */
-    @RequiresApi(api = Build.VERSION_CODES.O)
-    private int supportedRouteMask;
-
     /**
      * User selected device. When null the default is used depending on the
      * mode.
@@ -290,31 +136,6 @@ class AudioModeModule extends ReactContextBaseJavaModule
      */
     public AudioModeModule(ReactApplicationContext reactContext) {
         super(reactContext);
-
-        audioManager
-            = (AudioManager)
-                reactContext.getSystemService(Context.AUDIO_SERVICE);
-
-        // Starting Oreo the ConnectionImpl from ConnectionService is used to
-        // detect the available devices.
-        if (!useConnectionService()) {
-            // Setup runtime device change detection.
-            setupAudioRouteChangeDetection();
-
-            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
-                // Do an initial detection on Android >= M.
-                runInAudioThread(onAudioDeviceChangeRunner);
-            } else {
-                // On Android < M, detect if we have an earpiece.
-                PackageManager pm = reactContext.getPackageManager();
-                if (pm.hasSystemFeature(PackageManager.FEATURE_TELEPHONY)) {
-                    availableDevices.add(DEVICE_EARPIECE);
-                }
-
-                // Always assume there is a speaker.
-                availableDevices.add(DEVICE_SPEAKER);
-            }
-        }
     }
 
     /**
@@ -327,6 +148,7 @@ class AudioModeModule extends ReactContextBaseJavaModule
     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);
@@ -335,31 +157,26 @@ class AudioModeModule extends ReactContextBaseJavaModule
     }
 
     /**
-     * Gets the list of available audio device categories, i.e. 'bluetooth',
-     * 'earpiece ', 'speaker', 'headphones'.
-     *
-     * @param promise a {@link Promise} which will be resolved with an object
-     *                containing a 'devices' key with a list of devices, plus a
-     *                'selected' key with the selected one.
+     * Notifies JS land that the devices list has changed.
      */
-    @ReactMethod
-    public void getAudioDevices(final Promise promise) {
+    private void notifyDevicesChanged() {
         runInAudioThread(new Runnable() {
             @Override
             public void run() {
-                WritableMap map = Arguments.createMap();
-                map.putString("selected", selectedDevice);
-                WritableArray devices = Arguments.createArray();
+                WritableArray data = Arguments.createArray();
+                final boolean hasHeadphones = availableDevices.contains(DEVICE_HEADPHONES);
                 for (String device : availableDevices) {
-                    if (mode == VIDEO_CALL && device.equals(DEVICE_EARPIECE)) {
-                        // Skip earpiece when in video call mode.
+                    if (hasHeadphones && device.equals(DEVICE_EARPIECE)) {
+                        // Skip earpiece when headphones are plugged in.
                         continue;
                     }
-                    devices.pushString(device);
+                    WritableMap deviceInfo = Arguments.createMap();
+                    deviceInfo.putString("type", device);
+                    deviceInfo.putBoolean("selected", device.equals(selectedDevice));
+                    data.pushMap(deviceInfo);
                 }
-                map.putArray("devices", devices);
-
-                promise.resolve(map);
+                ReactInstanceManagerHolder.emitEvent(DEVICE_CHANGE_EVENT, data);
+                JitsiMeetLogger.i(TAG + " Updating audio device list");
             }
         });
     }
@@ -375,133 +192,36 @@ class AudioModeModule extends ReactContextBaseJavaModule
     }
 
     /**
-     * Helper method to trigger an audio route update when devices change. It
-     * makes sure the operation is performed on the main thread.
-     *
-     * Only used on Android >= M.
-     */
-    void onAudioDeviceChange() {
-        runInAudioThread(onAudioDeviceChangeRunner);
-    }
-
-    /**
-     * Helper method to trigger an audio route update when Bluetooth devices are
-     * connected / disconnected.
-     *
-     * Only used on Android < M. Runs on the main thread.
-     */
-    void onBluetoothDeviceChange() {
-        if (bluetoothHeadsetMonitor != null && bluetoothHeadsetMonitor.isHeadsetAvailable()) {
-            availableDevices.add(DEVICE_BLUETOOTH);
-        } else {
-            availableDevices.remove(DEVICE_BLUETOOTH);
-        }
-
-        if (mode != -1) {
-            updateAudioRoute(mode);
-        }
-    }
-
-    /**
-     * Helper method to trigger an audio route update when a headset is plugged
-     * or unplugged.
-     *
-     * Only used on Android < M.
-     */
-    void onHeadsetDeviceChange() {
-        runInAudioThread(new Runnable() {
-            @Override
-            public void run() {
-                // XXX: isWiredHeadsetOn is not deprecated when used just for
-                // knowing if there is a wired headset connected, regardless of
-                // audio being routed to it.
-                //noinspection deprecation
-                if (audioManager.isWiredHeadsetOn()) {
-                    availableDevices.add(DEVICE_HEADPHONES);
-                } else {
-                    availableDevices.remove(DEVICE_HEADPHONES);
-                }
-
-                if (mode != -1) {
-                    updateAudioRoute(mode);
-                }
-            }
-        });
-    }
-
-    @RequiresApi(api = Build.VERSION_CODES.O)
-    void onCallAudioStateChange(Object callAudioState_) {
-        final android.telecom.CallAudioState callAudioState
-            = (android.telecom.CallAudioState)callAudioState_;
-        runInAudioThread(new Runnable() {
-            @Override
-            public void run() {
-                int newSupportedRoutes = callAudioState.getSupportedRouteMask();
-                boolean audioDevicesChanged
-                        = supportedRouteMask != newSupportedRoutes;
-                if (audioDevicesChanged) {
-                    supportedRouteMask = newSupportedRoutes;
-                    availableDevices = routesToDeviceNames(supportedRouteMask);
-                    Log.d(TAG,
-                          "Available audio devices: "
-                                  + availableDevices.toString());
-                }
-
-                boolean audioRouteChanged
-                    = audioDeviceToRouteInt(selectedDevice)
-                            != callAudioState.getRoute();
-
-                if (audioRouteChanged || audioDevicesChanged) {
-                    // Reset user selection
-                    userSelectedDevice = null;
-
-                    // If the OS changes the Audio Route or Devices we could have lost
-                    // the selected audio device
-                    selectedDevice = null;
-
-                    if (mode != -1) {
-                        updateAudioRoute(mode);
-                    }
-                }
-            }
-        });
-    }
-
-    /**
-     * {@link AudioManager.OnAudioFocusChangeListener} interface method. Called
-     * when the audio focus of the system is updated.
-     *
-     * @param focusChange - The type of focus change.
+     * 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 onAudioFocusChange(int focusChange) {
-        switch (focusChange) {
-        case AudioManager.AUDIOFOCUS_GAIN: {
-            Log.d(TAG, "Audio focus gained");
-            // Some other application potentially stole our audio focus
-            // temporarily. Restore our mode.
-            if (audioFocusLost) {
-                updateAudioRoute(mode);
-            }
-            audioFocusLost = false;
-            break;
-        }
-        case AudioManager.AUDIOFOCUS_LOSS:
-        case AudioManager.AUDIOFOCUS_LOSS_TRANSIENT:
-        case AudioManager.AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK: {
-            Log.d(TAG, "Audio focus lost");
-            audioFocusLost = true;
-            break;
+    public void initialize() {
+        setAudioDeviceHandler();
+    }
+
+    private void setAudioDeviceHandler() {
+        if (audioDeviceHandler != null) {
+            audioDeviceHandler.stop();
         }
 
+        if (useConnectionService()) {
+            audioDeviceHandler = new AudioDeviceHandlerConnectionService();
+        } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+            audioDeviceHandler = new AudioDeviceHandlerGeneric();
+        } else {
+            audioDeviceHandler = new AudioDeviceHandlerLegacy();
         }
+
+        audioDeviceHandler.start(getReactApplicationContext(), this);
     }
 
     /**
      * Helper function to run operations on a dedicated thread.
      * @param runnable
      */
-    public void runInAudioThread(Runnable runnable) {
+    void runInAudioThread(Runnable runnable) {
         executor.execute(runnable);
     }
 
@@ -516,13 +236,13 @@ class AudioModeModule extends ReactContextBaseJavaModule
             @Override
             public void run() {
                 if (!availableDevices.contains(device)) {
-                    Log.d(TAG, "Audio device not available: " + device);
+                    JitsiMeetLogger.w(TAG + " Audio device not available: " + device);
                     userSelectedDevice = null;
                     return;
                 }
 
                 if (mode != -1) {
-                    Log.d(TAG, "User selected device set to: " + device);
+                    JitsiMeetLogger.i(TAG + " User selected device set to: " + device);
                     userSelectedDevice = device;
                     updateAudioRoute(mode);
                 }
@@ -530,46 +250,6 @@ class AudioModeModule extends ReactContextBaseJavaModule
         });
     }
 
-    /**
-     * The API >= 26 way of adjusting the audio route.
-     *
-     * @param audioDevice one of the "DEVICE_" names to set as the audio route.
-     */
-    @RequiresApi(api = Build.VERSION_CODES.O)
-    private void setAudioRoute(String audioDevice) {
-        int newAudioRoute = audioDeviceToRouteInt(audioDevice);
-
-        RNConnectionService.setAudioRoute(newAudioRoute);
-    }
-
-    /**
-     * The API < 26 way of adjusting the audio route.
-     *
-     * @param audioDevice one of the "DEVICE_" names to set as the audio route.
-     */
-    private void setAudioRoutePreO(String audioDevice) {
-        // Turn bluetooth on / off
-        setBluetoothAudioRoute(audioDevice.equals(DEVICE_BLUETOOTH));
-
-        // Turn speaker on / off
-        audioManager.setSpeakerphoneOn(audioDevice.equals(DEVICE_SPEAKER));
-    }
-
-    /**
-     * 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();
-        }
-    }
-
     /**
      * Public method to set the current audio mode.
      *
@@ -584,7 +264,7 @@ class AudioModeModule extends ReactContextBaseJavaModule
             return;
         }
 
-        Runnable r = new Runnable() {
+        runInAudioThread(new Runnable() {
             @Override
             public void run() {
                 boolean success;
@@ -593,80 +273,28 @@ class AudioModeModule extends ReactContextBaseJavaModule
                     success = updateAudioRoute(mode);
                 } catch (Throwable e) {
                     success = false;
-                    Log.e(
-                            TAG,
-                            "Failed to update audio route for mode: " + mode,
-                            e);
+                    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);
+                    promise.reject("setMode", "Failed to set audio mode to " + mode);
                 }
             }
-        };
-        runInAudioThread(r);
+        });
     }
 
     /**
-     * Setup the audio route change detection mechanism. We use the
-     * {@link android.media.AudioDeviceCallback} on 23 >= Android API < 26.
+     * 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.
      */
-    private void setupAudioRouteChangeDetection() {
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
-            setupAudioRouteChangeDetectionM();
-        } else {
-            setupAudioRouteChangeDetectionPreM();
-        }
-    }
-
-    /**
-     * Audio route change detection mechanism for 23 >= Android API < 26.
-     */
-    @TargetApi(Build.VERSION_CODES.M)
-    private void setupAudioRouteChangeDetectionM() {
-        android.media.AudioDeviceCallback audioDeviceCallback =
-                new android.media.AudioDeviceCallback() {
-                    @Override
-                    public void onAudioDevicesAdded(
-                            AudioDeviceInfo[] addedDevices) {
-                        Log.d(TAG, "Audio devices added");
-                        onAudioDeviceChange();
-                    }
-
-                    @Override
-                    public void onAudioDevicesRemoved(
-                            AudioDeviceInfo[] removedDevices) {
-                        Log.d(TAG, "Audio devices removed");
-                        onAudioDeviceChange();
-                    }
-                };
-
-        audioManager.registerAudioDeviceCallback(audioDeviceCallback, null);
-    }
-
-    /**
-     * Audio route change detection mechanism for Android API < 23.
-     */
-    private void setupAudioRouteChangeDetectionPreM() {
-        Context context = getReactApplicationContext();
-
-        // Detect changes in wired headset connections.
-        IntentFilter wiredHeadSetFilter = new IntentFilter(ACTION_HEADSET_PLUG);
-        BroadcastReceiver wiredHeadsetReceiver = new BroadcastReceiver() {
-            @Override
-            public void onReceive(Context context, Intent intent) {
-                Log.d(TAG, "Wired headset added / removed");
-                onHeadsetDeviceChange();
-            }
-        };
-        context.registerReceiver(wiredHeadsetReceiver, wiredHeadSetFilter);
-
-        // Detect Bluetooth device changes.
-        bluetoothHeadsetMonitor = new BluetoothHeadsetMonitor(this, context);
+    @ReactMethod
+    public void setUseConnectionService(boolean use) {
+        useConnectionService_ = use;
+        setAudioDeviceHandler();
     }
 
     /**
@@ -677,38 +305,21 @@ class AudioModeModule extends ReactContextBaseJavaModule
      * {@code false}, otherwise.
      */
     private boolean updateAudioRoute(int mode) {
-        Log.d(TAG, "Update audio route for mode: " + mode);
+        JitsiMeetLogger.i(TAG + " Update audio route for mode: " + mode);
+
+        if (!audioDeviceHandler.setMode(mode)) {
+            return false;
+        }
 
         if (mode == DEFAULT) {
-            if (!useConnectionService()) {
-                audioFocusLost = false;
-                audioManager.setMode(AudioManager.MODE_NORMAL);
-                audioManager.abandonAudioFocus(this);
-                audioManager.setSpeakerphoneOn(false);
-                setBluetoothAudioRoute(false);
-            }
             selectedDevice = null;
             userSelectedDevice = null;
 
+            notifyDevicesChanged();
             return true;
         }
 
-        if (!useConnectionService()) {
-            audioManager.setMode(AudioManager.MODE_IN_COMMUNICATION);
-            audioManager.setMicrophoneMute(false);
-
-            if (audioManager.requestAudioFocus(
-                    this,
-                    AudioManager.STREAM_VOICE_CALL,
-                    AudioManager.AUDIOFOCUS_GAIN)
-                    == AudioManager.AUDIOFOCUS_REQUEST_FAILED) {
-                Log.d(TAG, "Audio focus request failed");
-                return false;
-            }
-        }
-
         boolean bluetoothAvailable = availableDevices.contains(DEVICE_BLUETOOTH);
-        boolean earpieceAvailable = availableDevices.contains(DEVICE_EARPIECE);
         boolean headsetAvailable = availableDevices.contains(DEVICE_HEADPHONES);
 
         // Pick the desired device based on what's available and the mode.
@@ -717,15 +328,12 @@ class AudioModeModule extends ReactContextBaseJavaModule
             audioDevice = DEVICE_BLUETOOTH;
         } else if (headsetAvailable) {
             audioDevice = DEVICE_HEADPHONES;
-        } else if (mode == AUDIO_CALL && earpieceAvailable) {
-            audioDevice = DEVICE_EARPIECE;
         } else {
             audioDevice = DEVICE_SPEAKER;
         }
 
         // Consider the user's selection
-        if (userSelectedDevice != null
-                && availableDevices.contains(userSelectedDevice)) {
+        if (userSelectedDevice != null && availableDevices.contains(userSelectedDevice)) {
             audioDevice = userSelectedDevice;
         }
 
@@ -736,14 +344,99 @@ class AudioModeModule extends ReactContextBaseJavaModule
         }
 
         selectedDevice = audioDevice;
-        Log.d(TAG, "Selected audio device: " + audioDevice);
+        JitsiMeetLogger.i(TAG + " Selected audio device: " + audioDevice);
 
-        if (useConnectionService()) {
-            setAudioRoute(audioDevice);
-        } else {
-            setAudioRoutePreO(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);
+        }
+    }
+
+    /**
+     * Interface for the modules implementing the actual audio device management.
+     */
+    interface AudioDeviceHandlerInterface {
+        /**
+         * Start detecting audio device changes.
+         * @param context Android {@link Context} where detection should take place.
+         * @param audioModeModule Reference to the main {@link AudioModeModule}.
+         */
+        void start(Context context, 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/BaseReactView.java

@@ -20,9 +20,9 @@ package org.jitsi.meet.sdk;
 import android.app.Activity;
 import android.content.Context;
 import android.os.Bundle;
-import android.support.annotation.NonNull;
-import android.support.annotation.Nullable;
 import android.widget.FrameLayout;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
 
 import com.facebook.react.ReactRootView;
 import com.facebook.react.bridge.ReadableMap;
@@ -111,8 +111,7 @@ public abstract class BaseReactView<ListenerT>
 
         setBackgroundColor(BACKGROUND_COLOR);
 
-        ReactInstanceManagerHolder.initReactInstanceManager(
-            ((Activity) context).getApplication());
+        ReactInstanceManagerHolder.initReactInstanceManager((Activity)context);
 
         // Hook this BaseReactView into ExternalAPI.
         externalAPIScope = UUID.randomUUID().toString();

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

@@ -1,5 +1,5 @@
 /*
- * Copyright @ 2017-present Atlassian Pty Ltd
+ * 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.
@@ -24,7 +24,8 @@ import android.content.Context;
 import android.content.Intent;
 import android.content.IntentFilter;
 import android.media.AudioManager;
-import android.util.Log;
+
+import org.jitsi.meet.sdk.log.JitsiMeetLogger;
 
 /**
  * Helper class to detect and handle Bluetooth device changes.  It monitors
@@ -32,68 +33,43 @@ import android.util.Log;
  * about device changes when this occurs.
  */
 class BluetoothHeadsetMonitor {
-    /**
-     * {@link AudioModeModule} where this monitor reports.
-     */
-    private final AudioModeModule audioModeModule;
+    private final static String TAG = BluetoothHeadsetMonitor.class.getSimpleName();
 
     /**
-     * The {@link Context} in which {@link #audioModeModule} executes.
+     * The {@link Context} in which this module executes.
      */
     private final Context context;
 
+    /**
+     * Reference to the {@link BluetoothAdapter} object, used to access Bluetooth functionality.
+     */
+    private BluetoothAdapter adapter;
+
     /**
      * Reference to a proxy object which allows us to query connected devices.
      */
     private BluetoothHeadset headset;
 
     /**
-     * Flag indicating if there are any Bluetooth headset devices currently
-     * available.
+     * receiver registered for receiving Bluetooth connection state changes.
      */
-    private boolean headsetAvailable = false;
+    private BroadcastReceiver receiver;
 
     /**
-     * Helper for running Bluetooth operations on the main thread.
+     * Listener for receiving Bluetooth device change events.
      */
-    private final Runnable updateDevicesRunnable
-        = new Runnable() {
-            @Override
-            public void run() {
-                headsetAvailable
-                    = (headset != null)
-                        && !headset.getConnectedDevices().isEmpty();
-                audioModeModule.onBluetoothDeviceChange();
-            }
-        };
+    private Listener listener;
 
-    public BluetoothHeadsetMonitor(
-            AudioModeModule audioModeModule,
-            Context context) {
-        this.audioModeModule = audioModeModule;
+    public BluetoothHeadsetMonitor(Context context, Listener listener) {
         this.context = context;
-
-        AudioManager audioManager
-            = (AudioManager) context.getSystemService(Context.AUDIO_SERVICE);
-
-        if (!audioManager.isBluetoothScoAvailableOffCall()) {
-            Log.w(AudioModeModule.TAG, "Bluetooth SCO is not available");
-            return;
-        }
-
-        if (getBluetoothHeadsetProfileProxy()) {
-            registerBluetoothReceiver();
-
-            // Initial detection.
-            updateDevices();
-        }
+        this.listener = listener;
     }
 
     private boolean getBluetoothHeadsetProfileProxy() {
-        BluetoothAdapter adapter = BluetoothAdapter.getDefaultAdapter();
+        adapter = BluetoothAdapter.getDefaultAdapter();
 
         if (adapter == null) {
-            Log.w(AudioModeModule.TAG, "Device doesn't support Bluetooth");
+            JitsiMeetLogger.w(TAG + " Device doesn't support Bluetooth");
             return false;
         }
 
@@ -103,9 +79,7 @@ class BluetoothHeadsetMonitor {
         BluetoothProfile.ServiceListener listener
             = new BluetoothProfile.ServiceListener() {
                 @Override
-                public void onServiceConnected(
-                        int profile,
-                        BluetoothProfile proxy) {
+                public void onServiceConnected(int profile, BluetoothProfile proxy) {
                     if (profile == BluetoothProfile.HEADSET) {
                         headset = (BluetoothHeadset) proxy;
                         updateDevices();
@@ -119,21 +93,7 @@ class BluetoothHeadsetMonitor {
                 }
             };
 
-        return
-            adapter.getProfileProxy(
-                    context,
-                    listener,
-                    BluetoothProfile.HEADSET);
-    }
-
-    /**
-     * Returns the current headset availability.
-     *
-     * @return {@code true} if there is a Bluetooth headset connected;
-     * {@code false}, otherwise.
-     */
-    public boolean isHeadsetAvailable() {
-        return headsetAvailable;
+        return adapter.getProfileProxy(context, listener, BluetoothProfile.HEADSET);
     }
 
     private void onBluetoothReceiverReceive(Context context, Intent intent) {
@@ -148,9 +108,7 @@ class BluetoothHeadsetMonitor {
             switch (state) {
             case BluetoothHeadset.STATE_CONNECTED:
             case BluetoothHeadset.STATE_DISCONNECTED:
-                Log.d(
-                        AudioModeModule.TAG,
-                        "BT headset connection state changed: " + state);
+                JitsiMeetLogger.d(TAG + " BT headset connection state changed: " + state);
                 updateDevices();
                 break;
             }
@@ -158,15 +116,12 @@ class BluetoothHeadsetMonitor {
             // XXX: This action will be fired when the connection established
             // with a Bluetooth headset (called a SCO connection) changes state.
             // When the SCO connection is active we route audio to it.
-            int state
-                = intent.getIntExtra(AudioManager.EXTRA_SCO_AUDIO_STATE, -99);
+            int state = intent.getIntExtra(AudioManager.EXTRA_SCO_AUDIO_STATE, -99);
 
             switch (state) {
             case AudioManager.SCO_AUDIO_STATE_CONNECTED:
             case AudioManager.SCO_AUDIO_STATE_DISCONNECTED:
-                Log.d(
-                        AudioModeModule.TAG,
-                        "BT SCO connection state changed: " + state);
+                JitsiMeetLogger.d(TAG + " BT SCO connection state changed: " + state);
                 updateDevices();
                 break;
             }
@@ -174,24 +129,63 @@ class BluetoothHeadsetMonitor {
     }
 
     private void registerBluetoothReceiver() {
-        BroadcastReceiver receiver = new BroadcastReceiver() {
+        receiver = new BroadcastReceiver() {
             @Override
             public void onReceive(Context context, Intent intent) {
                 onBluetoothReceiverReceive(context, intent);
             }
         };
-        IntentFilter filter = new IntentFilter();
 
+        IntentFilter filter = new IntentFilter();
         filter.addAction(AudioManager.ACTION_SCO_AUDIO_STATE_UPDATED);
         filter.addAction(BluetoothHeadset.ACTION_CONNECTION_STATE_CHANGED);
+
         context.registerReceiver(receiver, filter);
     }
 
     /**
      * Detects if there are new devices connected / disconnected and fires the
-     * {@link AudioModeModule#onAudioDeviceChange()} callback.
+     * {@link Listener} registered event.
      */
     private void updateDevices() {
-        audioModeModule.runInAudioThread(updateDevicesRunnable);
+        boolean headsetAvailable = (headset != null) && !headset.getConnectedDevices().isEmpty();
+        listener.onBluetoothDeviceChange(headsetAvailable);
+    }
+
+    public void start() {
+        AudioManager audioManager = (AudioManager) context.getSystemService(Context.AUDIO_SERVICE);
+
+        if (!audioManager.isBluetoothScoAvailableOffCall()) {
+            JitsiMeetLogger.w(TAG + " Bluetooth SCO is not available");
+            return;
+        }
+
+        if (!getBluetoothHeadsetProfileProxy()) {
+            JitsiMeetLogger.w(TAG + " Couldn't get BT profile proxy");
+            return;
+        }
+
+        registerBluetoothReceiver();
+
+        // Initial detection.
+        updateDevices();
+    }
+
+    public void stop() {
+        if (receiver != null) {
+            context.unregisterReceiver(receiver);
+        }
+
+        if (adapter != null && headset != null) {
+            adapter.closeProfileProxy(BluetoothProfile.HEADSET, headset);
+        }
+
+        receiver = null;
+        headset = null;
+        adapter = null;
+    }
+
+    interface Listener {
+        void onBluetoothDeviceChange(boolean deviceAvailable);
     }
 }

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

@@ -5,7 +5,6 @@ import android.content.Context;
 import android.net.Uri;
 import android.os.Build;
 import android.os.Bundle;
-import android.support.annotation.RequiresApi;
 import android.telecom.CallAudioState;
 import android.telecom.Connection;
 import android.telecom.ConnectionRequest;
@@ -14,12 +13,14 @@ import android.telecom.PhoneAccount;
 import android.telecom.PhoneAccountHandle;
 import android.telecom.TelecomManager;
 import android.telecom.VideoProfile;
-import android.util.Log;
+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;
@@ -129,9 +130,7 @@ public class ConnectionService extends android.telecom.ConnectionService {
         if (connection != null) {
             connection.setActive();
         } else {
-            Log.e(TAG, String.format(
-                    "setConnectionActive - no connection for UUID: %s",
-                    callUUID));
+            JitsiMeetLogger.e("%s setConnectionActive - no connection for UUID: %s", TAG, callUUID);
         }
     }
 
@@ -162,7 +161,7 @@ public class ConnectionService extends android.telecom.ConnectionService {
             connection.setDisconnected(cause);
             connection.destroy();
         } else {
-            Log.e(TAG, "endCall no connection for UUID: " + callUUID);
+            JitsiMeetLogger.e(TAG + " endCall no connection for UUID: " + callUUID);
         }
     }
 
@@ -194,15 +193,14 @@ public class ConnectionService extends android.telecom.ConnectionService {
                 boolean hasVideo
                         = callState.getBoolean(ConnectionImpl.KEY_HAS_VIDEO);
 
-                Log.d(TAG, String.format(
-                        "updateCall: %s hasVideo: %s", callUUID, hasVideo));
+                JitsiMeetLogger.i(" %s updateCall: %s hasVideo: %s", TAG, callUUID, hasVideo);
                 connection.setVideoState(
                         hasVideo
                                 ? VideoProfile.STATE_BIDIRECTIONAL
                                 : VideoProfile.STATE_AUDIO_ONLY);
             }
         } else {
-            Log.e(TAG, "updateCall no connection for UUID: " + callUUID);
+            JitsiMeetLogger.e(TAG + " updateCall no connection for UUID: " + callUUID);
         }
     }
 
@@ -238,13 +236,11 @@ public class ConnectionService extends android.telecom.ConnectionService {
             = unregisterStartCallPromise(connection.getCallUUID());
 
         if (startCallPromise != null) {
-            Log.d(TAG,
-                  "onCreateOutgoingConnection " + connection.getCallUUID());
+            JitsiMeetLogger.d(TAG + " onCreateOutgoingConnection " + connection.getCallUUID());
             startCallPromise.resolve(null);
         } else {
-            Log.e(TAG, String.format(
-                "onCreateOutgoingConnection: no start call Promise for %s",
-                connection.getCallUUID()));
+            JitsiMeetLogger.e(
+                TAG + " onCreateOutgoingConnection: no start call Promise for " + connection.getCallUUID());
         }
 
         return connection;
@@ -268,7 +264,7 @@ public class ConnectionService extends android.telecom.ConnectionService {
         PhoneAccountHandle theAccountHandle = request.getAccountHandle();
         String callUUID = theAccountHandle.getId();
 
-        Log.e(TAG, "onCreateOutgoingConnectionFailed " + callUUID);
+        JitsiMeetLogger.e(TAG + " onCreateOutgoingConnectionFailed " + callUUID);
 
         if (callUUID != null) {
             Promise startCallPromise = unregisterStartCallPromise(callUUID);
@@ -278,12 +274,10 @@ public class ConnectionService extends android.telecom.ConnectionService {
                         "CREATE_OUTGOING_CALL_FAILED",
                         "The request has been denied by the system");
             } else {
-                Log.e(TAG, String.format(
-                        "startCallFailed - no start call Promise for UUID: %s",
-                        callUUID));
+                JitsiMeetLogger.e(TAG + " startCallFailed - no start call Promise for UUID: " + callUUID);
             }
         } else {
-            Log.e(TAG, "onCreateOutgoingConnectionFailed - no call UUID");
+            JitsiMeetLogger.e(TAG + " onCreateOutgoingConnectionFailed - no call UUID");
         }
 
         unregisterPhoneAccount(theAccountHandle);
@@ -295,10 +289,10 @@ public class ConnectionService extends android.telecom.ConnectionService {
             if (phoneAccountHandle != null) {
                 telecom.unregisterPhoneAccount(phoneAccountHandle);
             } else {
-                Log.e(TAG, "unregisterPhoneAccount - account handle is null");
+                JitsiMeetLogger.e(TAG + " unregisterPhoneAccount - account handle is null");
             }
         } else {
-            Log.e(TAG, "unregisterPhoneAccount - telecom is null");
+            JitsiMeetLogger.e(TAG + " unregisterPhoneAccount - telecom is null");
         }
     }
 
@@ -357,7 +351,7 @@ public class ConnectionService extends android.telecom.ConnectionService {
          */
         @Override
         public void onDisconnect() {
-            Log.d(TAG, "onDisconnect " + getCallUUID());
+            JitsiMeetLogger.i(TAG + " onDisconnect " + getCallUUID());
             WritableNativeMap data = new WritableNativeMap();
             data.putString("callUUID", getCallUUID());
             ReactInstanceManagerHolder.emitEvent(
@@ -377,7 +371,7 @@ public class ConnectionService extends android.telecom.ConnectionService {
          */
         @Override
         public void onAbort() {
-            Log.d(TAG, "onAbort " + getCallUUID());
+            JitsiMeetLogger.i(TAG + " onAbort " + getCallUUID());
             WritableNativeMap data = new WritableNativeMap();
             data.putString("callUUID", getCallUUID());
             ReactInstanceManagerHolder.emitEvent(
@@ -395,9 +389,7 @@ public class ConnectionService extends android.telecom.ConnectionService {
             // 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
-            Log.d(TAG, String.format(
-                  "onHold %s - HOLD is not supported, aborting the call...",
-                  getCallUUID()));
+            JitsiMeetLogger.w(TAG + " onHold %s - HOLD is not supported, aborting the call...", getCallUUID());
             this.onAbort();
         }
 
@@ -410,12 +402,10 @@ public class ConnectionService extends android.telecom.ConnectionService {
          */
         @Override
         public void onCallAudioStateChanged(CallAudioState state) {
-            Log.d(TAG, "onCallAudioStateChanged: " + state);
-            AudioModeModule audioModeModule
-                    = ReactInstanceManagerHolder
-                    .getNativeModule(AudioModeModule.class);
-            if (audioModeModule != null) {
-                audioModeModule.onCallAudioStateChange(state);
+            JitsiMeetLogger.d(TAG + " onCallAudioStateChanged: " + state);
+            RNConnectionService module = ReactInstanceManagerHolder.getNativeModule(RNConnectionService.class);
+            if (module != null) {
+                module.onCallAudioStateChange(state);
             }
         }
 
@@ -426,10 +416,8 @@ public class ConnectionService extends android.telecom.ConnectionService {
          */
         @Override
         public void onStateChanged(int state) {
-            Log.d(TAG,
-                  String.format("onStateChanged: %s %s",
-                                Connection.stateToString(state),
-                                getCallUUID()));
+            JitsiMeetLogger.d(
+                "%s onStateChanged: %s %s", TAG, Connection.stateToString(state), getCallUUID());
 
             if (state == STATE_DISCONNECTED) {
                 removeConnection(this);

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

@@ -16,14 +16,14 @@
 
 package org.jitsi.meet.sdk;
 
-import android.util.Log;
-
 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;
+
 /**
  * Module implementing an API for sending events from JavaScript to native code.
  */
@@ -67,17 +67,20 @@ class ExternalAPIModule
      */
     @ReactMethod
     public void sendEvent(String name, ReadableMap data, String scope) {
+        // Keep track of the current ongoing conference.
+        OngoingConferenceTracker.getInstance().onExternalAPIEvent(name, data);
+
         // The JavaScript App needs to provide uniquely identifying information
         // to the native ExternalAPI module so that the latter may match the
         // former to the native BaseReactView which hosts it.
         BaseReactView view = BaseReactView.findViewByExternalAPIScope(scope);
 
         if (view != null) {
-            Log.d(TAG, "Sending event: " + name + " with data: " + data);
+            JitsiMeetLogger.d(TAG + " Sending event: " + name + " with data: " + data);
             try {
                 view.onExternalAPIEvent(name, data);
             } catch(Exception e) {
-                Log.e(TAG, "onExternalAPIEvent: error sending event", e);
+                JitsiMeetLogger.e(e, TAG + " onExternalAPIEvent: error sending event");
             }
         }
     }

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/JitsiMeet.java

@@ -33,9 +33,21 @@ public class JitsiMeet {
     }
 
     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}.
      *

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

@@ -20,12 +20,13 @@ import android.content.Context;
 import android.content.Intent;
 import android.net.Uri;
 import android.os.Bundle;
-import android.support.annotation.Nullable;
-import android.support.v4.app.FragmentActivity;
-import android.util.Log;
+import androidx.annotation.Nullable;
+import androidx.fragment.app.FragmentActivity;
 
 import com.facebook.react.modules.core.PermissionListener;
 
+import org.jitsi.meet.sdk.log.JitsiMeetLogger;
+
 import java.util.Map;
 
 
@@ -73,7 +74,18 @@ public class JitsiMeetActivity extends FragmentActivity
 
     @Override
     public void 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.
         leave();
+        if (AudioModeModule.useConnectionService()) {
+            ConnectionService.abortConnections();
+        }
+        JitsiMeetOngoingConferenceService.abort(this);
 
         super.onDestroy();
     }
@@ -197,17 +209,19 @@ public class JitsiMeetActivity extends FragmentActivity
 
     @Override
     public void onConferenceJoined(Map<String, Object> data) {
-        Log.d(TAG, "Conference joined: " + data);
+        JitsiMeetLogger.i("Conference joined: " + data);
+        // Launch the service for the ongoing notification.
+        JitsiMeetOngoingConferenceService.launch(this);
     }
 
     @Override
     public void onConferenceTerminated(Map<String, Object> data) {
-        Log.d(TAG, "Conference terminated: " + data);
+        JitsiMeetLogger.i("Conference terminated: " + data);
         finish();
     }
 
     @Override
     public void onConferenceWillJoin(Map<String, Object> data) {
-        Log.d(TAG, "Conference will join: " + data);
+        JitsiMeetLogger.i("Conference will join: " + data);
     }
 }

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

@@ -25,6 +25,7 @@ import android.os.Build;
 import com.calendarevents.CalendarEventsPackage;
 import com.facebook.react.ReactInstanceManager;
 import com.facebook.react.bridge.Callback;
+import com.facebook.react.bridge.ReactContext;
 import com.facebook.react.modules.core.PermissionListener;
 
 /**
@@ -117,7 +118,13 @@ public class JitsiMeetActivityDelegate {
             = ReactInstanceManagerHolder.getReactInstanceManager();
 
         if (reactInstanceManager != null) {
-            reactInstanceManager.onHostPause(activity);
+            // Try to avoid a crash because some devices trip on this assert:
+            // https://github.com/facebook/react-native/blob/df4e67fe75d781d1eb264128cadf079989542755/ReactAndroid/src/main/java/com/facebook/react/ReactInstanceManager.java#L512
+            // Why this happens is a mystery wrapped in an enigma.
+            ReactContext reactContext = reactInstanceManager.getCurrentReactContext();
+            if (reactContext != null && activity == reactContext.getCurrentActivity()) {
+                reactInstanceManager.onHostPause(activity);
+            }
         }
     }
 

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

@@ -1,6 +1,6 @@
 package org.jitsi.meet.sdk;
 
-import android.support.v4.app.ActivityCompat;
+import androidx.core.app.ActivityCompat;
 
 import com.facebook.react.modules.core.PermissionAwareActivity;
 

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

@@ -72,6 +72,46 @@ public class JitsiMeetConferenceOptions implements Parcelable {
      */
     private JitsiMeetUserInfo userInfo;
 
+    public URL getServerURL() {
+        return serverURL;
+    }
+
+    public String getRoom() {
+        return room;
+    }
+
+    public String getSubject() {
+        return subject;
+    }
+
+    public String getToken() {
+        return token;
+    }
+
+    public Bundle getColorScheme() {
+        return colorScheme;
+    }
+
+    public Bundle getFeatureFlags() {
+        return featureFlags;
+    }
+
+    public boolean getAudioMuted() {
+        return audioMuted;
+    }
+
+    public boolean getAudioOnly() {
+        return audioOnly;
+    }
+
+    public boolean getVideoMuted() {
+        return videoMuted;
+    }
+
+    public JitsiMeetUserInfo getUserInfo() {
+        return userInfo;
+    }
+
     /**
      * Class used to build the immutable {@link JitsiMeetConferenceOptions} object.
      */
@@ -341,7 +381,7 @@ public class JitsiMeetConferenceOptions implements Parcelable {
         dest.writeString(token);
         dest.writeBundle(colorScheme);
         dest.writeBundle(featureFlags);
-        dest.writeBundle(userInfo.asBundle());
+        dest.writeBundle(userInfo != null ? userInfo.asBundle() : new Bundle());
         dest.writeByte((byte) (audioMuted == null ? 0 : audioMuted ? 1 : 2));
         dest.writeByte((byte) (audioOnly == null ? 0 : audioOnly ? 1 : 2));
         dest.writeByte((byte) (videoMuted == null ? 0 : videoMuted ? 1 : 2));

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

@@ -19,9 +19,10 @@ package org.jitsi.meet.sdk;
 
 import android.content.Intent;
 import android.os.Bundle;
-import android.support.annotation.NonNull;
-import android.support.annotation.Nullable;
-import android.support.v4.app.Fragment;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.fragment.app.Fragment;
+
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;

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

@@ -0,0 +1,121 @@
+/*
+ * 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.app.Notification;
+import android.app.Service;
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.os.Build;
+import android.os.IBinder;
+
+import org.jitsi.meet.sdk.log.JitsiMeetLogger;
+
+
+/**
+ * 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();
+
+    static final class Actions {
+        static final String START = TAG + ":START";
+        static final String HANGUP = TAG + ":HANGUP";
+    }
+
+    static void launch(Context context) {
+        OngoingNotification.createOngoingConferenceNotificationChannel();
+
+        Intent intent = new Intent(context, JitsiMeetOngoingConferenceService.class);
+        intent.setAction(Actions.START);
+
+        ComponentName componentName;
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            componentName = context.startForegroundService(intent);
+        } else {
+            componentName = context.startService(intent);
+        }
+        if (componentName == null) {
+            JitsiMeetLogger.w(TAG + " Ongoing conference service not started");
+        }
+    }
+
+    static void abort(Context context) {
+        Intent intent = new Intent(context, JitsiMeetOngoingConferenceService.class);
+        context.stopService(intent);
+    }
+
+    @Override
+    public void onCreate() {
+        super.onCreate();
+
+        OngoingConferenceTracker.getInstance().addListener(this);
+    }
+
+    @Override
+    public void onDestroy() {
+        OngoingConferenceTracker.getInstance().removeListener(this);
+
+        super.onDestroy();
+    }
+
+    @Override
+    public IBinder onBind(Intent intent) {
+        return null;
+    }
+
+    @Override
+    public int onStartCommand(Intent intent, int flags, int startId) {
+        final String action = intent.getAction();
+        if (Actions.START.equals(action)) {
+            Notification notification = OngoingNotification.buildOngoingConferenceNotification();
+            if (notification == null) {
+                stopSelf();
+                JitsiMeetLogger.w(TAG + " Couldn't start service, notification is null");
+            } else {
+                startForeground(OngoingNotification.NOTIFICATION_ID, notification);
+                JitsiMeetLogger.i(TAG + " Service started");
+            }
+        } else if (Actions.HANGUP.equals(action)) {
+            JitsiMeetLogger.i(TAG + " Hangup requested");
+            // Abort all ongoing calls
+            if (AudioModeModule.useConnectionService()) {
+                ConnectionService.abortConnections();
+            }
+            stopSelf();
+        } else {
+            JitsiMeetLogger.w(TAG + " Unknown action received: " + action);
+            stopSelf();
+        }
+
+        return START_NOT_STICKY;
+    }
+
+    @Override
+    public void onCurrentConferenceChanged(String conferenceUrl) {
+        if (conferenceUrl == null) {
+            stopSelf();
+            JitsiMeetLogger.i(TAG + "Service stopped");
+        }
+    }
+}

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

@@ -17,7 +17,7 @@
 
 package org.jitsi.meet.sdk;
 
-import android.util.Log;
+import org.jitsi.meet.sdk.log.JitsiMeetLogger;
 
 class JitsiMeetUncaughtExceptionHandler implements Thread.UncaughtExceptionHandler {
     private final Thread.UncaughtExceptionHandler defaultUncaughtExceptionHandler;
@@ -37,14 +37,7 @@ class JitsiMeetUncaughtExceptionHandler implements Thread.UncaughtExceptionHandl
 
     @Override
     public void uncaughtException(Thread t, Throwable e) {
-        Log.e(this.getClass().getSimpleName(), "FATAL ERROR", e);
-
-        // Terminate all conferences
-        for (BaseReactView view: BaseReactView.getViews()) {
-            if (view instanceof JitsiMeetView) {
-                ((JitsiMeetView) view).leave();
-            }
-        }
+        JitsiMeetLogger.e(e, this.getClass().getSimpleName() + " FATAL ERROR");
 
         // Abort all ConnectionService ongoing calls
         if (AudioModeModule.useConnectionService()) {

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

@@ -19,17 +19,19 @@ package org.jitsi.meet.sdk;
 
 import android.content.Context;
 import android.os.Bundle;
-import android.support.annotation.NonNull;
-import android.support.annotation.Nullable;
-import android.util.Log;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
 
 import com.facebook.react.bridge.ReadableMap;
 
+import org.jitsi.meet.sdk.log.JitsiMeetLogger;
+
 import java.lang.reflect.Method;
 import java.util.Map;
 
 
-public class JitsiMeetView extends BaseReactView<JitsiMeetViewListener> {
+public class JitsiMeetView extends BaseReactView<JitsiMeetViewListener>
+        implements OngoingConferenceTracker.OngoingConferenceListener {
 
     /**
      * The {@code Method}s of {@code JitsiMeetViewListener} by event name i.e.
@@ -38,12 +40,6 @@ public class JitsiMeetView extends BaseReactView<JitsiMeetViewListener> {
     private static final Map<String, Method> LISTENER_METHODS
         = ListenerUtils.mapListenerMethods(JitsiMeetViewListener.class);
 
-    /**
-     * The {@link Log} tag which identifies the source of the log messages of
-     * {@code JitsiMeetView}.
-     */
-    private static final String TAG = JitsiMeetView.class.getSimpleName();
-
     /**
      * The URL of the current conference.
      */
@@ -106,6 +102,14 @@ public class JitsiMeetView extends BaseReactView<JitsiMeetViewListener> {
         if (!(context instanceof JitsiMeetActivityInterface)) {
             throw new RuntimeException("Enclosing Activity must implement JitsiMeetActivityInterface");
         }
+
+        OngoingConferenceTracker.getInstance().addListener(this);
+    }
+
+    @Override
+    public void dispose() {
+        OngoingConferenceTracker.getInstance().removeListener(this);
+        super.dispose();
     }
 
     /**
@@ -128,7 +132,7 @@ public class JitsiMeetView extends BaseReactView<JitsiMeetViewListener> {
             try {
                 pipModule.enterPictureInPicture();
             } catch (RuntimeException re) {
-                Log.e(TAG, "failed to enter PiP mode", re);
+                JitsiMeetLogger.e(re, "Failed to enter PiP mode");
             }
         }
     }
@@ -173,27 +177,17 @@ public class JitsiMeetView extends BaseReactView<JitsiMeetViewListener> {
     }
 
     /**
-     * The internal processing for the URL of the current conference set on the
-     * associated {@link JitsiMeetView}.
-     *
-     * @param eventName the name of the external API event to be processed
-     * @param eventData the details/specifics of the event to process determined
-     * by/associated with the specified {@code eventName}.
+     * Handler for {@link OngoingConferenceTracker} events.
+     * @param conferenceUrl
      */
-    private void maybeSetViewURL(String eventName, ReadableMap eventData) {
-        String url = eventData.hasKey("url") ? eventData.getString("url") : null;
-
-        switch(eventName) {
-        case "CONFERENCE_WILL_JOIN":
-            this.url = url;
-            break;
-
-        case "CONFERENCE_TERMINATED":
-            if (url != null && url.equals(this.url)) {
-                this.url = null;
-            }
-            break;
-        }
+    @Override
+    public void onCurrentConferenceChanged(String conferenceUrl) {
+        // This property was introduced in order to address
+        // an exception in the Picture-in-Picture functionality which arose
+        // because of delays related to bridging between JavaScript and Java. To
+        // reduce these delays do not wait for the call to be transferred to the
+        // UI thread.
+        this.url = conferenceUrl;
     }
 
     /**
@@ -205,13 +199,6 @@ public class JitsiMeetView extends BaseReactView<JitsiMeetViewListener> {
      */
     @Override
     protected void onExternalAPIEvent(String name, ReadableMap data) {
-        // XXX The JitsiMeetView property URL was introduced in order to address
-        // an exception in the Picture-in-Picture functionality which arose
-        // because of delays related to bridging between JavaScript and Java. To
-        // reduce these delays do not wait for the call to be transferred to the
-        // UI thread.
-        maybeSetViewURL(name, data);
-
         onExternalAPIEvent(LISTENER_METHODS, name, data);
     }
 }

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,119 @@
+/*
+ * 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.app.Notification;
+import android.app.NotificationChannel;
+import android.app.NotificationManager;
+import android.app.PendingIntent;
+import android.content.Context;
+import android.content.Intent;
+import android.os.Build;
+import androidx.core.app.NotificationCompat;
+
+import org.jitsi.meet.sdk.log.JitsiMeetLogger;
+
+import java.util.Random;
+
+
+/**
+ * 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 final String CHANNEL_ID = "JitsiNotificationChannel";
+    private static final String CHANNEL_NAME = "Ongoing Conference Notifications";
+
+    static final int NOTIFICATION_ID = new Random().nextInt(99999) + 10000;
+
+
+    static void createOngoingConferenceNotificationChannel() {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
+            return;
+        }
+
+        Context context = ReactInstanceManagerHolder.getCurrentActivity();
+        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(CHANNEL_ID);
+        if (channel != null) {
+            // The channel was already created, no need to do it again.
+            return;
+        }
+
+        channel = new NotificationChannel(CHANNEL_ID, CHANNEL_NAME, NotificationManager.IMPORTANCE_DEFAULT);
+        channel.enableLights(false);
+        channel.enableVibration(false);
+        channel.setShowBadge(false);
+
+        notificationManager.createNotificationChannel(channel);
+    }
+
+    static Notification buildOngoingConferenceNotification() {
+        Context context = ReactInstanceManagerHolder.getCurrentActivity();
+        if (context == null) {
+            JitsiMeetLogger.w(TAG + " Cannot create notification: no current context");
+            return null;
+        }
+
+        Intent notificationIntent = new Intent(context, context.getClass());
+        PendingIntent pendingIntent = PendingIntent.getActivity(context, 0, notificationIntent, 0);
+
+        NotificationCompat.Builder builder;
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            builder = new NotificationCompat.Builder(context, CHANNEL_ID);
+        } else {
+            builder = new NotificationCompat.Builder(context);
+        }
+
+        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)
+            .setAutoCancel(false)
+            .setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
+            .setUsesChronometer(true)
+            .setOnlyAlertOnce(true)
+            .setSmallIcon(context.getResources().getIdentifier("ic_notification", "drawable", context.getPackageName()));
+
+        // Add a "hang-up" action only if we are using ConnectionService.
+        if (AudioModeModule.useConnectionService()) {
+            Intent hangupIntent = new Intent(context, JitsiMeetOngoingConferenceService.class);
+            hangupIntent.setAction(JitsiMeetOngoingConferenceService.Actions.HANGUP);
+            PendingIntent hangupPendingIntent
+                = PendingIntent.getService(context, 0, hangupIntent, PendingIntent.FLAG_UPDATE_CURRENT);
+            NotificationCompat.Action hangupAction = new NotificationCompat.Action(0, "Hang up", hangupPendingIntent);
+
+            builder.addAction(hangupAction);
+        }
+
+        return builder.build();
+    }
+}

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

@@ -20,7 +20,6 @@ import android.annotation.TargetApi;
 import android.app.Activity;
 import android.app.PictureInPictureParams;
 import android.os.Build;
-import android.util.Log;
 import android.util.Rational;
 
 import com.facebook.react.bridge.Promise;
@@ -29,6 +28,8 @@ 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;
+
 @ReactModule(name = PictureInPictureModule.NAME)
 class PictureInPictureModule
     extends ReactContextBaseJavaModule {
@@ -70,7 +71,7 @@ class PictureInPictureModule
             throw new IllegalStateException("No current Activity!");
         }
 
-        Log.d(TAG, "Entering Picture-in-Picture");
+        JitsiMeetLogger.i(TAG + " Entering Picture-in-Picture");
 
         PictureInPictureParams.Builder builder
             = new PictureInPictureParams.Builder()

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

@@ -5,13 +5,12 @@ import android.content.Context;
 import android.net.Uri;
 import android.os.Build;
 import android.os.Bundle;
-import android.support.annotation.RequiresApi;
 import android.telecom.DisconnectCause;
 import android.telecom.PhoneAccount;
 import android.telecom.PhoneAccountHandle;
 import android.telecom.TelecomManager;
 import android.telecom.VideoProfile;
-import android.util.Log;
+import androidx.annotation.RequiresApi;
 
 import com.facebook.react.bridge.Promise;
 import com.facebook.react.bridge.ReactApplicationContext;
@@ -20,6 +19,8 @@ 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;
+
 /**
  * The react-native side of Jitsi Meet's {@link ConnectionService}. Exposes
  * the Java Script API.
@@ -28,13 +29,18 @@ import com.facebook.react.module.annotations.ReactModule;
  */
 @RequiresApi(api = Build.VERSION_CODES.O)
 @ReactModule(name = RNConnectionService.NAME)
-class RNConnectionService
-    extends ReactContextBaseJavaModule {
+class RNConnectionService extends ReactContextBaseJavaModule {
 
     public static final String NAME = "ConnectionService";
 
     private static final String TAG = ConnectionService.TAG;
 
+    /**
+     * 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
      *
@@ -74,11 +80,11 @@ class RNConnectionService
             String handle,
             boolean hasVideo,
             Promise promise) {
-        Log.d(TAG,
-              String.format("startCall UUID=%s, h=%s, v=%s",
+        JitsiMeetLogger.d("%s startCall UUID=%s, h=%s, v=%s",
+                            TAG,
                             callUUID,
                             handle,
-                            hasVideo));
+                            hasVideo);
 
         ReactApplicationContext ctx = getReactApplicationContext();
 
@@ -118,7 +124,7 @@ class RNConnectionService
      */
     @ReactMethod
     public void reportCallFailed(String callUUID) {
-        Log.d(TAG, "reportCallFailed " + callUUID);
+        JitsiMeetLogger.d(TAG + " reportCallFailed " + callUUID);
         ConnectionService.setConnectionDisconnected(
                 callUUID,
                 new DisconnectCause(DisconnectCause.ERROR));
@@ -131,7 +137,7 @@ class RNConnectionService
      */
     @ReactMethod
     public void endCall(String callUUID) {
-        Log.d(TAG, "endCall " + callUUID);
+        JitsiMeetLogger.d(TAG + " endCall " + callUUID);
         ConnectionService.setConnectionDisconnected(
                 callUUID,
                 new DisconnectCause(DisconnectCause.LOCAL));
@@ -143,9 +149,10 @@ class RNConnectionService
      * @param callUUID - the call's UUID.
      */
     @ReactMethod
-    public void reportConnectedOutgoingCall(String callUUID) {
-        Log.d(TAG, "reportConnectedOutgoingCall " + callUUID);
+    public void reportConnectedOutgoingCall(String callUUID, Promise promise) {
+        JitsiMeetLogger.d(TAG + " reportConnectedOutgoingCall " + callUUID);
         ConnectionService.setConnectionActive(callUUID);
+        promise.resolve(null);
     }
 
     @Override
@@ -166,4 +173,28 @@ class RNConnectionService
     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);
+    }
 }

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

@@ -17,8 +17,8 @@
 
 package org.jitsi.meet.sdk;
 
-import android.app.Application;
-import android.support.annotation.Nullable;
+import android.app.Activity;
+import androidx.annotation.Nullable;
 
 import com.facebook.react.ReactInstanceManager;
 import com.facebook.react.ReactPackage;
@@ -27,7 +27,20 @@ import com.facebook.react.bridge.ReactContext;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.common.LifecycleState;
 import com.facebook.react.devsupport.DevInternalSettings;
+import com.facebook.react.jscexecutor.JSCExecutorFactory;
 import com.facebook.react.modules.core.DeviceEventManagerModule;
+import com.facebook.react.uimanager.ViewManager;
+import com.facebook.soloader.SoLoader;
+import com.oney.WebRTCModule.RTCVideoViewManager;
+import com.oney.WebRTCModule.WebRTCModule;
+
+import org.jitsi.meet.sdk.log.JitsiMeetLogger;
+import org.webrtc.SoftwareVideoDecoderFactory;
+import org.webrtc.SoftwareVideoEncoderFactory;
+import org.webrtc.VideoDecoderFactory;
+import org.webrtc.VideoEncoderFactory;
+import org.webrtc.audio.AudioDeviceModule;
+import org.webrtc.audio.JavaAudioDeviceModule;
 
 import java.lang.reflect.Constructor;
 import java.util.ArrayList;
@@ -46,8 +59,7 @@ class ReactInstanceManagerHolder {
      */
     private static ReactInstanceManager reactInstanceManager;
 
-    private static List<NativeModule> createNativeModules(
-            ReactApplicationContext reactContext) {
+    private static List<NativeModule> createNativeModules(ReactApplicationContext reactContext) {
         List<NativeModule> nativeModules
             = new ArrayList<>(Arrays.<NativeModule>asList(
                 new AndroidSettingsModule(reactContext),
@@ -55,7 +67,9 @@ class ReactInstanceManagerHolder {
                 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 WiFiStatsModule(reactContext),
@@ -65,6 +79,21 @@ class ReactInstanceManagerHolder {
             nativeModules.add(new RNConnectionService(reactContext));
         }
 
+        // Initialize the WebRTC module by hand, since we want to override some
+        // initialization options.
+        WebRTCModule.Options options = new WebRTCModule.Options();
+
+        AudioDeviceModule adm = JavaAudioDeviceModule.builder(reactContext)
+            .createAudioDeviceModule();
+        VideoDecoderFactory videoDecoderFactory = new SoftwareVideoDecoderFactory();
+        VideoEncoderFactory videoEncoderFactory = new SoftwareVideoEncoderFactory();
+
+        options.setAudioDeviceModule(adm);
+        options.setVideoDecoderFactory(videoDecoderFactory);
+        options.setVideoEncoderFactory(videoEncoderFactory);
+
+        nativeModules.add(new WebRTCModule(reactContext, options));
+
         try {
             Class<?> amplitudeModuleClass = Class.forName("org.jitsi.meet.sdk.AmplitudeModule");
             Constructor constructor = amplitudeModuleClass.getConstructor(ReactApplicationContext.class);
@@ -76,6 +105,13 @@ class ReactInstanceManagerHolder {
         return nativeModules;
     }
 
+    private static List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
+        return Arrays.<ViewManager>asList(
+            // WebRTC, see createNativeModules for details.
+            new RTCVideoViewManager()
+        );
+    }
+
     /**
      * Helper function to send an event to JavaScript.
      *
@@ -120,6 +156,18 @@ class ReactInstanceManagerHolder {
                 ? reactContext.getNativeModule(nativeModuleClass) : null;
     }
 
+    /**
+     * Gets the current {@link Activity} linked to React Native.
+     *
+     * @return An activity attached to React Native.
+     */
+    static Activity getCurrentActivity() {
+        ReactContext reactContext
+            = reactInstanceManager != null
+            ? reactInstanceManager.getCurrentReactContext() : null;
+        return reactContext != null ? reactContext.getCurrentActivity() : null;
+    }
+
     static ReactInstanceManager getReactInstanceManager() {
         return reactInstanceManager;
     }
@@ -130,24 +178,25 @@ class ReactInstanceManagerHolder {
      * time. All {@code ReactRootView} instances will be tied to the one and
      * only {@code ReactInstanceManager}.
      *
-     * @param application {@code Application} instance which is running.
+     * @param activity {@code Activity} current running Activity.
      */
-    static void initReactInstanceManager(Application application) {
+    static void initReactInstanceManager(Activity activity) {
         if (reactInstanceManager != null) {
             return;
         }
 
+        SoLoader.init(activity, /* native exopackage */ false);
+
         List<ReactPackage> packages
             = new ArrayList<>(Arrays.asList(
                 new com.BV.LinearGradient.LinearGradientPackage(),
                 new com.calendarevents.CalendarEventsPackage(),
                 new com.corbt.keepawake.KCKeepAwakePackage(),
-                new com.dylanvann.fastimage.FastImageViewPackage(),
                 new com.facebook.react.shell.MainReactPackage(),
-                new com.oblador.vectoricons.VectorIconsPackage(),
+                new com.horcrux.svg.SvgPackage(),
                 new com.ocetnik.timer.BackgroundTimerPackage(),
-                new com.oney.WebRTCModule.WebRTCModulePackage(),
                 new com.reactnativecommunity.asyncstorage.AsyncStoragePackage(),
+                new com.reactnativecommunity.netinfo.NetInfoPackage(),
                 new com.reactnativecommunity.webview.RNCWebViewPackage(),
                 new com.rnimmersive.RNImmersivePackage(),
                 new com.zmxv.RNSound.RNSoundPackage(),
@@ -156,6 +205,10 @@ class ReactInstanceManagerHolder {
                     public List<NativeModule> createNativeModules(ReactApplicationContext reactContext) {
                         return ReactInstanceManagerHolder.createNativeModules(reactContext);
                     }
+                    @Override
+                    public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
+                        return ReactInstanceManagerHolder.createViewManagers(reactContext);
+                    }
                 }));
 
         try {
@@ -166,11 +219,17 @@ class ReactInstanceManagerHolder {
             // Ignore any error, the module is not compiled when LIBRE_BUILD is enabled.
         }
 
+        // Keep on using JSC, the jury is out on Hermes.
+        JSCExecutorFactory jsFactory
+            = new JSCExecutorFactory("", "");
+
         reactInstanceManager
             = ReactInstanceManager.builder()
-                .setApplication(application)
+                .setApplication(activity.getApplication())
+                .setCurrentActivity(activity)
                 .setBundleAssetName("index.android.bundle")
                 .setJSMainModulePath("index.android")
+                .setJavaScriptExecutorFactory(jsFactory)
                 .addPackages(packages)
                 .setUseDeveloperSupport(BuildConfig.DEBUG)
                 .setInitialLifecycleState(LifecycleState.RESUMED)

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

@@ -19,7 +19,6 @@ package org.jitsi.meet.sdk;
 import android.content.Context;
 import android.net.wifi.WifiInfo;
 import android.net.wifi.WifiManager;
-import android.util.Log;
 
 import com.facebook.react.bridge.Promise;
 import com.facebook.react.bridge.ReactApplicationContext;
@@ -27,6 +26,7 @@ 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 org.json.JSONArray;
 import org.json.JSONObject;
 
@@ -144,8 +144,7 @@ class WiFiStatsModule
                     JSONObject result = new JSONObject();
                     result.put("rssi", rssi)
                         .put("signal", signalLevel)
-                        .put("timestamp",
-                                String.valueOf(System.currentTimeMillis()));
+                        .put("timestamp", System.currentTimeMillis());
 
                     JSONArray addresses = new JSONArray();
 
@@ -185,17 +184,15 @@ class WiFiStatsModule
 
                         }
                     } catch (SocketException e) {
-                        Log.wtf(TAG,
-                            "Unable to NetworkInterface.getNetworkInterfaces()"
-                        );
+                        JitsiMeetLogger.e(e, TAG + " Unable to NetworkInterface.getNetworkInterfaces()");
                     }
 
                     result.put("addresses", addresses);
                     promise.resolve(result.toString());
 
-                    Log.d(TAG, "WiFi stats: " + result.toString());
+                    JitsiMeetLogger.d(TAG + " WiFi stats: " + result.toString());
                 } catch (Throwable e) {
-                    Log.e(TAG, "Failed to obtain wifi stats", e);
+                    JitsiMeetLogger.e(e, TAG + " Failed to obtain wifi stats");
                     promise.reject(
                         new Exception("Failed to obtain wifi stats"));
                 }

android/sdk/src/main/java/org/jitsi/meet/sdk/incoming_call/IncomingCallInfo.java

@@ -16,7 +16,7 @@
 
 package org.jitsi.meet.sdk.incoming_call;
 
-import android.support.annotation.NonNull;
+import androidx.annotation.NonNull;
 
 public class IncomingCallInfo {
     /**

android/sdk/src/main/java/org/jitsi/meet/sdk/incoming_call/IncomingCallView.java

@@ -18,7 +18,7 @@ package org.jitsi.meet.sdk.incoming_call;
 
 import android.content.Context;
 import android.os.Bundle;
-import android.support.annotation.NonNull;
+import androidx.annotation.NonNull;
 
 import com.facebook.react.bridge.ReadableMap;
 

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,94 @@
+/*
+ * 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) {
+        Timber.plant(handler);
+    }
+
+    public static void removeHandler(JitsiMeetBaseLogHandler handler) {
+        Timber.uproot(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/NAT64AddrInfoModule.java

@@ -15,14 +15,14 @@
  */
 package org.jitsi.meet.sdk.net;
 
-import android.util.Log;
-
 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;
 
 /**
@@ -43,7 +43,7 @@ public class NAT64AddrInfoModule
      * 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 = "nat64.jitsi.net";
+    private final static String HOST = "ipv4only.arpa";
 
     /**
      * How long is the {@link NAT64AddrInfo} instance valid.
@@ -97,7 +97,7 @@ public class NAT64AddrInfoModule
             try {
                 info = NAT64AddrInfo.discover(host);
             } catch (UnknownHostException e) {
-                Log.e(TAG, "NAT64AddrInfo.discover: " + host, e);
+                JitsiMeetLogger.e(e, TAG + " NAT64AddrInfo.discover: " + host);
             }
             infoTimestamp = System.currentTimeMillis();
         }
@@ -107,7 +107,7 @@ public class NAT64AddrInfoModule
         try {
             result = info == null ? null : info.getIPv6Address(ipv4Address);
         } catch (IllegalArgumentException exc) {
-            Log.e(TAG, "Failed to get IPv6 address for: " + ipv4Address, 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.

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

@@ -1,4 +1,6 @@
 <resources>
     <string name="app_name">Jitsi Meet SDK</string>
     <string name="dropbox_app_key"></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>
 </resources>

android/settings.gradle

@@ -7,10 +7,10 @@ include ':react-native-calendar-events'
 project(':react-native-calendar-events').projectDir = new File(rootProject.projectDir, '../node_modules/react-native-calendar-events/android')
 include ':react-native-community-async-storage'
 project(':react-native-community-async-storage').projectDir = new File(rootProject.projectDir, '../node_modules/@react-native-community/async-storage/android')
-include ':react-native-fast-image'
-project(':react-native-fast-image').projectDir = new File(rootProject.projectDir, '../node_modules/react-native-fast-image/android')
+include ':react-native-community_netinfo'
+project(':react-native-community_netinfo').projectDir = new File(rootProject.projectDir, '../node_modules/@react-native-community/netinfo/android')
 include ':react-native-google-signin'
-project(':react-native-google-signin').projectDir = new File(rootProject.projectDir, '../node_modules/react-native-google-signin/android')
+project(':react-native-google-signin').projectDir = new File(rootProject.projectDir, '../node_modules/@react-native-community/google-signin/android')
 include ':react-native-immersive'
 project(':react-native-immersive').projectDir = new File(rootProject.projectDir, '../node_modules/react-native-immersive/android')
 include ':react-native-keep-awake'
@@ -19,8 +19,8 @@ include ':react-native-linear-gradient'
 project(':react-native-linear-gradient').projectDir = new File(rootProject.projectDir, '../node_modules/react-native-linear-gradient/android')
 include ':react-native-sound'
 project(':react-native-sound').projectDir = new File(rootProject.projectDir, '../node_modules/react-native-sound/android')
-include ':react-native-vector-icons'
-project(':react-native-vector-icons').projectDir = new File(rootProject.projectDir, '../node_modules/react-native-vector-icons/android')
+include ':react-native-svg'
+project(':react-native-svg').projectDir = new File(rootProject.projectDir, 	'../node_modules/react-native-svg/android')
 include ':react-native-webrtc'
 project(':react-native-webrtc').projectDir = new File(rootProject.projectDir, '../node_modules/react-native-webrtc/android')
 include ':react-native-webview'

conference.js

@@ -23,7 +23,8 @@ import {
     sendAnalytics
 } from './react/features/analytics';
 import {
-    redirectWithStoredParams,
+    maybeRedirectToWelcomePage,
+    redirectToStaticPage,
     reloadWithStoredParams
 } from './react/features/app';
 
@@ -43,6 +44,7 @@ import {
     conferenceWillJoin,
     conferenceWillLeave,
     dataChannelOpened,
+    kickedOut,
     lockStateChanged,
     onStartMutedPolicyChanged,
     p2pStatusChanged,
@@ -79,7 +81,6 @@ import {
 import { showNotification } from './react/features/notifications';
 import {
     dominantSpeakerChanged,
-    getAvatarURLByParticipantId,
     getLocalParticipant,
     getNormalizedDisplayName,
     getParticipantById,
@@ -97,28 +98,21 @@ import {
     createLocalTracksF,
     destroyLocalTracks,
     isLocalTrackMuted,
+    isUserInteractionRequiredForUnmute,
     replaceLocalTrack,
     trackAdded,
     trackRemoved
 } from './react/features/base/tracks';
-import {
-    getLocationContextRoot,
-    getJitsiMeetGlobalNS
-} from './react/features/base/util';
-import { notifyKickedOut } from './react/features/conference';
-import { addMessage } from './react/features/chat';
+import { getJitsiMeetGlobalNS } from './react/features/base/util';
 import { showDesktopPicker } from './react/features/desktop-picker';
 import { appendSuffix } from './react/features/display-name';
 import {
     maybeOpenFeedbackDialog,
     submitFeedback
 } from './react/features/feedback';
-import {
-    mediaPermissionPromptVisibilityChanged,
-    suspendDetected
-} from './react/features/overlay';
+import { mediaPermissionPromptVisibilityChanged } from './react/features/overlay';
+import { suspendDetected } from './react/features/power-monitor';
 import { setSharedVideoStatus } from './react/features/shared-video';
-import { isButtonEnabled } from './react/features/toolbox';
 import { endpointMessageReceived } from './react/features/subtitles';
 
 const logger = require('jitsi-meet-logger').getLogger(__filename);
@@ -212,77 +206,6 @@ function muteLocalVideo(muted) {
     APP.store.dispatch(setVideoMuted(muted));
 }
 
-/**
- * Check if the welcome page is enabled and redirects to it.
- * If requested show a thank you dialog before that.
- * If we have a close page enabled, redirect to it without
- * showing any other dialog.
- *
- * @param {object} options used to decide which particular close page to show
- * or if close page is disabled, whether we should show the thankyou dialog
- * @param {boolean} options.showThankYou - whether we should
- * show thank you dialog
- * @param {boolean} options.feedbackSubmitted - whether feedback was submitted
- */
-function maybeRedirectToWelcomePage(options) {
-    // if close page is enabled redirect to it, without further action
-    if (config.enableClosePage) {
-        const { isGuest } = APP.store.getState()['features/base/jwt'];
-
-        // save whether current user is guest or not, before navigating
-        // to close page
-        window.sessionStorage.setItem('guest', isGuest);
-        redirectToStaticPage(`static/${
-            options.feedbackSubmitted ? 'close.html' : 'close2.html'}`);
-
-        return;
-    }
-
-    // else: show thankYou dialog only if there is no feedback
-    if (options.showThankYou) {
-        APP.store.dispatch(showNotification({
-            titleArguments: { appName: interfaceConfig.APP_NAME },
-            titleKey: 'dialog.thankYou'
-        }));
-    }
-
-    // if Welcome page is enabled redirect to welcome page after 3 sec, if
-    // there is a thank you message to be shown, 0.5s otherwise.
-    if (config.enableWelcomePage) {
-        setTimeout(
-            () => {
-                APP.store.dispatch(redirectWithStoredParams('/'));
-            },
-            options.showThankYou ? 3000 : 500);
-    }
-}
-
-/**
- * Assigns a specific pathname to window.location.pathname taking into account
- * the context root of the Web app.
- *
- * @param {string} pathname - The pathname to assign to
- * window.location.pathname. If the specified pathname is relative, the context
- * root of the Web app will be prepended to the specified pathname before
- * assigning it to window.location.pathname.
- * @return {void}
- */
-function redirectToStaticPage(pathname) {
-    const windowLocation = window.location;
-    let newPathname = pathname;
-
-    if (!newPathname.startsWith('/')) {
-        // A pathname equal to ./ specifies the current directory. It will be
-        // fine but pointless to include it because contextRoot is the current
-        // directory.
-        newPathname.startsWith('./')
-            && (newPathname = newPathname.substring(2));
-        newPathname = getLocationContextRoot(windowLocation) + newPathname;
-    }
-
-    windowLocation.pathname = newPathname;
-}
-
 /**
  * A queue for the async replaceLocalTrack action so that multiple audio
  * replacements cannot happen simultaneously. This solves the issue where
@@ -319,8 +242,6 @@ class ConferenceConnector {
             this._handleConferenceJoined.bind(this));
         room.on(JitsiConferenceEvents.CONFERENCE_FAILED,
             this._onConferenceFailed.bind(this));
-        room.on(JitsiConferenceEvents.CONFERENCE_ERROR,
-            this._onConferenceError.bind(this));
     }
 
     /**
@@ -348,7 +269,7 @@ class ConferenceConnector {
 
         case JitsiConferenceErrors.NOT_ALLOWED_ERROR: {
             // let's show some auth not allowed page
-            redirectToStaticPage('static/authError.html');
+            APP.store.dispatch(redirectToStaticPage('static/authError.html'));
             break;
         }
 
@@ -423,31 +344,6 @@ class ConferenceConnector {
         }
     }
 
-    /**
-     *
-     */
-    _onConferenceError(err, ...params) {
-        logger.error('CONFERENCE Error:', err, params);
-        switch (err) {
-        case JitsiConferenceErrors.CHAT_ERROR:
-            logger.error('Chat error.', err);
-            if (isButtonEnabled('chat') && !interfaceConfig.filmStripOnly) {
-                const [ code, msg ] = params;
-
-                APP.store.dispatch(addMessage({
-                    hasRead: true,
-                    error: code,
-                    message: msg,
-                    messageType: 'error',
-                    timestamp: Date.now()
-                }));
-            }
-            break;
-        default:
-            logger.error('Unknown error.', err);
-        }
-    }
-
     /**
      *
      */
@@ -630,8 +526,7 @@ export default {
             // Resolve with no tracks
             tryCreateLocalTracks = Promise.resolve([]);
         } else {
-            tryCreateLocalTracks = createLocalTracksF(
-                { devices: initialDevices }, true)
+            tryCreateLocalTracks = createLocalTracksF({ devices: initialDevices }, true)
                 .catch(err => {
                     if (requestedAudio && requestedVideo) {
 
@@ -735,8 +630,11 @@ export default {
                 options.roomName, {
                     startAudioOnly: config.startAudioOnly,
                     startScreenSharing: config.startScreenSharing,
-                    startWithAudioMuted: config.startWithAudioMuted || config.startSilent,
+                    startWithAudioMuted: config.startWithAudioMuted
+                        || config.startSilent
+                        || isUserInteractionRequiredForUnmute(APP.store.getState()),
                     startWithVideoMuted: config.startWithVideoMuted
+                        || isUserInteractionRequiredForUnmute(APP.store.getState())
                 }))
             .then(([ tracks, con ]) => {
                 tracks.forEach(track => {
@@ -837,6 +735,13 @@ export default {
      * dialogs in case of media permissions error.
      */
     muteAudio(mute, showUI = true) {
+        if (!mute
+                && isUserInteractionRequiredForUnmute(APP.store.getState())) {
+            logger.error('Unmuting audio requires user interaction');
+
+            return;
+        }
+
         // Not ready to modify track's state yet
         if (!this._localTracksInitialized) {
             // This will only modify base/media.audio.muted which is then synced
@@ -900,6 +805,13 @@ export default {
      * dialogs in case of media permissions error.
      */
     muteVideo(mute, showUI = true) {
+        if (!mute
+                && isUserInteractionRequiredForUnmute(APP.store.getState())) {
+            logger.error('Unmuting video requires user interaction');
+
+            return;
+        }
+
         // If not ready to modify track's state yet adjust the base/media
         if (!this._localTracksInitialized) {
             // This will only modify base/media.video.muted which is then synced
@@ -1019,17 +931,15 @@ export default {
      * Returns the connection times stored in the library.
      */
     getConnectionTimes() {
-        return this._room.getConnectionTimes();
+        return room.getConnectionTimes();
     },
 
     // used by torture currently
     isJoined() {
-        return this._room
-            && this._room.isJoined();
+        return room && room.isJoined();
     },
     getConnectionState() {
-        return this._room
-            && this._room.getConnectionState();
+        return room && room.getConnectionState();
     },
 
     /**
@@ -1038,8 +948,7 @@ export default {
      * P2P connection
      */
     getP2PConnectionState() {
-        return this._room
-            && this._room.getP2PConnectionState();
+        return room && room.getP2PConnectionState();
     },
 
     /**
@@ -1048,7 +957,7 @@ export default {
      */
     _startP2P() {
         try {
-            this._room && this._room.startP2PSession();
+            room && room.startP2PSession();
         } catch (error) {
             logger.error('Start P2P failed', error);
             throw error;
@@ -1061,7 +970,7 @@ export default {
      */
     _stopP2P() {
         try {
-            this._room && this._room.stopP2PSession();
+            room && room.stopP2PSession();
         } catch (error) {
             logger.error('Stop P2P failed', error);
             throw error;
@@ -1076,7 +985,7 @@ export default {
      * false otherwise.
      */
     isConnectionInterrupted() {
-        return this._room.isConnectionInterrupted();
+        return room.isConnectionInterrupted();
     },
 
     /**
@@ -1137,7 +1046,7 @@ export default {
     },
 
     getMyUserId() {
-        return this._room && this._room.myUserId();
+        return room && room.myUserId();
     },
 
     /**
@@ -1160,7 +1069,7 @@ export default {
      * least one track.
      */
     getNumberOfParticipantsWithTracks() {
-        return this._room.getParticipants()
+        return room.getParticipants()
             .filter(p => p.getTracks().length > 0)
             .length;
     },
@@ -1298,17 +1207,34 @@ export default {
         const options = config;
 
         const nick = APP.store.getState()['features/base/settings'].displayName;
+        const { locationURL } = APP.store.getState()['features/base/connection'];
 
         if (nick) {
             options.displayName = nick;
         }
 
         options.applicationName = interfaceConfig.APP_NAME;
-        options.getWiFiStatsMethod = getJitsiMeetGlobalNS().getWiFiStats;
+        options.getWiFiStatsMethod = this._getWiFiStatsMethod;
+        options.confID = `${locationURL.host}${locationURL.pathname}`;
 
         return options;
     },
 
+    /**
+     * Returns the result of getWiFiStats from the global NS or does nothing
+     * (returns empty result).
+     * Fixes a concurrency problem where we need to pass a function when creating
+     * JitsiConference, but that method is added to the context later.
+     *
+     * @returns {Promise}
+     * @private
+     */
+    _getWiFiStatsMethod() {
+        const gloabalNS = getJitsiMeetGlobalNS();
+
+        return gloabalNS.getWiFiStats ? gloabalNS.getWiFiStats() : Promise.resolve('{}');
+    },
+
     /**
      * Start using provided video stream.
      * Stops previous video stream.
@@ -1324,7 +1250,7 @@ export default {
                         this.localVideo = newStream;
                         this._setSharingScreen(newStream);
                         if (newStream) {
-                            APP.UI.addLocalStream(newStream);
+                            APP.UI.addLocalVideoStream(newStream);
                         }
                         this.setVideoMuteStatus(this.isLocalVideoMuted());
                     })
@@ -1375,9 +1301,6 @@ export default {
                 replaceLocalTrack(this.localAudio, newStream, room))
                     .then(() => {
                         this.localAudio = newStream;
-                        if (newStream) {
-                            APP.UI.addLocalStream(newStream);
-                        }
                         this.setAudioMuteStatus(this.isLocalAudioMuted());
                     })
                     .then(resolve)
@@ -1393,8 +1316,7 @@ export default {
      * @returns {boolean}
      */
     isAudioOnly() {
-        return Boolean(
-            APP.store.getState()['features/base/conference'].audioOnly);
+        return Boolean(APP.store.getState()['features/base/audio-only'].enabled);
     },
 
     videoSwitchInProgress: false,
@@ -1506,7 +1428,9 @@ export default {
             return this._switchToScreenSharing(options);
         }
 
-        return this._untoggleScreenSharing();
+        return this._untoggleScreenSharing
+            ? this._untoggleScreenSharing()
+            : Promise.resolve();
     },
 
     /**
@@ -1758,14 +1682,7 @@ export default {
                 return;
             }
 
-            const displayName = user.getDisplayName();
-
             logger.log(`USER ${id} connnected:`, user);
-            APP.API.notifyUserJoined(id, {
-                displayName,
-                formattedDisplayName: appendSuffix(
-                    displayName || interfaceConfig.DEFAULT_REMOTE_DISPLAY_NAME)
-            });
             APP.UI.addUser(user);
 
             // check the roles for the new user and reflect them
@@ -1781,12 +1698,7 @@ export default {
             }
 
             logger.log(`USER ${id} LEFT:`, user);
-            APP.API.notifyUserLeft(id);
-            APP.UI.messageHandler.participantNotification(
-                user.getDisplayName(),
-                'notify.somebody',
-                'disconnected',
-                'notify.disconnected');
+
             APP.UI.onSharedVideoStop(id);
         });
 
@@ -1855,15 +1767,12 @@ export default {
             APP.UI.setAudioLevel(id, newLvl);
         });
 
-        room.on(JitsiConferenceEvents.TRACK_MUTE_CHANGED, (_, participantThatMutedUs) => {
+        room.on(JitsiConferenceEvents.TRACK_MUTE_CHANGED, (track, participantThatMutedUs) => {
             if (participantThatMutedUs) {
                 APP.store.dispatch(participantMutedUs(participantThatMutedUs));
             }
         });
 
-        room.on(JitsiConferenceEvents.TALK_WHILE_MUTED, () => {
-            APP.UI.showToolbar(6000);
-        });
         room.on(JitsiConferenceEvents.SUBJECT_CHANGED,
             subject => APP.store.dispatch(conferenceSubjectChanged(subject)));
 
@@ -1963,7 +1872,7 @@ export default {
 
         room.on(JitsiConferenceEvents.KICKED, participant => {
             APP.UI.hideStats();
-            APP.store.dispatch(notifyKickedOut(participant));
+            APP.store.dispatch(kickedOut(room, participant));
 
             // FIXME close
         });
@@ -1974,31 +1883,6 @@ export default {
 
         room.on(JitsiConferenceEvents.SUSPEND_DETECTED, () => {
             APP.store.dispatch(suspendDetected());
-
-            // After wake up, we will be in a state where conference is left
-            // there will be dialog shown to user.
-            // We do not want video/audio as we show an overlay and after it
-            // user need to rejoin or close, while waking up we can detect
-            // camera wakeup as a problem with device.
-            // We also do not care about device change, which happens
-            // on resume after suspending PC.
-            if (this.deviceChangeListener) {
-                JitsiMeetJS.mediaDevices.removeEventListener(
-                    JitsiMediaDevicesEvents.DEVICE_LIST_CHANGED,
-                    this.deviceChangeListener);
-            }
-
-            // stop local video
-            if (this.localVideo) {
-                this.localVideo.dispose();
-                this.localVideo = null;
-            }
-
-            // stop local audio
-            if (this.localAudio) {
-                this.localAudio.dispose();
-                this.localAudio = null;
-            }
         });
 
         APP.UI.addListener(UIEvents.AUDIO_MUTED, muted => {
@@ -2254,6 +2138,27 @@ export default {
             });
     },
 
+    /**
+     * Cleanups local conference on suspend.
+     */
+    onSuspendDetected() {
+        // After wake up, we will be in a state where conference is left
+        // there will be dialog shown to user.
+        // We do not want video/audio as we show an overlay and after it
+        // user need to rejoin or close, while waking up we can detect
+        // camera wakeup as a problem with device.
+        // We also do not care about device change, which happens
+        // on resume after suspending PC.
+        if (this.deviceChangeListener) {
+            JitsiMeetJS.mediaDevices.removeEventListener(
+                JitsiMediaDevicesEvents.DEVICE_LIST_CHANGED,
+                this.deviceChangeListener);
+        }
+
+        this.localVideo = null;
+        this.localAudio = null;
+    },
+
     /**
      * Callback invoked when the conference has been successfully joined.
      * Initializes the UI and various other features.
@@ -2266,30 +2171,12 @@ export default {
 
         APP.keyboardshortcut.init();
 
-        if (config.requireDisplayName
-                && !APP.conference.getLocalDisplayName()
-                && !this._room.isHidden()) {
-            APP.UI.promptDisplayName();
-        }
-
         APP.store.dispatch(conferenceJoined(room));
 
         const displayName
             = APP.store.getState()['features/base/settings'].displayName;
 
         APP.UI.changeDisplayName('localVideoContainer', displayName);
-        APP.API.notifyConferenceJoined(
-            this.roomName,
-            this._room.myUserId(),
-            {
-                displayName,
-                formattedDisplayName: appendSuffix(
-                    displayName,
-                    interfaceConfig.DEFAULT_LOCAL_DISPLAY_NAME),
-                avatarURL: getAvatarURLByParticipantId(
-                    APP.store.getState(), this._room.myUserId())
-            }
-        );
     },
 
     /**
@@ -2612,7 +2499,7 @@ export default {
             room = undefined;
 
             APP.API.notifyReadyToClose();
-            maybeRedirectToWelcomePage(values[0]);
+            APP.store.dispatch(maybeRedirectToWelcomePage(values[0]));
         });
     },
 
@@ -2624,7 +2511,11 @@ export default {
     leaveRoomAndDisconnect() {
         APP.store.dispatch(conferenceWillLeave(room));
 
-        return room.leave().then(disconnect, disconnect);
+        if (room.isJoined()) {
+            return room.leave().then(disconnect, disconnect);
+        }
+
+        return disconnect();
     },
 
     /**
@@ -2753,14 +2644,6 @@ export default {
             displayName: formattedNickname
         }));
 
-        APP.API.notifyDisplayNameChanged(id, {
-            displayName: formattedNickname,
-            formattedDisplayName:
-                appendSuffix(
-                    formattedNickname,
-                    interfaceConfig.DEFAULT_LOCAL_DISPLAY_NAME)
-        });
-
         if (room) {
             APP.UI.changeDisplayName(id, formattedNickname);
         }
@@ -2814,6 +2697,18 @@ export default {
                  */
                 convertVideoToDesktop: true,
 
+                /**
+                 * Callback invoked when the connection has been closed
+                 * automatically. Triggers cleanup of screensharing if active.
+                 *
+                 * @returns {void}
+                 */
+                onConnectionClosed: () => {
+                    if (this._untoggleScreenSharing) {
+                        this._untoggleScreenSharing();
+                    }
+                },
+
                 /**
                  * Callback invoked to pass messages from the local client back
                  * out to the external client.

config.js

@@ -1,16 +1,6 @@
 /* eslint-disable no-unused-vars, no-var */
 
 var config = {
-    // Configuration
-    //
-
-    // Alternative location for the configuration.
-    // configLocation: './config.json',
-
-    // Custom function which given the URL path should return a room name.
-    // getroomnode: function (path) { return 'someprefixpossiblybasedonpath'; },
-
-
     // Connection
     //
 
@@ -60,6 +50,10 @@ var config = {
 
         // Enables the test specific features consumed by jitsi-meet-torture
         // testMode: false
+
+        // Disables the auto-play behavior of *all* newly created video element.
+        // This is useful when the client runs on a host with limited resources.
+        // noAutoPlayVideo: false
     },
 
     // Disables ICE/UDP by filtering out local and remote UDP candidates in
@@ -123,10 +117,6 @@ var config = {
     // are requested again.
     // enableLayerSuspension: false,
 
-    // Suspend sending video if bandwidth estimation is too low. This may cause
-    // problems with audio playback. Disabled until these are fixed.
-    disableSuspendVideo: true,
-
     // Every participant after the Nth will start video muted.
     // startVideoMuted: 10,
 
@@ -201,6 +191,9 @@ var config = {
     // subtitles and buttons can be configured)
     // transcribingEnabled: false,
 
+    // Enables automatic turning on captions when recording is started
+    // autoCaptionOnRecord: false,
+
     // Misc
 
     // Default value for the channel "last N" attribute. -1 for unlimited.
@@ -418,10 +411,24 @@ var config = {
     // use only.
     // _desktopSharingSourceDevice: 'sample-id-or-label'
 
+    // If true, any checks to handoff to another application will be prevented
+    // and instead the app will continue to display in the current browser.
+    // disableDeepLinking: false
+
     // A property to disable the right click context menu for localVideo
     // the menu has option to flip the locally seen video for local presentations
     // disableLocalVideoFlip: false
 
+    // Deployment specific URLs.
+    // deploymentUrls: {
+    //    // If specified a 'Help' button will be displayed in the overflow menu with a link to the specified URL for
+    //    // user documentation.
+    //    userDocumentationURL: 'https://docs.example.com/video-meetings.html',
+    //    // If specified a 'Download our apps' button will be displayed in the overflow menu with a link
+    //    // to the specified URL for an app download page.
+    //    downloadAppsUrl: 'https://docs.example.com/our-apps.html'
+    // }
+
     // List of undocumented settings used in jitsi-meet
     /**
      _immediateReloadThreshold

css/_avatar.scss

@@ -0,0 +1,31 @@
+.avatar {
+    align-items: center;
+    background-color: #AAA;
+    display: flex;
+    border-radius: 50%;
+    color: rgba(255, 255, 255, 0.6);
+    font-weight: 100;
+    justify-content: center;
+    object-fit: cover;
+}
+
+.avatar-foreign {
+    align-items: center;
+    bottom: 0;
+    display: flex;
+    font-size: 40pt;
+    justify-content: center;
+    left: 0;
+    position: absolute;
+    right: 0;
+    top: 0;
+}
+
+.avatar-svg {
+    height: 100%;
+    width: 100%;
+}
+
+.defaultAvatar {
+    opacity: 0.6
+}

css/_base.scss

@@ -33,6 +33,10 @@ body {
     }
 }
 
+.jitsi-icon svg {
+    fill: white;
+}
+
 /**
  * AtlasKitThemeProvider sets a background color on an app-wrapping div, thereby
  * preventing transparency in filmstrip-only mode. The selector chosen to

css/_chat.scss

@@ -80,6 +80,28 @@
     }
 }
 
+#chat-recipient {
+    align-items: center;
+    background-color: $chatPrivateMessageBackgroundColor;
+    display: flex;
+    flex-direction: row;
+    font-weight: 100;
+    padding: 10px;
+
+    span {
+        color: white;
+        display: flex;
+        flex: 1;
+    }
+
+    div {
+        svg {
+            cursor: pointer;
+            fill: white
+        }
+    }
+}
+
 .chat-header {
     background-color: $chatHeaderBackgroundColor;
     height: 70px;
@@ -111,6 +133,7 @@
 #chat-input {
     border-top: 1px solid $chatInputSeparatorColor;
     display: flex;
+    padding: 5px 10px;
 
     * {
         background-color: transparent;
@@ -131,8 +154,7 @@
     box-shadow: none;
     color: white;
     font-size: 15px;
-    line-height: 30px;
-    padding: 5px;
+    padding: 10px;
     overflow-y: auto;
     resize: none;
     width: 100%;
@@ -162,6 +184,7 @@
     .display-name {
         font-size: 13px;
         font-weight: bold;
+        margin-bottom: 5px;
         white-space: nowrap;
         text-overflow: ellipsis;
         overflow: hidden;
@@ -175,7 +198,6 @@
     color: white;
     margin-top: 3px;
     max-width: 100%;
-    padding-bottom: 3px;
     position: relative;
 
     &.localuser {
@@ -196,6 +218,15 @@
             padding: 0;
         }
     }
+
+    .privatemessagenotice {
+        font-size: 11px;
+        font-weight: 100;
+    }
+
+    .messagecontent {
+        margin: 5px 10px;
+    }
 }
 
 .smiley {
@@ -228,6 +259,7 @@
 .smileys-panel {
     bottom: 100%;
     box-sizing: border-box;
+    background-color: rgba(0, 0, 0, .6) !important;
     height: auto;
     max-height: 0;
     overflow: hidden;
@@ -270,10 +302,6 @@
     cursor: pointer;
 }
 
-#usermsg::-webkit-input-placeholder {
-    line-height: 30px;
-}
-
 #usermsg::-webkit-scrollbar-track-piece {
     background: #3a3a3a;
 }
@@ -288,6 +316,10 @@
         .chatmessage {
             background-color: $chatLocalMessageBackgroundColor;
             border-radius: 6px 0px 6px 6px;
+
+            &.privatemessage {
+                background-color: $chatPrivateMessageBackgroundColor;
+            }
         }
 
         .display-name {
@@ -301,8 +333,9 @@
 
     &.error {
         .chatmessage {
+            background-color: $defaultWarningColor;
             border-radius: 0px;
-            color: red;
+            font-weight: 100;
         }
 
         .display-name {
@@ -312,6 +345,25 @@
 
     .chatmessage-wrapper {
         max-width: 100%;
+
+        .replywrapper {
+            display: flex;
+            flex-direction: row;
+            align-items: center;
+
+            .messageactions {
+                align-self: stretch;
+                border-left: 1px solid $chatActionsSeparatorColor;
+                display: flex;
+                flex-direction: column;
+                justify-content: center;
+                padding: 5px;
+
+                .toolbox-icon {
+                    cursor: pointer;
+                }
+            }
+        }
     }
 
     .chatmessage {
@@ -320,6 +372,9 @@
         display: inline-block;
         margin-top: 3px;
         color: white;
-        padding: 8px;
+
+        &.privatemessage {
+            background-color: $chatPrivateMessageBackgroundColor;
+        }
     }
 }

css/_font.scss

@@ -1,222 +0,0 @@
-@font-face {
-    font-family: 'jitsi';
-    src:  url('../fonts/jitsi.eot?3vw865');
-    src:  url('../fonts/jitsi.eot?3vw865#iefix') format('embedded-opentype'),
-        url('../fonts/jitsi.ttf?3vw865') format('truetype'),
-        url('../fonts/jitsi.woff?3vw865') format('woff'),
-        url('../fonts/jitsi.svg?3vw865#jitsi') format('svg');
-    font-weight: normal;
-    font-style: normal;
-}
-
-[class^="icon-"], [class*=" icon-"] {
-    font-family: 'jitsi';
-    speak: none;
-    font-style: normal;
-    font-weight: normal;
-    font-variant: normal;
-    text-transform: none;
-    line-height: 1.22em;
-    font-size: 1.22em;
-    cursor: default;
-
-    /* Better Font Rendering =========== */
-    -webkit-font-smoothing: antialiased;
-    -moz-osx-font-smoothing: grayscale;
-}
-
-.icon-enlarge:before {
-  content: "\e90a";
-}
-.icon-signal_cellular_0:before {
-  content: "\e901";
-}
-.icon-signal_cellular_1:before {
-  content: "\e902";
-}
-.icon-signal_cellular_2:before {
-  content: "\e907";
-}
-.icon-phone:before {
-  content: "\e0cd";
-}
-.icon-radio_button_unchecked:before {
-  content: "\e836";
-}
-.icon-radio_button_checked:before {
-  content: "\e837";
-}
-.icon-search:before {
-  content: "\e8b6";
-}
-.icon-chat-unread:before {
-  content: "\e0b7";
-}
-.icon-closed_caption:before {
-  content: "\e930";
-}
-.icon-tiles-many:before {
-  content: "\e92e";
-}
-.icon-close:before {
-  content: "\e5cd";
-}
-.icon-open_in_new:before {
-  content: "\e89e";
-}
-.icon-restore:before {
-  content: "\e8b3";
-}
-.icon-navigate_next:before {
-  content: "\e409";
-}
-.icon-menu:before {
-  content: "\e5d2";
-}
-.icon-arrow_back:before {
-  content: "\e5c4";
-}
-.icon-public:before {
-  content: "\e80b";
-}
-.icon-event_note:before {
-  content: "\e616";
-}
-.icon-bluetooth:before {
-  content: "\e1aa";
-}
-.icon-headset:before {
-  content: "\e310";
-}
-.icon-phone-talk:before {
-  content: "\e61d";
-}
-.icon-thumb-menu:before {
-  content: "\e5d4";
-}
-.icon-ninja:before {
-  content: "\e909";
-}
-.icon-invite:before {
-  content: "\e145";
-}
-.icon-add:before {
-  content: "\e146";
-}
-.icon-play:before {
-  content: "\f04b";
-}
-.icon-stop:before {
-  content: "\f04d";
-}
-.icon-dominant-speaker:before {
-  content: "\f0a1";
-}
-.icon-speaker:before {
-  content: "\e92d";
-}
-.icon-rec:before {
-  content: "\e92b";
-}
-.icon-camera-take-picture:before {
-  content: "\e92a";
-}
-.icon-AUD:before {
-  content: "\e900";
-}
-.icon-HD:before {
-  content: "\e927";
-}
-.icon-LD:before {
-  content: "\e928";
-}
-.icon-SD:before {
-  content: "\e929";
-}
-.icon-gsm-bars:before {
-  content: "\e926";
-}
-.icon-info:before {
-  content: "\e922";
-}
-.icon-mic-camera-combined:before {
-  content: "\e903";
-}
-.icon-feedback:before {
-  content: "\e91d";
-}
-.icon-hangup:before {
-  content: "\e905";
-}
-.icon-chat:before {
-  content: "\e906";
-}
-.icon-share-doc:before {
-  content: "\e908";
-}
-.icon-kick:before {
-  content: "\e904";
-}
-.icon-menu-up:before {
-  content: "\e91f";
-}
-.icon-menu-down:before {
-  content: "\e920";
-}
-.icon-full-screen:before {
-  content: "\e90b";
-}
-.icon-exit-full-screen:before {
-  content: "\e90c";
-}
-.icon-security:before {
-  content: "\e90d";
-}
-.icon-security-locked:before {
-  content: "\e90e";
-}
-.icon-microphone:before {
-  content: "\e910";
-}
-.icon-mic-disabled:before {
-  content: "\e912";
-}
-.icon-raised-hand:before {
-  content: "\e91e";
-}
-.icon-link:before {
-  content: "\e913";
-}
-.icon-shared-video:before {
-  content: "\e914";
-}
-.icon-settings:before {
-  content: "\e915";
-}
-.icon-star:before {
-  content: "\e916";
-}
-.icon-switch-camera:before {
-  content: "\e921";
-}
-.icon-share-desktop:before {
-  content: "\e917";
-}
-.icon-camera:before {
-  content: "\e918";
-}
-.icon-camera-disabled:before {
-  content: "\e919";
-}
-.icon-volume:before {
-  content: "\e91a";
-}
-.icon-presentation:before {
-  content: "\e603";
-}
-.icon-visibility:before {
-  content: "\e923";
-}
-.icon-visibility-off:before {
-  content: "\e924";
-}

css/_mini_toolbox.scss

@@ -0,0 +1,66 @@
+.filmstrip-toolbox,
+.always-on-top-toolbox {
+    background-color: $newToolbarBackgroundColor;
+    border-radius: 3px;
+    display: flex;
+    z-index: $toolbarZ;
+
+    .toolbox-icon {
+        cursor: pointer;
+        padding: 7px;
+
+        &.toggled {
+            background: $AOTToolbarButtonToggleColor;
+        }
+
+        &.disabled {
+            cursor: initial;
+        }
+    }
+}
+
+.always-on-top-toolbox {
+    flex-direction: row;
+    left: 50%;
+    position: absolute;
+    top: 10px;
+    transform: translateX(-50%);
+
+    .toolbox-button {
+        &:first-child {
+            .toolbox-icon {
+                border-top-left-radius: 3px;
+                border-bottom-left-radius: 3px;
+            }
+        }
+
+        &:nth-child(2) {
+            svg {
+                fill: $hangupColor;
+            }
+        }
+
+        &:last-child {
+            .toolbox-icon {
+                border-top-right-radius: 3px;
+                border-bottom-right-radius: 3px;
+            }
+        }
+    }
+}
+
+.filmstrip-toolbox {
+    flex-direction: column;
+
+    .toolbox-button {
+        &:nth-child(1) {
+            svg {
+                fill: $hangupColor;
+            }
+        }
+
+        .toolbox-icon {
+            border-radius: 3px;
+        }
+    }
+}

css/_participants-count.scss

@@ -0,0 +1,26 @@
+.participants-count {
+    background: #fff;
+    border-radius: 4px;
+    color: #5e6d7a;
+    cursor: pointer;
+    display: inline-block;
+    font-size: 13px;
+    line-height: 20px;
+    margin-left: 16px;
+    padding: 4px 8px;
+    pointer-events: auto;
+
+    &-number {
+        margin-right: 8px;
+        vertical-align: middle;
+    }
+
+    &-icon {
+        background: url('../images/user-groups.svg');
+        background-repeat: no-repeat;
+        display: inline-block;
+        height: 16px;
+        width: 16px;
+        vertical-align: middle;
+    }
+}

css/_popup_menu.scss

@@ -6,7 +6,7 @@
     min-width: 75px;
     text-align: left;
     padding: 0px;
-    width: 150px;
+    width: 180px;
     white-space: nowrap;
 
     &__item {
@@ -87,6 +87,7 @@
         display: inline-block;
         min-width: 20px;
         height: 100%;
+        padding-right: 10px;
 
         > * {
             @include absoluteAligning();

css/_promotional-footer.scss

@@ -0,0 +1 @@
+/** Insert custom CSS for any additional content in the promotional footer **/

css/_subject.scss

@@ -9,7 +9,7 @@
     text-align: center;
     font-size: 17px;
     color: #fff;
-    z-index: $toolbarBackgroundZ;
+    z-index: $zindex10;
     overflow: hidden;
     text-overflow: ellipsis;
     box-sizing: border-box;
@@ -19,4 +19,8 @@
     &.visible {
         top: 0px;
     }
+
+    &-text {
+        vertical-align: middle;
+    }
 }

css/_toolbars.scss

@@ -73,8 +73,62 @@
 
         .button-group-center {
             justify-content: center;
-            .toolbox-icon {
-                margin: 0px 4px;
+
+            .toolbox-button {
+
+                .toolbox-icon {
+                    background-color: #fff;
+                    border-radius: 50%;
+                    border: 1px solid #d1dbe8;
+                    margin: 0px 4px;
+                    width: 38px;
+                    height: 38px;
+        
+                    &:hover {
+                        background-color: #daebfa;
+                        border: 1px solid #daebfa;
+                    }
+        
+                    &.toggled {
+                        background: #2a3a4b;
+                        border: 1px solid #5e6d7a;
+    
+                        svg {
+                            fill: #fff;
+                        }
+        
+                        &:hover {
+                            background-color: #5e6d7a;
+                        }
+                    }
+        
+                    &.disabled, .disabled & {
+                        cursor: initial;
+                        color: #fff;
+                        background-color: #a4b8d1;
+                    }
+    
+                    svg {
+                        fill: #5e6d7a;
+                    }
+                }
+
+                &:nth-child(2) {
+                    .toolbox-icon {
+                        background-color: $hangupColor;
+                        border: 1px solid $hangupColor;
+                        width: 40px;
+                        height: 40px;
+                
+                        &:hover {
+                            background-color: $hangupColor;
+                        }
+
+                        svg {
+                            fill: #fff;
+                        }
+                    }
+                }
             }
         }
 
@@ -82,75 +136,6 @@
             justify-content: flex-end;
         }
 
-        i {
-            border-radius: 5px;
-            cursor: pointer;
-            display: block;
-            font-size: inherit;
-            height: 100%;
-            line-height: inherit;
-            width: 100%;
-        }
-
-        i:hover {
-            background: $newToolbarButtonHoverColor;
-        }
-
-        i.toggled {
-            background: $newToolbarButtonToggleColor;
-        }
-
-        i.toggled:hover {
-            background: $newToolbarButtonHoverColor;
-        }
-
-        .icon-hangup {
-            background-color: #e12d2d;
-            color: #fff;
-            border-radius: 50%;
-            width: 40px;
-            height: 40px;
-
-            &:hover {
-                background-color: #e54b4b;
-            }
-        }
-        i.disabled, .disabled i {
-            cursor: initial !important;
-            color: #fff !important;
-            background-color: #a4b8d1 !important;
-        }
-
-        .icon-mic-disabled, .icon-microphone, .icon-camera-disabled, .icon-camera {
-            background-color: #fff;
-            color: #5e6d7a;
-            border-radius: 50%;
-            border: 1px solid #d1dbe8;
-            width: 38px;
-            height: 38px;
-
-            &:hover {
-                background-color: #daebfa;
-                border: 1px solid #daebfa;
-            }
-
-            &.toggled {
-                background: #2a3a4b;
-                color: #fff;
-                border: 1px solid #5e6d7a;
-
-                &:hover {
-                    background-color: #5e6d7a;
-                }
-            }
-
-            &.disabled, .disabled & {
-                cursor: initial;
-                color: #fff;
-                background-color: #a4b8d1;
-            }
-        }
-
         .overflow-menu {
             font-size: 1.2em;
             list-style-type: none;
@@ -191,14 +176,6 @@
                     cursor: initial;
                     color: #3b475c;
                 }
-
-                i.toggled {
-                    background: inherit;
-                }
-
-                i.toggled:hover {
-                    background: inherit;
-                }
             }
 
             .beta-tag {
@@ -227,6 +204,10 @@
                     max-width: 24px;
                     max-height: 24px;
                 }
+
+                svg {
+                    fill: #B8C7E0 !important;
+                }
             }
 
             .profile-text {
@@ -265,104 +246,30 @@
         }
 
         .toolbox-icon {
-            height: $newToolbarSize;
+            display: flex;
+            border-radius: 5px;
+            flex-direction: column;
             font-size: 24px;
+            height: $newToolbarSize;
+            justify-content: center;
             width: $newToolbarSize;
+
+            &:hover, &.toggled {
+                background: $newToolbarButtonHoverColor;
+            }
+    
+            &.disabled {
+                cursor: initial !important;
+                background-color: #a4b8d1 !important;
+
+                svg {
+                    fill: #fff !important;
+                }
+            }
         }
     }
 }
 
-.always-on-top-toolbox,
-.filmstrip-toolbox {
-    background-color: $newToolbarBackgroundColor;
-    box-sizing: border-box;
-    display: flex;
-    flex-direction: column;
-    z-index: $toolbarZ;
-
-    i {
-        cursor: pointer;
-        display: block;
-    }
-
-    i:hover {
-        background-color: $AOTToolbarButtonHoverColor;
-    }
-
-    i.toggled {
-        background: $AOTToolbarButtonToggleColor;
-    }
-
-    i.toggled:hover:not(.disabled) {
-        background-color: $AOTToolbarButtonHoverColor;
-    }
-
-    .icon-hangup {
-        color: $hangupColor;
-    }
-
-    .toolbox-button {
-        color: $toolbarButtonColor;
-        cursor: pointer;
-        text-align: center;
-    }
-
-    border-radius: 3px;
-}
-
-.always-on-top-toolbox {
-    flex-direction: row;
-    left: 50%;
-    position: absolute;
-    top: 10px;
-    transform: translateX(-50%);
-    z-index: $toolbarZ;
-
-    i {
-        font-size: $newToolbarFontSize;
-        height: $newToolbarSize;
-        line-height: $newToolbarSize;
-        width: $newToolbarSize;
-    }
-
-    .icon-hangup {
-        font-size: $newToolbarHangupFontSize;
-    }
-
-    .disabled {
-        cursor: initial;
-    }
-
-    .toolbox-button:first-child i {
-        border-top-left-radius: 3px;
-        border-bottom-left-radius: 3px;
-    }
-
-    .toolbox-button:last-child i {
-        border-top-right-radius: 3px;
-        border-bottom-right-radius: 3px;
-    }
-}
-
-.filmstrip-toolbox {
-    i {
-        font-size: 1.9em;
-        height: 37px;
-        line-height: 37px;
-        width: 37px;
-    }
-
-    .toolbox-button:first-child i {
-        border-top-left-radius: 3px;
-        border-top-right-radius: 3px;
-    }
-
-    .toolbox-button:last-child i {
-        border-bottom-left-radius: 3px;
-        border-bottom-right-radius: 3px;
-    }
-}
-
 /**
  * START of fade in animation for main toolbar
  */

css/_variables.scss

@@ -28,6 +28,7 @@ $defaultColor: #F1F1F1;
 $defaultSideBarFontColor: #44A5FF;
 $defaultSemiDarkColor: #ACACAC;
 $defaultDarkColor: #2b3d5c;
+$defaultWarningColor: rgb(215, 121, 118);
 
 /**
  * Toolbar
@@ -85,10 +86,12 @@ $modalTextColor: #333;
 /**
  * Chat
  */
+$chatActionsSeparatorColor: rgb(173, 105, 112);
 $chatHeaderBackgroundColor: rgba(42, 58, 75, 0.9);
 $chatInputSeparatorColor: #A4B8D1;
-$chatLocalMessageBackgroundColor: rgba(26, 108, 180, 1);
-$chatRemoteMessageBackgroundColor:  rgba(240, 243, 247, 0.15);
+$chatLocalMessageBackgroundColor: rgb(4, 98, 178);
+$chatPrivateMessageBackgroundColor: rgb(153, 69, 77);
+$chatRemoteMessageBackgroundColor:  rgb(86, 101, 114);
 $sidebarWidth: 375px;
 
  /**
@@ -163,11 +166,93 @@ $watermarkHeight: 74px;
  */
 $welcomePageDescriptionColor: #fff;
 $welcomePageFontFamily: inherit;
-$welcomePageHeaderBackground: linear-gradient(-90deg, #1251AE 0%, #0074FF 50%, #1251AE 100%);
+$welcomePageBackground: linear-gradient(-90deg, #1251AE 0%, #0074FF 50%, #1251AE 100%);
 $welcomePageTitleColor: #fff;
 
+$welcomePageHeaderBackground: none;
+$welcomePageHeaderBackgroundSmall: none;
+$welcomePageHeaderBackgroundPosition: none;
+$welcomePageHeaderBackgroundRepeat: none;
+$welcomePageHeaderBackgroundSize: none;
+$welcomePageHeaderPaddingBottom: 0px;
+
+$welcomePageHeaderTextMarginTop: 35px;
+$welcomePageHeaderTextMarginBottom: 35px;
+
+$welcomePageHeaderTextTitleMarginBottom: 16px;
+$welcomePageHeaderTextTitleFontSize: 2.5rem;
+$welcomePageHeaderTextTitleFontWeight: 500;
+$welcomePageHeaderTextTitleLineHeight: 1.18;
+$welcomePageHeaderTextTitleOpacity: 1;
+
+$welcomePageHeaderTextDescriptionDisplay: inherit;
+$welcomePageHeaderTextDescriptionFontSize: 1rem;
+$welcomePageHeaderTextDescriptionFontWeight: 400;
+$welcomePageHeaderTextDescriptionLineHeight: 24px;
+$welcomePageHeaderTextDescriptionMarginBottom: 20px;
+$welcomePageHeaderTextDescriptionAlignSelf: inherit;
+
+$welcomePageEnterRoomWidth: 680px;
+$welcomePageEnterRoomPadding: 25px 30px;
+$welcomePageEnterRoomBorderRadius: 0px;
+
+$welcomePageEnterRoomInputContainerPadding: 0 8px 5px 0px;
+$welcomePageEnterRoomInputContainerBorderWidth: 0px 0px 2px 0px;
+$welcomePageEnterRoomInputContainerBorderStyle: solid;
+$welcomePageEnterRoomInputContainerBorderImage: linear-gradient(to right, #dee1e6, #fff) 1;
+
+$welcomePageEnterRoomTitleDisplay: inherit;
+
+$welcomePageTabContainerDisplay: flex;
+$welcomePageTabContentDisplay: inherit;
+$welcomePageTabButtonsDisplay: flex;
+$welcomePageTabDisplay: block;
+
+$welcomePageButtonWidth: 51px;
+$welcomePageButtonMinWidth: inherit;
+$welcomePageButtonFontSize: 14px;
+$welcomePageButtonHeight: 35px;
+$welcomePageButtonFontWeight: inherit;
+$welcomePageButtonBorderRadius: 4px;
+$welcomePageButtonLineHeight: 35px;
+
 /**
  * Deep-linking page variables.
  */
 $deepLinkingMobileLogoHeight: 40px;
+
 $deepLinkingMobileHeaderBackground: #f1f2f5;
+
+$deepLinkingMobileLinkColor: inherit;
+$deepLinkingMobileTextFontSize: inherit;
+$deepLinkingMobileTextLineHeight: inherit;
+
+$deepLinkingDialInConferenceIdMargin: 10px 0 10px 0;
+$deepLinkingDialInConferenceIdPadding: inherit;
+$deepLinkingDialInConferenceIdBackgroundColor: inherit;
+$deepLinkingDialInConferenceIdBorderRadius: inherit;
+
+$deepLinkingDialInConferenceNameFontSize: inherit;
+$deepLinkingDialInConferenceNameLineHeight: inherit;
+$deepLinkingDialInConferenceNameMarginBottom: none;
+$deepLinkingDialInConferenceNameFontWeight: inherit;
+
+$deepLinkingDialInConferenceDescriptionFontSize: 0.8em;
+$deepLinkingDialInConferenceDescriptionLineHeight: inherit;
+$deepLinkingDialInConferenceDescriptionMarginBottom: none;
+
+$deepLinkingDialInConferencePinFontSize: inherit;
+$deepLinkingDialInConferencePinLineHeight: inherit;
+
+$depLinkingMobileHrefLineHeight: 2.2857142857142856em;
+$deepLinkingMobileHrefFontWeight: bolder;
+$deepLinkingMobileHrefFontSize: inherit;
+
+$deepLinkingMobileButtonHeight: 2.2857142857142856em;
+$deepLinkingMobileButtonLineHeight: 2.2857142857142856em;
+$deepLinkingMobileButtonMargin: 18px auto 10px;
+$deepLinkingMobileButtonWidth: auto;
+$deepLinkingMobileButtonFontWeight: bold;
+$deepLinkingMobileButtonFontSize: inherit;
+
+$primaryDeepLinkingMobileButtonBorderRadius: inherit;

css/_videolayout_default.scss

@@ -344,8 +344,11 @@
 /**
  * Toolbar icon internal i elements (font icons).
  */
-.toolbar-icon>i {
-    line-height: $thumbnailToolbarHeight;
+.toolbar-icon>div {
+    height: $thumbnailToolbarHeight;
+    display: flex;
+    flex-direction: column;
+    justify-content: center;
 }
 
 /**
@@ -493,7 +496,6 @@
 }
 
 #dominantSpeakerAvatarContainer,
-#dominantSpeakerAvatar,
 .dynamic-shadow {
     width: 200px;
     height: 200px;
@@ -503,14 +505,9 @@
     top: 50px;
     margin: auto;
     position: relative;
-    border-radius: 100px;
     overflow: hidden;
     visibility: inherit;
 }
-#dominantSpeakerAvatar {
-    background-color: #000000;
-    object-fit: cover;
-}
 
 .dynamic-shadow {
     border-radius: 50%;
@@ -524,7 +521,6 @@
 .avatar-container {
     @include maxSize(60px);
     @include absoluteAligning();
-    border-radius: 50%;
     display: flex;
     justify-content: center;
     height: 50%;

css/_welcome_page.scss

@@ -4,7 +4,7 @@ body.welcome-page {
 }
 
 .welcome {
-    background-image: $welcomePageHeaderBackground;
+    background-image: $welcomePageBackground;
     display: flex;
     flex-direction: column;
     font-family: $welcomePageFontFamily;
@@ -13,6 +13,11 @@ body.welcome-page {
     position: relative;
 
     .header {
+        background-image: $welcomePageHeaderBackground;
+        background-position: $welcomePageHeaderBackgroundPosition;
+        background-repeat: $welcomePageHeaderBackgroundRepeat;
+        background-size: $welcomePageHeaderBackgroundSize;
+        padding-bottom: $welcomePageHeaderPaddingBottom;
         align-items: center;
         display: flex;
         flex-direction: column;
@@ -24,8 +29,8 @@ body.welcome-page {
         .header-text {
             display: flex;
             flex-direction: column;
-            margin-top: $watermarkHeight + 35;
-            margin-bottom: 35px;
+            margin-top: $watermarkHeight + $welcomePageHeaderTextMarginTop;
+            margin-bottom: $welcomePageHeaderTextMarginBottom;
             max-width: calc(100% - 40px);
             width: 650px;
             z-index: $zindex2;
@@ -33,41 +38,45 @@ body.welcome-page {
 
         .header-text-title {
             color: $welcomePageTitleColor;
-            font-size: 2.5rem;
-            font-weight: 500;
-            line-height: 1.18;
-            margin-bottom: 16px;
+            font-size: $welcomePageHeaderTextTitleFontSize;
+            font-weight: $welcomePageHeaderTextTitleFontWeight;
+            line-height: $welcomePageHeaderTextTitleLineHeight;
+            margin-bottom: $welcomePageHeaderTextTitleMarginBottom;
+            opacity: $welcomePageHeaderTextTitleOpacity;
         }
 
         .header-text-description {
+            display: $welcomePageHeaderTextDescriptionDisplay;
             color: $welcomePageDescriptionColor;
-            font-size: 1rem;
-            font-weight: 400;
-            line-height: 24px;
-            margin-bottom: 20px;
+            font-size: $welcomePageHeaderTextDescriptionFontSize;
+            font-weight: $welcomePageHeaderTextDescriptionFontWeight;
+            line-height: $welcomePageHeaderTextDescriptionLineHeight;
+            margin-bottom: $welcomePageHeaderTextDescriptionMarginBottom;
+            align-self: $welcomePageHeaderTextDescriptionAlignSelf;
         }
 
         #enter_room {
             display: flex;
             align-items: center;
             max-width: calc(100% - 40px);
-            width: 680px;
+            width: $welcomePageEnterRoomWidth;
             z-index: $zindex2;
             background-color: #fff;
-            padding: 25px 30px;
+            padding: $welcomePageEnterRoomPadding;
+            border-radius: $welcomePageEnterRoomBorderRadius;
 
             .enter-room-input-container {
                 width: 100%;
-                padding-right: 8px;
-                padding-bottom: 5px;
+                padding: $welcomePageEnterRoomInputContainerPadding;
                 text-align: left;
                 color: #253858;
                 height: fit-content;
-                border-width: 0px 0px 2px 0px;
-                border-style: solid;
-                border-image: linear-gradient(to right, #dee1e6, #fff) 1;
+                border-width: $welcomePageEnterRoomInputContainerBorderWidth;
+                border-style: $welcomePageEnterRoomInputContainerBorderStyle;
+                border-image: $welcomePageEnterRoomInputContainerBorderImage;
 
                 .enter-room-title {
+                    display: $welcomePageEnterRoomTitleDisplay;
                     font-size: 18px;
                     font-weight: bold;
                     padding-bottom: 5px;
@@ -94,10 +103,11 @@ body.welcome-page {
             min-height: 354px;
             width: 710px;
             background: #75A7E7;
-            display: flex;
+            display: $welcomePageTabContainerDisplay;
             flex-direction: column;
 
             .tab-content{
+                display: $welcomePageTabContentDisplay;
                 margin: 5px 0px;
                 overflow: hidden;
                 flex-grow: 1;
@@ -111,13 +121,14 @@ body.welcome-page {
             .tab-buttons {
                 font-size: 18px;
                 color: #FFFFFF;
-                display: flex;
+                display: $welcomePageTabButtonsDisplay;
                 flex-grow: 0;
                 flex-direction: row;
                 min-height: 54px;
                 width: 100%;
 
                 .tab {
+                    display: $welcomePageTabDisplay;
                     text-align: center;
                     background: rgba(9,30,66,0.37);
                     height: 55px;
@@ -138,15 +149,17 @@ body.welcome-page {
     }
 
     .welcome-page-button {
-        width: 51px;
-        height: 35px;
-        font-size: 14px;
+        width: $welcomePageButtonWidth;
+        min-width: $welcomePageButtonMinWidth;
+        height: $welcomePageButtonHeight;
+        font-size: $welcomePageButtonFontSize;
+        font-weight: $welcomePageButtonFontWeight;
         background: #0074E0;
-        border-radius: 4px;
+        border-radius: $welcomePageButtonBorderRadius;
         color: #FFFFFF;
         text-align: center;
         vertical-align: middle;
-        line-height: 35px;
+        line-height: $welcomePageButtonLineHeight;
         cursor: pointer;
     }
 

css/_welcome_page_settings_toolbar.scss

@@ -0,0 +1 @@
+/** Insert custom CSS for any additional content in the welcome page settings toolbar **/

css/deep-linking/_mobile.scss

@@ -19,7 +19,8 @@
     }
 
     a {
-        text-decoration: none
+        text-decoration: none;
+        color: $deepLinkingMobileLinkColor;
     }
 
     &__body {
@@ -41,6 +42,8 @@
 
     &__text {
         font-weight: bolder;
+        font-size: $deepLinkingMobileTextFontSize;
+        line-height: $deepLinkingMobileTextLineHeight;
         padding: 10px 10px 0px 10px;
     }
 
@@ -65,11 +68,28 @@
         }
 
         .dial-in-conference-id {
-            margin: 10px 0 10px 0;
+            margin: $deepLinkingDialInConferenceIdMargin;
+            padding: $deepLinkingDialInConferenceIdPadding;
+            background-color: $deepLinkingDialInConferenceIdBackgroundColor;
+            border-radius: $deepLinkingDialInConferenceIdBorderRadius;
+        }
+
+        .dial-in-conference-name {
+            font-size: $deepLinkingDialInConferenceNameFontSize;
+            line-height: $deepLinkingDialInConferenceNameLineHeight;
+            margin-bottom: $deepLinkingDialInConferenceNameMarginBottom;
+            font-weight: $deepLinkingDialInConferenceNameFontWeight;
         }
 
         .dial-in-conference-description {
-            font-size: 0.8em;
+            font-size: $deepLinkingDialInConferenceDescriptionFontSize;
+            line-height: $deepLinkingDialInConferenceDescriptionLineHeight;
+            margin-bottom: $deepLinkingDialInConferenceDescriptionMarginBottom;
+        }
+
+        .dial-in-conference-pin {
+            font-size: $deepLinkingDialInConferencePinFontSize;
+            line-height: $deepLinkingDialInConferencePinLineHeight;
         }
 
         .toll-free-list {
@@ -88,25 +108,27 @@
 
     &__href {
         height: 2.2857142857142856em;
-        line-height: 2.2857142857142856em;
+        line-height: $depLinkingMobileHrefLineHeight;
         margin: 18px auto 20px;
         max-width: 300px;
         width: auto;
-        font-weight: bolder;
+        font-weight: $deepLinkingMobileHrefFontWeight;
+        font-size: $deepLinkingMobileHrefFontSize;
     }
 
     &__button {
         border: 0;
-        height: 2.2857142857142856em;
-        line-height: 2.2857142857142856em;
-        margin: 18px auto 10px;
+        height: $deepLinkingMobileButtonHeight;
+        line-height: $deepLinkingMobileButtonLineHeight;
+        margin: $deepLinkingMobileButtonMargin;
         padding: 0px 10px 0px 10px;
         max-width: 300px;
-        width: auto;
+        width: $deepLinkingMobileButtonWidth;
         @include border-radius(3px);
         background-color: $unsupportedBrowserButtonBgColor;
         color: #505F79;
-        font-weight: bold;
+        font-weight: $deepLinkingMobileButtonFontWeight;
+        font-size: $deepLinkingMobileButtonFontSize;
 
         &:active {
             background-color: $unsupportedBrowserButtonBgColor;
@@ -115,7 +137,7 @@
         &_primary {
             background-color: $primaryUnsupportedBrowserButtonBgColor;
             color: #FFFFFF;
-
+            border-radius: $primaryDeepLinkingMobileButtonBorderRadius;
             &:active {
                 background-color: $primaryUnsupportedBrowserButtonBgColor;
             }

css/main.scss

@@ -23,12 +23,6 @@ $flagsImagePath: "../images/";
 @import "../node_modules/bc-css-flags/dist/css/bc-css-flags.scss";
 /* Flags END */
 
-/* Fonts BEGIN */
-
-@import 'font';
-
-/* Fonts END */
-
 /* Modules BEGIN */
 
 @import 'aui_reset';
@@ -38,6 +32,7 @@ $flagsImagePath: "../images/";
 @import 'overlay/overlay';
 @import 'inlay';
 @import 'reload_overlay/reload_overlay';
+@import 'mini_toolbox';
 @import 'modals/desktop-picker/desktop-picker';
 @import 'modals/device-selection/device-selection';
 @import 'modals/dialog';
@@ -50,6 +45,7 @@ $flagsImagePath: "../images/";
 @import 'videolayout_default';
 @import 'notice';
 @import 'subject';
+@import 'participants-count';
 @import 'popup_menu';
 @import 'recording';
 @import 'login_menu';
@@ -57,6 +53,7 @@ $flagsImagePath: "../images/";
 @import 'ringing/ringing';
 @import 'welcome_page';
 @import 'welcome_page_content';
+@import 'welcome_page_settings_toolbar';
 @import 'toolbars';
 @import 'jquery.contextMenu';
 @import 'keyboard-shortcuts';
@@ -86,5 +83,7 @@ $flagsImagePath: "../images/";
 @import 'navigate_section_list';
 @import 'third-party-branding/google';
 @import 'third-party-branding/microsoft';
+@import 'avatar';
+@import 'promotional-footer';
 
 /* Modules END */

css/modals/invite/_info.scss

@@ -63,6 +63,8 @@
         width: -webkit-max-content;
         word-break: break-all;
         max-width: 400px;
+        display: flex;
+        align-items: center;
     }
 
     .info-dialog-dial-in {
@@ -86,6 +88,15 @@
         cursor: inherit;
     }
 
+    .info-dialog-url-icon {
+        display: inline-block;
+        margin-left: 5px;
+
+        svg {
+            cursor: pointer;
+        }
+    }
+
     .info-dialog-title {
         font-weight: bold;
         margin-bottom: 10px;
@@ -214,4 +225,10 @@
         -moz-user-select: text;
         -webkit-user-select: text;
     }
+
+    .info-dialog-url-text-unselectable {
+        user-select: none;
+        -moz-user-select: none;
+        -webkit-user-select: none;
+    }
 }

debian/rules

@@ -17,8 +17,15 @@ override_dh_install: $(LANGUAGES)
 	dh_install -X/config.js -X/package.json
 
 $(LANGUAGES):
+	LOCALE=$$(echo $@ | cut -c1-2) ; \
 	if [ -f $(COUNTRIES_DIR)/$@.json ] ; \
 	then \
 		dh_install -pjitsi-meet-web $(COUNTRIES_DIR)/$@.json usr/share/jitsi-meet/lang/; \
 		mv debian/jitsi-meet-web/usr/share/jitsi-meet/lang/$@.json debian/jitsi-meet-web/usr/share/jitsi-meet/lang/countries-$@.json; \
+	else \
+		if [ -f $(COUNTRIES_DIR)/$$LOCALE.json ] ; \
+		then \
+			dh_install -pjitsi-meet-web $(COUNTRIES_DIR)/$$LOCALE.json usr/share/jitsi-meet/lang/; \
+			mv debian/jitsi-meet-web/usr/share/jitsi-meet/lang/$$LOCALE.json debian/jitsi-meet-web/usr/share/jitsi-meet/lang/countries-$@.json; \
+		fi; \
 	fi;