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.
@@ -33,26 +41,12 @@
 [libs]
 node_modules/react-native/Libraries/react-native/react-native-interface.js
 node_modules/react-native/flow/
-node_modules/react-native/flow-github/
 
 [options]
 emoji=true
 
-module.system=haste
-
-munge_underscores=true
-
-module.name_mapper='^[./a-zA-Z0-9$_-]+\.\(bmp\|gif\|jpg\|jpeg\|png\|psd\|svg\|webp\|m4v\|mov\|mp4\|mpeg\|mpg\|webm\|aac\|aiff\|caf\|m4a\|mp3\|wav\|html\|pdf\)$' -> 'RelativeImageStub'
-
-suppress_type=$FlowIssue
-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\\)*\\$FlowExpectedError
+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
@@ -63,8 +57,62 @@ suppress_comment=\\(.\\|\n\\)*\\$FlowExpectedError
 module.file_ext=.web.js
 ; Flow's defaults:
 module.file_ext=.js
-module.file_ext=.jsx
 module.file_ext=.json
+module.file_ext=.ios.js
+
+module.system=haste
+module.system.haste.use_name_reducers=true
+# get basename
+module.system.haste.name_reducers='^.*/\([a-zA-Z0-9$_.-]+\.js\(\.flow\)?\)$' -> '\1'
+# strip .js or .js.flow suffix
+module.system.haste.name_reducers='^\(.*\)\.js\(\.flow\)?$' -> '\1'
+# strip .ios suffix
+module.system.haste.name_reducers='^\(.*\)\.ios$' -> '\1'
+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.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
+
+module.name_mapper='^[./a-zA-Z0-9$_-]+\.\(bmp\|gif\|jpg\|jpeg\|png\|psd\|svg\|webp\|m4v\|mov\|mp4\|mpeg\|mpg\|webm\|aac\|aiff\|caf\|m4a\|mp3\|wav\|html\|pdf\)$' -> 'RelativeImageStub'
+
+suppress_type=$FlowIssue
+suppress_type=$FlowFixMe
+suppress_type=$FlowFixMeProps
+suppress_type=$FlowFixMeState
+
+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
+
+[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.67.0
+^0.104.0

.github/ISSUE_TEMPLATE/1-bug-report.md

@@ -1,12 +1,13 @@
 ---
-name: Bug Report
-about: Before posting, please make sure you check https://community.jitsi.org
+name: Bug report
+about: Create a report to help us improve
 
 ---
 
 *This Issue tracker is only for reporting bugs and tracking code related issues.*
 
-Before posting, please make sure you check community.jitsi.org to see if the same or similar bugs have already been discussed. General questions, installation help, and feature requests can also be posted to community.jitsi.org.
+Before posting, please make sure you check community.jitsi.org to see if the same or similar bugs have already been discussed.
+General questions, installation help, and feature requests can also be posted to community.jitsi.org.
 
 ## Description
 ---

.github/ISSUE_TEMPLATE/2-help.md

@@ -0,0 +1,10 @@
+---
+name: Need help with Jitsi Meet?
+about: Please ask it in our community at https://community.jitsi.org
+
+---
+
+If you have a question about Jitsi Meet that is not a bug report or feature
+request, please post it in https://community.jitsi.org
+
+Questions posted to this repository will be closed.

.github/ISSUE_TEMPLATE/3-feature-request.md

@@ -0,0 +1,23 @@
+---
+name: "Feature request"
+about: Suggest an idea for this project
+
+---
+
+<!--
+Thank you for suggesting an idea to make Jitsi Meet better.
+
+Please fill in as much of the template below as you're able.
+
+Note that the ultimate decission for implementing features lies on the Jitsi team, not all feature requests shall be accepted.
+-->
+
+**Is your feature request related to a problem you are facing?**
+Please describe the problem you are trying to solve.
+
+**Describe the solution you'd like**
+Please describe the desired behavior.
+
+**Describe alternatives you've considered**
+Please describe alternative solutions or features you have considered.
+

.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.

.github/stale.yml

@@ -0,0 +1,16 @@
+# Number of days of inactivity before an issue becomes stale
+daysUntilStale: 90
+# Number of days of inactivity before a stale issue is closed
+daysUntilClose: 7
+# Issues with these labels will never be considered stale
+exemptLabels:
+  - confirmed
+staleLabel: wontfix
+# Comment to post when marking an issue as stale. Set to `false` to disable
+markComment: >
+  This issue has been automatically marked as stale because it has not had
+  recent activity. It will be closed if no further activity occurs. Thank you
+  for your contributions.
+# Comment to post when closing a stale issue. Set to `false` to disable
+closeComment: false
+

.gitignore

@@ -35,6 +35,7 @@ xcuserdata
 DerivedData
 *.hmap
 *.ipa
+*.dSYM.zip
 *.xcuserstate
 project.xcworkspace
 
@@ -69,10 +70,23 @@ buck-out/
 */fastlane/Preview.html
 */fastlane/screenshots
 
-# Bundle artifact
+# Build artifacts
 *.jsbundle
+*.framework
+android/app/debug
+android/app/release
 
 # precommit-hook
 .jshintignore
 .jshintrc
 
+# VSCode files
+android/.project
+android/.settings/org.eclipse.buildship.core.prefs
+
+# Secrets
+android/app/dropbox.key
+android/app/google-services.json
+ios/app/dropbox.key
+ios/app/GoogleService-Info.plist
+

.travis.yml

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

CONTRIBUTING.md

@@ -13,7 +13,7 @@ Found a bug and know how to fix it? Great! Please read on.
 ## Contributor License Agreement
 While the Jitsi projects are released under the
 [Apache License 2.0](https://github.com/jitsi/jitsi-meet/blob/master/LICENSE), the copyright
-holder and principal creator is [Atlassian](https://www.atlassian.com/). To
+holder and principal creator is [8x8](https://www.8x8.com/). To
 ensure that we can continue making these projects available under an Open Source license,
 we need you to sign our Apache-based contributor
 license agreement as either a [corporation](https://jitsi.org/ccla) or an

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)
@@ -43,6 +44,12 @@ deploy-appbundle:
 		$(BUILD_DIR)/alwaysontop.min.js \
 		$(BUILD_DIR)/alwaysontop.min.map \
 		$(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:
@@ -59,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) ; \
@@ -67,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

@@ -1,16 +1,16 @@
 # Jitsi Meet - Secure, Simple and Scalable Video Conferences
 
-Jitsi Meet is an open-source (Apache) WebRTC JavaScript application that uses [Jitsi Videobridge](https://jitsi.org/videobridge) to provide high quality, [secure](#security) and scalable video conferences. You can see Jitsi Meet in action [here at the session #482 of the VoIP Users Conference](http://youtu.be/7vFUVClsNh0).
+Jitsi Meet is an open-source (Apache) WebRTC JavaScript application that uses [Jitsi Videobridge](https://jitsi.org/videobridge) to provide high quality, [secure](#security) and scalable video conferences. Jitsi Meet in action can be seen at [here at the session #482 of the VoIP Users Conference](http://youtu.be/7vFUVClsNh0).
 
-The Jitsi Meet client runs in your browser, without the need for installing anything on your computer. You can also try it out yourself at https://meet.jit.si .
+The Jitsi Meet client runs in your browser, without installing anything on your computer. You can try it out at https://meet.jit.si .
 
-Jitsi Meet allows for very efficient collaboration. It allows users to stream their desktop or only some windows. It also supports shared document editing with Etherpad.
+Jitsi Meet allows very efficient collaboration. Users can stream their desktop or only some windows. It also supports shared document editing with Etherpad.
 
 ## Installation
 
-On the client side, no installation is necessary. You just point your browser to the URL of your deployment. This section is about installing the Jitsi Meet suite on your server and hosting your own conferencing service.
+On the client side, no installation is necessary. You just point your browser to the URL of your deployment. This section is about installing a Jitsi Meet suite on your server and hosting your own conferencing service.
 
-Installing Jitsi Meet is quite a simple experience. For Debian-based systems, we recommend following the [quick-install](https://github.com/jitsi/jitsi-meet/blob/master/doc/quick-install.md) document, which uses the package system. You can also see a demonstration of the process in [this tutorial video](https://jitsi.org/tutorial).
+Installing Jitsi Meet is a simple experience. For Debian-based system, following the [quick-install](https://github.com/jitsi/jitsi-meet/blob/master/doc/quick-install.md) document, which uses the package system. You can also see a demonstration of the process in [this tutorial video](https://jitsi.org/tutorial).
 
 For other systems, or if you wish to install all components manually, see the [detailed manual installation instructions](https://github.com/jitsi/jitsi-meet/blob/master/doc/manual-install.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 >= 8 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' will not do it.
-```
-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
-```
-
-So now 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, 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
 
@@ -115,27 +42,30 @@ see our [guidelines for contributing](CONTRIBUTING.md).
 
 ## Embedding in external applications
 
-Jitsi Meet provides a very flexible way of embedding it in external applications by using the [Jitsi Meet API](doc/api.md).
+Jitsi Meet provides a very flexible way of embedding in external applications by using the [Jitsi Meet API](doc/api.md).
 
 ## Security
-WebRTC today does not provide a way of conducting multiparty conversations with
-end-to-end encryption. As a matter of fact, unless you consistently vocally
-compare DTLS fingerprints with your peers, the same goes for one-to-one calls.
-As a result when using a Jitsi Meet instance, your stream is encrypted on the
-network but decrypted on the machine that hosts the bridge.
+
+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.
 
 The Jitsi Meet architecture allows you to deploy your own version, including
-all server components, and in that case your security guarantees will be roughly
-equivalent to these of a direct one-to-one WebRTC call. This is what's unique to
+all server components. In that case, your security guarantees will be roughly
+equivalent to a direct one-to-one WebRTC call. This is the uniqueness of
 Jitsi Meet in terms of security.
 
 The [meet.jit.si](https://meet.jit.si) service is maintained by the Jitsi team
-at [Atlassian](https://atlassian.com).
+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
 
-Jitsi Meet started out as a sample conferencing application using Jitsi Videobridge. It was originally developed by then ESTOS' developer Philipp Hancke who then contributed it to the community where development continues with joint forces!
+Jitsi Meet started out as a sample conferencing application using Jitsi Videobridge. It was originally developed by ESTOS' developer Philipp Hancke who then contributed it to the community where development continues with joint forces!

analytics-ga.js

@@ -126,6 +126,15 @@
             return;
         }
 
+        const ignoredEvents
+            = [ 'e2e_rtt', 'rtp.stats', 'rtt.by.region', 'available.device',
+                'stream.switch.delay', 'ice.state.changed', 'ice.duration' ];
+
+        // Temporary removing some of the events that are too noisy.
+        if (ignoredEvents.indexOf(event.action) !== -1) {
+            return;
+        }
+
         const gaEvent = {
             'eventCategory': 'jitsi-meet',
             'eventAction': this._extractAction(event),

android/README.md

@@ -1,9 +1,18 @@
 # Jitsi Meet SDK for Android
 
+## Sample applications using the SDK
+
+If you want to see how easy integrating the Jitsi Meet SDK into a native application is, take a look at the
+[sample applications repository](https://github.com/jitsi/jitsi-meet-sdk-samples).
+
 ## Build your own, or use a pre-build SDK artifacts/binaries
-Jitsi conveniently provides a pre-build SDK artifacts/binaries in its Maven repository. When you do not require any modification to the SDK itself, it's suggested to use the pre-build SDK. This avoids the complexity of building and installing your own SDK artifacts/binaries.
+
+Jitsi conveniently provides a pre-build SDK artifacts/binaries in its Maven repository. When you do not require any
+modification to the SDK itself or any of its dependencies, it's suggested to use the pre-build SDK. This avoids the
+complexity of building and installing your own SDK artifacts/binaries.
 
 ### Use pre-build SDK artifacts/binaries
+
 In your project, add the Maven repository
 `https://github.com/jitsi/jitsi-maven-repository/raw/master/releases` and the
 dependency `org.jitsi.react:jitsi-meet-sdk` into your `build.gradle` files.
@@ -27,86 +36,58 @@ Dependency definitions belong in the individual module `build.gradle` files:
 ```gradle
 dependencies {
     // (other dependencies)
-    implementation ('org.jitsi.react:jitsi-meet-sdk:+') { transitive = true }
+    implementation ('org.jitsi.react:jitsi-meet-sdk:2.+') { transitive = true }
 }
 ```
 
 ### Build and use your own SDK artifacts/binaries
 
-1. Install all required [dependencies](https://github.com/jitsi/jitsi-meet/blob/master/doc/mobile.md).
+<details>
+<summary>Show building instructions</summary>
 
-2. Create the SDK-release assembly, by invoking the following in the jitsi-meet
-   project source:
+Start by making sure that your development environment [is set up correctly](https://github.com/jitsi/jitsi-meet/blob/master/doc/mobile.md).
 
-   ```bash
-   cd android/
-   ./gradlew :sdk:assembleRelease
-   ```
-   When this successfully executes, artifacts/binaries are ready to be published
-   into a Maven repository of your choice.
+A note on dependencies: Apart from the SDK, Jitsi also publishes a binary Maven artifact for some of the SDK dependencies (that are not otherwise publicly available) to the Jitsi Maven repository. When you're planning to use a SDK that is built from source, you'll likely use a version of the source code that is newer (or at least _different_) than the version of the source that was used to create the binary SDK artifact. As a consequence, the dependencies that your project will need, might also be different from those that are published in the Jitsi Maven repository. This might lead to build problems, caused by dependencies that are unavailable.
 
-3. Configure the Maven repositories in which you are going to publish the
-   artifacts/binaries during step 4.
+If you want to use a SDK that is built from source, you will likely benefit from composing a local Maven repository that contains these dependencies. The text below describes how you create a repository that includes both the SDK as well as these dependencies. For illustration purposes, we'll define the location of this local Maven repository as `/tmp/repo`
 
-   In the file `android/sdk/build.gradle` modify the line that contains
-   `"file:${rootProject.projectDir}/../../../jitsi/jitsi-maven-repository/releases"`
+In source code form, the Android SDK dependencies are locked/pinned by package.json and package-lock.json of the Jitsi Meet project. To obtain the data, execute NPM in the jitsi-meet project directory:
 
-   Change this value (which represents the Maven repository location used internally
-   by the Jitsi Developers) to the location of the repository that you'd like to use.
+    npm install
 
-4. Publish the Maven artifact/binary of Jitsi Meet SDK for Android in the Maven
-   repository configured in step 3:
+This will pull in the dependencies in either binary format, or in source code format, somewhere under /node_modules/
 
-   ```bash
-   ./gradlew :sdk:publish
-   cd ../
-   ```
-5. In _your_ project, add the Maven repository that you configured in step 3, as well
-   as the dependency `org.jitsi.react:jitsi-meet-sdk` into your `build.gradle`
-   file. Note that it's needed to pull in the transitive dependencies:
+Third-party React Native _modules_, which Jitsi Meet SDK for Android depends on, are download by NPM in source code 
+or binary form. These need to be assembled into Maven artifacts, and then published to your local Maven repository.
+A script is provided to facilitate this. From the root of the jitsi-meet project repository, run:
 
-   ```gradle
-   implementation ('org.jitsi.react:jitsi-meet-sdk:+') { transitive = true }
-   ```
+    ./android/scripts/release-sdk.sh /tmp/repo
 
-Generally, if you are modifying the JavaScript code of Jitsi Meet SDK for Android only,
-the above will suffice. If you would like to publish a third-party react-native module
-which Jitsi Meet SDK for Android depends on (and is not publicly available in Maven
-repositories) continue below.
+This will build and publish the SDK, and all of its dependencies to the specified Maven repository (`/tmp/repo`) in
+this example.
 
-6. Create the release assembly for _each_ third-party react-native module that you
-   need, replacing it's name in the example below.
+You're now ready to use the artifacts. In _your_ project, add the Maven repository that you used above (`/tmp/repo`) into your top-level `build.gradle` file:
 
-   ```bash
-   ./gradlew :react-native-webrtc:assembleRelease
-   ```
+    allprojects {
+        repositories {
+            maven { url "file:/tmp/repo" }
+            google()
+            jcenter()
+        }
+    }
 
-7. Configure the Maven repositories in which you are going to publish the
-   artifacts/binaries during step 8.
+You can use your local repository to replace the Jitsi repository (`maven { url "https://github.com/jitsi/jitsi-maven-repository/raw/master/releases" }`) when you published _all_ subprojects. If you didn't do that, you'll have to add both repositories. Make sure your local repository is listed first!
 
-   In the file `android/build.gradle` (note that this is a different file than the file
-   that was modified in step 3) modify the line that contains
-   `"file:${rootProject.projectDir}/../../../jitsi/jitsi-maven-repository/releases"`
+Then, define the dependency `org.jitsi.react:jitsi-meet-sdk` into the `build.gradle` file of your module:
 
-   Change this value (which represents the Maven repository location used internally
-   by the Jitsi Developers) to the location of the repository that you'd like to use.
-   You can use the same repository as the one you configured in step 3 if you want.
+    implementation ('org.jitsi.react:jitsi-meet-sdk:+') { transitive = true }
 
-8. Publish the Maven artifact/binary of _each_ third-party react-native module that
-   you need, replacing it's name in the example below. For example, to publish
-   react-native-webrtc:
-
-   ```bash
-   ./gradlew :react-native-webrtc:publish
-   ```
-
-   Note that there should not be a need to explicitly add these dependencies in
-   _your_ project, as they will be pulled in as transitive dependencies of
-   `jitsi-meet-sdk`.
+Note that there should not be a need to explicitly add the other dependencies, as they will be pulled in as transitive
+dependencies of `jitsi-meet-sdk`.
 
+</details>
 
 ## Using the API
-=======
 
 Jitsi Meet SDK is an Android library which embodies the whole Jitsi Meet
 experience and makes it reusable by third-party apps.
@@ -134,25 +115,42 @@ public class MainActivity extends JitsiMeetActivity {
 ```
 
 Alternatively, you can use the `org.jitsi.meet.sdk.JitsiMeetView` class which
-extends `android.view.View`:
+extends `android.view.View`.
+
+Note that this should only be needed when `JitsiMeetActivity` cannot be used for
+some reason. Extending `JitsiMeetView` requires manual wiring of the view to
+the activity, using a lot of boilerplate code. Using the Activity instead of the
+View is strongly recommended.
+
+<details>
+<summary>Show example</summary>
 
 ```java
 package org.jitsi.example;
 
 import android.os.Bundle;
-import android.support.v7.app.AppCompatActivity;
+import android.support.v4.app.FragmentActivity;
 
 import org.jitsi.meet.sdk.JitsiMeetView;
+import org.jitsi.meet.sdk.ReactActivityLifecycleCallbacks;
 
-public class MainActivity extends AppCompatActivity {
+// Example
+//
+public class MainActivity extends FragmentActivity implements JitsiMeetActivityInterface {
     private JitsiMeetView view;
 
+    @Override
+    protected void onActivityResult(
+            int requestCode,
+            int resultCode,
+            Intent data) {
+        JitsiMeetActivityDelegate.onActivityResult(
+                this, requestCode, resultCode, data);
+    }
+
     @Override
     public void onBackPressed() {
-        if (!JitsiMeetView.onBackPressed()) {
-            // Invoke the default handler if it wasn't handled by React.
-            super.onBackPressed();
-        }
+        JitsiMeetActivityDelegate.onBackPressed();
     }
 
     @Override
@@ -160,7 +158,10 @@ public class MainActivity extends AppCompatActivity {
         super.onCreate(savedInstanceState);
 
         view = new JitsiMeetView(this);
-        view.loadURL(null);
+        JitsiMeetConferenceOptions options = new JitsiMeetConferenceOptions.Builder()
+            .setRoom("https://meet.jit.si/test123")
+            .build();
+        view.join(options);
 
         setContentView(view);
     }
@@ -172,155 +173,109 @@ public class MainActivity extends AppCompatActivity {
         view.dispose();
         view = null;
 
-        JitsiMeetView.onHostDestroy(this);
+        JitsiMeetActivityDelegate.onHostDestroy(this);
     }
 
     @Override
     public void onNewIntent(Intent intent) {
-        JitsiMeetView.onNewIntent(intent);
+        JitsiMeetActivityDelegate.onNewIntent(intent);
+    }
+
+    @Override
+    public void onRequestPermissionsResult(
+            final int requestCode,
+            final String[] permissions,
+            final int[] grantResults) {
+        JitsiMeetActivityDelegate.onRequestPermissionsResult(requestCode, permissions, grantResults);
     }
 
     @Override
     protected void onResume() {
         super.onResume();
 
-        JitsiMeetView.onHostResume(this);
+        JitsiMeetActivityDelegate.onHostResume(this);
     }
 
     @Override
     protected void onStop() {
         super.onStop();
 
-        JitsiMeetView.onHostPause(this);
+        JitsiMeetActivityDelegate.onHostPause(this);
     }
 }
 ```
 
+</details>
+
 ### JitsiMeetActivity
 
-This class encapsulates a high level API in the form of an Android `Activity`
-which displays a single `JitsiMeetView`.
-
-#### getDefaultURL()
-
-See JitsiMeetView.getDefaultURL.
-
-#### isPictureInPictureEnabled()
-
-See JitsiMeetView.isPictureInPictureEnabled.
-
-#### isWelcomePageEnabled()
-
-See JitsiMeetView.isWelcomePageEnabled.
-
-#### loadURL(URL)
-
-See JitsiMeetView.loadURL.
-
-#### setDefaultURL(URL)
-
-See JitsiMeetView.setDefaultURL.
-
-#### setPictureInPictureEnabled(boolean)
-
-See JitsiMeetView.setPictureInPictureEnabled.
-
-#### setWelcomePageEnabled(boolean)
-
-See JitsiMeetView.setWelcomePageEnabled.
+This class encapsulates a high level API in the form of an Android `FragmentActivity`
+which displays a single `JitsiMeetView`. You can pass a URL as a `ACTION_VIEW`
+on the Intent when starting it and it will join the conference, and will be
+automatically terminated (finish() will be called on the activity) when the
+conference ends or fails.
 
 ### JitsiMeetView
 
 The `JitsiMeetView` class is the core of Jitsi Meet SDK. It's designed to
 display a Jitsi Meet conference (or a welcome page).
 
+#### join(options)
+
+Joins the conference specified by the given `JitsiMeetConferenceOptions`.
+
+#### leave()
+
+Leaves the currently active conference. If the welcome page is enabled it will
+go back to it, otherwise a black window will be shown.
+
 #### dispose()
 
 Releases all resources associated with this view. This method MUST be called
 when the Activity holding this view is going to be destroyed, usually in the
 `onDestroy()` method.
 
-#### getDefaultURL()
-
-Returns the default base URL used to join a conference when a partial URL (e.g.
-a room name only) is specified to `loadURLString`/`loadURLObject`. If not set or
-if set to `null`, the default built in JavaScript is used: https://meet.jit.si.
-
 #### getListener()
 
 Returns the `JitsiMeetViewListener` instance attached to the view.
 
-#### isPictureInPictureEnabled()
-
-Returns `true` if Picture-in-Picture is enabled; `false`, otherwise. If not
-explicitly set (by a preceding `setPictureInPictureEnabled` call), defaults to
-`true` if the platform supports Picture-in-Picture natively; `false`, otherwise.
-
-#### isWelcomePageEnabled()
-
-Returns true if the Welcome page is enabled; otherwise, false. If false, a black
-empty view will be rendered when not in a conference. Defaults to false.
-
-#### loadURL(URL)
-
-Loads a specific URL which may identify a conference to join. If the specified
-URL is null and the Welcome page is enabled, the Welcome page is displayed
-instead.
-
-#### loadURLString(String)
-
-Loads a specific URL which may identify a conference to join. If the specified
-URL is null and the Welcome page is enabled, the Welcome page is displayed
-instead.
-
-#### loadURLObject(Bundle)
-
-Loads a specific URL which may identify a conference to join. The URL is
-specified in the form of a Bundle of properties which (1) internally are
-sufficient to construct a URL (string) while (2) abstracting the specifics of
-constructing the URL away from API clients/consumers. If the specified URL is
-null and the Welcome page is enabled, the Welcome page is displayed instead.
-
-Example:
-
-```java
-Bundle config = new Bundle();
-config.putBoolean("startWithAudioMuted", true);
-config.putBoolean("startWithVideoMuted", false);
-Bundle urlObject = new Bundle();
-urlObject.putBundle("config", config);
-urlObject.putString("url", "https://meet.jit.si/Test123");
-view.loadURLObject(urlObject);
-```
-
-#### setDefaultURL(URL)
-
-Sets the default URL. See `getDefaultURL` for more information.
-
-NOTE: Must be called before (if at all) `loadURL`/`loadURLString` for it to take
-effect.
-
 #### setListener(listener)
 
 Sets the given listener (class implementing the `JitsiMeetViewListener`
 interface) on the view.
 
-#### setPictureInPictureEnabled(boolean)
+### JitsiMeetConferenceOptions
 
-Sets whether Picture-in-Picture is enabled. If not set, Jitsi Meet SDK
-automatically enables/disables Picture-in-Picture based on native platform
-support.
+This object encapsulates all the options that can be tweaked when joining
+a conference.
 
-NOTE: Must be called (if at all) before `loadURL`/`loadURLString` for it to take
-effect.
+Example:
 
-#### setWelcomePageEnabled(boolean)
+```java
+JitsiMeetConferenceOptions options = new JitsiMeetConferenceOptions.Builder()
+    .setServerURL(new URL("https://meet.jit.si"))
+    .setRoom("test123")
+    .setAudioMuted(false)
+    .setVideoMuted(false)
+    .setAudioOnly(false)
+    .setWelcomePageEnabled(false)
+    .build();
+```
 
-Sets whether the Welcome page is enabled. See `isWelcomePageEnabled` for more
-information.
+See the `JitsiMeetConferenceOptions` implementation for all available options.
 
-NOTE: Must be called (if at all) before `loadURL`/`loadURLString` for it to take
-effect.
+### JitsiMeetActivityDelegate
+
+This class handles the interaction between `JitsiMeetView` and its enclosing
+`Activity`. Generally this shouldn't be consumed by users, because they'd be
+using `JitsiMeetActivity` instead, which is already completely integrated.
+
+All its methods are static.
+
+#### onActivityResult(...)
+
+Helper method to handle results of auxiliary activities launched by the SDK.
+Should be called from the activity method of the same name.
 
 #### onBackPressed()
 
@@ -329,34 +284,29 @@ If this function returns `true`, it means the action was handled and thus no
 extra processing is required; otherwise the app should call the parent's
 `onBackPressed` method.
 
-This is a static method.
-
-#### onHostDestroy(activity)
+#### onHostDestroy(...)
 
 Helper method which should be called from the activity's `onDestroy` method.
 
-This is a static method.
-
-#### onHostPause(activity)
-
-Helper method which should be called from the activity's `onPause` method.
-
-This is a static method.
-
-#### onHostResume(activity)
+#### onHostResume(...)
 
 Helper method which should be called from the activity's `onResume` or `onStop`
 method.
 
-This is a static method.
+#### onHostStop(...)
 
-#### onNewIntent(intent)
+Helper method which should be called from the activity's `onSstop` method.
+
+#### onNewIntent(...)
 
 Helper method for integrating the *deep linking* functionality. If your app's
 activity is launched in "singleTask" mode this method should be called from the
 activity's `onNewIntent` method.
 
-This is a static method.
+#### onRequestPermissionsResult(...)
+
+Helper method to handle permission requests inside the SDK. It should be called
+from the activity method of the same name.
 
 #### onUserLeaveHint()
 
@@ -370,31 +320,20 @@ This is a static method.
 `JitsiMeetViewListener` provides an interface apps can implement to listen to
 the state of the Jitsi Meet conference displayed in a `JitsiMeetView`.
 
-### JitsiMeetViewAdapter
-
-A default implementation of the `JitsiMeetViewListener` interface. Apps may
-extend the class instead of implementing the interface in order to minimize
-boilerplate.
-
-##### onConferenceFailed
-
-Called when a joining a conference was unsuccessful or when there was an error
-while in a conference.
-
-The `data` `Map` contains an "error" key describing the error and a "url" key
-with the conference URL.
-
 #### onConferenceJoined
 
 Called when a conference was joined.
 
 The `data` `Map` contains a "url" key with the conference URL.
 
-#### onConferenceLeft
+#### onConferenceTerminated
 
-Called when a conference was left.
+Called when a conference was terminated either by user choice or due to a
+failure.
 
-The `data` `Map` contains a "url" key with the conference URL.
+The `data` `Map` contains an "error" key with the error and a "url" key
+with the conference URL. If the conference finished gracefully no `error`
+key will be present.
 
 #### onConferenceWillJoin
 
@@ -402,85 +341,11 @@ Called before a conference is joined.
 
 The `data` `Map` contains a "url" key with the conference URL.
 
-#### onConferenceWillLeave
-
-Called before a conference is left.
-
-The `data` `Map` contains a "url" key with the conference URL.
-
-#### onLoadConfigError
-
-Called when loading the main configuration file from the Jitsi Meet deployment
-fails.
-
-The `data` `Map` contains an "error" key with the error and a "url" key with the
-conference URL which necessitated the loading of the configuration file.
-
 ## ProGuard rules
 
 When using the SDK on a project some proguard rules have to be added in order
 to avoid necessary code being stripped. Add the following to your project's
-rules file:
-
-```
-# React Native
-
-# Keep our interfaces so they can be used by other ProGuard rules.
-# See http://sourceforge.net/p/proguard/bugs/466/
--keep,allowobfuscation @interface com.facebook.proguard.annotations.DoNotStrip
--keep,allowobfuscation @interface com.facebook.proguard.annotations.KeepGettersAndSetters
--keep,allowobfuscation @interface com.facebook.common.internal.DoNotStrip
-
-# Do not strip any method/class that is annotated with @DoNotStrip
--keep @com.facebook.proguard.annotations.DoNotStrip class *
--keep @com.facebook.common.internal.DoNotStrip class *
--keepclassmembers class * {
-    @com.facebook.proguard.annotations.DoNotStrip *;
-    @com.facebook.common.internal.DoNotStrip *;
-}
-
--keepclassmembers @com.facebook.proguard.annotations.KeepGettersAndSetters class * {
-  void set*(***);
-  *** get*();
-}
-
--keep class * extends com.facebook.react.bridge.JavaScriptModule { *; }
--keep class * extends com.facebook.react.bridge.NativeModule { *; }
--keepclassmembers,includedescriptorclasses class * { native <methods>; }
--keepclassmembers class *  { @com.facebook.react.uimanager.UIProp <fields>; }
--keepclassmembers class *  { @com.facebook.react.uimanager.annotations.ReactProp <methods>; }
--keepclassmembers class *  { @com.facebook.react.uimanager.annotations.ReactPropGroup <methods>; }
-
--dontwarn com.facebook.react.**
-
-# TextLayoutBuilder uses a non-public Android constructor within StaticLayout.
-# See libs/proxy/src/main/java/com/facebook/fbui/textlayoutbuilder/proxy for details.
--dontwarn android.text.StaticLayout
-
-# okhttp
-
--keepattributes Signature
--keepattributes *Annotation*
--keep class okhttp3.** { *; }
--keep interface okhttp3.** { *; }
--dontwarn okhttp3.**
-
-# okio
-
--keep class sun.misc.Unsafe { *; }
--dontwarn java.nio.file.*
--dontwarn org.codehaus.mojo.animal_sniffer.IgnoreJRERequirement
--dontwarn okio.**
-
-# WebRTC
-
--keep class org.webrtc.** { *; }
--dontwarn org.chromium.build.BuildHooksAndroid
-
-# Jisti Meet SDK
-
--keep class org.jitsi.meet.sdk.** { *; }
-```
+rules file: https://github.com/jitsi/jitsi-meet/blob/master/android/app/proguard-rules.pro
 
 ## Picture-in-Picture
 
@@ -488,6 +353,28 @@ rules file:
 Picture-in-Picture style scenario, in a rectangle too small to accommodate its
 "full" UI.
 
-Jitsi Meet SDK automatically enables (unless explicitly disabled by a
-`setPictureInPictureEnabled(false)` call) Android's native Picture-in-Picture
-mode iff the platform is supported i.e. Android >= Oreo.
+## Dropbox integration
+
+To setup the Dropbox integration, follow these steps:
+
+1. Add the following to the app's AndroidManifest.xml and change `<APP_KEY>` to
+your Dropbox app key:
+```
+<activity
+    android:configChanges="keyboard|orientation"
+    android:launchMode="singleTask"
+    android:name="com.dropbox.core.android.AuthActivity">
+  <intent-filter>
+    <action android:name="android.intent.action.VIEW" />
+    <category android:name="android.intent.category.BROWSABLE" />
+    <category android:name="android.intent.category.DEFAULT" />
+    <data android:scheme="db-<APP_KEY>" />
+  </intent-filter>
+</activity>
+```
+
+2. Add the following to the app's strings.xml and change `<APP_KEY>` to your
+Dropbox app key:
+```
+<string name="dropbox_app_key"><APP_KEY></string>
+```

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

@@ -1,35 +1,58 @@
 apply plugin: 'com.android.application'
 
+boolean googleServicesEnabled \
+    = project.file('google-services.json').exists() && !rootProject.ext.libreBuild
+
+// Crashlytics integration is done as part of Firebase now, so it gets
+// automagically activated with google-services.json
+if (googleServicesEnabled) {
+    apply plugin: 'io.fabric'
+}
+
+// Use the number of seconds/10 since Jan 1 2019 as the versionCode.
+// This lets us upload a new build at most every 10 seconds for the
+// next ~680 years.
+// https://stackoverflow.com/a/38643838
+def vcode = (int)(((new Date().getTime()/1000) - 1546297200) / 10)
+
 android {
     compileSdkVersion rootProject.ext.compileSdkVersion
+    buildToolsVersion rootProject.ext.buildToolsVersion
 
     defaultConfig {
         applicationId 'org.jitsi.meet'
-        versionCode Integer.parseInt("${version}")
-        versionName "1.9.${version}"
+        versionCode vcode
+        versionName project.appVersion
 
         minSdkVersion rootProject.ext.minSdkVersion
         targetSdkVersion rootProject.ext.targetSdkVersion
 
         ndk {
-            abiFilters 'armeabi-v7a', 'x86'
-        }
-
-        packagingOptions {
-            // The project react-native does not provide 64-bit binaries at the
-            // time of this writing. Unfortunately, packaging any 64-bit
-            // binaries into the .apk will crash the app at runtime on 64-bit
-            // platforms.
-            exclude '/lib/mips64/**'
-            exclude '/lib/arm64-v8a/**'
-            exclude '/lib/x86_64/**'
+            abiFilters 'armeabi-v7a', 'arm64-v8a', 'x86', 'x86_64'
         }
     }
 
     buildTypes {
+        debug {
+            buildConfigField "boolean", "GOOGLE_SERVICES_ENABLED", "${googleServicesEnabled}"
+            buildConfigField "boolean", "LIBRE_BUILD", "${rootProject.ext.libreBuild}"
+        }
         release {
-            minifyEnabled false
-            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+            minifyEnabled true
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules-release.pro'
+            buildConfigField "boolean", "GOOGLE_SERVICES_ENABLED", "${googleServicesEnabled}"
+            buildConfigField "boolean", "LIBRE_BUILD", "${rootProject.ext.libreBuild}"
+        }
+    }
+
+    sourceSets {
+        main {
+            java {
+                if (rootProject.ext.libreBuild) {
+                    srcDir "src"
+                    exclude "**/GoogleServicesHelper.java"
+                }
+            }
         }
     }
 
@@ -39,8 +62,108 @@ android {
     }
 }
 
+repositories {
+    maven { url 'https://maven.fabric.io/public' }
+}
+
 dependencies {
-    compile fileTree(dir: 'libs', include: ['*.jar'])
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    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'
+
+        // Firebase
+        //  - Crashlytics
+        //  - Dynamic Links
+        implementation 'com.google.firebase:firebase-core:16.0.6'
+        implementation 'com.crashlytics.sdk.android:crashlytics:2.9.8'
+        implementation 'com.google.firebase:firebase-dynamic-links:16.1.5'
+    }
 
     implementation project(':sdk')
+
+    debugImplementation 'com.squareup.leakcanary:leakcanary-android:1.6.1'
+    releaseImplementation 'com.squareup.leakcanary:leakcanary-android-no-op:1.6.1'
+}
+
+gradle.projectsEvaluated {
+    // Dropbox integration
+    //
+
+    def dropboxAppKey
+    if (project.file('dropbox.key').exists()) {
+        dropboxAppKey = project.file('dropbox.key').text.trim() - 'db-'
+    }
+
+    if (dropboxAppKey) {
+        android.defaultConfig.resValue('string', 'dropbox_app_key', "${dropboxAppKey}")
+
+        def dropboxActivity = """
+          <activity
+              android:configChanges="keyboard|orientation"
+              android:launchMode="singleTask"
+              android:name="com.dropbox.core.android.AuthActivity">
+            <intent-filter>
+              <action android:name="android.intent.action.VIEW" />
+              <category android:name="android.intent.category.BROWSABLE" />
+              <category android:name="android.intent.category.DEFAULT" />
+              <data android:scheme="db-${dropboxAppKey}" />
+            </intent-filter>
+          </activity>"""
+
+        android.applicationVariants.all { variant ->
+            variant.outputs.each { output ->
+                output.getProcessManifestProvider().get().doLast {
+                    def outputDir = manifestOutputDirectory.get().asFile
+                    def manifestPath = new File(outputDir, 'AndroidManifest.xml')
+                    def charset = 'UTF-8'
+                    def text
+                    text = manifestPath.getText(charset)
+                    text = text.replace('</application>', "${dropboxActivity}</application>")
+                    manifestPath.write(text, charset)
+                }
+            }
+        }
+    }
+
+    // Run React packager
+    android.applicationVariants.all { variant ->
+        def targetName = variant.name.capitalize()
+
+        def currentRunPackagerTask = tasks.create(
+                name: "run${targetName}ReactPackager",
+                type: Exec) {
+            group = "react"
+            description = "Run the React packager."
+
+            doFirst {
+                println "Starting the React packager..."
+
+                def androidRoot = file("${projectDir}/../")
+
+                // Set up the call to the script
+                workingDir androidRoot
+
+                // Run the packager
+                commandLine("scripts/run-packager.sh")
+            }
+
+            // Set up dev mode
+            def devEnabled = !targetName.toLowerCase().contains("release")
+
+            // Only enable for dev builds
+            enabled devEnabled
+        }
+
+        def packageTask = variant.packageApplicationProvider.get()
+
+        packageTask.dependsOn(currentRunPackagerTask)
+    }
+
+}
+
+if (googleServicesEnabled) {
+   apply plugin: 'com.google.gms.google-services'
 }

android/app/proguard-rules-release.pro

@@ -0,0 +1,6 @@
+-include proguard-rules.pro
+
+# Crashlytics
+-keepattributes *Annotation*
+-keepattributes SourceFile,LineNumberTable
+-keep public class * extends java.lang.Exception

android/app/proguard-rules.pro

@@ -9,17 +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 *;
-#}
-
-# 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
-
 # React Native
 
 # Keep our interfaces so they can be used by other ProGuard rules.
@@ -49,10 +38,7 @@
 -keepclassmembers class *  { @com.facebook.react.uimanager.annotations.ReactPropGroup <methods>; }
 
 -dontwarn com.facebook.react.**
-
-# TextLayoutBuilder uses a non-public Android constructor within StaticLayout.
-# See libs/proxy/src/main/java/com/facebook/fbui/textlayoutbuilder/proxy for details.
--dontwarn android.text.StaticLayout
+-keep,includedescriptorclasses class com.facebook.react.bridge.** { *; }
 
 # okhttp
 
@@ -67,10 +53,36 @@
 -keep class sun.misc.Unsafe { *; }
 -dontwarn java.nio.file.*
 -dontwarn org.codehaus.mojo.animal_sniffer.IgnoreJRERequirement
+-keep class okio.** { *; }
 -dontwarn okio.**
 
-# FastImage
+# WebRTC
 
--keep public class com.dylanvann.fastimage.* {*;}
--keep public class com.dylanvann.fastimage.** {*;}
+-keep class org.webrtc.** { *; }
+-dontwarn org.chromium.build.BuildHooksAndroid
 
+# Jisti Meet SDK
+
+-keep class org.jitsi.meet.** { *; }
+-keep class org.jitsi.meet.sdk.** { *; }
+
+# We added the following when we switched minifyEnabled on. Probably because we
+# ran the app and hit problems...
+
+-keep class com.facebook.react.bridge.CatalystInstanceImpl { *; }
+-keep class com.facebook.react.bridge.ExecutorToken { *; }
+-keep class com.facebook.react.bridge.JavaScriptExecutor { *; }
+-keep class com.facebook.react.bridge.ModuleRegistryHolder { *; }
+-keep class com.facebook.react.bridge.ReadableType { *; }
+-keep class com.facebook.react.bridge.queue.NativeRunnable { *; }
+-keep class com.facebook.react.devsupport.** { *; }
+
+-dontwarn com.facebook.react.devsupport.**
+-dontwarn com.google.appengine.**
+-dontwarn com.squareup.okhttp.**
+-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/AndroidManifest.xml

@@ -5,6 +5,8 @@
       android:allowBackup="true"
       android:icon="@mipmap/ic_launcher"
       android:label="@string/app_name"
+      android:name=".MainApplication"
+      android:networkSecurityConfig="@xml/network_security_config"
       android:theme="@style/AppTheme">
     <activity
         android:configChanges="keyboard|keyboardHidden|orientation|screenLayout|screenSize|smallestScreenSize"
@@ -14,6 +16,7 @@
         android:resizeableActivity="true"
         android:supportsPictureInPicture="true"
         android:windowSoftInputMode="adjustResize">
+      <meta-data android:name="firebase_crashlytics_collection_enabled" android:value="false" />
       <intent-filter>
         <action android:name="android.intent.action.MAIN" />
         <category android:name="android.intent.category.LAUNCHER" />
@@ -22,11 +25,8 @@
         <action android:name="android.intent.action.VIEW" />
         <category android:name="android.intent.category.BROWSABLE" />
         <category android:name="android.intent.category.DEFAULT" />
-        <data android:host="beta.hipchat.me" android:scheme="https" />
+        <data android:host="alpha.jitsi.net" android:scheme="https" />
         <data android:host="beta.meet.jit.si" android:scheme="https" />
-        <data android:host="chaos.hipchat.me" android:scheme="https" />
-        <data android:host="enso.me" android:scheme="https" />
-        <data android:host="hipchat.me" android:scheme="https" />
         <data android:host="meet.jit.si" android:scheme="https" />
       </intent-filter>
       <intent-filter>

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

@@ -0,0 +1,40 @@
+package org.jitsi.meet;
+
+import android.net.Uri;
+import android.util.Log;
+
+import com.crashlytics.android.Crashlytics;
+import com.google.firebase.dynamiclinks.FirebaseDynamicLinks;
+import io.fabric.sdk.android.Fabric;
+
+import org.jitsi.meet.sdk.JitsiMeetActivity;
+
+/**
+ * Helper class to initialize Google related services and functionality.
+ * This functionality is compiled conditionally and called via reflection, that's why it was
+ * extracted here.
+ *
+ * "Libre builds" (builds with the LIBRE_BUILD flag set) will not include this file.
+ */
+final class GoogleServicesHelper {
+    public static void initialize(JitsiMeetActivity activity) {
+        if (BuildConfig.GOOGLE_SERVICES_ENABLED) {
+            Log.d(activity.getClass().getSimpleName(), "Initializing Google Services");
+
+            Fabric.with(activity, new Crashlytics());
+
+            FirebaseDynamicLinks.getInstance().getDynamicLink(activity.getIntent())
+                .addOnSuccessListener(activity, pendingDynamicLinkData -> {
+                    Uri dynamicLink = null;
+
+                    if (pendingDynamicLinkData != null) {
+                        dynamicLink = pendingDynamicLinkData.getLink();
+                    }
+
+                    if (dynamicLink != null) {
+                        activity.join(dynamicLink.toString());
+                    }
+                });
+        }
+    }
+}

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

@@ -1,5 +1,6 @@
 /*
- * Copyright @ 2017-present Atlassian Pty Ltd
+ * Copyright @ 2018-present 8x8, Inc.
+ * Copyright @ 2017-2018 Atlassian Pty Ltd
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,233 +17,134 @@
 
 package org.jitsi.meet;
 
-import android.os.Bundle;
+import android.content.Intent;
+import android.net.Uri;
+import android.os.Build;
+import android.provider.Settings;
 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.JitsiMeetView;
-import org.jitsi.meet.sdk.JitsiMeetViewListener;
-import org.jitsi.meet.sdk.invite.AddPeopleController;
-import org.jitsi.meet.sdk.invite.AddPeopleControllerListener;
-import org.jitsi.meet.sdk.invite.InviteController;
-import org.jitsi.meet.sdk.invite.InviteControllerListener;
+import org.jitsi.meet.sdk.JitsiMeetConferenceOptions;
 
-import com.calendarevents.CalendarEventsPackage;
-import com.facebook.react.bridge.UiThreadUtil;
-
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
+import java.lang.reflect.Method;
+import java.net.MalformedURLException;
+import java.net.URL;
 import java.util.Map;
 
 /**
- * The one and only {@link Activity} that the Jitsi Meet app needs. The
+ * The one and only Activity that the Jitsi Meet app needs. The
  * {@code Activity} is launched in {@code singleTask} mode, so it will be
  * created upon application initialization and there will be a single instance
  * of it. Further attempts at launching the application once it was already
- * launched will result in {@link Activity#onNewIntent(Intent)} being called.
- *
- * This {@code Activity} extends {@link JitsiMeetActivity} to keep the React
- * Native CLI working, since the latter always tries to launch an
- * {@code Activity} named {@code MainActivity} when doing
- * {@code react-native run-android}.
+ * launched will result in {@link MainActivity#onNewIntent(Intent)} being called.
  */
 public class MainActivity extends JitsiMeetActivity {
     /**
-     * The query to perform through {@link AddPeopleController} when the
-     * {@code InviteButton} is tapped in order to exercise the public API of the
-     * feature invite. If {@code null}, the {@code InviteButton} will not be
-     * rendered.
+     * The request code identifying requests for the permission to draw on top
+     * of other apps. The value must be 16-bit and is arbitrarily chosen here.
      */
-    private static final String ADD_PEOPLE_CONTROLLER_QUERY = null;
+    private static final int OVERLAY_PERMISSION_REQUEST_CODE
+        = (int) (Math.random() * Short.MAX_VALUE);
+
+    // JitsiMeetActivity overrides
+    //
 
     @Override
-    protected JitsiMeetView initializeView() {
-        JitsiMeetView view = super.initializeView();
+    protected boolean extraInitialize() {
+        Log.d(this.getClass().getSimpleName(), "LIBRE_BUILD="+BuildConfig.LIBRE_BUILD);
 
-        // XXX In order to increase (1) awareness of API breakages and (2) API
-        // coverage, utilize JitsiMeetViewListener in the Debug configuration of
-        // the app.
-        if (BuildConfig.DEBUG && view != null) {
-            view.setListener(new JitsiMeetViewListener() {
-                private void on(String name, Map<String, Object> data) {
-                    UiThreadUtil.assertOnUiThread();
-
-                    // Log with the tag "ReactNative" in order to have the log
-                    // visible in react-native log-android as well.
-                    Log.d(
-                        "ReactNative",
-                        JitsiMeetViewListener.class.getSimpleName() + " "
-                            + name + " "
-                            + data);
-                }
-
-                @Override
-                public void onConferenceFailed(Map<String, Object> data) {
-                    on("CONFERENCE_FAILED", data);
-                }
-
-                @Override
-                public void onConferenceJoined(Map<String, Object> data) {
-                    on("CONFERENCE_JOINED", data);
-                }
-
-                @Override
-                public void onConferenceLeft(Map<String, Object> data) {
-                    on("CONFERENCE_LEFT", data);
-                }
-
-                @Override
-                public void onConferenceWillJoin(Map<String, Object> data) {
-                    on("CONFERENCE_WILL_JOIN", data);
-                }
-
-                @Override
-                public void onConferenceWillLeave(Map<String, Object> data) {
-                    on("CONFERENCE_WILL_LEAVE", data);
-                }
-
-                @Override
-                public void onLoadConfigError(Map<String, Object> data) {
-                    on("LOAD_CONFIG_ERROR", data);
-                }
-            });
-
-            // inviteController
-            final InviteController inviteController
-                = view.getInviteController();
-
-            inviteController.setListener(new InviteControllerListener() {
-                public void beginAddPeople(
-                        AddPeopleController addPeopleController) {
-                    onInviteControllerBeginAddPeople(
-                        inviteController,
-                        addPeopleController);
-                }
-            });
-            inviteController.setAddPeopleEnabled(
-                ADD_PEOPLE_CONTROLLER_QUERY != null);
-            inviteController.setDialOutEnabled(
-                inviteController.isAddPeopleEnabled());
+        // Setup Crashlytics and Firebase Dynamic Links
+        // Here we are using reflection since it may have been disabled at compile time.
+        try {
+            Class<?> cls = Class.forName("org.jitsi.meet.GoogleServicesHelper");
+            Method m = cls.getMethod("initialize", JitsiMeetActivity.class);
+            m.invoke(null, this);
+        } catch (Exception e) {
+            // Ignore any error, the module is not compiled when LIBRE_BUILD is enabled.
         }
 
-        return view;
+        // In Debug builds React needs permission to write over other apps in
+        // order to display the warning and error overlays.
+        if (BuildConfig.DEBUG) {
+            if (canRequestOverlayPermission() && !Settings.canDrawOverlays(this)) {
+                Intent intent
+                    = new Intent(
+                    Settings.ACTION_MANAGE_OVERLAY_PERMISSION,
+                    Uri.parse("package:" + getPackageName()));
+
+                startActivityForResult(intent, OVERLAY_PERMISSION_REQUEST_CODE);
+
+                return true;
+            }
+        }
+
+        return false;
     }
 
-    private void onAddPeopleControllerInviteSettled(
-            AddPeopleController addPeopleController,
-            List<Map<String, Object>> failedInvitees) {
-        UiThreadUtil.assertOnUiThread();
+    @Override
+    protected void initialize() {
+        // Set default options
+        JitsiMeetConferenceOptions defaultOptions
+            = new JitsiMeetConferenceOptions.Builder()
+                .setWelcomePageEnabled(true)
+                .setServerURL(buildURL("https://meet.jit.si"))
+                .build();
+        JitsiMeet.setDefaultConferenceOptions(defaultOptions);
 
-        // XXX Explicitly invoke endAddPeople on addPeopleController; otherwise,
-        // it is going to be memory-leaked in the associated InviteController
-        // and no subsequent InviteButton clicks/taps will be delivered.
-        // Technically, endAddPeople will automatically be invoked if there are
-        // no failedInviteees i.e. the invite succeeeded for all specified
-        // invitees.
-        addPeopleController.endAddPeople();
+        super.initialize();
     }
 
-    private void onAddPeopleControllerReceivedResults(
-            AddPeopleController addPeopleController,
-            List<Map<String, Object>> results,
-            String query) {
-        UiThreadUtil.assertOnUiThread();
+    @Override
+    public void onConferenceTerminated(Map<String, Object> data) {
+        Log.d(TAG, "Conference terminated: " + data);
+    }
 
-        int size = results.size();
+    // Activity lifecycle method overrides
+    //
 
-        if (size > 0) {
-            // Exercise AddPeopleController's inviteById implementation.
-            List<String> ids = new ArrayList<>(size);
-
-            for (Map<String, Object> result : results) {
-                Object id = result.get("id");
-
-                if (id != null) {
-                    ids.add(id.toString());
-                }
+    @Override
+    public void onActivityResult(int requestCode, int resultCode, Intent data) {
+        if (requestCode == OVERLAY_PERMISSION_REQUEST_CODE
+                && canRequestOverlayPermission()) {
+            if (Settings.canDrawOverlays(this)) {
+                initialize();
+                return;
             }
 
-            addPeopleController.inviteById(ids);
-
-            return;
+            throw new RuntimeException("Overlay permission is required when running in Debug mode.");
         }
 
-        // XXX Explicitly invoke endAddPeople on addPeopleController; otherwise,
-        // it is going to be memory-leaked in the associated InviteController
-        // and no subsequent InviteButton clicks/taps will be delivered.
-        addPeopleController.endAddPeople();
+        super.onActivityResult(requestCode, resultCode, data);
     }
 
+    // ReactAndroid/src/main/java/com/facebook/react/ReactActivity.java
     @Override
-    protected void onCreate(Bundle savedInstanceState) {
-        // As this is the Jitsi Meet app (i.e. not the Jitsi Meet SDK), we do
-        // want to enable some options.
+    public boolean onKeyUp(int keyCode, KeyEvent event) {
+        if (BuildConfig.DEBUG && keyCode == KeyEvent.KEYCODE_MENU) {
+            JitsiMeet.showDevOptions();
+            return true;
+        }
 
-        // The welcome page defaults to disabled in the SDK at the time of this
-        // writing but it is clearer to be explicit about what we want anyway.
-        setWelcomePageEnabled(true);
-
-        super.onCreate(savedInstanceState);
+        return super.onKeyUp(keyCode, event);
     }
 
-    private void onInviteControllerBeginAddPeople(
-            InviteController inviteController,
-            AddPeopleController addPeopleController) {
-        UiThreadUtil.assertOnUiThread();
+    // Helper methods
+    //
 
-        // Log with the tag "ReactNative" in order to have the log visible in
-        // react-native log-android as well.
-        Log.d(
-            "ReactNative",
-            InviteControllerListener.class.getSimpleName() + ".beginAddPeople");
-
-        String query = ADD_PEOPLE_CONTROLLER_QUERY;
-    
-        if (query != null
-                && (inviteController.isAddPeopleEnabled()
-                    || inviteController.isDialOutEnabled())) {
-            addPeopleController.setListener(new AddPeopleControllerListener() {
-                public void onInviteSettled(
-                        AddPeopleController addPeopleController,
-                        List<Map<String, Object>> failedInvitees) {
-                    onAddPeopleControllerInviteSettled(
-                        addPeopleController,
-                        failedInvitees);
-                }
-
-                public void onReceivedResults(
-                        AddPeopleController addPeopleController,
-                        List<Map<String, Object>> results,
-                        String query) {
-                    onAddPeopleControllerReceivedResults(
-                        addPeopleController,
-                        results, query);
-                }
-            });
-            addPeopleController.performQuery(query);
-        } else {
-            // XXX Explicitly invoke endAddPeople on addPeopleController;
-            // otherwise, it is going to be memory-leaked in the associated
-            // InviteController and no subsequent InviteButton clicks/taps will
-            // be delivered.
-            addPeopleController.endAddPeople();
+    private @Nullable URL buildURL(String urlStr) {
+        try {
+            return new URL(urlStr);
+        } catch (MalformedURLException e) {
+            return null;
         }
     }
 
-    @Override
-    public void onRequestPermissionsResult(
-            int requestCode,
-            String[] permissions,
-            int[] grantResults) {
-        CalendarEventsPackage.onRequestPermissionsResult(
-            requestCode,
-            permissions,
-            grantResults);
-
-        super.onRequestPermissionsResult(
-            requestCode,
-            permissions,
-            grantResults);
+    private boolean canRequestOverlayPermission() {
+        return
+            Build.VERSION.SDK_INT >= Build.VERSION_CODES.M
+                && getApplicationInfo().targetSdkVersion >= Build.VERSION_CODES.M;
     }
 }

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

@@ -14,17 +14,23 @@
  * limitations under the License.
  */
 
-#import <React/RCTBridge.h>
-#import <React/RCTEventEmitter.h>
+package org.jitsi.meet;
 
-@interface Invite : RCTEventEmitter <RCTBridgeModule>
+import android.app.Application;
 
-- (void)            invite:(NSArray<NSDictionary *> * _Nonnull)invitees
-          externalAPIScope:(NSString * _Nonnull)externalAPIScope
-  addPeopleControllerScope:(NSString * _Nonnull)addPeopleControllerScope;
+import com.squareup.leakcanary.LeakCanary;
 
-- (void)      performQuery:(NSString * _Nonnull)query
-          externalAPIScope:(NSString * _Nonnull)externalAPIScope
-  addPeopleControllerScope:(NSString * _Nonnull)addPeopleControllerScope;
+/**
+ * Simple {@link Application} for hooking up LeakCanary:
+ * https://github.com/square/leakcanary
+ */
+public class MainApplication extends Application {
+    @Override
+    public void onCreate() {
+        super.onCreate();
 
-@end
+        if (!LeakCanary.isInAnalyzerProcess(this)) {
+            LeakCanary.install(this);
+        }
+    }
+}

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/app/src/main/res/values/styles.xml

@@ -2,5 +2,6 @@
     <!-- Base application theme. -->
     <style name="AppTheme" parent="Theme.AppCompat.Light.NoActionBar">
         <!-- Customize your theme here. -->
+        <item name="android:navigationBarColor">#1081B2</item>
     </style>
 </resources>

android/app/src/main/res/xml/network_security_config.xml

@@ -0,0 +1,6 @@
+<network-security-config>
+    <domain-config cleartextTrafficPermitted="true">
+        <domain includeSubdomains="false">localhost</domain>
+        <domain includeSubdomains="false">10.0.2.2</domain>
+    </domain-config>
+</network-security-config>

android/build.gradle

@@ -1,3 +1,5 @@
+import groovy.json.JsonSlurper
+
 // Top-level build file where you can add configuration options common to all
 // sub-projects/modules.
 
@@ -5,9 +7,14 @@ buildscript {
     repositories {
         google()
         jcenter()
+        repositories {
+            maven { url 'https://maven.fabric.io/public' }
+        }
     }
     dependencies {
-        classpath 'com.android.tools.build:gradle:3.0.1'
+        classpath 'com.android.tools.build:gradle:3.3.2'
+        classpath 'com.google.gms:google-services:4.2.0'
+        classpath 'io.fabric.tools:gradle:1.27.0'
 
         // NOTE: Do not place your application dependencies here; they belong
         // in the individual module build.gradle files.
@@ -18,10 +25,10 @@ allprojects {
     repositories {
         google()
         jcenter()
-        maven { url "$rootDir/../node_modules/jsc-android/dist" }
-        // 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
@@ -32,15 +39,9 @@ allprojects {
                 if (details.requested.group == 'com.facebook.react'
                         && details.requested.name == 'react-native') {
                     def file = new File("$rootDir/../node_modules/react-native/package.json")
-                    def version = new groovy.json.JsonSlurper().parseText(file.text).version
+                    def version = new JsonSlurper().parseText(file.text).version
                     details.useVersion version
                 }
-                if (details.requested.group == 'org.webkit'
-                        && details.requested.name == 'android-jsc') {
-                    def file = new File("$rootDir/../node_modules/jsc-android/package.json")
-                    def version = new groovy.json.JsonSlurper().parseText(file.text).version
-                    details.useVersion "r${version.tokenize('.')[0]}"
-                }
             }
         }
     }
@@ -55,48 +56,41 @@ allprojects {
         publishing {
             publications {}
             repositories {
-                maven { url "file:${rootProject.projectDir}/../../../jitsi/jitsi-maven-repository/releases" }
+                maven {
+                    url rootProject.ext.mavenRepo
+                    if (!rootProject.ext.mavenRepo.startsWith("file")) {
+                        credentials {
+                            username rootProject.ext.mavenUser
+                            password rootProject.ext.mavenPassword
+                        }
+                    }
+                }
             }
         }
     }
 
+    // Use the number of seconds/10 since Jan 1 2019 as the version qualifier number.
+    // This will last for the next ~680 years.
+    // https://stackoverflow.com/a/38643838
+    def versionQualifierNumber = (int)(((new Date().getTime()/1000) - 1546297200) / 10)
+
     afterEvaluate { project ->
-        if (project.name.startsWith('react-native-')) {
-            def npmManifest = project.file('../package.json')
-            def json = new groovy.json.JsonSlurper().parseText(npmManifest.text)
-
-            // React Native modules have an npm peer dependency on react-native,
-            // they do not have an npm dependency on it. Further below though we
-            // choose a react-native version (range) when we represent them as
-            // Maven artifacts. Effectively, we are forking the projects by not
-            // complying with the full range of their npm peer dependency and,
-            // consequently, we should qualify their version.
-            def versionQualifier = '-jitsi-1'
-            if ('react-native-webrtc'.equals(project.name))
-                versionQualifier = '-jitsi-1'
-
-            project.version = "${json.version}${versionQualifier}"
-
+        if (project.plugins.hasPlugin('android') || project.plugins.hasPlugin('android-library')) {
             project.android {
                 compileSdkVersion rootProject.ext.compileSdkVersion
-                if (rootProject.ext.has('buildToolsVersion')) {
-                    buildToolsVersion rootProject.ext.buildToolsVersion
-                }
-                defaultConfig {
-                    minSdkVersion rootProject.ext.minSdkVersion
-                    targetSdkVersion rootProject.ext.targetSdkVersion
-                }
+                buildToolsVersion rootProject.ext.buildToolsVersion
             }
+        }
+
+        if (project.name.startsWith('react-native-')) {
+            def npmManifest = project.file('../package.json')
+            def json = new JsonSlurper().parseText(npmManifest.text)
+
+            // Release every dependency the SDK has with a -jitsi-XXX qualified version. This allows
+            // us to pin the dependencies and make sure they are always updated, no matter what.
+
+            project.version = "${json.version}-jitsi-${versionQualifierNumber}"
 
-            task androidJavadocs(type: Javadoc) {
-                source = android.sourceSets.main.java.source
-                classpath += project.files(android.getBootClasspath().join(File.pathSeparator))
-                failOnError false
-            }
-            task androidJavadocsJar(type: Jar, dependsOn: androidJavadocs) {
-                classifier = 'javadoc'
-                from androidJavadocs.destinationDir
-            }
             task androidSourcesJar(type: Jar) {
                 classifier = 'sources'
                 from android.sourceSets.main.java.source
@@ -112,7 +106,6 @@ allprojects {
                         extension "aar"
                     }
                     artifact(androidSourcesJar)
-                    artifact(androidJavadocsJar)
                     pom.withXml {
                         def pomXml = asNode()
                         pomXml.appendNode('name', project.name)
@@ -133,7 +126,7 @@ allprojects {
                             // (third-party) React Native modules we utilize can
                             // depend not on a specific react-native release but
                             // a wider range.
-                            if (artifactId.equals('react-native')) {
+                            if (artifactId == 'react-native') {
                                 def versionNumber = VersionNumber.parse(version)
                                 version = "${versionNumber.major}.${versionNumber.minor}"
                             }
@@ -151,16 +144,69 @@ allprojects {
 }
 
 ext {
-    buildToolsVersion = "26.0.2"
-    compileSdkVersion = 26
+    buildToolsVersion = "28.0.3"
+    compileSdkVersion = 28
     minSdkVersion    = 21
-    targetSdkVersion = 26
+    targetSdkVersion = 28
+    supportLibVersion = "28.0.0"
 
     // The Maven artifact groupdId of the third-party react-native modules which
     // Jitsi Meet SDK for Android depends on and which are not available in
     // third-party Maven repositories so we have to deploy to a Maven repository
     // of ours.
     moduleGroupId = 'com.facebook.react'
+
+    // Maven repo where artifacts will be published
+    mavenRepo = System.env.MVN_REPO ?: ""
+    mavenUser = System.env.MVN_USER ?: ""
+    mavenPassword = System.env.MVN_PASSWORD ?: ""
+
+    // Libre build
+    libreBuild = (System.env.LIBRE_BUILD ?: "false").toBoolean()
+}
+
+// If Android SDK is not installed, accept its license so that it
+// is automatically downloaded.
+afterEvaluate { project ->
+    // Either the environment variable ANDROID_HOME or the property sdk.dir in
+    // local.properties identifies where Android SDK is installed.
+    def androidHome = System.env.ANDROID_HOME
+    if (!androidHome) {
+        // ANDROID_HOME is not set. Is sdk.dir set?
+        def file = file("${project.rootDir}/local.properties")
+        def props = new Properties()
+        if (file.canRead()) {
+            file.withInputStream {
+                props.load(it)
+                androidHome = props.'sdk.dir'
+            }
+        }
+        if (!androidHome && (!file.exists() || file.canWrite())) {
+            // Neither ANDROID_HOME nor sdk.dir is set. Set sdk.dir (because
+            // environment variables cannot be set).
+            props.'sdk.dir' = "${project.buildDir}/android-sdk".toString()
+            file.withOutputStream {
+                props.store(it, null)
+                androidHome = props.'sdk.dir'
+            }
+        }
+    }
+    // If the license is not accepted, accept it so that automatic downloading
+    // kicks in.
+    // The license hash can be taken from the accepted licenses, by doing this
+    // on your local machine the file is
+    // ${androidHome}/licenses/android-sdk-license
+    if (androidHome) {
+        def dir = file("${androidHome}/licenses")
+        dir.mkdirs()
+        def file = file("${dir.path}/android-sdk-license")
+        if (!file.exists()) {
+            file.withWriter {
+                def hash = 'd56f5187479451eabf01fb78af6dfcb131a6481e'
+                it.write(hash, 0, hash.length())
+            }
+        }
+    }
 }
 
 // Force the version of the Android build tools we have chosen on all

android/fastlane/Appfile

@@ -0,0 +1,2 @@
+json_key_file("")
+package_name("org.jitsi.meet")

android/fastlane/Fastfile

@@ -0,0 +1,34 @@
+ENV["FASTLANE_SKIP_UPDATE_CHECK"] = "1"
+opt_out_usage
+
+default_platform(:android)
+
+platform :android do
+    desc "Deploy a new version to Goolge Play (Closed Beta)"
+    lane :deploy do
+        # Cleanup
+        gradle(task: "clean")
+
+        # Build and sign the app
+        gradle(
+            task: "assemble",
+            build_type: "Release",
+            print_command: false,
+            properties: {
+                "android.injected.signing.store.file" => ENV["JITSI_KEYSTORE"],
+                "android.injected.signing.store.password" => ENV["JITSI_KEYSTORE_PASSWORD"],
+                "android.injected.signing.key.alias" => ENV["JITSI_KEY_ALIAS"],
+                "android.injected.signing.key.password" => ENV["JITSI_KEY_PASSWORD"],
+            }
+        )
+
+        # Upload built artifact to the Closed Beta track
+        upload_to_play_store(
+            track: "Closed Beta",
+            json_key: ENV["JITSI_JSON_KEY_FILE"],
+            skip_upload_metadata: true,
+            skip_upload_images: true,
+            skip_upload_screenshots: true
+        )
+    end
+end

android/fastlane/README.md

@@ -0,0 +1,29 @@
+fastlane documentation
+================
+# Installation
+
+Make sure you have the latest version of the Xcode command line tools installed:
+
+```
+xcode-select --install
+```
+
+Install _fastlane_ using
+```
+[sudo] gem install fastlane -NV
+```
+or alternatively using `brew cask install fastlane`
+
+# Available Actions
+## Android
+### android deploy
+```
+fastlane android deploy
+```
+Deploy a new version to Goolge Play (Closed Beta)
+
+----
+
+This README.md is auto-generated and will be re-generated every time [fastlane](https://fastlane.tools) is run.
+More information about fastlane can be found on [fastlane.tools](https://fastlane.tools).
+The documentation of fastlane can be found on [docs.fastlane.tools](https://docs.fastlane.tools).

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
 
-android.useDeprecatedNdk=true
-version=1
+android.useAndroidX=true
+android.enableJetifier=true
+
+appVersion=19.4.0
+sdkVersion=2.4.0

android/gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
-#Fri Sep 08 10:42:14 CEST 2017
+#Fri Mar 08 13:36:51 CET 2019
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-4.1-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-4.10.1-all.zip

android/gradlew

@@ -1,4 +1,4 @@
-#!/usr/bin/env bash
+#!/usr/bin/env sh
 
 ##############################################################################
 ##
@@ -6,47 +6,6 @@
 ##
 ##############################################################################
 
-# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS=""
-
-APP_NAME="Gradle"
-APP_BASE_NAME=`basename "$0"`
-
-# Use the maximum available, or set MAX_FD != -1 to use that value.
-MAX_FD="maximum"
-
-warn ( ) {
-    echo "$*"
-}
-
-die ( ) {
-    echo
-    echo "$*"
-    echo
-    exit 1
-}
-
-# OS specific support (must be 'true' or 'false').
-cygwin=false
-msys=false
-darwin=false
-case "`uname`" in
-  CYGWIN* )
-    cygwin=true
-    ;;
-  Darwin* )
-    darwin=true
-    ;;
-  MINGW* )
-    msys=true
-    ;;
-esac
-
-# For Cygwin, ensure paths are in UNIX format before anything is touched.
-if $cygwin ; then
-    [ -n "$JAVA_HOME" ] && JAVA_HOME=`cygpath --unix "$JAVA_HOME"`
-fi
-
 # Attempt to set APP_HOME
 # Resolve links: $0 may be a link
 PRG="$0"
@@ -61,9 +20,49 @@ while [ -h "$PRG" ] ; do
     fi
 done
 SAVED="`pwd`"
-cd "`dirname \"$PRG\"`/" >&-
+cd "`dirname \"$PRG\"`/" >/dev/null
 APP_HOME="`pwd -P`"
-cd "$SAVED" >&-
+cd "$SAVED" >/dev/null
+
+APP_NAME="Gradle"
+APP_BASE_NAME=`basename "$0"`
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS=""
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD="maximum"
+
+warn () {
+    echo "$*"
+}
+
+die () {
+    echo
+    echo "$*"
+    echo
+    exit 1
+}
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "`uname`" in
+  CYGWIN* )
+    cygwin=true
+    ;;
+  Darwin* )
+    darwin=true
+    ;;
+  MINGW* )
+    msys=true
+    ;;
+  NONSTOP* )
+    nonstop=true
+    ;;
+esac
 
 CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
 
@@ -90,7 +89,7 @@ location of your Java installation."
 fi
 
 # Increase the maximum file descriptors if we can.
-if [ "$cygwin" = "false" -a "$darwin" = "false" ] ; then
+if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
     MAX_FD_LIMIT=`ulimit -H -n`
     if [ $? -eq 0 ] ; then
         if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
@@ -114,6 +113,7 @@ fi
 if $cygwin ; then
     APP_HOME=`cygpath --path --mixed "$APP_HOME"`
     CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+    JAVACMD=`cygpath --unix "$JAVACMD"`
 
     # We build the pattern for arguments to be converted via cygpath
     ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
@@ -154,11 +154,19 @@ if $cygwin ; then
     esac
 fi
 
-# Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules
-function splitJvmOpts() {
-    JVM_OPTS=("$@")
+# Escape application args
+save () {
+    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
+    echo " "
 }
-eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS
-JVM_OPTS[${#JVM_OPTS[*]}]="-Dorg.gradle.appname=$APP_BASE_NAME"
+APP_ARGS=$(save "$@")
 
-exec "$JAVACMD" "${JVM_OPTS[@]}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@"
+# Collect all arguments for the java command, following the shell quoting and substitution rules
+eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
+
+# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
+if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
+  cd "$(dirname "$0")"
+fi
+
+exec "$JAVACMD" "$@"

android/gradlew.bat

@@ -8,14 +8,14 @@
 @rem Set local scope for the variables with windows NT shell
 if "%OS%"=="Windows_NT" setlocal
 
-@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-set DEFAULT_JVM_OPTS=
-
 set DIRNAME=%~dp0
 if "%DIRNAME%" == "" set DIRNAME=.
 set APP_BASE_NAME=%~n0
 set APP_HOME=%DIRNAME%
 
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS=
+
 @rem Find java.exe
 if defined JAVA_HOME goto findJavaFromJavaHome
 
@@ -46,10 +46,9 @@ echo location of your Java installation.
 goto fail
 
 :init
-@rem Get command-line arguments, handling Windowz variants
+@rem Get command-line arguments, handling Windows variants
 
 if not "%OS%" == "Windows_NT" goto win9xME_args
-if "%@eval[2+2]" == "4" goto 4NT_args
 
 :win9xME_args
 @rem Slurp the command line arguments.
@@ -60,11 +59,6 @@ set _SKIP=2
 if "x%~1" == "x" goto execute
 
 set CMD_LINE_ARGS=%*
-goto execute
-
-:4NT_args
-@rem Get arguments from the 4NT Shell from JP Software
-set CMD_LINE_ARGS=%$
 
 :execute
 @rem Setup the command line

android/scripts/release-sdk.sh

@@ -0,0 +1,107 @@
+#!/bin/bash
+
+set -e -u
+
+
+THIS_DIR=$(cd -P "$(dirname "$(readlink "${BASH_SOURCE[0]}" || echo "${BASH_SOURCE[0]}")")" && pwd)
+DEFAULT_MVN_REPO="${THIS_DIR}/../../../jitsi-maven-repository/releases"
+THE_MVN_REPO=${MVN_REPO:-${1:-$DEFAULT_MVN_REPO}}
+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
+    MVN_HTTP=1
+else
+    MVN_REPO_PATH=$(realpath $THE_MVN_REPO)
+    THE_MVN_REPO="file:${MVN_REPO_PATH}"
+fi
+
+export MVN_REPO=$THE_MVN_REPO
+
+echo "Releasing Jitsi Meet SDK ${SDK_VERSION}"
+echo "Using ${MVN_REPO} as the Maven repo"
+
+if [[ $MVN_HTTP == 1 ]]; then
+    # Push React Native
+    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}
+    mvn \
+        deploy:deploy-file \
+        -Durl=${MVN_REPO} \
+        -DrepositoryId=${MVN_REPO_ID} \
+        -Dfile=react-native-${RN_VERSION}.aar \
+        -Dpackaging=aar \
+        -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
+    # 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}
+        mvn \
+            deploy:deploy-file \
+            -Durl=${MVN_REPO} \
+            -Dfile=react-native-${RN_VERSION}.aar \
+            -Dpackaging=aar \
+            -DgeneratePom=false \
+            -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
+echo "Building and publishing the Jitsi Meet SDK"
+pushd ${THIS_DIR}/../
+./gradlew clean assembleRelease publish
+popd
+
+if [[ $DO_GIT_TAG == 1 ]]; then
+    # The artifacts are now on the Maven repo, commit them
+    pushd ${MVN_REPO_PATH}
+    git add -A .
+    git commit -m "Jitsi Meet SDK + dependencies: ${SDK_VERSION}"
+    popd
+
+    # Tag the release
+    git tag android-sdk-${SDK_VERSION}
+fi
+
+# Done!
+echo "Finished! Don't forget to push the tag and the Maven repo artifacts."

android/scripts/run-packager.sh

@@ -0,0 +1,26 @@
+#!/bin/bash
+
+# This script is executed bt Gradle to start the React packager for Debug
+# targets.
+
+THIS_DIR=$(cd -P "$(dirname "$(readlink "${BASH_SOURCE[0]}" || echo "${BASH_SOURCE[0]}")")" && pwd)
+
+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
+    CMD="${THIS_DIR}/../../node_modules/react-native/scripts/launchPackager.command"
+    if [[ `uname` == "Darwin"  ]]; then
+        open -g "${CMD}" || echo "Can't start packager automatically"
+    else
+        xdg-open "${CMD}" || echo "Can't start packager automatically"
+    fi
+fi
+

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

@@ -10,147 +10,182 @@ android {
     }
 
     buildTypes {
-        debug {}
+        debug {
+            buildConfigField "boolean", "LIBRE_BUILD", "${rootProject.ext.libreBuild}"
+        }
         release {
             minifyEnabled false
             proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+            buildConfigField "boolean", "LIBRE_BUILD", "${rootProject.ext.libreBuild}"
+        }
+    }
+
+    sourceSets {
+        main {
+            java {
+                if (rootProject.ext.libreBuild) {
+                    srcDir "src"
+                    exclude "**/AmplitudeModule.java"
+                }
+                exclude "test/"
+            }
         }
     }
 }
 
 dependencies {
-    compile fileTree(dir: 'libs', include: ['*.jar'])
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
 
-    compile 'com.android.support:appcompat-v7:27.0.2'
-    compile 'com.facebook.react:react-native:+'
+    implementation 'androidx.legacy:legacy-support-v4:1.0.0'
+    implementation 'androidx.appcompat:appcompat:1.0.2'
+    implementation 'androidx.fragment:fragment:1.0.0'
 
-    compile project(':react-native-background-timer')
-    compile project(':react-native-fast-image')
-    compile project(':react-native-immersive')
-    compile project(':react-native-keep-awake')
-    compile project(':react-native-linear-gradient')
-    compile project(':react-native-locale-detector')
-    compile project(':react-native-sound')
-    compile project(':react-native-vector-icons')
-    compile project(':react-native-webrtc')
-    compile project(':react-native-calendar-events')
+    api 'com.facebook.react:react-native:+'
+    implementation 'org.webkit:android-jsc:+'
 
-    testCompile 'junit:junit:4.12'
+    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: 'androidx'
+        }
+    }
+
+    implementation project(':react-native-background-timer')
+    implementation project(':react-native-calendar-events')
+    implementation project(':react-native-community-async-storage')
+    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-svg')
+    implementation project(':react-native-webrtc')
+    implementation project(':react-native-webview')
+
+    testImplementation 'junit:junit:4.12'
 }
 
-// Build process helpers
-//
 
-void runBefore(String dependentTaskName, Task task) {
-    Task dependentTask = tasks.findByPath(dependentTaskName);
-    if (dependentTask != null) {
-        dependentTask.dependsOn task
+// Here we bundle all assets, resources and React files. We cannot use the
+// react.gradle file provided by react-native because it's designed to be used
+// in an application (it taps into applicationVariants, but the SDK is a library
+// so we need libraryVariants instead).
+android.libraryVariants.all { def variant ->
+    // Create variant and target names
+    def targetName = variant.name.capitalize()
+    def targetPath = variant.dirName
+
+    // React js bundle directories
+    def jsBundleDir = file("$buildDir/generated/assets/react/${targetPath}")
+    def resourcesDir = file("$buildDir/generated/res/react/${targetPath}")
+
+    def jsBundleFile = file("$jsBundleDir/index.android.bundle")
+
+    def currentBundleTask = tasks.create(
+            name: "bundle${targetName}JsAndAssets",
+            type: Exec) {
+        group = "react"
+        description = "bundle JS and assets for ${targetName}."
+
+        // Create dirs if they are not there (e.g. the "clean" task just ran)
+        doFirst {
+            jsBundleDir.deleteDir()
+            jsBundleDir.mkdirs()
+            resourcesDir.deleteDir()
+            resourcesDir.mkdirs()
+        }
+
+        // Set up inputs and outputs so gradle can cache the result
+        def reactRoot = file("${projectDir}/../../")
+        inputs.files fileTree(dir: reactRoot, excludes: ["android/**", "ios/**"])
+        outputs.dir jsBundleDir
+        outputs.dir resourcesDir
+
+        // Set up the call to the react-native cli
+        workingDir reactRoot
+
+        // Set up dev mode
+        def devEnabled = !targetName.toLowerCase().contains("release")
+
+        // Run the bundler
+        commandLine(
+                "node",
+                "node_modules/react-native/local-cli/cli.js",
+                "bundle",
+                "--platform", "android",
+                "--dev", "${devEnabled}",
+                "--reset-cache",
+                "--entry-file", "index.android.js",
+                "--bundle-output", jsBundleFile,
+                "--assets-dest", resourcesDir)
+
+        // Disable bundling on dev builds
+        enabled !devEnabled
+    }
+
+    currentBundleTask.ext.generatedResFolders = files(resourcesDir).builtBy(currentBundleTask)
+    currentBundleTask.ext.generatedAssetsFolders = files(jsBundleDir).builtBy(currentBundleTask)
+    variant.registerGeneratedResFolders(currentBundleTask.generatedResFolders)
+
+    def mergeAssetsTask = variant.mergeAssetsProvider.get()
+    def mergeResourcesTask = variant.mergeResourcesProvider.get()
+
+    mergeAssetsTask.dependsOn(currentBundleTask)
+    mergeResourcesTask.dependsOn(currentBundleTask)
+
+    mergeAssetsTask.doLast {
+        def assetsDir = mergeAssetsTask.outputDir
+
+        // 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")
+            from("${projectDir}/../../sounds/recordingOff.mp3")
+            from("${projectDir}/../../sounds/rejected.wav")
+            into("${assetsDir}/sounds")
+        }
+
+        // Copy React assets
+        //
+        if (currentBundleTask.enabled) {
+            copy {
+                from(jsBundleFile)
+                into(assetsDir)
+            }
+        }
+    }
+
+    mergeResourcesTask.doLast {
+        // Copy React resources
+        //
+        if (currentBundleTask.enabled) {
+            copy {
+                from(resourcesDir)
+                into(mergeResourcesTask.outputDir)
+            }
+        }
     }
 }
 
-gradle.projectsEvaluated {
-    android.buildTypes.all { buildType ->
-        def buildNameCapitalized = "${buildType.name.capitalize()}"
-        def bundlePath = "${buildDir}/intermediates/bundles/${buildType.name}"
-
-        // Bundle fonts in react-native-vector-icons.
-        //
-
-        def currentFontTask = tasks.create(
-                name: "copy${buildNameCapitalized}Fonts",
-                type: Copy) {
-            from("${projectDir}/../../fonts/jitsi.ttf")
-            from("${projectDir}/../../node_modules/react-native-vector-icons/Fonts/")
-            into("${bundlePath}/assets/fonts")
-        }
-
-        currentFontTask.dependsOn("merge${buildNameCapitalized}Resources")
-        currentFontTask.dependsOn("merge${buildNameCapitalized}Assets")
-
-        runBefore("processArmeabi-v7a${buildNameCapitalized}Resources", currentFontTask)
-        runBefore("processX86${buildNameCapitalized}Resources", currentFontTask)
-        runBefore("processUniversal${buildNameCapitalized}Resources", currentFontTask)
-        runBefore("process${buildNameCapitalized}Resources", currentFontTask)
-
-        def currentSoundsTask = tasks.create(
-                name: "copy${buildNameCapitalized}Sounds",
-                type: Copy) {
-             from("${projectDir}/../../sounds/joined.wav")
-             from("${projectDir}/../../sounds/left.wav")
-             from("${projectDir}/../../sounds/outgoingRinging.wav")
-             from("${projectDir}/../../sounds/outgoingStart.wav")
-             from("${projectDir}/../../sounds/recordingOn.mp3")
-             from("${projectDir}/../../sounds/recordingOff.mp3")
-             from("${projectDir}/../../sounds/rejected.wav")
-             into("${bundlePath}/assets/sounds")
-        }
-
-        currentSoundsTask.dependsOn("merge${buildNameCapitalized}Resources")
-        currentSoundsTask.dependsOn("merge${buildNameCapitalized}Assets")
-
-        runBefore("processArmeabi-v7a${buildNameCapitalized}Resources", currentSoundsTask)
-        runBefore("processX86${buildNameCapitalized}Resources", currentSoundsTask)
-        runBefore("processUniversal${buildNameCapitalized}Resources", currentSoundsTask)
-        runBefore("process${buildNameCapitalized}Resources", currentSoundsTask)
-
-        // Bundle JavaScript and React resources.
-        // (adapted from react-native/react.gradle)
-        //
-
-        // React JS bundle directories
-        def jsBundleDir = file("${bundlePath}/assets")
-        def resourcesDir = file("${bundlePath}/res/merged")
-        def jsBundleFile = file("${jsBundleDir}/index.android.bundle")
-
-        // Bundle task name for variant.
-        def bundleJsAndAssetsTaskName = "bundle${buildNameCapitalized}JsAndAssets"
-
-        def currentBundleTask = tasks.create(
-                name: bundleJsAndAssetsTaskName,
-                type: Exec) {
-            // Set up inputs and outputs so gradle can cache the result.
-            def reactRoot = file("${projectDir}/../../")
-            inputs.files fileTree(dir: reactRoot, excludes: ['android/**', 'ios/**'])
-            outputs.dir jsBundleDir
-            outputs.dir resourcesDir
-
-            // Set up the call to the react-native cli.
-            workingDir reactRoot
-
-            // Create JS bundle
-            def devEnabled = !buildNameCapitalized.toLowerCase().contains('release')
-            commandLine(
-                'node',
-                'node_modules/react-native/local-cli/cli.js',
-                'bundle',
-                '--assets-dest', resourcesDir,
-                '--bundle-output', jsBundleFile,
-                '--dev', "${devEnabled}",
-                '--entry-file', 'index.android.js',
-                '--platform', 'android',
-                '--reset-cache')
-
-            // Disable bundling on dev builds
-            enabled !devEnabled
-        }
-
-        // Hook bundle${productFlavor}${buildType}JsAndAssets into the android build process
-        currentBundleTask.dependsOn("merge${buildNameCapitalized}Resources")
-        currentBundleTask.dependsOn("merge${buildNameCapitalized}Assets")
-
-        runBefore("processArmeabi-v7a${buildNameCapitalized}Resources", currentBundleTask)
-        runBefore("processX86${buildNameCapitalized}Resources", currentBundleTask)
-        runBefore("processUniversal${buildNameCapitalized}Resources", currentBundleTask)
-        runBefore("process${buildNameCapitalized}Resources", currentBundleTask)
-    }
-}
 
 publishing {
     publications {
         aarArchive(MavenPublication) {
             groupId 'org.jitsi.react'
             artifactId 'jitsi-meet-sdk'
-            version '1.9.0'
+            version System.env.OVERRIDE_SDK_VERSION ?: project.sdkVersion
 
             artifact("${project.buildDir}/outputs/aar/${project.name}-release.aar") {
                 extension "aar"
@@ -169,8 +204,7 @@ publishing {
                     def groupId = it.moduleGroup
                     def artifactId = it.moduleName
 
-                    if (artifactId.startsWith('react-native-')
-                            && groupId.equals('jitsi-meet')) {
+                    if (artifactId.startsWith('react-native-') && groupId.equals('jitsi-meet')) {
                         groupId = rootProject.ext.moduleGroupId
                     }
 
@@ -184,6 +218,14 @@ publishing {
 
     }
     repositories {
-        maven { url "file:${rootProject.projectDir}/../../../jitsi/jitsi-maven-repository/releases" }
+        maven {
+            url rootProject.ext.mavenRepo
+            if (!rootProject.ext.mavenRepo.startsWith("file")) {
+                credentials {
+                    username rootProject.ext.mavenUser
+                    password rootProject.ext.mavenPassword
+                }
+            }
+        }
     }
 }

android/sdk/proguard-rules.pro

@@ -1,25 +0,0 @@
-# Add project specific ProGuard rules here.
-# By default, the flags in this file are appended to flags specified
-# in /Users/scorretge/Library/Android/sdk/tools/proguard/proguard-android.txt
-# You can edit the include path and order by changing the proguardFiles
-# directive in build.gradle.
-#
-# For more details, see
-#   http://developer.android.com/guide/developing/tools/proguard.html
-
-# 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 *;
-#}
-
-# Uncomment this to preserve the line number information for
-# debugging stack traces.
-#-keepattributes SourceFile,LineNumberTable
-
-# If you keep the line number information, uncomment this to
-# hide the original source file name.
-#-renamesourcefileattribute SourceFile

android/sdk/src/main/AndroidManifest.xml

@@ -1,30 +1,52 @@
-<manifest
-    xmlns:android="http://schemas.android.com/apk/res/android"
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
     package="org.jitsi.meet.sdk">
-  <!-- XXX ACCESS_NETWORK_STATE is required by WebRTC. -->
-  <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
-  <uses-permission android:name="android.permission.BLUETOOTH" />
-  <uses-permission android:name="android.permission.CAMERA" />
-  <uses-permission android:name="android.permission.INTERNET" />
-  <uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS" />
-  <uses-permission android:name="android.permission.RECORD_AUDIO" />
-  <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" />
+    <!-- XXX ACCESS_NETWORK_STATE is required by WebRTC. -->
+    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+    <uses-permission android:name="android.permission.BLUETOOTH" />
+    <uses-permission android:name="android.permission.CAMERA" />
+    <uses-permission android:name="android.permission.INTERNET" />
+    <uses-permission android:name="android.permission.MANAGE_OWN_CALLS" />
+    <uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS" />
+    <uses-permission android:name="android.permission.RECORD_AUDIO" />
+    <uses-permission android:name="android.permission.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" android:required="true" />
-  <uses-feature
-      android:name="android.hardware.camera"
-      android:required="false" />
-  <uses-feature
-      android:name="android.hardware.camera.autofocus"
-      android:required="false" />
+    <uses-feature
+        android:glEsVersion="0x00020000"
+        android:required="true" />
+    <uses-feature
+        android:name="android.hardware.camera"
+        android:required="false" />
+    <uses-feature
+        android:name="android.hardware.camera.autofocus"
+        android:required="false" />
 
-  <application
-      android:allowBackup="true"
-      android:label="@string/app_name"
-      android:supportsRtl="true">
-    <activity
-        android:name="com.facebook.react.devsupport.DevSettingsActivity" />
-  </application>
-</manifest>
+    <application
+        android:allowBackup="true"
+        android:label="@string/app_name"
+        android:supportsRtl="true">
+        <activity
+            android:name=".JitsiMeetActivity"
+            android:configChanges="keyboard|keyboardHidden|orientation|screenLayout|screenSize|smallestScreenSize"
+            android:launchMode="singleTask"
+            android:resizeableActivity="true"
+            android:supportsPictureInPicture="true"
+            android:windowSoftInputMode="adjustResize">
+        </activity>
+        <activity android:name="com.facebook.react.devsupport.DevSettingsActivity" />
+
+        <service
+            android:name=".ConnectionService"
+            android:permission="android.permission.BIND_TELECOM_CONNECTION_SERVICE">
+            <intent-filter>
+                <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

@@ -0,0 +1,102 @@
+/*
+ * 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.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;
+
+/**
+ * Implements the react-native module for the Amplitude integration.
+ */
+@ReactModule(name = AmplitudeModule.NAME)
+class AmplitudeModule
+        extends ReactContextBaseJavaModule {
+
+    public static final String NAME = "Amplitude";
+
+    public AmplitudeModule(ReactApplicationContext reactContext) {
+        super(reactContext);
+    }
+
+    /**
+     * Initializes the Amplitude SDK.
+     *
+     * @param instanceName The name of the Amplitude instance. Should
+     * be used only for multi-project logging.
+     * @param apiKey The API_KEY of the Amplitude project.
+     */
+    @ReactMethod
+    public void init(String instanceName, String apiKey) {
+        Amplitude.getInstance(instanceName).initialize(getCurrentActivity(), apiKey);
+    }
+
+    /**
+     * Sets the user ID for an Amplitude instance.
+     *
+     * @param instanceName The name of the Amplitude instance.
+     * @param userId The new value for the user ID.
+     */
+    @ReactMethod
+    public void setUserId(String instanceName, String userId) {
+            Amplitude.getInstance(instanceName).setUserId(userId);
+    }
+
+    /**
+     * Sets the user properties for an Amplitude instance.
+     *
+     * @param instanceName The name of the Amplitude instance.
+     * @param userProps JSON string with user properties to be set.
+     */
+    @ReactMethod
+    public void setUserProperties(String instanceName, ReadableMap userProps) {
+        if (userProps != null) {
+            Amplitude.getInstance(instanceName).setUserProperties(
+                    new JSONObject(userProps.toHashMap()));
+        }
+    }
+
+    /**
+     * Log an analytics event.
+     *
+     * @param instanceName The name of the Amplitude instance.
+     * @param eventType The event type.
+     * @param eventPropsString JSON string with the event properties.
+     */
+    @ReactMethod
+    public void logEvent(String instanceName, String eventType, String eventPropsString) {
+        try {
+            JSONObject eventProps = new JSONObject(eventPropsString);
+            Amplitude.getInstance(instanceName).logEvent(eventType, eventProps);
+        } catch (JSONException e) {
+            JitsiMeetLogger.e(e, "Error logging event");
+        }
+    }
+
+    @Override
+    public String getName() {
+        return NAME;
+    }
+}

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

@@ -15,17 +15,21 @@ import com.facebook.react.bridge.Promise;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReactContextBaseJavaModule;
 import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.module.annotations.ReactModule;
 
+@ReactModule(name = AndroidSettingsModule.NAME)
 class AndroidSettingsModule
     extends ReactContextBaseJavaModule {
 
+    public static final String NAME = "AndroidSettings";
+
     public AndroidSettingsModule(ReactApplicationContext reactContext) {
         super(reactContext);
     }
 
     @Override
     public String getName() {
-        return "AndroidSettings";
+        return NAME;
     }
 
     @ReactMethod

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

@@ -23,13 +23,17 @@ import android.content.pm.PackageManager;
 
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.module.annotations.ReactModule;
 
 import java.util.HashMap;
 import java.util.Map;
 
+@ReactModule(name = AppInfoModule.NAME)
 class AppInfoModule
     extends ReactContextBaseJavaModule {
 
+    public static final String NAME = "AppInfo";
+
     public AppInfoModule(ReactApplicationContext reactContext) {
         super(reactContext);
     }
@@ -60,6 +64,9 @@ class AppInfoModule
 
         Map<String, Object> constants = new HashMap<>();
 
+        constants.put(
+            "buildNumber",
+            packageInfo == null ? "" : String.valueOf(packageInfo.versionCode));
         constants.put(
             "name",
             applicationInfo == null
@@ -68,12 +75,13 @@ class AppInfoModule
         constants.put(
             "version",
             packageInfo == null ? "" : packageInfo.versionName);
+        constants.put("LIBRE_BUILD", BuildConfig.LIBRE_BUILD);
 
         return constants;
     }
 
     @Override
     public String getName() {
-        return "AppInfo";
+        return NAME;
     }
 }

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,16 +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.util.Log;
 
 import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.Promise;
@@ -34,6 +26,9 @@ import com.facebook.react.bridge.ReactContextBaseJavaModule;
 import com.facebook.react.bridge.ReactMethod;
 import com.facebook.react.bridge.WritableArray;
 import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.module.annotations.ReactModule;
+
+import org.jitsi.meet.sdk.log.JitsiMeetLogger;
 
 import java.util.HashMap;
 import java.util.HashSet;
@@ -57,9 +52,9 @@ import java.util.concurrent.Executors;
  * Before a call has started and after it has ended the
  * {@code AudioModeModule.DEFAULT} mode should be used.
  */
-class AudioModeModule
-    extends ReactContextBaseJavaModule
-    implements AudioManager.OnAudioFocusChangeListener {
+@ReactModule(name = AudioModeModule.NAME)
+class AudioModeModule extends ReactContextBaseJavaModule {
+    public static final String NAME = "AudioMode";
 
     /**
      * Constants representing the audio mode.
@@ -70,116 +65,33 @@ class AudioModeModule
      * - 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;
-
-    /**
-     * The name of {@code AudioModeModule} to be used in the React Native
-     * bridge.
-     */
-    private static final String MODULE_NAME = "AudioMode";
+    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 = MODULE_NAME;
+    static final String TAG = NAME;
 
     /**
-     * Indicator that we have lost audio focus.
+     * Whether or not the ConnectionService is used for selecting audio devices.
      */
-    private boolean audioFocusLost = false;
 
-    /**
-     * {@link AudioManager} instance used to interact with the Android audio
-     * subsystem.
-     */
-    private final AudioManager audioManager;
+    private static final boolean supportsConnectionService = Build.VERSION.SDK_INT >= Build.VERSION_CODES.O;
+    private static boolean useConnectionService_ = supportsConnectionService;
 
-    /**
-     * {@link BluetoothHeadsetMonitor} for detecting Bluetooth device changes in
-     * old (< M) Android versions.
-     */
-    private BluetoothHeadsetMonitor bluetoothHeadsetMonitor;
+    static boolean useConnectionService() {
+        return supportsConnectionService && useConnectionService_;
+    }
+
+    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.
@@ -189,10 +101,15 @@ class AudioModeModule
     /**
      * 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.
@@ -219,27 +136,6 @@ class AudioModeModule
      */
     public AudioModeModule(ReactApplicationContext reactContext) {
         super(reactContext);
-
-        audioManager
-            = (AudioManager)
-                reactContext.getSystemService(Context.AUDIO_SERVICE);
-
-        // Setup runtime device change detection.
-        setupAudioRouteChangeDetection();
-
-        // Do an initial detection on Android >= M.
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.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);
-        }
     }
 
     /**
@@ -252,6 +148,7 @@ class AudioModeModule
     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);
@@ -260,31 +157,26 @@ class AudioModeModule
     }
 
     /**
-     * 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");
             }
         });
     }
@@ -296,99 +188,40 @@ class AudioModeModule
      */
     @Override
     public String getName() {
-        return MODULE_NAME;
+        return NAME;
     }
 
     /**
-     * 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);
-                }
-            }
-        });
-    }
-
-    /**
-     * {@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);
     }
 
@@ -403,13 +236,13 @@ class AudioModeModule
             @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);
                 }
@@ -417,21 +250,6 @@ class AudioModeModule
         });
     }
 
-    /**
-     * 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.
      *
@@ -446,7 +264,7 @@ class AudioModeModule
             return;
         }
 
-        Runnable r = new Runnable() {
+        runInAudioThread(new Runnable() {
             @Override
             public void run() {
                 boolean success;
@@ -455,80 +273,28 @@ class AudioModeModule
                     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} API on Android >= 23 only.
+     * 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 Android API >= 23.
-     */
-    @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();
     }
 
     /**
@@ -539,34 +305,21 @@ class AudioModeModule
      * {@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 (mode == DEFAULT) {
-            audioFocusLost = false;
-            audioManager.setMode(AudioManager.MODE_NORMAL);
-            audioManager.abandonAudioFocus(this);
-            audioManager.setSpeakerphoneOn(false);
-            setBluetoothAudioRoute(false);
-            selectedDevice = null;
-            userSelectedDevice = null;
-
-            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) {
-            Log.d(TAG, "Audio focus request failed");
+        if (!audioDeviceHandler.setMode(mode)) {
             return false;
         }
 
+        if (mode == DEFAULT) {
+            selectedDevice = null;
+            userSelectedDevice = null;
+
+            notifyDevicesChanged();
+            return true;
+        }
+
         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.
@@ -575,15 +328,12 @@ class AudioModeModule
             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;
         }
 
@@ -594,14 +344,99 @@ class AudioModeModule
         }
 
         selectedDevice = audioDevice;
-        Log.d(TAG, "Selected audio device: " + audioDevice);
+        JitsiMeetLogger.i(TAG + " Selected audio device: " + audioDevice);
 
-        // Turn bluetooth on / off
-        setBluetoothAudioRoute(audioDevice.equals(DEVICE_BLUETOOTH));
-
-        // Turn speaker on / off
-        audioManager.setSpeakerphoneOn(audioDevice.equals(DEVICE_SPEAKER));
+        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

@@ -1,5 +1,6 @@
 /*
- * Copyright @ 2018-present Atlassian Pty Ltd
+ * Copyright @ 2018-present 8x8, Inc.
+ * Copyright @ 2018 Atlassian Pty Ltd
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -19,16 +20,16 @@ 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.util.Log;
 import android.widget.FrameLayout;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
 
 import com.facebook.react.ReactRootView;
 import com.facebook.react.bridge.ReadableMap;
 import com.rnimmersive.RNImmersiveModule;
 
 import java.lang.reflect.Method;
+import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Map;
 import java.util.Set;
@@ -77,6 +78,15 @@ public abstract class BaseReactView<ListenerT>
         return null;
     }
 
+    /**
+     * Gets all registered React views.
+     *
+     * @return An {@link ArrayList} containing all views currently held by React.
+     */
+    static ArrayList<BaseReactView> getViews() {
+        return new ArrayList<>(views);
+    }
+
     /**
      * The unique identifier of this {@code BaseReactView} within the process
      * for the purposes of {@link ExternalAPIModule}. The name scope was
@@ -101,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();
@@ -170,7 +179,7 @@ public abstract class BaseReactView<ListenerT>
      * @param data - The details of the event associated with/specific to the
      * specified {@code name}.
      */
-    public abstract void onExternalAPIEvent(String name, ReadableMap data);
+    protected abstract void onExternalAPIEvent(String name, ReadableMap data);
 
     protected void onExternalAPIEvent(
             Map<String, Method> listenerMethods,
@@ -194,29 +203,10 @@ public abstract class BaseReactView<ListenerT>
         super.onWindowFocusChanged(hasFocus);
 
         // https://github.com/mockingbot/react-native-immersive#restore-immersive-state
-
-        // FIXME The singleton pattern employed by RNImmersiveModule is not
-        // advisable because a react-native mobule is consumable only after its
-        // BaseJavaModule#initialize() has completed and here we have no
-        // knowledge of whether the precondition is really met.
         RNImmersiveModule immersive = RNImmersiveModule.getInstance();
 
         if (hasFocus && immersive != null) {
-            try {
-                immersive.emitImmersiveStateChangeEvent();
-            } catch (RuntimeException re) {
-                // FIXME I don't know how to check myself whether
-                // BaseJavaModule#initialize() has been invoked and thus
-                // RNImmersiveModule is consumable. A safe workaround is to
-                // swallow the failure because the whole full-screen/immersive
-                // functionality is brittle anyway, akin to the icing on the
-                // cake, and has been working without onWindowFocusChanged for a
-                // very long time.
-                Log.e(
-                    "RNImmersiveModule",
-                    "emitImmersiveStateChangeEvent() failed!",
-                    re);
-            }
+            immersive.emitImmersiveStateChangeEvent();
         }
     }
 

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

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

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

@@ -1,5 +1,6 @@
 /*
- * Copyright @ 2017-present Atlassian Pty Ltd
+ * Copyright @ 2019-present 8x8, Inc.
+ * Copyright @ 2017-2018 Atlassian Pty Ltd
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -21,15 +22,14 @@ import android.app.Activity;
 import com.facebook.react.modules.core.DefaultHardwareBackBtnHandler;
 
 /**
- * Defines the default behavior of {@code JitsiMeetActivity} and
+ * Defines the default behavior of {@code JitsiMeetFragment} and
  * {@code JitsiMeetView} upon invoking the back button if no
  * {@code JitsiMeetView} handles the invocation. For example, a
  * {@code JitsiMeetView} may (1) handle the invocation of the back button
  * during a conference by leaving the conference and (2) not handle the
  * invocation when not in a conference.
  */
-public class DefaultHardwareBackBtnHandlerImpl
-    implements DefaultHardwareBackBtnHandler {
+class DefaultHardwareBackBtnHandlerImpl implements DefaultHardwareBackBtnHandler {
 
     /**
      * The {@code Activity} to which the default handling of the back button

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

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

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

@@ -16,20 +16,24 @@
 
 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.
  */
+@ReactModule(name = ExternalAPIModule.NAME)
 class ExternalAPIModule
     extends ReactContextBaseJavaModule {
 
-    private static final String TAG = ExternalAPIModule.class.getSimpleName();
+    public static final String NAME = "ExternalAPI";
+
+    private static final String TAG = NAME;
 
     /**
      * Initializes a new module instance. There shall be a single instance of
@@ -49,7 +53,7 @@ class ExternalAPIModule
      */
     @Override
     public String getName() {
-        return "ExternalAPI";
+        return NAME;
     }
 
     /**
@@ -63,16 +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) {
+            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

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

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

@@ -1,5 +1,5 @@
 /*
- * Copyright @ 2017-present Atlassian Pty Ltd
+ * 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.
@@ -16,307 +16,212 @@
 
 package org.jitsi.meet.sdk;
 
+import android.content.Context;
 import android.content.Intent;
 import android.net.Uri;
-import android.os.Build;
 import android.os.Bundle;
-import android.provider.Settings;
-import android.support.annotation.Nullable;
-import android.support.v7.app.AppCompatActivity;
-import android.view.KeyEvent;
+import androidx.annotation.Nullable;
+import androidx.fragment.app.FragmentActivity;
 
-import com.facebook.react.ReactInstanceManager;
-import com.facebook.react.modules.core.DefaultHardwareBackBtnHandler;
+import com.facebook.react.modules.core.PermissionListener;
+
+import org.jitsi.meet.sdk.log.JitsiMeetLogger;
+
+import java.util.Map;
 
-import java.net.URL;
 
 /**
- * Base Activity for applications integrating Jitsi Meet at a higher level. It
- * contains all the required wiring between the {@code JitsiMeetView} and
- * the Activity lifecycle methods already implemented.
- *
- * In this activity we use a single {@code JitsiMeetView} instance. This
- * instance gives us access to a view which displays the welcome page and the
- * conference itself. All lifetime methods associated with this Activity are
- * hooked to the React Native subsystem via proxy calls through the
- * {@code JitsiMeetView} static methods.
+ * A base activity for SDK users to embed. It uses {@link JitsiMeetFragment} to do the heavy
+ * lifting and wires the remaining Activity lifecycle methods so it works out of the box.
  */
-public class JitsiMeetActivity
-    extends AppCompatActivity {
+public class JitsiMeetActivity extends FragmentActivity
+        implements JitsiMeetActivityInterface, JitsiMeetViewListener {
 
-    /**
-     * The request code identifying requests for the permission to draw on top
-     * of other apps. The value must be 16-bit and is arbitrarily chosen here.
-     */
-    private static final int OVERLAY_PERMISSION_REQUEST_CODE
-        = (int) (Math.random() * Short.MAX_VALUE);
+    protected static final String TAG = JitsiMeetActivity.class.getSimpleName();
 
-    /**
-     * The default behavior of this {@code JitsiMeetActivity} upon invoking the
-     * back button if {@link #view} does not handle the invocation.
-     */
-    private DefaultHardwareBackBtnHandler defaultBackButtonImpl;
+    private static final String ACTION_JITSI_MEET_CONFERENCE = "org.jitsi.meet.CONFERENCE";
+    private static final String JITSI_MEET_CONFERENCE_OPTIONS = "JitsiMeetConferenceOptions";
 
-    /**
-     * The default base {@code URL} used to join a conference when a partial URL
-     * (e.g. a room name only) is specified. The value is used only while
-     * {@link #view} equals {@code null}.
-     */
-    private URL defaultURL;
+    // Helpers for starting the activity
+    //
 
-    /**
-     * Instance of the {@link JitsiMeetView} which this activity will display.
-     */
-    private JitsiMeetView view;
-
-    /**
-     * Whether Picture-in-Picture is enabled. The value is used only while
-     * {@link #view} equals {@code null}.
-     */
-    private Boolean pictureInPictureEnabled;
-
-    /**
-     * Whether the Welcome page is enabled. The value is used only while
-     * {@link #view} equals {@code null}.
-     */
-    private boolean welcomePageEnabled;
-
-    private boolean canRequestOverlayPermission() {
-        return
-            BuildConfig.DEBUG
-                && Build.VERSION.SDK_INT >= Build.VERSION_CODES.M
-                && getApplicationInfo().targetSdkVersion
-                    >= Build.VERSION_CODES.M;
+    public static void launch(Context context, JitsiMeetConferenceOptions options) {
+        Intent intent = new Intent(context, JitsiMeetActivity.class);
+        intent.setAction(ACTION_JITSI_MEET_CONFERENCE);
+        intent.putExtra(JITSI_MEET_CONFERENCE_OPTIONS, options);
+        context.startActivity(intent);
     }
 
-    /**
-     *
-     * @see JitsiMeetView#getDefaultURL()
-     */
-    public URL getDefaultURL() {
-        return view == null ? defaultURL : view.getDefaultURL();
+    public static void launch(Context context, String url) {
+        JitsiMeetConferenceOptions options
+            = new JitsiMeetConferenceOptions.Builder().setRoom(url).build();
+        launch(context, options);
     }
 
-    /**
-     * Initializes the {@link #view} of this {@code JitsiMeetActivity} with a
-     * new {@link JitsiMeetView} instance.
-     */
-    private void initializeContentView() {
-        JitsiMeetView view = initializeView();
-
-        if (view != null) {
-            // XXX Allow extenders who override initializeView() to configure
-            // the view before the first loadURL(). Probably works around a
-            // problem related to ReactRootView#setAppProperties().
-            view.loadURL(null);
-
-            this.view = view;
-            setContentView(this.view);
-        }
-    }
-
-    /**
-     * Initializes a new {@link JitsiMeetView} instance.
-     *
-     * @return a new {@code JitsiMeetView} instance.
-     */
-    protected JitsiMeetView initializeView() {
-        JitsiMeetView view = new JitsiMeetView(this);
-
-        // XXX Before calling JitsiMeetView#loadURL, make sure to call whatever
-        // is documented to need such an order in order to take effect:
-        view.setDefaultURL(defaultURL);
-        if (pictureInPictureEnabled != null) {
-            view.setPictureInPictureEnabled(
-                pictureInPictureEnabled.booleanValue());
-        }
-        view.setWelcomePageEnabled(welcomePageEnabled);
-
-        return view;
-    }
-
-    /**
-     *
-     * @see JitsiMeetView#isPictureInPictureEnabled()
-     */
-    public boolean isPictureInPictureEnabled() {
-        return
-            view == null
-                ? pictureInPictureEnabled
-                : view.isPictureInPictureEnabled();
-    }
-
-    /**
-     *
-     * @see JitsiMeetView#isWelcomePageEnabled()
-     */
-    public boolean isWelcomePageEnabled() {
-        return view == null ? welcomePageEnabled : view.isWelcomePageEnabled();
-    }
-
-    /**
-     * Loads the given URL and displays the conference. If the specified URL is
-     * null, the welcome page is displayed instead.
-     *
-     * @param url The conference URL.
-     */
-    public void loadURL(@Nullable URL url) {
-        view.loadURL(url);
-    }
-
-    @Override
-    protected void onActivityResult(
-            int requestCode,
-            int resultCode,
-            Intent data) {
-        if (requestCode == OVERLAY_PERMISSION_REQUEST_CODE
-                && canRequestOverlayPermission()) {
-            if (Settings.canDrawOverlays(this)) {
-                initializeContentView();
-            }
-        }
-    }
-
-    @Override
-    public void onBackPressed() {
-        if (!ReactActivityLifecycleCallbacks.onBackPressed()) {
-            // JitsiMeetView didn't handle the invocation of the back button.
-            // Generally, an Activity extender would very likely want to invoke
-            // Activity#onBackPressed(). For the sake of consistency with
-            // JitsiMeetView and within the Jitsi Meet SDK for Android though,
-            // JitsiMeetActivity does what JitsiMeetView would've done if it
-            // were able to handle the invocation.
-            if (defaultBackButtonImpl == null) {
-                super.onBackPressed();
-            } else {
-                defaultBackButtonImpl.invokeDefaultOnBackPressed();
-            }
-        }
-    }
+    // Overrides
+    //
 
     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
 
-        // In Debug builds React needs permission to write over other apps in
-        // order to display the warning and error overlays.
-        if (canRequestOverlayPermission() && !Settings.canDrawOverlays(this)) {
-            Intent intent
-                = new Intent(
-                        Settings.ACTION_MANAGE_OVERLAY_PERMISSION,
-                        Uri.parse("package:" + getPackageName()));
+        setContentView(R.layout.activity_jitsi_meet);
 
-            startActivityForResult(intent, OVERLAY_PERMISSION_REQUEST_CODE);
-            return;
+        if (!extraInitialize()) {
+            initialize();
         }
-
-        initializeContentView();
     }
 
     @Override
-    protected void onDestroy() {
+    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();
-
-        if (view != null) {
-            view.dispose();
-            view = null;
-        }
-
-        ReactActivityLifecycleCallbacks.onHostDestroy(this);
     }
 
-    // ReactAndroid/src/main/java/com/facebook/react/ReactActivity.java
     @Override
-    public boolean onKeyUp(int keyCode, KeyEvent event) {
-        ReactInstanceManager reactInstanceManager;
+    public void finish() {
+        leave();
 
-        if (!super.onKeyUp(keyCode, event)
-                && BuildConfig.DEBUG
-                && (reactInstanceManager
-                        = ReactInstanceManagerHolder.getReactInstanceManager())
-                    != null
-                && keyCode == KeyEvent.KEYCODE_MENU) {
-            reactInstanceManager.showDevOptionsDialog();
-            return true;
+        super.finish();
+    }
+
+    // Helper methods
+    //
+
+    protected JitsiMeetView getJitsiView() {
+        JitsiMeetFragment fragment
+            = (JitsiMeetFragment) getSupportFragmentManager().findFragmentById(R.id.jitsiFragment);
+        return fragment.getJitsiView();
+    }
+
+    public void join(@Nullable String url) {
+        JitsiMeetConferenceOptions options
+            = new JitsiMeetConferenceOptions.Builder()
+                .setRoom(url)
+                .build();
+        join(options);
+    }
+
+    public void join(JitsiMeetConferenceOptions options) {
+        getJitsiView().join(options);
+    }
+
+    public void leave() {
+        getJitsiView().leave();
+    }
+
+    private @Nullable JitsiMeetConferenceOptions getConferenceOptions(Intent intent) {
+        String action = intent.getAction();
+
+        if (Intent.ACTION_VIEW.equals(action)) {
+            Uri uri = intent.getData();
+            if (uri != null) {
+                return new JitsiMeetConferenceOptions.Builder().setRoom(uri.toString()).build();
+            }
+        } else if (ACTION_JITSI_MEET_CONFERENCE.equals(action)) {
+            return intent.getParcelableExtra(JITSI_MEET_CONFERENCE_OPTIONS);
         }
+
+        return null;
+    }
+
+    /**
+     * Helper function called during activity initialization. If {@code true} is returned, the
+     * initialization is delayed and the {@link JitsiMeetActivity#initialize()} method is not
+     * called. In this case, it's up to the subclass to call the initialize method when ready.
+     *
+     * This is mainly required so we do some extra initialization in the Jitsi Meet app.
+     *
+     * @return {@code true} if the initialization will be delayed, {@code false} otherwise.
+     */
+    protected boolean extraInitialize() {
         return false;
     }
 
+    protected void initialize() {
+        // Listen for conference events.
+        getJitsiView().setListener(this);
+
+        // Join the room specified by the URL the app was launched with.
+        // Joining without the room option displays the welcome page.
+        join(getConferenceOptions(getIntent()));
+    }
+
+    // Activity lifecycle methods
+    //
+
+    @Override
+    public void onActivityResult(int requestCode, int resultCode, Intent data) {
+        JitsiMeetActivityDelegate.onActivityResult(this, requestCode, resultCode, data);
+    }
+
+    @Override
+    public void onBackPressed() {
+        JitsiMeetActivityDelegate.onBackPressed();
+    }
+
     @Override
     public void onNewIntent(Intent intent) {
-        // XXX At least twice we received bug reports about malfunctioning
-        // loadURL in the Jitsi Meet SDK while the Jitsi Meet app seemed to
-        // functioning as expected in our testing. But that was to be expected
-        // because the app does not exercise loadURL. In order to increase the
-        // test coverage of loadURL, channel deep linking through loadURL.
-        Uri uri;
+        super.onNewIntent(intent);
 
-        if (Intent.ACTION_VIEW.equals(intent.getAction())
-                && (uri = intent.getData()) != null
-                && JitsiMeetView.loadURLStringInViews(uri.toString())) {
+        JitsiMeetConferenceOptions options;
+
+        if ((options = getConferenceOptions(intent)) != null) {
+            join(options);
             return;
         }
 
-        ReactActivityLifecycleCallbacks.onNewIntent(intent);
-    }
-
-    @Override
-    protected void onResume() {
-        super.onResume();
-
-        defaultBackButtonImpl = new DefaultHardwareBackBtnHandlerImpl(this);
-        ReactActivityLifecycleCallbacks.onHostResume(this, defaultBackButtonImpl);
-    }
-
-    @Override
-    public void onStop() {
-        super.onStop();
-
-        ReactActivityLifecycleCallbacks.onHostPause(this);
-        defaultBackButtonImpl = null;
+        JitsiMeetActivityDelegate.onNewIntent(intent);
     }
 
     @Override
     protected void onUserLeaveHint() {
-        if (view != null) {
-            view.enterPictureInPicture();
-        }
+        getJitsiView().enterPictureInPicture();
     }
 
-    /**
-     *
-     * @see JitsiMeetView#setDefaultURL(URL)
-     */
-    public void setDefaultURL(URL defaultURL) {
-        if (view == null) {
-            this.defaultURL = defaultURL;
-        } else {
-            view.setDefaultURL(defaultURL);
-        }
+    // JitsiMeetActivityInterface
+    //
+
+    @Override
+    public void requestPermissions(String[] permissions, int requestCode, PermissionListener listener) {
+        JitsiMeetActivityDelegate.requestPermissions(this, permissions, requestCode, listener);
     }
 
-    /**
-     *
-     * @see JitsiMeetView#setPictureInPictureEnabled(boolean)
-     */
-    public void setPictureInPictureEnabled(boolean pictureInPictureEnabled) {
-        if (view == null) {
-            this.pictureInPictureEnabled
-                = Boolean.valueOf(pictureInPictureEnabled);
-        } else {
-            view.setPictureInPictureEnabled(pictureInPictureEnabled);
-        }
+    @Override
+    public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
+        JitsiMeetActivityDelegate.onRequestPermissionsResult(requestCode, permissions, grantResults);
     }
 
-    /**
-     *
-     * @see JitsiMeetView#setWelcomePageEnabled(boolean)
-     */
-    public void setWelcomePageEnabled(boolean welcomePageEnabled) {
-        if (view == null) {
-            this.welcomePageEnabled = welcomePageEnabled;
-        } else {
-            view.setWelcomePageEnabled(welcomePageEnabled);
-        }
+    // JitsiMeetViewListener
+    //
+
+    @Override
+    public void onConferenceJoined(Map<String, Object> data) {
+        JitsiMeetLogger.i("Conference joined: " + data);
+        // Launch the service for the ongoing notification.
+        JitsiMeetOngoingConferenceService.launch(this);
+    }
+
+    @Override
+    public void onConferenceTerminated(Map<String, Object> data) {
+        JitsiMeetLogger.i("Conference terminated: " + data);
+        finish();
+    }
+
+    @Override
+    public void onConferenceWillJoin(Map<String, Object> data) {
+        JitsiMeetLogger.i("Conference will join: " + data);
     }
 }

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

@@ -1,5 +1,6 @@
 /*
- * Copyright @ 2018-present Atlassian Pty Ltd
+ * Copyright @ 2019-present 8x8, Inc.
+ * Copyright @ 2018 Atlassian Pty Ltd
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,18 +17,62 @@
 
 package org.jitsi.meet.sdk;
 
+import android.annotation.TargetApi;
 import android.app.Activity;
 import android.content.Intent;
+import android.os.Build;
 
+import com.calendarevents.CalendarEventsPackage;
 import com.facebook.react.ReactInstanceManager;
-import com.facebook.react.modules.core.DefaultHardwareBackBtnHandler;
+import com.facebook.react.bridge.Callback;
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.modules.core.PermissionListener;
 
 /**
  * Helper class to encapsulate the work which needs to be done on
  * {@link Activity} lifecycle methods in order for the React side to be aware of
  * it.
  */
-public class ReactActivityLifecycleCallbacks {
+public class JitsiMeetActivityDelegate {
+    /**
+     * Needed for making sure this class working with the "PermissionsAndroid"
+     * React Native module.
+     */
+    private static PermissionListener permissionListener;
+    private static Callback permissionsCallback;
+
+    /**
+     * Tells whether or not the permissions request is currently in progress.
+     *
+     * @return {@code true} if the permssions are being requested or {@code false} otherwise.
+     */
+    static boolean arePermissionsBeingRequested() {
+        return permissionListener != null;
+    }
+
+    /**
+     * {@link Activity} lifecycle method which should be called from
+     * {@code Activity#onActivityResult} so we are notified about results of external intents
+     * started/finished.
+     *
+     * @param activity {@code Activity} activity from where the result comes from.
+     * @param requestCode {@code int} code of the request.
+     * @param resultCode {@code int} code of the result.
+     * @param data {@code Intent} the intent of the activity.
+     */
+    public static void onActivityResult(
+            Activity activity,
+            int requestCode,
+            int resultCode,
+            Intent data) {
+        ReactInstanceManager reactInstanceManager
+                = ReactInstanceManagerHolder.getReactInstanceManager();
+
+        if (reactInstanceManager != null) {
+            reactInstanceManager.onActivityResult(activity, requestCode, resultCode, data);
+        }
+    }
+
     /**
      * {@link Activity} lifecycle method which should be called from
      * {@link Activity#onBackPressed} so we can do the required internal
@@ -37,15 +82,12 @@ public class ReactActivityLifecycleCallbacks {
      * otherwise. If {@code false}, the application should call the
      * {@code super}'s implementation.
      */
-    public static boolean onBackPressed() {
+    public static void onBackPressed() {
         ReactInstanceManager reactInstanceManager
             = ReactInstanceManagerHolder.getReactInstanceManager();
 
-        if (reactInstanceManager == null) {
-            return false;
-        } else {
+        if (reactInstanceManager != null) {
             reactInstanceManager.onBackPressed();
-            return true;
         }
     }
 
@@ -76,7 +118,13 @@ public class ReactActivityLifecycleCallbacks {
             = 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);
+            }
         }
     }
 
@@ -87,25 +135,16 @@ public class ReactActivityLifecycleCallbacks {
      * @param activity {@code Activity} being resumed.
      */
     public static void onHostResume(Activity activity) {
-        onHostResume(activity, new DefaultHardwareBackBtnHandlerImpl(activity));
-    }
-
-    /**
-     * {@link Activity} lifecycle method which should be called from
-     * {@code Activity#onResume} so we can do the required internal processing.
-     *
-     * @param activity {@code Activity} being resumed.
-     * @param defaultBackButtonImpl a {@link DefaultHardwareBackBtnHandler} to
-     * handle invoking the back button if no {@link BaseReactView} handles it.
-     */
-    public static void onHostResume(
-            Activity activity,
-            DefaultHardwareBackBtnHandler defaultBackButtonImpl) {
         ReactInstanceManager reactInstanceManager
             = ReactInstanceManagerHolder.getReactInstanceManager();
 
         if (reactInstanceManager != null) {
-            reactInstanceManager.onHostResume(activity, defaultBackButtonImpl);
+            reactInstanceManager.onHostResume(activity, new DefaultHardwareBackBtnHandlerImpl(activity));
+        }
+
+        if (permissionsCallback != null) {
+            permissionsCallback.invoke();
+            permissionsCallback = null;
         }
     }
 
@@ -126,4 +165,29 @@ public class ReactActivityLifecycleCallbacks {
             reactInstanceManager.onNewIntent(intent);
         }
     }
+
+    public static void onRequestPermissionsResult(
+        final int requestCode,
+        final String[] permissions,
+        final int[] grantResults) {
+        CalendarEventsPackage.onRequestPermissionsResult(
+            requestCode,
+            permissions,
+            grantResults);
+        permissionsCallback = new Callback() {
+            @Override
+            public void invoke(Object... args) {
+                if (permissionListener != null
+                        && permissionListener.onRequestPermissionsResult(requestCode, permissions, grantResults)) {
+                    permissionListener = null;
+                }
+            }
+        };
+    }
+
+    @TargetApi(Build.VERSION_CODES.M)
+    public static void requestPermissions(Activity activity, String[] permissions, int requestCode, PermissionListener listener) {
+        permissionListener = listener;
+        activity.requestPermissions(permissions, requestCode);
+    }
 }

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

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

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

@@ -0,0 +1,394 @@
+/*
+ * Copyright @ 2019-present 8x8, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jitsi.meet.sdk;
+
+import android.os.Bundle;
+import android.os.Parcel;
+import android.os.Parcelable;
+
+import java.net.URL;
+
+
+/**
+ * This class represents the options when joining a Jitsi Meet conference. The user can create an
+ * instance by using {@link JitsiMeetConferenceOptions.Builder} and setting the desired options
+ * there.
+ *
+ * The resulting {@link JitsiMeetConferenceOptions} object is immutable and represents how the
+ * conference will be joined.
+ */
+public class JitsiMeetConferenceOptions implements Parcelable {
+    /**
+     * Server where the conference should take place.
+     */
+    private URL serverURL;
+    /**
+     * Room name.
+     */
+    private String room;
+    /**
+     * Conference subject.
+     */
+    private String subject;
+    /**
+     * JWT token used for authentication.
+     */
+    private String token;
+
+    /**
+     * Color scheme override, see: https://github.com/jitsi/jitsi-meet/blob/dbedee5e22e5dcf9c92db96ef5bb3c9982fc526d/react/features/base/color-scheme/defaultScheme.js
+     */
+    private Bundle colorScheme;
+
+    /**
+     * Feature flags. See: https://github.com/jitsi/jitsi-meet/blob/master/react/features/base/flags/constants.js
+     */
+    private Bundle featureFlags;
+
+    /**
+     * Set to {@code true} to join the conference with audio / video muted or to start in audio
+     * only mode respectively.
+     */
+    private Boolean audioMuted;
+    private Boolean audioOnly;
+    private Boolean videoMuted;
+
+    /**
+     * USer information, to be used when no token is specified.
+     */
+    private JitsiMeetUserInfo userInfo;
+
+    public URL getServerURL() {
+        return serverURL;
+    }
+
+    public String getRoom() {
+        return room;
+    }
+
+    public String 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.
+     */
+    public static class Builder {
+        private URL serverURL;
+        private String room;
+        private String subject;
+        private String token;
+
+        private Bundle colorScheme;
+        private Bundle featureFlags;
+
+        private Boolean audioMuted;
+        private Boolean audioOnly;
+        private Boolean videoMuted;
+
+        private JitsiMeetUserInfo userInfo;
+
+        public Builder() {
+            featureFlags = new Bundle();
+        }
+
+        /**\
+         * Sets the server URL.
+         * @param url - {@link URL} of the server where the conference should take place.
+         * @return - The {@link Builder} object itself so the method calls can be chained.
+         */
+        public Builder setServerURL(URL url) {
+            this.serverURL = url;
+
+            return this;
+        }
+
+        /**
+         * Sets the room where the conference will take place.
+         * @param room - Name of the room.
+         * @return - The {@link Builder} object itself so the method calls can be chained.
+         */
+        public Builder setRoom(String room) {
+            this.room = room;
+
+            return this;
+        }
+
+        /**
+         * Sets the conference subject.
+         * @param subject - Subject for the conference.
+         * @return - The {@link Builder} object itself so the method calls can be chained.
+         */
+        public Builder setSubject(String subject) {
+            this.subject = subject;
+
+            return this;
+        }
+
+        /**
+         * Sets the JWT token to be used for authentication when joining a conference.
+         * @param token - The JWT token to be used for authentication.
+         * @return - The {@link Builder} object itself so the method calls can be chained.
+         */
+        public Builder setToken(String token) {
+            this.token = token;
+
+            return this;
+        }
+
+        /**
+         * Sets the color scheme override so the app is themed. See:
+         * https://github.com/jitsi/jitsi-meet/blob/master/react/features/base/color-scheme/defaultScheme.js
+         * for the structure.
+         * @param colorScheme - A color scheme to be applied to the app.
+         * @return - The {@link Builder} object itself so the method calls can be chained.
+         */
+        public Builder setColorScheme(Bundle colorScheme) {
+            this.colorScheme = colorScheme;
+
+            return this;
+        }
+
+        /**
+         * Indicates the conference will be joined with the microphone muted.
+         * @param muted - Muted indication.
+         * @return - The {@link Builder} object itself so the method calls can be chained.
+         */
+        public Builder setAudioMuted(boolean muted) {
+            this.audioMuted = muted;
+
+            return this;
+        }
+
+        /**
+         * Indicates the conference will be joined in audio-only mode. In this mode no video is
+         * sent or received.
+         * @param audioOnly - Audio-mode indicator.
+         * @return - The {@link Builder} object itself so the method calls can be chained.
+         */
+        public Builder setAudioOnly(boolean audioOnly) {
+            this.audioOnly = audioOnly;
+
+            return this;
+        }
+        /**
+         * Indicates the conference will be joined with the camera muted.
+         * @param videoMuted - Muted indication.
+         * @return - The {@link Builder} object itself so the method calls can be chained.
+         */
+        public Builder setVideoMuted(boolean videoMuted) {
+            this.videoMuted = videoMuted;
+
+            return this;
+        }
+
+        /**
+         * Sets the welcome page enabled / disabled. The welcome page lists recent meetings and
+         * calendar appointments and it's meant to be used by standalone applications. Defaults to
+         * false.
+         * @param enabled - Whether the welcome page should be enabled or not.
+         * @return - The {@link Builder} object itself so the method calls can be chained.
+         */
+        public Builder setWelcomePageEnabled(boolean enabled) {
+            this.featureFlags.putBoolean("welcomepage.enabled", enabled);
+
+            return this;
+        }
+
+        public Builder setFeatureFlag(String flag, boolean value) {
+            this.featureFlags.putBoolean(flag, value);
+
+            return this;
+        }
+
+        public Builder setFeatureFlag(String flag, String value) {
+            this.featureFlags.putString(flag, value);
+
+            return this;
+        }
+
+        public Builder setFeatureFlag(String flag, int value) {
+            this.featureFlags.putInt(flag, value);
+
+            return this;
+        }
+
+        public Builder setUserInfo(JitsiMeetUserInfo userInfo) {
+            this.userInfo = userInfo;
+
+            return this;
+        }
+
+        /**
+         * Builds the immutable {@link JitsiMeetConferenceOptions} object with the configuration
+         * that this {@link Builder} instance specified.
+         * @return - The built {@link JitsiMeetConferenceOptions} object.
+         */
+        public JitsiMeetConferenceOptions build() {
+            JitsiMeetConferenceOptions options = new JitsiMeetConferenceOptions();
+
+            options.serverURL = this.serverURL;
+            options.room = this.room;
+            options.subject = this.subject;
+            options.token = this.token;
+            options.colorScheme = this.colorScheme;
+            options.featureFlags = this.featureFlags;
+            options.audioMuted = this.audioMuted;
+            options.audioOnly = this.audioOnly;
+            options.videoMuted = this.videoMuted;
+            options.userInfo = this.userInfo;
+
+            return options;
+        }
+    }
+
+    private JitsiMeetConferenceOptions() {
+    }
+
+    private JitsiMeetConferenceOptions(Parcel in) {
+        room = in.readString();
+        subject = in.readString();
+        token = in.readString();
+        colorScheme = in.readBundle();
+        featureFlags = in.readBundle();
+        userInfo = new JitsiMeetUserInfo(in.readBundle());
+        byte tmpAudioMuted = in.readByte();
+        audioMuted = tmpAudioMuted == 0 ? null : tmpAudioMuted == 1;
+        byte tmpAudioOnly = in.readByte();
+        audioOnly = tmpAudioOnly == 0 ? null : tmpAudioOnly == 1;
+        byte tmpVideoMuted = in.readByte();
+        videoMuted = tmpVideoMuted == 0 ? null : tmpVideoMuted == 1;
+    }
+
+    Bundle asProps() {
+        Bundle props = new Bundle();
+
+        // Android always has the PiP flag set by default.
+        if (!featureFlags.containsKey("pip.enabled")) {
+            featureFlags.putBoolean("pip.enabled", true);
+        }
+
+        props.putBundle("flags", featureFlags);
+
+        if (colorScheme != null) {
+            props.putBundle("colorScheme", colorScheme);
+        }
+
+        Bundle config = new Bundle();
+
+        if (audioMuted != null) {
+            config.putBoolean("startWithAudioMuted", audioMuted);
+        }
+        if (audioOnly != null) {
+            config.putBoolean("startAudioOnly", audioOnly);
+        }
+        if (videoMuted != null) {
+            config.putBoolean("startWithVideoMuted", videoMuted);
+        }
+        if (subject != null) {
+            config.putString("subject", subject);
+        }
+
+        Bundle urlProps = new Bundle();
+
+        // The room is fully qualified
+        if (room != null && room.contains("://")) {
+            urlProps.putString("url", room);
+        } else {
+            if (serverURL != null) {
+                urlProps.putString("serverURL", serverURL.toString());
+            }
+            if (room != null) {
+                urlProps.putString("room", room);
+            }
+        }
+
+        if (token != null) {
+            urlProps.putString("jwt", token);
+        }
+
+        if (token == null && userInfo != null) {
+            props.putBundle("userInfo", userInfo.asBundle());
+        }
+
+        urlProps.putBundle("config", config);
+        props.putBundle("url", urlProps);
+
+        return props;
+    }
+
+    // Parcelable interface
+    //
+
+    public static final Creator<JitsiMeetConferenceOptions> CREATOR = new Creator<JitsiMeetConferenceOptions>() {
+        @Override
+        public JitsiMeetConferenceOptions createFromParcel(Parcel in) {
+            return new JitsiMeetConferenceOptions(in);
+        }
+
+        @Override
+        public JitsiMeetConferenceOptions[] newArray(int size) {
+            return new JitsiMeetConferenceOptions[size];
+        }
+    };
+
+    @Override
+    public void writeToParcel(Parcel dest, int flags) {
+        dest.writeString(room);
+        dest.writeString(subject);
+        dest.writeString(token);
+        dest.writeBundle(colorScheme);
+        dest.writeBundle(featureFlags);
+        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));
+    }
+
+    @Override
+    public int describeContents() {
+        return 0;
+    }
+}

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

@@ -0,0 +1,96 @@
+/*
+ * Copyright @ 2019-present 8x8, Inc.
+ * Copyright @ 2017-2018 Atlassian Pty Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jitsi.meet.sdk;
+
+import android.content.Intent;
+import android.os.Bundle;
+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;
+
+/**
+ * Base {@link Fragment} for applications integrating Jitsi Meet at a higher level. It
+ * contains all the required wiring between the {@code JitsiMeetView} and
+ * the Fragment lifecycle methods already implemented.
+ *
+ * In this fragment we use a single {@code JitsiMeetView} instance. This
+ * instance gives us access to a view which displays the welcome page and the
+ * conference itself. All lifecycle methods associated with this Fragment are
+ * hooked to the React Native subsystem via proxy calls through the
+ * {@code JitsiMeetActivityDelegate} static methods.
+ */
+public class JitsiMeetFragment extends Fragment {
+
+    /**
+     * Instance of the {@link JitsiMeetView} which this activity will display.
+     */
+    private JitsiMeetView view;
+
+    @Nullable
+    @Override
+    public View onCreateView(@NonNull LayoutInflater inflater,
+                             @Nullable ViewGroup container,
+                             @Nullable Bundle savedInstanceState) {
+        return this.view = new JitsiMeetView(getActivity());
+    }
+
+    public JitsiMeetView getJitsiView() {
+        return view;
+    }
+
+    @Override
+    public void onActivityResult(int requestCode, int resultCode, Intent data) {
+        JitsiMeetActivityDelegate.onActivityResult(
+                getActivity(), requestCode, resultCode, data);
+    }
+
+    @Override
+    public void onDestroyView() {
+        if (view != null) {
+            view.dispose();
+            view = null;
+        }
+
+        super.onDestroyView();
+    }
+
+    @Override
+    public void onDestroy() {
+        super.onDestroy();
+
+        JitsiMeetActivityDelegate.onHostDestroy(getActivity());
+    }
+
+    @Override
+    public void onResume() {
+        super.onResume();
+
+        JitsiMeetActivityDelegate.onHostResume(getActivity());
+    }
+
+    @Override
+    public void onStop() {
+        super.onStop();
+
+        JitsiMeetActivityDelegate.onHostPause(getActivity());
+    }
+}

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

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

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

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

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

@@ -1,5 +1,6 @@
 /*
- * Copyright @ 2017-present Atlassian Pty Ltd
+ * Copyright @ 2018-present 8x8, Inc.
+ * Copyright @ 2017-2018 Atlassian Pty Ltd
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -18,20 +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.invite.InviteController;
+import org.jitsi.meet.sdk.log.JitsiMeetLogger;
 
 import java.lang.reflect.Method;
-import java.net.URL;
 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.
@@ -40,57 +40,6 @@ public class JitsiMeetView
     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();
-
-    /**
-     * Loads a specific URL {@code String} in all existing
-     * {@code JitsiMeetView}s.
-     *
-     * @param urlString he URL {@code String} to load in all existing
-     * {@code JitsiMeetView}s.
-     * @return If the specified {@code urlString} was submitted for loading in
-     * at least one {@code JitsiMeetView}, then {@code true}; otherwise,
-     * {@code false}.
-     */
-    public static boolean loadURLStringInViews(String urlString) {
-        boolean loaded = false;
-
-        synchronized (views) {
-            for (BaseReactView view : views) {
-                if (view instanceof JitsiMeetView) {
-                    ((JitsiMeetView)view).loadURLString(urlString);
-                    loaded = true;
-                }
-            }
-        }
-
-        return loaded;
-    }
-
-    /**
-     * The default base {@code URL} used to join a conference when a partial URL
-     * (e.g. a room name only) is specified to {@link #loadURLString(String)} or
-     * {@link #loadURLObject(Bundle)}.
-     */
-    private URL defaultURL;
-
-    /**
-     * The entry point into the invite feature of Jitsi Meet. The Java
-     * counterpart of the JavaScript {@code InviteButton}.
-     */
-    private final InviteController inviteController;
-
-    /**
-     * Whether Picture-in-Picture is enabled. If {@code null}, defaults to
-     * {@code true} iff the Android platform supports Picture-in-Picture
-     * natively.
-     */
-    private Boolean pictureInPictureEnabled;
-
     /**
      * The URL of the current conference.
      */
@@ -99,16 +48,68 @@ public class JitsiMeetView
     private volatile String url;
 
     /**
-     * Whether the Welcome page is enabled.
+     * Helper method to recursively merge 2 {@link Bundle} objects representing React Native props.
+     *
+     * @param a - The first {@link Bundle}.
+     * @param b - The second {@link Bundle}.
+     * @return The merged {@link Bundle} object.
      */
-    private boolean welcomePageEnabled;
+    private static Bundle mergeProps(@Nullable Bundle a, @Nullable Bundle b) {
+        Bundle result = new Bundle();
+
+        if (a == null) {
+            if (b != null) {
+                result.putAll(b);
+            }
+
+            return result;
+        }
+
+        if (b == null) {
+            result.putAll(a);
+
+            return result;
+        }
+
+        // Start by putting all of a in the result.
+        result.putAll(a);
+
+        // Iterate over each key in b and override if appropriate.
+        for (String key : b.keySet()) {
+            Object bValue = b.get(key);
+            Object aValue = a.get(key);
+            String valueType = bValue.getClass().getSimpleName();
+
+            if (valueType.contentEquals("Boolean")) {
+                result.putBoolean(key, (Boolean)bValue);
+            } else if (valueType.contentEquals("String")) {
+                result.putString(key, (String)bValue);
+            } else if (valueType.contentEquals("Bundle")) {
+                result.putBundle(key, mergeProps((Bundle)aValue, (Bundle)bValue));
+            } else {
+                throw new RuntimeException("Unsupported type: " + valueType);
+            }
+        }
+
+        return result;
+    }
 
     public JitsiMeetView(@NonNull Context context) {
         super(context);
 
-        // The entry point into the invite feature of Jitsi Meet. The Java
-        // counterpart of the JavaScript InviteButton.
-        inviteController = new InviteController(externalAPIScope);
+        // Check if the parent Activity implements JitsiMeetActivityInterface,
+        // otherwise things may go wrong.
+        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();
     }
 
     /**
@@ -121,200 +122,72 @@ public class JitsiMeetView
      * page.
      */
     public void enterPictureInPicture() {
-        if (isPictureInPictureEnabled() && getURL() != null) {
-            PictureInPictureModule pipModule
-                = ReactInstanceManagerHolder.getNativeModule(
+        PictureInPictureModule pipModule
+            = ReactInstanceManagerHolder.getNativeModule(
                 PictureInPictureModule.class);
-
-            if (pipModule != null) {
-                try {
-                    pipModule.enterPictureInPicture();
-                } catch (RuntimeException re) {
-                    Log.e(TAG, "onUserLeaveHint: failed to enter PiP mode", re);
-                }
+        if (pipModule != null
+                && PictureInPictureModule.isPictureInPictureSupported()
+                && !JitsiMeetActivityDelegate.arePermissionsBeingRequested()
+                && this.url != null) {
+            try {
+                pipModule.enterPictureInPicture();
+            } catch (RuntimeException re) {
+                JitsiMeetLogger.e(re, "Failed to enter PiP mode");
             }
         }
     }
 
     /**
-     * Gets the default base {@code URL} used to join a conference when a
-     * partial URL (e.g. a room name only) is specified to
-     * {@link #loadURLString(String)} or {@link #loadURLObject(Bundle)}. If not
-     * set or if set to {@code null}, the default built in JavaScript is used:
-     * https://meet.jit.si
-     *
-     * @return The default base {@code URL} or {@code null}.
+     * Joins the conference specified by the given {@link JitsiMeetConferenceOptions}. If there is
+     * already an active conference, it will be left and the new one will be joined.
+     * @param options - Description of what conference must be joined and what options will be used
+     *                when doing so.
      */
-    public URL getDefaultURL() {
-        return defaultURL;
+    public void join(@Nullable JitsiMeetConferenceOptions options) {
+        setProps(options != null ? options.asProps() : new Bundle());
     }
 
     /**
-     * Gets the {@link InviteController} which represents the entry point into
-     * the invite feature of Jitsi Meet and is the Java counterpart of the
-     * JavaScript {@code InviteButton}.
-     *
-     * @return the {@link InviteController} which represents the entry point
-     * into the invite feature of Jitsi Meet and is the Java counterpart of the
-     * JavaScript {@code InviteButton}
+     * Leaves the currently active conference.
      */
-    public InviteController getInviteController() {
-        return inviteController;
+    public void leave() {
+        setProps(new Bundle());
     }
 
     /**
-     * Gets the URL of the current conference.
-     *
-     * XXX The method is meant for internal purposes only at the time of this
-     * writing because there is no equivalent API on iOS.
-     *
-     * @return the URL {@code String} of the current conference if any;
-     * otherwise, {@code null}.
+     * Helper method to set the React Native props.
+     * @param newProps - New props to be set on the React Native view.
      */
-    String getURL() {
-        return url;
-    }
+    private void setProps(@NonNull Bundle newProps) {
+        // Merge the default options with the newly provided ones.
+        Bundle props = mergeProps(JitsiMeet.getDefaultProps(), newProps);
 
-    /**
-     * Gets whether Picture-in-Picture is enabled. Picture-in-Picture is
-     * natively supported on Android API >= 26 (Oreo), so it should not be
-     * enabled on older platform versions.
-     *
-     * @return If Picture-in-Picture is enabled, {@code true}; {@code false},
-     * otherwise.
-     */
-    public boolean isPictureInPictureEnabled() {
-        return
-            PictureInPictureModule.isPictureInPictureSupported()
-                && (pictureInPictureEnabled == null
-                    || pictureInPictureEnabled);
-    }
-
-    /**
-     * Gets whether the Welcome page is enabled. If {@code true}, the Welcome
-     * page is rendered when this {@code JitsiMeetView} is not at a URL
-     * identifying a Jitsi Meet conference/room.
-     *
-     * @return {@code true} if the Welcome page is enabled; otherwise,
-     * {@code false}.
-     */
-    public boolean isWelcomePageEnabled() {
-        return welcomePageEnabled;
-    }
-
-    /**
-     * Loads a specific {@link URL} which may identify a conference to join. If
-     * the specified {@code URL} is {@code null} and the Welcome page is
-     * enabled, the Welcome page is displayed instead.
-     *
-     * @param url The {@code URL} to load which may identify a conference to
-     * join.
-     */
-    public void loadURL(@Nullable URL url) {
-        loadURLString(url == null ? null : url.toString());
-    }
-
-    /**
-     * Loads a specific URL which may identify a conference to join. The URL is
-     * specified in the form of a {@link Bundle} of properties which (1)
-     * internally are sufficient to construct a URL {@code String} while (2)
-     * abstracting the specifics of constructing the URL away from API
-     * clients/consumers. If the specified URL is {@code null} and the Welcome
-     * page is enabled, the Welcome page is displayed instead.
-     *
-     * @param urlObject The URL to load which may identify a conference to join.
-     */
-    public void loadURLObject(@Nullable Bundle urlObject) {
-        Bundle props = new Bundle();
-
-        // defaultURL
-        if (defaultURL != null) {
-            props.putString("defaultURL", defaultURL.toString());
-        }
-
-        // inviteController
-        InviteController inviteController = getInviteController();
-
-        if (inviteController != null) {
-            props.putBoolean(
-                "addPeopleEnabled",
-                inviteController.isAddPeopleEnabled());
-            props.putBoolean(
-                "dialOutEnabled",
-                inviteController.isDialOutEnabled());
-        }
-
-        // pictureInPictureEnabled
-        props.putBoolean(
-            "pictureInPictureEnabled",
-            isPictureInPictureEnabled());
-
-        // url
-        if (urlObject != null) {
-            props.putBundle("url", urlObject);
-        }
-
-        // welcomePageEnabled
-        props.putBoolean("welcomePageEnabled", welcomePageEnabled);
-
-        // XXX The method loadURLObject: is supposed to be imperative i.e.
+        // XXX The setProps() method is supposed to be imperative i.e.
         // a second invocation with one and the same URL is expected to join
         // the respective conference again if the first invocation was followed
         // by leaving the conference. However, React and, respectively,
         // appProperties/initialProperties are declarative expressions i.e. one
-        // and the same URL will not trigger componentWillReceiveProps in the
+        // and the same URL will not trigger an automatic re-render in the
         // JavaScript source code. The workaround implemented bellow introduces
-        // imperativeness in React Component props by defining a unique value
-        // per loadURLObject: invocation.
+        // "imperativeness" in React Component props by defining a unique value
+        // per setProps() invocation.
         props.putLong("timestamp", System.currentTimeMillis());
 
         createReactRootView("App", props);
     }
 
     /**
-     * Loads a specific URL {@link String} which may identify a conference to
-     * join. If the specified URL {@code String} is {@code null} and the Welcome
-     * page is enabled, the Welcome page is displayed instead.
-     *
-     * @param urlString The URL {@code String} to load which may identify a
-     * conference to join.
+     * Handler for {@link OngoingConferenceTracker} events.
+     * @param conferenceUrl
      */
-    public void loadURLString(@Nullable String urlString) {
-        Bundle urlObject;
-
-        if (urlString == null) {
-            urlObject = null;
-        } else {
-            urlObject = new Bundle();
-            urlObject.putString("url", urlString);
-        }
-        loadURLObject(urlObject);
-    }
-
-    /**
-     * 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}.
-     */
-    private void maybeSetViewURL(String eventName, ReadableMap eventData) {
-        switch(eventName) {
-        case "CONFERENCE_WILL_JOIN":
-            setURL(eventData.getString("url"));
-            break;
-
-        case "CONFERENCE_FAILED":
-        case "CONFERENCE_WILL_LEAVE":
-        case "LOAD_CONFIG_ERROR":
-            String url = eventData.getString("url");
-
-            if (url != null && url.equals(getURL())) {
-                setURL(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;
     }
 
     /**
@@ -325,63 +198,7 @@ public class JitsiMeetView
      * by/associated with the specified {@code name}.
      */
     @Override
-    public 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);
-
+    protected void onExternalAPIEvent(String name, ReadableMap data) {
         onExternalAPIEvent(LISTENER_METHODS, name, data);
     }
-
-    /**
-     * Sets the default base {@code URL} used to join a conference when a
-     * partial URL (e.g. a room name only) is specified to
-     * {@link #loadURLString(String)} or {@link #loadURLObject(Bundle)}. Must be
-     * called before {@link #loadURL(URL)} for it to take effect.
-     *
-     * @param defaultURL The {@code URL} to be set as the default base URL.
-     * @see #getDefaultURL()
-     */
-    public void setDefaultURL(URL defaultURL) {
-        this.defaultURL = defaultURL;
-    }
-
-    /**
-     * Sets whether Picture-in-Picture is enabled. Because Picture-in-Picture is
-     * natively supported only since certain platform versions, specifying
-     * {@code true} will have no effect on unsupported platform versions.
-     *
-     * @param pictureInPictureEnabled To enable Picture-in-Picture,
-     * {@code true}; otherwise, {@code false}.
-     */
-    public void setPictureInPictureEnabled(boolean pictureInPictureEnabled) {
-        this.pictureInPictureEnabled = pictureInPictureEnabled;
-    }
-
-    /**
-     * Sets the URL of the current conference.
-     *
-     * XXX The method is meant for internal purposes only. It does not
-     * {@code loadURL}, it merely remembers the specified URL.
-     *
-     * @param url the URL {@code String} which to be set as the URL of the
-     * current conference.
-     */
-    void setURL(String url) {
-        this.url = url;
-    }
-
-    /**
-     * Sets whether the Welcome page is enabled. Must be called before
-     * {@link #loadURL(URL)} for it to take effect.
-     *
-     * @param welcomePageEnabled {@code true} to enable the Welcome page;
-     * otherwise, {@code false}.
-     */
-    public void setWelcomePageEnabled(boolean welcomePageEnabled) {
-        this.welcomePageEnabled = welcomePageEnabled;
-    }
 }

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

@@ -1,51 +0,0 @@
-/*
- * Copyright @ 2017-present Atlassian Pty Ltd
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jitsi.meet.sdk;
-
-import java.util.Map;
-
-/**
- * Implements {@link JitsiMeetViewListener} so apps don't have to add stubs for
- * all methods in the interface if they are only interested in some.
- */
-public abstract class JitsiMeetViewAdapter
-    implements JitsiMeetViewListener {
-
-    @Override
-    public void onConferenceFailed(Map<String, Object> data) {
-    }
-
-    @Override
-    public void onConferenceJoined(Map<String, Object> data) {
-    }
-
-    @Override
-    public void onConferenceLeft(Map<String, Object> data) {
-    }
-
-    @Override
-    public void onConferenceWillJoin(Map<String, Object> data) {
-    }
-
-    @Override
-    public void onConferenceWillLeave(Map<String, Object> data) {
-    }
-
-    @Override
-    public void onLoadConfigError(Map<String, Object> data) {
-    }
-}

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

@@ -22,15 +22,6 @@ import java.util.Map;
  * Interface for listening to events coming from Jitsi Meet.
  */
 public interface JitsiMeetViewListener {
-    /**
-     * Called when joining a conference fails or an ongoing conference is
-     * interrupted due to a failure.
-     *
-     * @param data Map with an "error" key describing the problem, and a "url"
-     * key with the conference URL.
-     */
-    void onConferenceFailed(Map<String, Object> data);
-
     /**
      * Called when a conference was joined.
      *
@@ -39,11 +30,16 @@ public interface JitsiMeetViewListener {
     void onConferenceJoined(Map<String, Object> data);
 
     /**
-     * Called when the conference was left, typically after hanging up.
+     * Called when the active conference ends, be it because of user choice or
+     * because of a failure.
      *
-     * @param data Map with a "url" key with the conference URL.
+     * @param data Map with an "error" key with the error and a "url" key with
+     * the conference URL. If the conference finished gracefully no `error`
+     * key will be present. The possible values for "error" are described here:
+     * https://github.com/jitsi/lib-jitsi-meet/blob/master/JitsiConnectionErrors.js
+     * https://github.com/jitsi/lib-jitsi-meet/blob/master/JitsiConferenceErrors.js
      */
-    void onConferenceLeft(Map<String, Object> data);
+    void onConferenceTerminated(Map<String, Object> data);
 
     /**
      * Called before the conference is joined.
@@ -51,21 +47,4 @@ public interface JitsiMeetViewListener {
      * @param data Map with a "url" key with the conference URL.
      */
     void onConferenceWillJoin(Map<String, Object> data);
-
-    /**
-     * Called before the conference is left.
-     *
-     * @param data Map with a "url" key with the conference URL.
-     */
-    void onConferenceWillLeave(Map<String, Object> data);
-
-    /**
-     * Called when loading the main configuration file from the Jitsi Meet
-     * deployment fails.
-     *
-     * @param data Map with an "error" key with the error and a "url" key with
-     * the conference URL which necessitated the loading of the configuration
-     * file.
-     */
-    void onLoadConfigError(Map<String, Object> data);
 }

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

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

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

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

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

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

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

@@ -0,0 +1,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

@@ -16,21 +16,27 @@
 
 package org.jitsi.meet.sdk;
 
+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;
 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;
+
+@ReactModule(name = PictureInPictureModule.NAME)
 class PictureInPictureModule
     extends ReactContextBaseJavaModule {
 
-    private final static String TAG = "PictureInPicture";
+    public static final String NAME = "PictureInPicture";
+
+    private static final String TAG = NAME;
 
     static boolean isPictureInPictureSupported() {
         return Build.VERSION.SDK_INT >= Build.VERSION_CODES.O;
@@ -53,6 +59,7 @@ class PictureInPictureModule
      * including when the activity is not visible (paused or stopped), if the
      * screen is locked or if the user has an activity pinned.
      */
+    @TargetApi(Build.VERSION_CODES.O)
     public void enterPictureInPicture() {
         if (!isPictureInPictureSupported()) {
             throw new IllegalStateException("Picture-in-Picture not supported");
@@ -64,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()
@@ -99,6 +106,6 @@ class PictureInPictureModule
 
     @Override
     public String getName() {
-        return TAG;
+        return NAME;
     }
 }

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

@@ -24,6 +24,7 @@ import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReactContextBaseJavaModule;
 import com.facebook.react.bridge.ReactMethod;
 import com.facebook.react.bridge.UiThreadUtil;
+import com.facebook.react.module.annotations.ReactModule;
 
 /**
  * Module implementing a simple API to enable a proximity sensor-controlled
@@ -31,14 +32,11 @@ import com.facebook.react.bridge.UiThreadUtil;
  * object it will dim the screen and disable touch controls. The functionality
  * is used with the conference audio-only mode.
  */
+@ReactModule(name = ProximityModule.NAME)
 class ProximityModule
     extends ReactContextBaseJavaModule {
 
-    /**
-     * The name of {@code ProximityModule} to be used in the React Native
-     * bridge.
-     */
-    private static final String MODULE_NAME = "Proximity";
+    public static final String NAME = "Proximity";
 
     /**
      * This type of wake lock (the one activated by the proximity sensor) has
@@ -74,7 +72,7 @@ class ProximityModule
             wakeLock
                 = powerManager.newWakeLock(
                         PROXIMITY_SCREEN_OFF_WAKE_LOCK,
-                        MODULE_NAME);
+                        "jitsi:"+NAME);
         } catch (Throwable ignored) {
             wakeLock = null;
         }
@@ -89,7 +87,7 @@ class ProximityModule
      */
     @Override
     public String getName() {
-        return MODULE_NAME;
+        return NAME;
     }
 
     /**

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

@@ -0,0 +1,200 @@
+package org.jitsi.meet.sdk;
+
+import android.annotation.SuppressLint;
+import android.content.Context;
+import android.net.Uri;
+import android.os.Build;
+import android.os.Bundle;
+import android.telecom.DisconnectCause;
+import android.telecom.PhoneAccount;
+import android.telecom.PhoneAccountHandle;
+import android.telecom.TelecomManager;
+import android.telecom.VideoProfile;
+import androidx.annotation.RequiresApi;
+
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.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.
+ *
+ * @author Pawel Domas
+ */
+@RequiresApi(api = Build.VERSION_CODES.O)
+@ReactModule(name = RNConnectionService.NAME)
+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
+     *
+     * @param audioRoute the new audio route to be set. See
+     * {@link android.telecom.CallAudioState} constants prefixed with "ROUTE_".
+     */
+    @RequiresApi(api = Build.VERSION_CODES.O)
+    static void setAudioRoute(int audioRoute) {
+        for (ConnectionService.ConnectionImpl c
+                : ConnectionService.getConnections()) {
+            c.setAudioRoute(audioRoute);
+        }
+    }
+
+    RNConnectionService(ReactApplicationContext reactContext) {
+        super(reactContext);
+    }
+
+    /**
+     * Starts a new outgoing call.
+     *
+     * @param callUUID - unique call identifier assigned by Jitsi Meet to
+     *        a conference call.
+     * @param handle - a call handle which by default is Jitsi Meet room's URL.
+     * @param hasVideo - whether or not user starts with the video turned on.
+     * @param promise - the Promise instance passed by the React-native bridge,
+     *        so that this method returns a Promise on the JS side.
+     *
+     * NOTE regarding the "missingPermission" suppress - SecurityException will
+     * be handled as part of the Exception try catch block and the Promise will
+     * be rejected.
+     */
+    @SuppressLint("MissingPermission")
+    @ReactMethod
+    public void startCall(
+            String callUUID,
+            String handle,
+            boolean hasVideo,
+            Promise promise) {
+        JitsiMeetLogger.d("%s startCall UUID=%s, h=%s, v=%s",
+                            TAG,
+                            callUUID,
+                            handle,
+                            hasVideo);
+
+        ReactApplicationContext ctx = getReactApplicationContext();
+
+        Uri address = Uri.fromParts(PhoneAccount.SCHEME_SIP, handle, null);
+        PhoneAccountHandle accountHandle
+            = ConnectionService.registerPhoneAccount(
+                    getReactApplicationContext(), address, callUUID);
+
+        Bundle extras = new Bundle();
+        extras.putParcelable(
+                TelecomManager.EXTRA_PHONE_ACCOUNT_HANDLE,
+                accountHandle);
+        extras.putInt(
+            TelecomManager.EXTRA_START_CALL_WITH_VIDEO_STATE,
+            hasVideo
+                ? VideoProfile.STATE_BIDIRECTIONAL
+                : VideoProfile.STATE_AUDIO_ONLY);
+
+        ConnectionService.registerStartCallPromise(callUUID, promise);
+
+        try {
+            TelecomManager tm
+                = (TelecomManager) ctx.getSystemService(
+                        Context.TELECOM_SERVICE);
+
+            tm.placeCall(address, extras);
+        } catch (Exception e) {
+            ConnectionService.unregisterStartCallPromise(callUUID);
+            promise.reject(e);
+        }
+    }
+
+    /**
+     * Called by the JS side of things to mark the call as failed.
+     *
+     * @param callUUID - the call's UUID.
+     */
+    @ReactMethod
+    public void reportCallFailed(String callUUID) {
+        JitsiMeetLogger.d(TAG + " reportCallFailed " + callUUID);
+        ConnectionService.setConnectionDisconnected(
+                callUUID,
+                new DisconnectCause(DisconnectCause.ERROR));
+    }
+
+    /**
+     * Called by the JS side of things to mark the call as disconnected.
+     *
+     * @param callUUID - the call's UUID.
+     */
+    @ReactMethod
+    public void endCall(String callUUID) {
+        JitsiMeetLogger.d(TAG + " endCall " + callUUID);
+        ConnectionService.setConnectionDisconnected(
+                callUUID,
+                new DisconnectCause(DisconnectCause.LOCAL));
+    }
+
+    /**
+     * Called by the JS side of things to mark the call as active.
+     *
+     * @param callUUID - the call's UUID.
+     */
+    @ReactMethod
+    public void reportConnectedOutgoingCall(String callUUID, Promise promise) {
+        JitsiMeetLogger.d(TAG + " reportConnectedOutgoingCall " + callUUID);
+        ConnectionService.setConnectionActive(callUUID);
+        promise.resolve(null);
+    }
+
+    @Override
+    public String getName() {
+        return NAME;
+    }
+
+    /**
+     * Called by the JS side to update the call's state.
+     *
+     * @param callUUID - the call's UUID.
+     * @param callState - the map which carries infor about the current call's
+     * state. See static fields in {@link ConnectionService.ConnectionImpl}
+     * prefixed with "KEY_" for the values supported by the Android
+     * implementation.
+     */
+    @ReactMethod
+    public void updateCall(String callUUID, ReadableMap callState) {
+        ConnectionService.updateCall(callUUID, callState);
+    }
+
+    public CallAudioStateListener getCallAudioStateListener() {
+        return callAudioStateListener;
+    }
+
+    public void setCallAudioStateListener(CallAudioStateListener callAudioStateListener) {
+        this.callAudioStateListener = callAudioStateListener;
+    }
+
+    /**
+     * Handler for call state changes. {@code ConnectionServiceImpl} will call this handler when the
+     * call audio state changes.
+     *
+     * @param callAudioState The current call's audio state.
+     */
+    void onCallAudioStateChange(android.telecom.CallAudioState callAudioState) {
+        if (callAudioStateListener != null) {
+            callAudioStateListener.onCallAudioStateChange(callAudioState);
+        }
+    }
+
+    interface CallAudioStateListener {
+        void onCallAudioStateChange(android.telecom.CallAudioState callAudioState);
+    }
+}

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

@@ -1,43 +0,0 @@
-/*
- * Copyright @ 2017-present Atlassian Pty Ltd
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jitsi.meet.sdk;
-
-import android.support.annotation.Nullable;
-
-import com.facebook.react.bridge.ReactContext;
-import com.facebook.react.modules.core.DeviceEventManagerModule;
-
-public class ReactContextUtils {
-    public static boolean emitEvent(
-            ReactContext reactContext,
-            String eventName,
-            @Nullable Object data) {
-        if (reactContext == null) {
-            // XXX If no ReactContext is specified, emit through the
-            // ReactContext of ReactInstanceManager. ReactInstanceManager
-            // cooperates with ReactContextUtils i.e. ReactInstanceManager will
-            // not invoke ReactContextUtils without a ReactContext.
-            return ReactInstanceManagerHolder.emitEvent(eventName, data);
-        }
-
-        reactContext
-            .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
-            .emit(eventName, data);
-
-        return true;
-    }
-}

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

@@ -1,5 +1,6 @@
 /*
- * Copyright @ 2017-present Atlassian Pty Ltd
+ * Copyright @ 2019-present 8x8, Inc.
+ * Copyright @ 2017-2018 Atlassian Pty Ltd
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,37 +17,98 @@
 
 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;
 import com.facebook.react.bridge.NativeModule;
 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;
 import java.util.Arrays;
 import java.util.List;
 
 class ReactInstanceManagerHolder {
     /**
+     * FIXME (from linter): Do not place Android context classes in static
+     * fields (static reference to ReactInstanceManager which has field
+     * mApplicationContext pointing to Context); this is a memory leak (and
+     * also breaks Instant Run).
+     *
      * React Native bridge. The instance manager allows embedding applications
      * to create multiple root views off the same JavaScript bundle.
      */
     private static ReactInstanceManager reactInstanceManager;
 
-    private static List<NativeModule> createNativeModules(
-            ReactApplicationContext reactContext) {
-        return Arrays.<NativeModule>asList(
-            new AndroidSettingsModule(reactContext),
-            new AppInfoModule(reactContext),
-            new AudioModeModule(reactContext),
-            new ExternalAPIModule(reactContext),
-            new PictureInPictureModule(reactContext),
-            new ProximityModule(reactContext),
-            new WiFiStatsModule(reactContext),
-            new org.jitsi.meet.sdk.invite.InviteModule(reactContext),
-            new org.jitsi.meet.sdk.net.NAT64AddrInfoModule(reactContext)
+    private static List<NativeModule> createNativeModules(ReactApplicationContext reactContext) {
+        List<NativeModule> nativeModules
+            = new ArrayList<>(Arrays.<NativeModule>asList(
+                new AndroidSettingsModule(reactContext),
+                new AppInfoModule(reactContext),
+                new AudioModeModule(reactContext),
+                new DropboxModule(reactContext),
+                new ExternalAPIModule(reactContext),
+                new JavaScriptSandboxModule(reactContext),
+                new LocaleDetector(reactContext),
+                new LogBridgeModule(reactContext),
+                new PictureInPictureModule(reactContext),
+                new ProximityModule(reactContext),
+                new WiFiStatsModule(reactContext),
+                new org.jitsi.meet.sdk.net.NAT64AddrInfoModule(reactContext)));
+
+        if (AudioModeModule.useConnectionService()) {
+            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);
+            nativeModules.add((NativeModule)constructor.newInstance(reactContext));
+        } catch (Exception e) {
+            // Ignore any error, the module is not compiled when LIBRE_BUILD is enabled.
+        }
+
+        return nativeModules;
+    }
+
+    private static List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
+        return Arrays.<ViewManager>asList(
+            // WebRTC, see createNativeModules for details.
+            new RTCVideoViewManager()
         );
     }
 
@@ -56,7 +118,7 @@ class ReactInstanceManagerHolder {
      * @param eventName {@code String} containing the event name.
      * @param data {@code Object} optional ancillary data for the event.
      */
-    public static boolean emitEvent(
+    static void emitEvent(
             String eventName,
             @Nullable Object data) {
         ReactInstanceManager reactInstanceManager
@@ -66,15 +128,12 @@ class ReactInstanceManagerHolder {
             ReactContext reactContext
                 = reactInstanceManager.getCurrentReactContext();
 
-            return
-                reactContext != null
-                    && ReactContextUtils.emitEvent(
-                        reactContext,
-                        eventName,
-                        data);
+            if (reactContext != null) {
+                reactContext
+                    .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+                    .emit(eventName, data);
+            }
         }
-
-        return false;
     }
 
     /**
@@ -97,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;
     }
@@ -107,40 +178,71 @@ 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.facebook.react.shell.MainReactPackage(),
+                new com.horcrux.svg.SvgPackage(),
+                new com.ocetnik.timer.BackgroundTimerPackage(),
+                new com.reactnativecommunity.asyncstorage.AsyncStoragePackage(),
+                new com.reactnativecommunity.netinfo.NetInfoPackage(),
+                new com.reactnativecommunity.webview.RNCWebViewPackage(),
+                new com.rnimmersive.RNImmersivePackage(),
+                new com.zmxv.RNSound.RNSoundPackage(),
+                new ReactPackageAdapter() {
+                    @Override
+                    public List<NativeModule> createNativeModules(ReactApplicationContext reactContext) {
+                        return ReactInstanceManagerHolder.createNativeModules(reactContext);
+                    }
+                    @Override
+                    public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
+                        return ReactInstanceManagerHolder.createViewManagers(reactContext);
+                    }
+                }));
+
+        try {
+            Class<?> googlePackageClass = Class.forName("co.apptailor.googlesignin.RNGoogleSigninPackage");
+            Constructor constructor = googlePackageClass.getConstructor();
+            packages.add((ReactPackage)constructor.newInstance());
+        } catch (Exception e) {
+            // Ignore any error, the module is not compiled when LIBRE_BUILD is enabled.
+        }
+
+        // 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")
-                .addPackage(new com.BV.LinearGradient.LinearGradientPackage())
-                .addPackage(new com.calendarevents.CalendarEventsPackage())
-                .addPackage(new com.corbt.keepawake.KCKeepAwakePackage())
-                .addPackage(new com.dylanvann.fastimage.FastImageViewPackage())
-                .addPackage(new com.facebook.react.shell.MainReactPackage())
-                .addPackage(new com.i18n.reactnativei18n.ReactNativeI18n())
-                .addPackage(new com.oblador.vectoricons.VectorIconsPackage())
-                .addPackage(new com.ocetnik.timer.BackgroundTimerPackage())
-                .addPackage(new com.oney.WebRTCModule.WebRTCModulePackage())
-                .addPackage(new com.rnimmersive.RNImmersivePackage())
-                .addPackage(new com.zmxv.RNSound.RNSoundPackage())
-                .addPackage(new ReactPackageAdapter() {
-                    @Override
-                    public List<NativeModule> createNativeModules(
-                            ReactApplicationContext reactContext) {
-                        return
-                            ReactInstanceManagerHolder.createNativeModules(
-                                reactContext);
-                    }
-                })
+                .setJavaScriptExecutorFactory(jsFactory)
+                .addPackages(packages)
                 .setUseDeveloperSupport(BuildConfig.DEBUG)
                 .setInitialLifecycleState(LifecycleState.RESUMED)
                 .build();
+
+        // Disable delta updates on Android, they have caused trouble.
+        DevInternalSettings devSettings
+            = (DevInternalSettings)reactInstanceManager.getDevSupportManager().getDevSettings();
+        if (devSettings != null) {
+            devSettings.setBundleDeltasEnabled(false);
+        }
+
+        // Register our uncaught exception handler.
+        JitsiMeetUncaughtExceptionHandler.register();
     }
 }