log: Fixes a log message

.flowconfig

@@ -2,36 +2,31 @@
 ; 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
-node_modules/react-native/Libraries/react-native/React.js
-
-; Flow doesn't support platforms
-.*/Libraries/Utilities/LoadingView.js
+.*/Libraries/react-native/React.js
 
 ; Ignore polyfills
-node_modules/react-native/Libraries/polyfills/.*
-
-; 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/.*/.*
+.*/Libraries/polyfills/.*
 
 ; 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.
-.*/node_modules/@atlaskit/.*/*.js.flow
+.*/node_modules/@atlassian
+.*/node_modules/bower/lib/node_modules/bower-json/test/.*
+.*/node_modules/immutable/dist/immutable.js.flow
+.*/node_modules/jsonlint/test/.*
+
+; FIXME Remove once we update past commit
+; https://github.com/facebook/react-native/commit/df8d0d1db9203cc87ad3682e6138b2a9ed714365
+.*/node_modules/react-native/local-cli/link/link.js
 .*/node_modules/react-native-keep-awake/.*
-.*/node_modules/react-native-permissions/.*
 .*/node_modules/styled-components/.*
 
 .*/\.git/.*
@@ -45,8 +40,28 @@ node_modules/react-native/flow/
 [options]
 emoji=true
 
-esproposal.optional_chaining=enable
-esproposal.nullish_coalescing=enable
+module.system=haste
+
+munge_underscores=true
+
+; FIXME Remove once we update past commit
+; https://github.com/facebook/react-native/commit/df8d0d1db9203cc87ad3682e6138b2a9ed714365
+module.name_mapper='^./link/link$' -> 'emptyObject'
+
+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_type=$FixMe
+
+suppress_comment=\\(.\\|\n\\)*\\$FlowFixMe\\($\\|[^(]\\|(\\(>=0\\.\\(5[0-7]\\|[1-4][0-9]\\|[0-9]\\).[0-9]\\)? *\\(site=[a-z,_]*react_native[a-z,_]*\\)?)\\)
+suppress_comment=\\(.\\|\n\\)*\\$FlowIssue\\((\\(>=0\\.\\(5[0-7]\\|[1-4][0-9]\\|[0-9]\\).[0-9]\\)? *\\(site=[a-z,_]*react_native[a-z,_]*\\)?)\\)?:? #[0-9]+
+suppress_comment=\\(.\\|\n\\)*\\$FlowFixedInNextDeploy
+suppress_comment=\\(.\\|\n\\)*\\$FlowExpectedError
+
+unsafe.enable_getters_and_setters=true
 
 ; 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
@@ -57,62 +72,8 @@ esproposal.nullish_coalescing=enable
 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.104.0
+^0.57.0

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

@@ -1,28 +0,0 @@
----
-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.
-
-## Description
----
-
-## Current behavior
----
-
-## Expected Behavior
----
-
-## Possible Solution
----
-
-## Steps to reproduce
----
-
-# Environment details
----

.github/ISSUE_TEMPLATE/2-help.md

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

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

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

@@ -1,16 +0,0 @@
-# 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,7 +35,6 @@ xcuserdata
 DerivedData
 *.hmap
 *.ipa
-*.dSYM.zip
 *.xcuserstate
 project.xcworkspace
 
@@ -69,24 +68,3 @@ buck-out/
 */fastlane/report.xml
 */fastlane/Preview.html
 */fastlane/screenshots
-
-# 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,6 +0,0 @@
-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 [8x8](https://www.8x8.com/). To
+holder and principal creator is [Atlassian](https://www.atlassian.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
@@ -21,7 +21,7 @@ license agreement as either a [corporation](https://jitsi.org/ccla) or an
 in the agreement, unfortunately, we cannot accept your contribution.
 
 ## Creating Pull Requests
-- Make sure your code passes the linter rules beforehand. The linter is executed
+- Make sure your code passes the linter rules beforehand. The linter is exeuted
   automatically when committing code.
 - Perform **one** logical change per pull request.
 - Maintain a clean list of commits, squash them if necessary.

Makefile

@@ -2,8 +2,6 @@ BUILD_DIR = build
 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 = .
@@ -11,7 +9,6 @@ STYLES_BUNDLE = css/all.bundle.css
 STYLES_DESTINATION = css/all.css
 STYLES_MAIN = css/main.scss
 WEBPACK = ./node_modules/.bin/webpack
-WEBPACK_DEV_SERVER = ./node_modules/.bin/webpack-dev-server
 
 all: compile deploy clean
 
@@ -21,10 +18,9 @@ compile:
 clean:
 	rm -fr $(BUILD_DIR)
 
-deploy: deploy-init deploy-appbundle deploy-rnnoise-binary deploy-lib-jitsi-meet deploy-libflac deploy-css deploy-local
+deploy: deploy-init deploy-appbundle deploy-lib-jitsi-meet deploy-css deploy-local
 
 deploy-init:
-	rm -fr $(DEPLOY_DIR)
 	mkdir -p $(DEPLOY_DIR)
 
 deploy-appbundle:
@@ -35,8 +31,6 @@ deploy-appbundle:
 		$(BUILD_DIR)/do_external_connect.min.map \
 		$(BUILD_DIR)/external_api.min.js \
 		$(BUILD_DIR)/external_api.min.map \
-		$(BUILD_DIR)/flacEncodeWorker.min.js \
-		$(BUILD_DIR)/flacEncodeWorker.min.map \
 		$(BUILD_DIR)/device_selection_popup_bundle.min.js \
 		$(BUILD_DIR)/device_selection_popup_bundle.min.map \
 		$(BUILD_DIR)/dial_in_info_bundle.min.js \
@@ -44,12 +38,6 @@ 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:
@@ -60,17 +48,6 @@ deploy-lib-jitsi-meet:
 		$(LIBJITSIMEET_DIR)/modules/browser/capabilities.json \
 		$(DEPLOY_DIR)
 
-deploy-libflac:
-	cp \
-		$(LIBFLAC_DIR)/libflac4-1.3.2.min.js \
-		$(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) ; \
@@ -79,9 +56,6 @@ deploy-css:
 deploy-local:
 	([ ! -x deploy-local.sh ] || ./deploy-local.sh)
 
-dev: deploy-init deploy-css deploy-rnnoise-binary deploy-lib-jitsi-meet deploy-libflac
-	$(WEBPACK_DEV_SERVER)
-
 source-package:
 	mkdir -p source_package/jitsi-meet/css && \
 	cp -r *.js *.html connection_optimization favicon.ico fonts images libs static sounds LICENSE lang source_package/jitsi-meet && \

README.md

@@ -1,24 +1,21 @@
 # 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. Jitsi Meet in action can be seen at [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. You can see Jitsi Meet in action [here at the session #482 of the VoIP Users Conference](http://youtu.be/7vFUVClsNh0).
 
-The Jitsi Meet client runs in your browser, without installing anything on your computer. You can try it out at https://meet.jit.si .
+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 .
 
-Jitsi Meet allows very efficient collaboration. Users can stream their desktop or only some windows. It also supports shared document editing with Etherpad.
+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.
 
 ## 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 a 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 the Jitsi Meet suite on your server and hosting your own conferencing service.
 
-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).
+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.
 
 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).
 
 ## Download
 
-| Latest stable release | [![release](https://img.shields.io/badge/release-latest-green.svg)](https://github.com/jitsi/jitsi-meet/releases/latest) |
-|---|---|
-
 You can download Debian/Ubuntu binaries:
 * [stable](https://download.jitsi.org/stable/) ([instructions](https://jitsi.org/downloads/ubuntu-debian-installations-instructions/))
 * [testing](https://download.jitsi.org/testing/) ([instructions](https://jitsi.org/downloads/ubuntu-debian-installations-instructions-for-testing/))
@@ -31,9 +28,81 @@ 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)
 
-## Development
+## Building the sources
 
-For web development see [here](doc/development.md), and for mobile see [here](doc/mobile.md).
+Node.js >= 6 is required.
+
+On Debian/Ubuntu systems, the required packages can be installed with:
+```
+sudo apt-get install npm nodejs-legacy
+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
+```
+node_modules/.bin/webpack-dev-server
+```
+
+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, type 
+```
+WEBPACK_DEV_SERVER_PROXY_TARGET=https://your-example-server.com node_modules/.bin/webpack-dev-server
+```
+
+The app should be running at https://localhost:8080/
 
 ## Contributing
 
@@ -42,30 +111,27 @@ see our [guidelines for contributing](CONTRIBUTING.md).
 
 ## Embedding in external applications
 
-Jitsi Meet provides a very flexible way of embedding in external applications by using the [Jitsi Meet API](doc/api.md).
+Jitsi Meet provides a very flexible way of embedding it in external applications by using the [Jitsi Meet API](doc/api.md).
 
 ## Security
-
-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.
+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.
 
 The Jitsi Meet architecture allows you to deploy your own version, including
-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
+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 
 Jitsi Meet in terms of security.
 
 The [meet.jit.si](https://meet.jit.si) service is maintained by the Jitsi team
-at [8x8](https://8x8.com).
+at [Atlassian](https://atlassian.com).
 
-## 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.**
+## 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).
 
 ## Acknowledgements
 
-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!
+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!

analytics-ga.js

@@ -20,7 +20,7 @@
         (function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
             (i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
         })(window,document,'script','//www.google-analytics.com/analytics.js','ga');
-        ga('create', options.googleAnalyticsTrackingId, 'auto');
+        ga('create', options.googleAnalyticsTrackingId, 'jit.si');
         ga('send', 'pageview');
 
         /* eslint-enable */
@@ -126,15 +126,6 @@
             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,107 +1,53 @@
 # Jitsi Meet SDK for Android
 
-## Sample applications using the SDK
+## Build
 
-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).
+1. Install all required [dependencies](https://github.com/jitsi/jitsi-meet/blob/master/doc/mobile.md).
 
-## Build your own, or use a pre-build SDK artifacts/binaries
+2. ```bash
+   cd android/
+   ./gradlew :sdk:assembleRelease
+   ```
 
-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.
+3. Configure the Maven repositories in which you are going to publish the
+   artifacts/binaries during step 4. Modify
+   `"file:${rootProject.projectDir}/../../../jitsi/jitsi-maven-repository/releases"`
+   in adroid/sdk/build.gradle for Jitsi Meet SDK for Android and/or
+   `"file:${rootProject.projectDir}/../../../jitsi/jitsi-maven-repository/releases"`
+   in android/build.gradle for the third-party react-native modules which Jitsi
+   Meet SDK for Android depends on and are not publicly available in Maven
+   repositories. Generally, if you are modifying the JavaScript code of Jitsi
+   Meet SDK for Android only, you will very likely need to consider the former
+   only.
 
-### Use pre-build SDK artifacts/binaries
+4. Publish the Maven artifact/binary of Jitsi Meet SDK for Android in the Maven
+   repository configured in step 3:
 
-In your project, add the Maven repository
+   ```bash
+   ./gradlew :sdk:publish
+   cd ../
+   ```
+
+   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, replace `sdk` with the name of the react-native module. For
+   example, to publish react-native-webrtc:
+
+   ```bash
+   ./gradlew :react-native-webrtc:publish
+   ```
+
+## Install
+
+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.
+dependency `org.jitsi.react:jitsi-meet-sdk:1.9.0` into your `build.gradle`.
 
-The repository typically goes into the `build.gradle` file in the root of your project:
-
-```gradle
-allprojects {
-    repositories {
-        google()
-        jcenter()
-        maven {
-            url "https://github.com/jitsi/jitsi-maven-repository/raw/master/releases"
-        }
-    }
-}
-```
-
-Dependency definitions belong in the individual module `build.gradle` files:
-
-```gradle
-dependencies {
-    // (other dependencies)
-    implementation ('org.jitsi.react:jitsi-meet-sdk:2.+') { transitive = true }
-}
-```
-
-### Build and use your own SDK artifacts/binaries
-
-<details>
-<summary>Show building instructions</summary>
-
-Start by making sure that your development environment [is set up correctly](https://github.com/jitsi/jitsi-meet/blob/master/doc/mobile.md).
-
-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.
-
-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 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:
-
-    npm install
-
-This will pull in the dependencies in either binary format, or in source code format, somewhere under /node_modules/
-
-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:
-
-    ./android/scripts/release-sdk.sh /tmp/repo
-
-This will build and publish the SDK, and all of its dependencies to the specified Maven repository (`/tmp/repo`) in
-this example.
-
-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:
-
-    allprojects {
-        repositories {
-            maven { url "file:/tmp/repo" }
-            google()
-            jcenter()
-        }
-    }
-
-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!
-
-Then, define the dependency `org.jitsi.react:jitsi-meet-sdk` into the `build.gradle` file of your module:
-
-    implementation ('org.jitsi.react:jitsi-meet-sdk:+') { transitive = true }
-
-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
+## API
 
 Jitsi Meet SDK is an Android library which embodies the whole Jitsi Meet
 experience and makes it reusable by third-party apps.
 
-First, add Java 1.8 compatibility support to your project by adding the
-following lines into your `build.gradle` file:
-
-```
-compileOptions {
-    sourceCompatibility JavaVersion.VERSION_1_8
-    targetCompatibility JavaVersion.VERSION_1_8
-}
-```
-
 To get started, extends your `android.app.Activity` from
 `org.jitsi.meet.sdk.JitsiMeetActivity`:
 
@@ -115,42 +61,25 @@ public class MainActivity extends JitsiMeetActivity {
 ```
 
 Alternatively, you can use the `org.jitsi.meet.sdk.JitsiMeetView` class which
-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>
+extends `android.view.View`:
 
 ```java
 package org.jitsi.example;
 
 import android.os.Bundle;
-import android.support.v4.app.FragmentActivity;
+import android.support.v7.app.AppCompatActivity;
 
 import org.jitsi.meet.sdk.JitsiMeetView;
-import org.jitsi.meet.sdk.ReactActivityLifecycleCallbacks;
 
-// Example
-//
-public class MainActivity extends FragmentActivity implements JitsiMeetActivityInterface {
+public class MainActivity extends AppCompatActivity {
     private JitsiMeetView view;
 
-    @Override
-    protected void onActivityResult(
-            int requestCode,
-            int resultCode,
-            Intent data) {
-        JitsiMeetActivityDelegate.onActivityResult(
-                this, requestCode, resultCode, data);
-    }
-
     @Override
     public void onBackPressed() {
-        JitsiMeetActivityDelegate.onBackPressed();
+        if (!JitsiMeetView.onBackPressed()) {
+            // Invoke the default handler if it wasn't handled by React.
+            super.onBackPressed();
+        }
     }
 
     @Override
@@ -158,10 +87,7 @@ public class MainActivity extends FragmentActivity implements JitsiMeetActivityI
         super.onCreate(savedInstanceState);
 
         view = new JitsiMeetView(this);
-        JitsiMeetConferenceOptions options = new JitsiMeetConferenceOptions.Builder()
-            .setRoom("https://meet.jit.si/test123")
-            .build();
-        view.join(options);
+        view.loadURL(null);
 
         setContentView(view);
     }
@@ -173,109 +99,155 @@ public class MainActivity extends FragmentActivity implements JitsiMeetActivityI
         view.dispose();
         view = null;
 
-        JitsiMeetActivityDelegate.onHostDestroy(this);
+        JitsiMeetView.onHostDestroy(this);
     }
 
     @Override
     public void onNewIntent(Intent intent) {
-        JitsiMeetActivityDelegate.onNewIntent(intent);
-    }
-
-    @Override
-    public void onRequestPermissionsResult(
-            final int requestCode,
-            final String[] permissions,
-            final int[] grantResults) {
-        JitsiMeetActivityDelegate.onRequestPermissionsResult(requestCode, permissions, grantResults);
+        JitsiMeetView.onNewIntent(intent);
     }
 
     @Override
     protected void onResume() {
         super.onResume();
 
-        JitsiMeetActivityDelegate.onHostResume(this);
+        JitsiMeetView.onHostResume(this);
     }
 
     @Override
     protected void onStop() {
         super.onStop();
 
-        JitsiMeetActivityDelegate.onHostPause(this);
+        JitsiMeetView.onHostPause(this);
     }
 }
 ```
 
-</details>
-
 ### JitsiMeetActivity
 
-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.
+This class encapsulates a high level API in the form of an Android `Activity`
+which displays a single `JitsiMeetView`.
+
+#### getDefaultURL()
+
+See JitsiMeetView.getDefaultURL.
+
+#### getPictureInPictureEnabled()
+
+See JitsiMeetView.getPictureInPictureEnabled.
+
+#### getWelcomePageEnabled()
+
+See JitsiMeetView.getWelcomePageEnabled.
+
+#### loadURL(URL)
+
+See JitsiMeetView.loadURL.
+
+#### setDefaultURL(URL)
+
+See JitsiMeetView.setDefaultURL.
+
+#### setPictureInPictureEnabled(boolean)
+
+See JitsiMeetView.setPictureInPictureEnabled.
+
+#### setWelcomePageEnabled(boolean)
+
+See JitsiMeetView.setWelcomePageEnabled.
 
 ### 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.
 
+#### getPictureInPictureEnabled()
+
+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.
+
+#### getWelcomePageEnabled()
+
+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.
 
-### JitsiMeetConferenceOptions
+#### setPictureInPictureEnabled(boolean)
 
-This object encapsulates all the options that can be tweaked when joining
-a conference.
+Sets whether Picture-in-Picture is enabled. If not set, Jitsi Meet SDK
+automatically enables/disables Picture-in-Picture based on native platform
+support.
 
-Example:
+NOTE: Must be called (if at all) before `loadURL`/`loadURLString` for it to take
+effect.
 
-```java
-JitsiMeetConferenceOptions options = new JitsiMeetConferenceOptions.Builder()
-    .setServerURL(new URL("https://meet.jit.si"))
-    .setRoom("test123")
-    .setAudioMuted(false)
-    .setVideoMuted(false)
-    .setAudioOnly(false)
-    .setWelcomePageEnabled(false)
-    .build();
-```
+#### setWelcomePageEnabled(boolean)
 
-See the `JitsiMeetConferenceOptions` implementation for all available options.
+Sets whether the Welcome page is enabled. See `getWelcomePageEnabled` for more
+information.
 
-### 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.
+NOTE: Must be called (if at all) before `loadURL`/`loadURLString` for it to take
+effect.
 
 #### onBackPressed()
 
@@ -284,29 +256,34 @@ 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.
 
-#### onHostDestroy(...)
+This is a static method.
+
+#### onHostDestroy(activity)
 
 Helper method which should be called from the activity's `onDestroy` method.
 
-#### onHostResume(...)
+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)
 
 Helper method which should be called from the activity's `onResume` or `onStop`
 method.
 
-#### onHostStop(...)
+This is a static method.
 
-Helper method which should be called from the activity's `onSstop` method.
-
-#### onNewIntent(...)
+#### onNewIntent(intent)
 
 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.
 
-#### onRequestPermissionsResult(...)
-
-Helper method to handle permission requests inside the SDK. It should be called
-from the activity method of the same name.
+This is a static method.
 
 #### onUserLeaveHint()
 
@@ -320,20 +297,31 @@ 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.
 
-#### onConferenceTerminated
+#### onConferenceLeft
 
-Called when a conference was terminated either by user choice or due to a
-failure.
+Called when a conference was left.
 
-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.
+The `data` `Map` contains a "url" key with the conference URL.
 
 #### onConferenceWillJoin
 
@@ -341,11 +329,85 @@ 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: https://github.com/jitsi/jitsi-meet/blob/master/android/app/proguard-rules.pro
+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.** { *; }
+```
 
 ## Picture-in-Picture
 
@@ -353,28 +415,6 @@ rules file: https://github.com/jitsi/jitsi-meet/blob/master/android/app/proguard
 Picture-in-Picture style scenario, in a rectangle too small to accommodate its
 "full" UI.
 
-## 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>
-```
+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.

android/app/.classpath

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

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

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

android/app/build.gradle

@@ -1,169 +1,40 @@
 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 vcode
-        versionName project.appVersion
+        versionCode Integer.parseInt("${version}")
+        versionName "1.9.${version}"
 
         minSdkVersion rootProject.ext.minSdkVersion
         targetSdkVersion rootProject.ext.targetSdkVersion
 
         ndk {
-            abiFilters 'armeabi-v7a', 'arm64-v8a', 'x86', 'x86_64'
+            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/**'
         }
     }
-
     buildTypes {
-        debug {
-            buildConfigField "boolean", "GOOGLE_SERVICES_ENABLED", "${googleServicesEnabled}"
-            buildConfigField "boolean", "LIBRE_BUILD", "${rootProject.ext.libreBuild}"
-        }
         release {
-            minifyEnabled true
-            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules-release.pro'
-            buildConfigField "boolean", "GOOGLE_SERVICES_ENABLED", "${googleServicesEnabled}"
-            buildConfigField "boolean", "LIBRE_BUILD", "${rootProject.ext.libreBuild}"
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
         }
     }
-
-    sourceSets {
-        main {
-            java {
-                if (rootProject.ext.libreBuild) {
-                    srcDir "src"
-                    exclude "**/GoogleServicesHelper.java"
-                }
-            }
-        }
-    }
-
-    compileOptions {
-        sourceCompatibility JavaVersion.VERSION_1_8
-        targetCompatibility JavaVersion.VERSION_1_8
-    }
-}
-
-repositories {
-    maven { url 'https://maven.fabric.io/public' }
 }
 
 dependencies {
-    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'
-    }
+    compile fileTree(dir: 'libs', include: ['*.jar'])
 
     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

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

android/app/proguard-rules.pro

@@ -9,6 +9,17 @@
 
 # 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.
@@ -38,7 +49,10 @@
 -keepclassmembers class *  { @com.facebook.react.uimanager.annotations.ReactPropGroup <methods>; }
 
 -dontwarn com.facebook.react.**
--keep,includedescriptorclasses class com.facebook.react.bridge.** { *; }
+
+# 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
 
@@ -53,36 +67,4 @@
 -keep class sun.misc.Unsafe { *; }
 -dontwarn java.nio.file.*
 -dontwarn org.codehaus.mojo.animal_sniffer.IgnoreJRERequirement
--keep class okio.** { *; }
 -dontwarn okio.**
-
-# WebRTC
-
--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,8 +5,6 @@
       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"
@@ -16,7 +14,6 @@
         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" />
@@ -25,8 +22,11 @@
         <action android:name="android.intent.action.VIEW" />
         <category android:name="android.intent.category.BROWSABLE" />
         <category android:name="android.intent.category.DEFAULT" />
-        <data android:host="alpha.jitsi.net" android:scheme="https" />
+        <data android:host="beta.hipchat.me" 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

@@ -1,40 +0,0 @@
-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,6 +1,5 @@
 /*
- * Copyright @ 2018-present 8x8, Inc.
- * Copyright @ 2017-2018 Atlassian Pty Ltd
+ * 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.
@@ -17,134 +16,99 @@
 
 package org.jitsi.meet;
 
-import android.content.Intent;
-import android.net.Uri;
-import android.os.Build;
-import android.provider.Settings;
+import android.os.Bundle;
 import android.util.Log;
-import android.view.KeyEvent;
-import androidx.annotation.Nullable;
 
-import org.jitsi.meet.sdk.JitsiMeet;
 import org.jitsi.meet.sdk.JitsiMeetActivity;
-import org.jitsi.meet.sdk.JitsiMeetConferenceOptions;
+import org.jitsi.meet.sdk.JitsiMeetView;
+import org.jitsi.meet.sdk.JitsiMeetViewListener;
+
+import com.calendarevents.CalendarEventsPackage;
 
-import java.lang.reflect.Method;
-import java.net.MalformedURLException;
-import java.net.URL;
 import java.util.Map;
 
 /**
- * The one and only Activity that the Jitsi Meet app needs. The
+ * The one and only {@link 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 MainActivity#onNewIntent(Intent)} being called.
+ * 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}.
  */
 public class MainActivity extends JitsiMeetActivity {
-    /**
-     * 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);
-
-    // JitsiMeetActivity overrides
-    //
-
     @Override
-    protected boolean extraInitialize() {
-        Log.d(this.getClass().getSimpleName(), "LIBRE_BUILD="+BuildConfig.LIBRE_BUILD);
+    protected JitsiMeetView initializeView() {
+        JitsiMeetView view = super.initializeView();
 
-        // 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.
+        // 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) {
+                    // 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);
+                }
+            });
         }
 
-        // 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;
+        return view;
     }
 
     @Override
-    protected void initialize() {
-        // Set default options
-        JitsiMeetConferenceOptions defaultOptions
-            = new JitsiMeetConferenceOptions.Builder()
-                .setWelcomePageEnabled(true)
-                .setServerURL(buildURL("https://meet.jit.si"))
-                .build();
-        JitsiMeet.setDefaultConferenceOptions(defaultOptions);
+    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.
 
-        super.initialize();
+        // 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);
     }
 
     @Override
-    public void onConferenceTerminated(Map<String, Object> data) {
-        Log.d(TAG, "Conference terminated: " + data);
-    }
-
-    // Activity lifecycle method overrides
-    //
-
-    @Override
-    public void onActivityResult(int requestCode, int resultCode, Intent data) {
-        if (requestCode == OVERLAY_PERMISSION_REQUEST_CODE
-                && canRequestOverlayPermission()) {
-            if (Settings.canDrawOverlays(this)) {
-                initialize();
-                return;
-            }
-
-            throw new RuntimeException("Overlay permission is required when running in Debug mode.");
-        }
-
-        super.onActivityResult(requestCode, resultCode, data);
-    }
-
-    // ReactAndroid/src/main/java/com/facebook/react/ReactActivity.java
-    @Override
-    public boolean onKeyUp(int keyCode, KeyEvent event) {
-        if (BuildConfig.DEBUG && keyCode == KeyEvent.KEYCODE_MENU) {
-            JitsiMeet.showDevOptions();
-            return true;
-        }
-
-        return super.onKeyUp(keyCode, event);
-    }
-
-    // Helper methods
-    //
-
-    private @Nullable URL buildURL(String urlStr) {
-        try {
-            return new URL(urlStr);
-        } catch (MalformedURLException e) {
-            return null;
-        }
-    }
-
-    private boolean canRequestOverlayPermission() {
-        return
-            Build.VERSION.SDK_INT >= Build.VERSION_CODES.M
-                && getApplicationInfo().targetSdkVersion >= Build.VERSION_CODES.M;
-    }
+  public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
+      CalendarEventsPackage.onRequestPermissionsResult(requestCode, permissions, grantResults);
+      super.onRequestPermissionsResult(requestCode, permissions, grantResults);
+  }
 }

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

@@ -1,36 +0,0 @@
-/*
- * Copyright @ 2018-present Atlassian Pty Ltd
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jitsi.meet;
-
-import android.app.Application;
-
-import com.squareup.leakcanary.LeakCanary;
-
-/**
- * Simple {@link Application} for hooking up LeakCanary:
- * https://github.com/square/leakcanary
- */
-public class MainApplication extends Application {
-    @Override
-    public void onCreate() {
-        super.onCreate();
-
-        if (!LeakCanary.isInAnalyzerProcess(this)) {
-            LeakCanary.install(this);
-        }
-    }
-}

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

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

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

@@ -1,4 +0,0 @@
-<?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,6 +2,5 @@
     <!-- 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

@@ -1,6 +0,0 @@
-<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,5 +1,3 @@
-import groovy.json.JsonSlurper
-
 // Top-level build file where you can add configuration options common to all
 // sub-projects/modules.
 
@@ -7,14 +5,9 @@ buildscript {
     repositories {
         google()
         jcenter()
-        repositories {
-            maven { url 'https://maven.fabric.io/public' }
-        }
     }
     dependencies {
-        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'
+        classpath 'com.android.tools.build:gradle:3.0.1'
 
         // NOTE: Do not place your application dependencies here; they belong
         // in the individual module build.gradle files.
@@ -25,25 +18,9 @@ allprojects {
     repositories {
         google()
         jcenter()
-        // React Native (JS, Obj-C sources, Android binaries) is installed from npm.
+        // React Native (JS, Obj-C sources, Android binaries) is installed from
+        // npm.
         maven { url "$rootDir/../node_modules/react-native/android" }
-        // Android JSC is installed from npm.
-        maven { url("$rootDir/../node_modules/jsc-android/dist") }
-    }
-
-    // Make sure we use the react-native version in node_modules and not the one
-    // published in jcenter / elsewhere.
-    configurations.all {
-        resolutionStrategy {
-            eachDependency { DependencyResolveDetails details ->
-                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 JsonSlurper().parseText(file.text).version
-                    details.useVersion version
-                }
-            }
-        }
     }
 
     // Third-party react-native modules which Jitsi Meet SDK for Android depends
@@ -56,41 +33,48 @@ allprojects {
         publishing {
             publications {}
             repositories {
-                maven {
-                    url rootProject.ext.mavenRepo
-                    if (!rootProject.ext.mavenRepo.startsWith("file")) {
-                        credentials {
-                            username rootProject.ext.mavenUser
-                            password rootProject.ext.mavenPassword
-                        }
-                    }
-                }
+                maven { url "file:${rootProject.projectDir}/../../../jitsi/jitsi-maven-repository/releases" }
             }
         }
     }
 
-    // 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.plugins.hasPlugin('android') || project.plugins.hasPlugin('android-library')) {
-            project.android {
-                compileSdkVersion rootProject.ext.compileSdkVersion
-                buildToolsVersion rootProject.ext.buildToolsVersion
-            }
-        }
-
         if (project.name.startsWith('react-native-')) {
             def npmManifest = project.file('../package.json')
-            def json = new JsonSlurper().parseText(npmManifest.text)
+            def json = new groovy.json.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.
+            // 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}-jitsi-${versionQualifierNumber}"
+            project.version = "${json.version}${versionQualifier}"
 
+            project.android {
+                compileSdkVersion rootProject.ext.compileSdkVersion
+                if (rootProject.ext.has('buildToolsVersion')) {
+                    buildToolsVersion rootProject.ext.buildToolsVersion
+                }
+                defaultConfig {
+                    minSdkVersion rootProject.ext.minSdkVersion
+                    targetSdkVersion rootProject.ext.targetSdkVersion
+                }
+            }
+
+            task 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
@@ -106,6 +90,7 @@ allprojects {
                         extension "aar"
                     }
                     artifact(androidSourcesJar)
+                    artifact(androidJavadocsJar)
                     pom.withXml {
                         def pomXml = asNode()
                         pomXml.appendNode('name', project.name)
@@ -126,7 +111,7 @@ allprojects {
                             // (third-party) React Native modules we utilize can
                             // depend not on a specific react-native release but
                             // a wider range.
-                            if (artifactId == 'react-native') {
+                            if (artifactId.equals('react-native')) {
                                 def versionNumber = VersionNumber.parse(version)
                                 version = "${versionNumber.major}.${versionNumber.minor}"
                             }
@@ -144,69 +129,16 @@ allprojects {
 }
 
 ext {
-    buildToolsVersion = "28.0.3"
-    compileSdkVersion = 28
-    minSdkVersion    = 21
-    targetSdkVersion = 28
-    supportLibVersion = "28.0.0"
+    buildToolsVersion = "26.0.2"
+    compileSdkVersion = 26
+    minSdkVersion    = 16
+    targetSdkVersion = 26
 
     // 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

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

android/fastlane/Fastfile

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

@@ -1,29 +0,0 @@
-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,8 +17,5 @@
 # http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects
 # org.gradle.parallel=true
 
-android.useAndroidX=true
-android.enableJetifier=true
-
-appVersion=19.4.0
-sdkVersion=2.4.0
+android.useDeprecatedNdk=true
+version=1

android/gradle/wrapper/gradle-wrapper.properties

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

android/gradlew

@@ -1,4 +1,4 @@
-#!/usr/bin/env sh
+#!/usr/bin/env bash
 
 ##############################################################################
 ##
@@ -6,6 +6,47 @@
 ##
 ##############################################################################
 
+# 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"
@@ -20,49 +61,9 @@ while [ -h "$PRG" ] ; do
     fi
 done
 SAVED="`pwd`"
-cd "`dirname \"$PRG\"`/" >/dev/null
+cd "`dirname \"$PRG\"`/" >&-
 APP_HOME="`pwd -P`"
-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
+cd "$SAVED" >&-
 
 CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
 
@@ -89,7 +90,7 @@ location of your Java installation."
 fi
 
 # Increase the maximum file descriptors if we can.
-if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
+if [ "$cygwin" = "false" -a "$darwin" = "false" ] ; then
     MAX_FD_LIMIT=`ulimit -H -n`
     if [ $? -eq 0 ] ; then
         if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
@@ -113,7 +114,6 @@ 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,19 +154,11 @@ if $cygwin ; then
     esac
 fi
 
-# Escape application args
-save () {
-    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
-    echo " "
+# Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules
+function splitJvmOpts() {
+    JVM_OPTS=("$@")
 }
-APP_ARGS=$(save "$@")
+eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS
+JVM_OPTS[${#JVM_OPTS[*]}]="-Dorg.gradle.appname=$APP_BASE_NAME"
 
-# 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" "$@"
+exec "$JAVACMD" "${JVM_OPTS[@]}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@"

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,9 +46,10 @@ echo location of your Java installation.
 goto fail
 
 :init
-@rem Get command-line arguments, handling Windows variants
+@rem Get command-line arguments, handling Windowz 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.
@@ -59,6 +60,11 @@ 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

@@ -1,107 +0,0 @@
-#!/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)
-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

@@ -1,26 +0,0 @@
-#!/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

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

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

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

android/sdk/build.gradle

@@ -10,182 +10,123 @@ android {
     }
 
     buildTypes {
-        debug {
-            buildConfigField "boolean", "LIBRE_BUILD", "${rootProject.ext.libreBuild}"
-        }
+        debug {}
         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 {
-    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    compile fileTree(dir: 'libs', include: ['*.jar'])
 
-    implementation 'androidx.legacy:legacy-support-v4:1.0.0'
-    implementation 'androidx.appcompat:appcompat:1.0.2'
-    implementation 'androidx.fragment:fragment:1.0.0'
+    compile 'com.android.support:appcompat-v7:27.0.2'
+    compile 'com.facebook.react:react-native:+'
 
-    api 'com.facebook.react:react-native:+'
-    implementation 'org.webkit:android-jsc:+'
-
-    implementation 'com.dropbox.core:dropbox-core-sdk:3.0.8'
-    implementation 'com.jakewharton.timber:timber:4.7.1'
-    implementation 'com.squareup.duktape:duktape-android:1.3.0'
-
-    if (!rootProject.ext.libreBuild) {
-        implementation 'com.amplitude:android-sdk:2.14.1'
-        implementation(project(":react-native-google-signin")) {
-            exclude group: 'com.google.android.gms'
-            exclude group: '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'
+    compile project(':react-native-background-timer')
+    compile project(':react-native-fetch-blob')
+    compile project(':react-native-immersive')
+    compile project(':react-native-keep-awake')
+    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')
 }
 
+// Build process helpers
+//
 
-// 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)
-            }
-        }
+void runBefore(String dependentTaskName, Task task) {
+    Task dependentTask = tasks.findByPath(dependentTaskName);
+    if (dependentTask != null) {
+        dependentTask.dependsOn task
     }
 }
 
+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)
+
+        // 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 System.env.OVERRIDE_SDK_VERSION ?: project.sdkVersion
+            version '1.9.0'
 
             artifact("${project.buildDir}/outputs/aar/${project.name}-release.aar") {
                 extension "aar"
@@ -204,7 +145,8 @@ 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
                     }
 
@@ -218,14 +160,6 @@ publishing {
 
     }
     repositories {
-        maven {
-            url rootProject.ext.mavenRepo
-            if (!rootProject.ext.mavenRepo.startsWith("file")) {
-                credentials {
-                    username rootProject.ext.mavenUser
-                    password rootProject.ext.mavenPassword
-                }
-            }
-        }
+        maven { url "file:${rootProject.projectDir}/../../../jitsi/jitsi-maven-repository/releases" }
     }
 }

android/sdk/proguard-rules.pro

@@ -0,0 +1,25 @@
+# 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,52 +1,30 @@
-<?xml version="1.0" encoding="utf-8"?>
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+<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.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"/>
+  <!-- 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" />
 
-    <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=".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>
+  <application
+      android:allowBackup="true"
+      android:label="@string/app_name"
+      android:supportsRtl="true">
+    <activity
+        android:name="com.facebook.react.devsupport.DevSettingsActivity" />
+  </application>
+</manifest>

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

@@ -1,102 +0,0 @@
-/*
- * 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,21 +15,15 @@ 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";
 
+class AndroidSettingsModule extends ReactContextBaseJavaModule {
     public AndroidSettingsModule(ReactApplicationContext reactContext) {
         super(reactContext);
     }
 
     @Override
     public String getName() {
-        return NAME;
+        return "AndroidSettings";
     }
 
     @ReactMethod

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

@@ -1,19 +1,3 @@
-/*
- * 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.content.Context;
@@ -23,17 +7,11 @@ 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";
-
+class AppInfoModule extends ReactContextBaseJavaModule {
     public AppInfoModule(ReactApplicationContext reactContext) {
         super(reactContext);
     }
@@ -64,9 +42,6 @@ class AppInfoModule
 
         Map<String, Object> constants = new HashMap<>();
 
-        constants.put(
-            "buildNumber",
-            packageInfo == null ? "" : String.valueOf(packageInfo.versionCode));
         constants.put(
             "name",
             applicationInfo == null
@@ -75,13 +50,12 @@ class AppInfoModule
         constants.put(
             "version",
             packageInfo == null ? "" : packageInfo.versionName);
-        constants.put("LIBRE_BUILD", BuildConfig.LIBRE_BUILD);
 
         return constants;
     }
 
     @Override
     public String getName() {
-        return NAME;
+        return "AppInfo";
     }
 }

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

@@ -25,7 +25,9 @@ import android.content.pm.PackageManager;
 import android.media.AudioDeviceInfo;
 import android.media.AudioManager;
 import android.os.Build;
-import androidx.annotation.RequiresApi;
+import android.os.Handler;
+import android.os.Looper;
+import android.util.Log;
 
 import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.Promise;
@@ -34,16 +36,11 @@ 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;
 import java.util.Map;
 import java.util.Set;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
 
 /**
  * Module implementing a simple API to select the appropriate audio device for a
@@ -60,12 +57,7 @@ import java.util.concurrent.Executors;
  * Before a call has started and after it has ended the
  * {@code AudioModeModule.DEFAULT} mode should be used.
  */
-@ReactModule(name = AudioModeModule.NAME)
-class AudioModeModule extends ReactContextBaseJavaModule
-    implements AudioManager.OnAudioFocusChangeListener {
-
-    public static final String NAME = "AudioMode";
-
+class AudioModeModule extends ReactContextBaseJavaModule {
     /**
      * Constants representing the audio mode.
      * - DEFAULT: Used before and after every call. It represents the default
@@ -80,8 +72,7 @@ class AudioModeModule extends ReactContextBaseJavaModule
     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)
@@ -89,84 +80,15 @@ class AudioModeModule extends ReactContextBaseJavaModule
             : Intent.ACTION_HEADSET_PLUG;
 
     /**
-     * Constant defining a USB headset. Only available on API level >= 26.
-     * The value of: AudioDeviceInfo.TYPE_USB_HEADSET
+     * The name of {@code AudioModeModule} to be used in the React Native
+     * bridge.
      */
-    private static final int TYPE_USB_HEADSET = 22;
+    private static final String MODULE_NAME = "AudioMode";
 
     /**
      * The {@code Log} tag {@code AudioModeModule} is to log messages with.
      */
-    static final String TAG = NAME;
-
-    /**
-     * Converts any of the "DEVICE_" constants into the corresponding
-     * {@link android.telecom.CallAudioState} "ROUTE_" number.
-     *
-     * @param audioDevice one of the "DEVICE_" constants.
-     * @return a route number {@link android.telecom.CallAudioState#ROUTE_EARPIECE} if
-     * no match is found.
-     */
-    @RequiresApi(api = Build.VERSION_CODES.M)
-    private static int audioDeviceToRouteInt(String audioDevice) {
-        if (audioDevice == null) {
-            return android.telecom.CallAudioState.ROUTE_EARPIECE;
-        }
-        switch (audioDevice) {
-            case DEVICE_BLUETOOTH:
-                return android.telecom.CallAudioState.ROUTE_BLUETOOTH;
-            case DEVICE_EARPIECE:
-                return android.telecom.CallAudioState.ROUTE_EARPIECE;
-            case DEVICE_HEADPHONES:
-                return android.telecom.CallAudioState.ROUTE_WIRED_HEADSET;
-            case DEVICE_SPEAKER:
-                return android.telecom.CallAudioState.ROUTE_SPEAKER;
-            default:
-                JitsiMeetLogger.e(TAG + " Unsupported device name: " + audioDevice);
-                return android.telecom.CallAudioState.ROUTE_EARPIECE;
-        }
-    }
-
-    /**
-     * Populates given route mask into the "DEVICE_" list.
-     *
-     * @param supportedRouteMask an integer coming from
-     * {@link android.telecom.CallAudioState#getSupportedRouteMask()}.
-     * @return a list of device names.
-     */
-    @RequiresApi(api = Build.VERSION_CODES.M)
-    private static Set<String> routesToDeviceNames(int supportedRouteMask) {
-        Set<String> devices = new HashSet<>();
-        if ((supportedRouteMask & android.telecom.CallAudioState.ROUTE_EARPIECE)
-                == android.telecom.CallAudioState.ROUTE_EARPIECE) {
-            devices.add(DEVICE_EARPIECE);
-        }
-        if ((supportedRouteMask & android.telecom.CallAudioState.ROUTE_BLUETOOTH)
-                == android.telecom.CallAudioState.ROUTE_BLUETOOTH) {
-            devices.add(DEVICE_BLUETOOTH);
-        }
-        if ((supportedRouteMask & android.telecom.CallAudioState.ROUTE_SPEAKER)
-                == android.telecom.CallAudioState.ROUTE_SPEAKER) {
-            devices.add(DEVICE_SPEAKER);
-        }
-        if ((supportedRouteMask & android.telecom.CallAudioState.ROUTE_WIRED_HEADSET)
-                == android.telecom.CallAudioState.ROUTE_WIRED_HEADSET) {
-            devices.add(DEVICE_HEADPHONES);
-        }
-        return devices;
-    }
-
-    /**
-     * Whether or not the ConnectionService is used for selecting audio devices.
-     */
-    static boolean useConnectionService() {
-        return Build.VERSION.SDK_INT >= Build.VERSION_CODES.O;
-    }
-
-    /**
-     * Indicator that we have lost audio focus.
-     */
-    private boolean audioFocusLost = false;
+    static final String TAG = MODULE_NAME;
 
     /**
      * {@link AudioManager} instance used to interact with the Android audio
@@ -181,11 +103,10 @@ class AudioModeModule extends ReactContextBaseJavaModule
     private BluetoothHeadsetMonitor bluetoothHeadsetMonitor;
 
     /**
-     * {@link ExecutorService} for running all audio operations on a dedicated
-     * thread.
+     * {@link Handler} for running all operations on the main thread.
      */
-    private static final ExecutorService executor
-        = Executors.newSingleThreadExecutor();
+    private final Handler mainThreadHandler
+        = new Handler(Looper.getMainLooper());
 
     /**
      * {@link Runnable} for running audio device detection the main thread.
@@ -212,14 +133,13 @@ class AudioModeModule extends ReactContextBaseJavaModule
                     break;
                 case AudioDeviceInfo.TYPE_WIRED_HEADPHONES:
                 case AudioDeviceInfo.TYPE_WIRED_HEADSET:
-                case TYPE_USB_HEADSET:
                     devices.add(DEVICE_HEADPHONES);
                     break;
                 }
             }
 
             availableDevices = devices;
-            JitsiMeetLogger.i(TAG + " Available audio devices: " +
+            Log.d(TAG, "Available audio devices: " +
                 availableDevices.toString());
 
             // Reset user selection
@@ -231,6 +151,19 @@ class AudioModeModule extends ReactContextBaseJavaModule
         }
     };
 
+    /**
+     * {@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);
+                }
+            }
+        };
+
     /**
      * Audio mode currently in use.
      */
@@ -244,11 +177,6 @@ class AudioModeModule extends ReactContextBaseJavaModule
     private static final String DEVICE_HEADPHONES = "HEADPHONES";
     private 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.
      */
@@ -259,15 +187,6 @@ class AudioModeModule extends ReactContextBaseJavaModule
      */
     private String selectedDevice;
 
-    /**
-     * Used on API >= 26 to store the most recently reported audio devices.
-     * Makes it easier to compare for a change, because the devices are stored
-     * as a mask in the {@link android.telecom.CallAudioState}. The mask is populated into
-     * the {@link #availableDevices} on each update.
-     */
-    @RequiresApi(api = Build.VERSION_CODES.O)
-    private int supportedRouteMask;
-
     /**
      * User selected device. When null the default is used depending on the
      * mode.
@@ -288,25 +207,21 @@ class AudioModeModule extends ReactContextBaseJavaModule
             = (AudioManager)
                 reactContext.getSystemService(Context.AUDIO_SERVICE);
 
-        // Starting Oreo the ConnectionImpl from ConnectionService is used to
-        // detect the available devices.
-        if (!useConnectionService()) {
-            // Setup runtime device change detection.
-            setupAudioRouteChangeDetection();
+        // Setup runtime device change detection.
+        setupAudioRouteChangeDetection();
 
-            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
-                // Do an initial detection on Android >= M.
-                onAudioDeviceChange();
-            } 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);
+        // Do an initial detection on Android >= M.
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+            mainThreadHandler.post(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);
         }
     }
 
@@ -320,7 +235,6 @@ class AudioModeModule extends ReactContextBaseJavaModule
     public Map<String, Object> getConstants() {
         Map<String, Object> constants = new HashMap<>();
 
-        constants.put("DEVICE_CHANGE_EVENT", DEVICE_CHANGE_EVENT);
         constants.put("AUDIO_CALL", AUDIO_CALL);
         constants.put("DEFAULT", DEFAULT);
         constants.put("VIDEO_CALL", VIDEO_CALL);
@@ -329,26 +243,31 @@ class AudioModeModule extends ReactContextBaseJavaModule
     }
 
     /**
-     * Notifies JS land that the devices list has changed.
+     * 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.
      */
-    private void notifyDevicesChanged() {
-        runInAudioThread(new Runnable() {
+    @ReactMethod
+    public void getAudioDevices(final Promise promise) {
+        mainThreadHandler.post(new Runnable() {
             @Override
             public void run() {
-                WritableArray data = Arguments.createArray();
-                final boolean hasHeadphones = availableDevices.contains(DEVICE_HEADPHONES);
+                WritableMap map = Arguments.createMap();
+                map.putString("selected", selectedDevice);
+                WritableArray devices = Arguments.createArray();
                 for (String device : availableDevices) {
-                    if (hasHeadphones && device.equals(DEVICE_EARPIECE)) {
-                        // Skip earpiece when headphones are plugged in.
+                    if (mode == VIDEO_CALL && device.equals(DEVICE_EARPIECE)) {
+                        // Skip earpiece when in video call mode.
                         continue;
                     }
-                    WritableMap deviceInfo = Arguments.createMap();
-                    deviceInfo.putString("type", device);
-                    deviceInfo.putBoolean("selected", device.equals(selectedDevice));
-                    data.pushMap(deviceInfo);
+                    devices.pushString(device);
                 }
-                ReactInstanceManagerHolder.emitEvent(DEVICE_CHANGE_EVENT, data);
-                JitsiMeetLogger.i(TAG + " Updating audio device list");
+                map.putArray("devices", devices);
+
+                promise.resolve(map);
             }
         });
     }
@@ -360,7 +279,7 @@ class AudioModeModule extends ReactContextBaseJavaModule
      */
     @Override
     public String getName() {
-        return NAME;
+        return MODULE_NAME;
     }
 
     /**
@@ -370,7 +289,7 @@ class AudioModeModule extends ReactContextBaseJavaModule
      * Only used on Android >= M.
      */
     void onAudioDeviceChange() {
-        runInAudioThread(onAudioDeviceChangeRunner);
+        mainThreadHandler.post(onAudioDeviceChangeRunner);
     }
 
     /**
@@ -398,7 +317,7 @@ class AudioModeModule extends ReactContextBaseJavaModule
      * Only used on Android < M.
      */
     void onHeadsetDeviceChange() {
-        runInAudioThread(new Runnable() {
+        mainThreadHandler.post(new Runnable() {
             @Override
             public void run() {
                 // XXX: isWiredHeadsetOn is not deprecated when used just for
@@ -418,81 +337,6 @@ class AudioModeModule extends ReactContextBaseJavaModule
         });
     }
 
-    @RequiresApi(api = Build.VERSION_CODES.O)
-    void onCallAudioStateChange(Object callAudioState_) {
-        final android.telecom.CallAudioState callAudioState
-            = (android.telecom.CallAudioState)callAudioState_;
-        runInAudioThread(new Runnable() {
-            @Override
-            public void run() {
-                int newSupportedRoutes = callAudioState.getSupportedRouteMask();
-                boolean audioDevicesChanged
-                        = supportedRouteMask != newSupportedRoutes;
-                if (audioDevicesChanged) {
-                    supportedRouteMask = newSupportedRoutes;
-                    availableDevices = routesToDeviceNames(supportedRouteMask);
-                    JitsiMeetLogger.i(TAG + " Available audio devices: "
-                                  + availableDevices.toString());
-                }
-
-                boolean audioRouteChanged
-                    = audioDeviceToRouteInt(selectedDevice)
-                            != callAudioState.getRoute();
-
-                if (audioRouteChanged || audioDevicesChanged) {
-                    // Reset user selection
-                    userSelectedDevice = null;
-
-                    // If the OS changes the Audio Route or Devices we could have lost
-                    // the selected audio device
-                    selectedDevice = null;
-
-                    if (mode != -1) {
-                        updateAudioRoute(mode);
-                    }
-                }
-            }
-        });
-    }
-
-    /**
-     * {@link AudioManager.OnAudioFocusChangeListener} interface method. Called
-     * when the audio focus of the system is updated.
-     *
-     * @param focusChange - The type of focus change.
-     */
-    @Override
-    public void onAudioFocusChange(int focusChange) {
-        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) {
-                updateAudioRoute(mode);
-            }
-            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 function to run operations on a dedicated thread.
-     * @param runnable
-     */
-    public void runInAudioThread(Runnable runnable) {
-        executor.execute(runnable);
-    }
-
     /**
      * Sets the user selected audio device as the active audio device.
      *
@@ -500,17 +344,17 @@ class AudioModeModule extends ReactContextBaseJavaModule
      */
     @ReactMethod
     public void setAudioDevice(final String device) {
-        runInAudioThread(new Runnable() {
+        mainThreadHandler.post(new Runnable() {
             @Override
             public void run() {
                 if (!availableDevices.contains(device)) {
-                    JitsiMeetLogger.w(TAG + " Audio device not available: " + device);
+                    Log.d(TAG, "Audio device not available: " + device);
                     userSelectedDevice = null;
                     return;
                 }
 
                 if (mode != -1) {
-                    JitsiMeetLogger.i(TAG + " User selected device set to: " + device);
+                    Log.d(TAG, "User selected device set to: " + device);
                     userSelectedDevice = device;
                     updateAudioRoute(mode);
                 }
@@ -518,31 +362,6 @@ class AudioModeModule extends ReactContextBaseJavaModule
         });
     }
 
-    /**
-     * The API >= 26 way of adjusting the audio route.
-     *
-     * @param audioDevice one of the "DEVICE_" names to set as the audio route.
-     */
-    @RequiresApi(api = Build.VERSION_CODES.O)
-    private void setAudioRoute(String audioDevice) {
-        int newAudioRoute = audioDeviceToRouteInt(audioDevice);
-
-        RNConnectionService.setAudioRoute(newAudioRoute);
-    }
-
-    /**
-     * The API < 26 way of adjusting the audio route.
-     *
-     * @param audioDevice one of the "DEVICE_" names to set as the audio route.
-     */
-    private void setAudioRoutePreO(String audioDevice) {
-        // Turn bluetooth on / off
-        setBluetoothAudioRoute(audioDevice.equals(DEVICE_BLUETOOTH));
-
-        // Turn speaker on / off
-        audioManager.setSpeakerphoneOn(audioDevice.equals(DEVICE_SPEAKER));
-    }
-
     /**
      * Helper method to set the output route to a Bluetooth device.
      *
@@ -572,7 +391,7 @@ class AudioModeModule extends ReactContextBaseJavaModule
             return;
         }
 
-        runInAudioThread(new Runnable() {
+        Runnable r = new Runnable() {
             @Override
             public void run() {
                 boolean success;
@@ -581,7 +400,10 @@ class AudioModeModule extends ReactContextBaseJavaModule
                     success = updateAudioRoute(mode);
                 } catch (Throwable e) {
                     success = false;
-                    JitsiMeetLogger.e(e, TAG + " Failed to update audio route for mode: " + mode);
+                    Log.e(
+                            TAG,
+                            "Failed to update audio route for mode: " + mode,
+                            e);
                 }
                 if (success) {
                     AudioModeModule.this.mode = mode;
@@ -592,12 +414,13 @@ class AudioModeModule extends ReactContextBaseJavaModule
                             "Failed to set audio mode to " + mode);
                 }
             }
-        });
+        };
+        mainThreadHandler.post(r);
     }
 
     /**
      * Setup the audio route change detection mechanism. We use the
-     * {@link android.media.AudioDeviceCallback} on 23 >= Android API < 26.
+     * {@link android.media.AudioDeviceCallback} API on Android >= 23 only.
      */
     private void setupAudioRouteChangeDetection() {
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
@@ -608,7 +431,7 @@ class AudioModeModule extends ReactContextBaseJavaModule
     }
 
     /**
-     * Audio route change detection mechanism for 23 >= Android API < 26.
+     * Audio route change detection mechanism for Android API >= 23.
      */
     @TargetApi(Build.VERSION_CODES.M)
     private void setupAudioRouteChangeDetectionM() {
@@ -617,14 +440,14 @@ class AudioModeModule extends ReactContextBaseJavaModule
                     @Override
                     public void onAudioDevicesAdded(
                             AudioDeviceInfo[] addedDevices) {
-                        JitsiMeetLogger.d(TAG + " Audio devices added");
+                        Log.d(TAG, "Audio devices added");
                         onAudioDeviceChange();
                     }
 
                     @Override
                     public void onAudioDevicesRemoved(
                             AudioDeviceInfo[] removedDevices) {
-                        JitsiMeetLogger.d(TAG + " Audio devices removed");
+                        Log.d(TAG, "Audio devices removed");
                         onAudioDeviceChange();
                     }
                 };
@@ -643,7 +466,7 @@ class AudioModeModule extends ReactContextBaseJavaModule
         BroadcastReceiver wiredHeadsetReceiver = new BroadcastReceiver() {
             @Override
             public void onReceive(Context context, Intent intent) {
-                JitsiMeetLogger.d(TAG + " Wired headset added / removed");
+                Log.d(TAG, "Wired headset added / removed");
                 onHeadsetDeviceChange();
             }
         };
@@ -661,38 +484,33 @@ class AudioModeModule extends ReactContextBaseJavaModule
      * {@code false}, otherwise.
      */
     private boolean updateAudioRoute(int mode) {
-        JitsiMeetLogger.i(TAG + " Update audio route for mode: " + mode);
+        Log.d(TAG, "Update audio route for mode: " + mode);
 
         if (mode == DEFAULT) {
-            if (!useConnectionService()) {
-                audioFocusLost = false;
-                audioManager.setMode(AudioManager.MODE_NORMAL);
-                audioManager.abandonAudioFocus(this);
-                audioManager.setSpeakerphoneOn(false);
-                setBluetoothAudioRoute(false);
-            }
+            audioManager.setMode(AudioManager.MODE_NORMAL);
+            audioManager.abandonAudioFocus(null);
+            audioManager.setSpeakerphoneOn(false);
+            setBluetoothAudioRoute(false);
             selectedDevice = null;
             userSelectedDevice = null;
 
-            notifyDevicesChanged();
             return true;
         }
 
-        if (!useConnectionService()) {
-            audioManager.setMode(AudioManager.MODE_IN_COMMUNICATION);
-            audioManager.setMicrophoneMute(false);
+        audioManager.setMode(AudioManager.MODE_IN_COMMUNICATION);
+        audioManager.setMicrophoneMute(false);
 
-            if (audioManager.requestAudioFocus(
-                    this,
+        if (audioManager.requestAudioFocus(
+                    null,
                     AudioManager.STREAM_VOICE_CALL,
                     AudioManager.AUDIOFOCUS_GAIN)
-                    == AudioManager.AUDIOFOCUS_REQUEST_FAILED) {
-                JitsiMeetLogger.w(TAG + " Audio focus request failed");
-                return false;
-            }
+                == AudioManager.AUDIOFOCUS_REQUEST_FAILED) {
+            Log.d(TAG, "Audio focus request failed");
+            return false;
         }
 
         boolean bluetoothAvailable = availableDevices.contains(DEVICE_BLUETOOTH);
+        boolean earpieceAvailable = availableDevices.contains(DEVICE_EARPIECE);
         boolean headsetAvailable = availableDevices.contains(DEVICE_HEADPHONES);
 
         // Pick the desired device based on what's available and the mode.
@@ -701,6 +519,8 @@ class AudioModeModule extends ReactContextBaseJavaModule
             audioDevice = DEVICE_BLUETOOTH;
         } else if (headsetAvailable) {
             audioDevice = DEVICE_HEADPHONES;
+        } else if (mode == AUDIO_CALL && earpieceAvailable) {
+            audioDevice = DEVICE_EARPIECE;
         } else {
             audioDevice = DEVICE_SPEAKER;
         }
@@ -718,15 +538,14 @@ class AudioModeModule extends ReactContextBaseJavaModule
         }
 
         selectedDevice = audioDevice;
-        JitsiMeetLogger.i(TAG + " Selected audio device: " + audioDevice);
+        Log.d(TAG, "Selected audio device: " + audioDevice);
 
-        if (useConnectionService()) {
-            setAudioRoute(audioDevice);
-        } else {
-            setAudioRoutePreO(audioDevice);
-        }
+        // Turn bluetooth on / off
+        setBluetoothAudioRoute(audioDevice.equals(DEVICE_BLUETOOTH));
+
+        // Turn speaker on / off
+        audioManager.setSpeakerphoneOn(audioDevice.equals(DEVICE_SPEAKER));
 
-        notifyDevicesChanged();
         return true;
     }
 }

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

@@ -1,221 +0,0 @@
-/*
- * 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.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jitsi.meet.sdk;
-
-import android.app.Activity;
-import android.content.Context;
-import android.os.Bundle;
-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;
-import java.util.UUID;
-import java.util.WeakHashMap;
-
-/**
- * Base class for all views which are backed by a React Native view.
- */
-public abstract class BaseReactView<ListenerT>
-    extends FrameLayout {
-
-    /**
-     * Background color used by {@code BaseReactView} and the React Native root
-     * view.
-     */
-    protected static int BACKGROUND_COLOR = 0xFF111111;
-
-    /**
-     * The collection of all existing {@code BaseReactView}s. Used to find the
-     * {@code BaseReactView} when delivering events coming from
-     * {@link ExternalAPIModule}.
-     */
-    static final Set<BaseReactView> views
-        = Collections.newSetFromMap(new WeakHashMap<BaseReactView, Boolean>());
-
-    /**
-     * Finds a {@code BaseReactView} which matches a specific external API
-     * scope.
-     *
-     * @param externalAPIScope - The external API scope associated with the
-     * {@code BaseReactView} to find.
-     * @return The {@code BaseReactView}, if any, associated with the specified
-     * {@code externalAPIScope}; otherwise, {@code null}.
-     */
-    public static BaseReactView findViewByExternalAPIScope(
-            String externalAPIScope) {
-        synchronized (views) {
-            for (BaseReactView view : views) {
-                if (view.externalAPIScope.equals(externalAPIScope)) {
-                    return view;
-                }
-            }
-        }
-
-        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
-     * inspired by postis which we use on Web for the similar purposes of the
-     * iframe-based external API.
-     */
-    protected final String externalAPIScope;
-
-    /**
-     * The listener (e.g. {@link JitsiMeetViewListener}) instance for reporting
-     * events occurring in Jitsi Meet.
-     */
-    private ListenerT listener;
-
-    /**
-     * React Native root view.
-     */
-    private ReactRootView reactRootView;
-
-    public BaseReactView(@NonNull Context context) {
-        super(context);
-
-        setBackgroundColor(BACKGROUND_COLOR);
-
-        ReactInstanceManagerHolder.initReactInstanceManager((Activity)context);
-
-        // Hook this BaseReactView into ExternalAPI.
-        externalAPIScope = UUID.randomUUID().toString();
-        synchronized (views) {
-            views.add(this);
-        }
-    }
-
-    /**
-     * Creates the {@code ReactRootView} for the given app name with the given
-     * props. Once created it's set as the view of this {@code FrameLayout}.
-     *
-     * @param appName - The name of the "app" (in React Native terms) to load.
-     * @param props - The React Component props to pass to the app.
-     */
-    public void createReactRootView(String appName, @Nullable Bundle props) {
-        if (props == null) {
-            props = new Bundle();
-        }
-
-        props.putString("externalAPIScope", externalAPIScope);
-
-        if (reactRootView == null) {
-            reactRootView = new ReactRootView(getContext());
-            reactRootView.startReactApplication(
-                ReactInstanceManagerHolder.getReactInstanceManager(),
-                appName,
-                props);
-            reactRootView.setBackgroundColor(BACKGROUND_COLOR);
-            addView(reactRootView);
-        } else {
-            reactRootView.setAppProperties(props);
-        }
-    }
-
-    /**
-     * Releases the React resources (specifically the {@link ReactRootView})
-     * associated with this view.
-     *
-     * MUST be called when the {@link Activity} holding this view is destroyed,
-     * typically in the {@code onDestroy} method.
-     */
-    public void dispose() {
-        if (reactRootView != null) {
-            removeView(reactRootView);
-            reactRootView.unmountReactApplication();
-            reactRootView = null;
-        }
-    }
-
-    /**
-     * Gets the listener set on this {@code BaseReactView}.
-     *
-     * @return The listener set on this {@code BaseReactView}.
-     */
-    public ListenerT getListener() {
-        return listener;
-    }
-
-    /**
-     * Abstract method called by {@link ExternalAPIModule} when an event is
-     * received for this view.
-     *
-     * @param name - The name of the event.
-     * @param data - The details of the event associated with/specific to the
-     * specified {@code name}.
-     */
-    protected abstract void onExternalAPIEvent(String name, ReadableMap data);
-
-    protected void onExternalAPIEvent(
-            Map<String, Method> listenerMethods,
-            String name, ReadableMap data) {
-        ListenerT listener = getListener();
-
-        if (listener != null) {
-            ListenerUtils.runListenerMethod(
-                listener, listenerMethods, name, data);
-        }
-    }
-
-    /**
-     * Called when the window containing this view gains or loses focus.
-     *
-     * @param hasFocus If the window of this view now has focus, {@code true};
-     * otherwise, {@code false}.
-     */
-    @Override
-    public void onWindowFocusChanged(boolean hasFocus) {
-        super.onWindowFocusChanged(hasFocus);
-
-        // https://github.com/mockingbot/react-native-immersive#restore-immersive-state
-        RNImmersiveModule immersive = RNImmersiveModule.getInstance();
-
-        if (hasFocus && immersive != null) {
-            immersive.emitImmersiveStateChangeEvent();
-        }
-    }
-
-    /**
-     * Sets a specific listener on this {@code BaseReactView}.
-     *
-     * @param listener The listener to set on this {@code BaseReactView}.
-     */
-    public void setListener(ListenerT listener) {
-        this.listener = listener;
-    }
-}

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

@@ -24,8 +24,9 @@ import android.content.Context;
 import android.content.Intent;
 import android.content.IntentFilter;
 import android.media.AudioManager;
-
-import org.jitsi.meet.sdk.log.JitsiMeetLogger;
+import android.os.Handler;
+import android.os.Looper;
+import android.util.Log;
 
 /**
  * Helper class to detect and handle Bluetooth device changes.  It monitors
@@ -54,6 +55,12 @@ class BluetoothHeadsetMonitor {
      */
     private boolean headsetAvailable = false;
 
+    /**
+     * {@link Handler} for running all operations on the main thread.
+     */
+    private final Handler mainThreadHandler
+        = new Handler(Looper.getMainLooper());
+
     /**
      * Helper for running Bluetooth operations on the main thread.
      */
@@ -78,7 +85,7 @@ class BluetoothHeadsetMonitor {
             = (AudioManager) context.getSystemService(Context.AUDIO_SERVICE);
 
         if (!audioManager.isBluetoothScoAvailableOffCall()) {
-            JitsiMeetLogger.w(AudioModeModule.TAG + " Bluetooth SCO is not available");
+            Log.w(AudioModeModule.TAG, "Bluetooth SCO is not available");
             return;
         }
 
@@ -94,7 +101,7 @@ class BluetoothHeadsetMonitor {
         BluetoothAdapter adapter = BluetoothAdapter.getDefaultAdapter();
 
         if (adapter == null) {
-            JitsiMeetLogger.w(AudioModeModule.TAG + " Device doesn't support Bluetooth");
+            Log.w(AudioModeModule.TAG, "Device doesn't support Bluetooth");
             return false;
         }
 
@@ -149,7 +156,9 @@ class BluetoothHeadsetMonitor {
             switch (state) {
             case BluetoothHeadset.STATE_CONNECTED:
             case BluetoothHeadset.STATE_DISCONNECTED:
-                JitsiMeetLogger.d(AudioModeModule.TAG + " BT headset connection state changed: " + state);
+                Log.d(
+                        AudioModeModule.TAG,
+                        "BT headset connection state changed: " + state);
                 updateDevices();
                 break;
             }
@@ -163,7 +172,9 @@ class BluetoothHeadsetMonitor {
             switch (state) {
             case AudioManager.SCO_AUDIO_STATE_CONNECTED:
             case AudioManager.SCO_AUDIO_STATE_DISCONNECTED:
-                JitsiMeetLogger.d(AudioModeModule.TAG + " BT SCO connection state changed: " + state);
+                Log.d(
+                        AudioModeModule.TAG,
+                        "BT SCO connection state changed: " + state);
                 updateDevices();
                 break;
             }
@@ -189,6 +200,6 @@ class BluetoothHeadsetMonitor {
      * {@link AudioModeModule#onAudioDeviceChange()} callback.
      */
     private void updateDevices() {
-        audioModeModule.runInAudioThread(updateDevicesRunnable);
+        mainThreadHandler.post(updateDevicesRunnable);
     }
 }

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

@@ -1,451 +0,0 @@
-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);
-            AudioModeModule audioModeModule
-                    = ReactInstanceManagerHolder
-                    .getNativeModule(AudioModeModule.class);
-            if (audioModeModule != null) {
-                audioModeModule.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,6 +1,5 @@
 /*
- * Copyright @ 2019-present 8x8, Inc.
- * Copyright @ 2017-2018 Atlassian Pty Ltd
+ * 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.
@@ -22,14 +21,15 @@ import android.app.Activity;
 import com.facebook.react.modules.core.DefaultHardwareBackBtnHandler;
 
 /**
- * Defines the default behavior of {@code JitsiMeetFragment} and
+ * Defines the default behavior of {@code JitsiMeetActivity} and
  * {@code JitsiMeetView} upon invoking the back button if no
  * {@code JitsiMeetView} handles the invocation. For example, a
  * {@code JitsiMeetView} may (1) handle the invocation of the back button
  * during a conference by leaving the conference and (2) not handle the
  * invocation when not in a conference.
  */
-class DefaultHardwareBackBtnHandlerImpl implements DefaultHardwareBackBtnHandler {
+public 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

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

@@ -20,24 +20,79 @@ 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 com.facebook.react.bridge.ReadableMapKeySetIterator;
 
-import org.jitsi.meet.sdk.log.JitsiMeetLogger;
+import org.jitsi.meet.sdk.JitsiMeetView;
+import org.jitsi.meet.sdk.JitsiMeetViewListener;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.util.HashMap;
+import java.util.Locale;
+import java.util.Map;
+import java.util.regex.Pattern;
 
 /**
- * Module implementing an API for sending events from JavaScript to native code.
+ * Module implementing a simple API to enable a proximity sensor-controlled
+ * wake lock. When the lock is held, if the proximity sensor detects a nearby
+ * object it will dim the screen and disable touch controls. The functionality
+ * is used with the conference audio-only mode.
  */
-@ReactModule(name = ExternalAPIModule.NAME)
-class ExternalAPIModule
-    extends ReactContextBaseJavaModule {
+class ExternalAPIModule extends ReactContextBaseJavaModule {
+    /**
+     * The {@code Method}s of {@code JitsiMeetViewListener} by event name i.e.
+     * redux action types.
+     */
+    private static final Map<String, Method> JITSI_MEET_VIEW_LISTENER_METHODS
+        = new HashMap<>();
 
-    public static final String NAME = "ExternalAPI";
+    static {
+        // Figure out the mapping between the JitsiMeetViewListener methods
+        // and the events i.e. redux action types.
+        Pattern onPattern = Pattern.compile("^on[A-Z]+");
+        Pattern camelcasePattern = Pattern.compile("([a-z0-9]+)([A-Z0-9]+)");
 
-    private static final String TAG = NAME;
+        for (Method method : JitsiMeetViewListener.class.getDeclaredMethods()) {
+            // * The method must be public (because it is declared by an
+            //   interface).
+            // * The method must be/return void.
+            if (!Modifier.isPublic(method.getModifiers())
+                    || !Void.TYPE.equals(method.getReturnType())) {
+                continue;
+            }
+
+            // * The method name must start with "on" followed by a
+            //   capital/uppercase letter (in agreement with the camelcase
+            //   coding style customary to Java in general and the projects of
+            //   the Jitsi community in particular).
+            String name = method.getName();
+
+            if (!onPattern.matcher(name).find()) {
+                continue;
+            }
+
+            // * The method must accept/have exactly 1 parameter of a type
+            //   assignable from HashMap.
+            Class<?>[] parameterTypes = method.getParameterTypes();
+
+            if (parameterTypes.length != 1
+                    || !parameterTypes[0].isAssignableFrom(HashMap.class)) {
+                continue;
+            }
+
+            // Convert the method name to an event name.
+            name
+                = camelcasePattern.matcher(name.substring(2))
+                    .replaceAll("$1_$2")
+                    .toUpperCase(Locale.ROOT);
+            JITSI_MEET_VIEW_LISTENER_METHODS.put(name, method);
+        }
+    }
 
     /**
      * Initializes a new module instance. There shall be a single instance of
-     * this module throughout the lifetime of the app.
+     * this module throughout the lifetime of the application.
      *
      * @param reactContext the {@link ReactApplicationContext} where this module
      * is created.
@@ -53,12 +108,11 @@ class ExternalAPIModule
      */
     @Override
     public String getName() {
-        return NAME;
+        return "ExternalAPI";
     }
 
     /**
-     * Dispatches an event that occurred on the JavaScript side of the SDK to
-     * the specified {@link BaseReactView}'s listener.
+     * Dispatches an event that occurred on JavaScript to the view's listener.
      *
      * @param name The name of the event.
      * @param data The details/specifics of the event to send determined
@@ -67,21 +121,52 @@ 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);
+        // former to the native JitsiMeetView which hosts it.
+        JitsiMeetView view = JitsiMeetView.findViewByExternalAPIScope(scope);
 
-        if (view != null) {
-            JitsiMeetLogger.d(TAG + " Sending event: " + name + " with data: " + data);
+        if (view == null) {
+            return;
+        }
+
+        JitsiMeetViewListener listener = view.getListener();
+
+        if (listener == null) {
+            return;
+        }
+
+        Method method = JITSI_MEET_VIEW_LISTENER_METHODS.get(name);
+
+        if (method != null) {
             try {
-                view.onExternalAPIEvent(name, data);
-            } catch(Exception e) {
-                JitsiMeetLogger.e(e, TAG + " onExternalAPIEvent: error sending event");
+                method.invoke(listener, toHashMap(data));
+            } catch (IllegalAccessException | InvocationTargetException e) {
+                throw new RuntimeException(e);
             }
         }
     }
+
+    /**
+     * Initializes a new {@code HashMap} instance with the key-value
+     * associations of a specific {@code ReadableMap}.
+     *
+     * @param readableMap the {@code ReadableMap} specifying the key-value
+     * associations with which the new {@code HashMap} instance is to be
+     * initialized.
+     * @return a new {@code HashMap} instance initialized with the key-value
+     * associations of the specified {@code readableMap}.
+     */
+    private HashMap<String, Object> toHashMap(ReadableMap readableMap) {
+        HashMap<String, Object> hashMap = new HashMap<>();
+
+        for (ReadableMapKeySetIterator i = readableMap.keySetIterator();
+                i.hasNextKey();) {
+            String key = i.nextKey();
+
+            hashMap.put(key, readableMap.getString(key));
+        }
+
+        return hashMap;
+    }
 }

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

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

@@ -1,75 +0,0 @@
-/*
- * 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 @ 2019-present 8x8, Inc.
+ * 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.
@@ -16,212 +16,288 @@
 
 package org.jitsi.meet.sdk;
 
-import android.content.Context;
 import android.content.Intent;
+import android.content.res.Configuration;
 import android.net.Uri;
+import android.os.Build;
 import android.os.Bundle;
-import androidx.annotation.Nullable;
-import androidx.fragment.app.FragmentActivity;
+import android.provider.Settings;
+import android.support.annotation.Nullable;
+import android.support.v7.app.AppCompatActivity;
+import android.view.KeyEvent;
 
-import com.facebook.react.modules.core.PermissionListener;
-
-import org.jitsi.meet.sdk.log.JitsiMeetLogger;
-
-import java.util.Map;
+import com.facebook.react.ReactInstanceManager;
+import com.facebook.react.modules.core.DefaultHardwareBackBtnHandler;
 
+import java.net.URL;
 
 /**
- * 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.
+ * 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.
  */
-public class JitsiMeetActivity extends FragmentActivity
-        implements JitsiMeetActivityInterface, JitsiMeetViewListener {
+public class JitsiMeetActivity extends AppCompatActivity {
+    /**
+     * 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;
 
-    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);
+    /**
+     * 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, String url) {
-        JitsiMeetConferenceOptions options
-            = new JitsiMeetConferenceOptions.Builder().setRoom(url).build();
-        launch(context, options);
+    /**
+     *
+     * @see JitsiMeetView#getDefaultURL()
+     */
+    public URL getDefaultURL() {
+        return view == null ? defaultURL : view.getDefaultURL();
     }
 
-    // Overrides
-    //
+    /**
+     *
+     * @see JitsiMeetView#getPictureInPictureEnabled()
+     */
+    public boolean getPictureInPictureEnabled() {
+        return
+            view == null
+                ? pictureInPictureEnabled
+                : view.getPictureInPictureEnabled();
+    }
+
+    /**
+     *
+     * @see JitsiMeetView#getWelcomePageEnabled()
+     */
+    public boolean getWelcomePageEnabled() {
+        return view == null ? welcomePageEnabled : view.getWelcomePageEnabled();
+    }
+
+    /**
+     * Initializes the {@link #view} of this {@code JitsiMeetActivity} with a
+     * new {@link JitsiMeetView} instance.
+     */
+    private void initializeContentView() {
+        JitsiMeetView view = initializeView();
+
+        if (view != 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);
+
+        view.loadURL(null);
+
+        return view;
+    }
+
+    /**
+     * 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 (!JitsiMeetView.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();
+            }
+        }
+    }
 
     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
 
-        setContentView(R.layout.activity_jitsi_meet);
+        // 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()));
 
-        if (!extraInitialize()) {
-            initialize();
+            startActivityForResult(intent, OVERLAY_PERMISSION_REQUEST_CODE);
+            return;
         }
+
+        initializeContentView();
     }
 
     @Override
-    public void onDestroy() {
-        // Here we are trying to handle the following corner case: an application using the SDK
-        // is using this Activity for displaying meetings, but there is another "main" Activity
-        // with other content. If this Activity is "swiped out" from the recent list we will get
-        // Activity#onDestroy() called without warning. At this point we can try to leave the
-        // current meeting, but when our view is detached from React the JS <-> Native bridge won't
-        // be operational so the external API won't be able to notify the native side that the
-        // conference terminated. Thus, try our best to clean up.
-        leave();
-        if (AudioModeModule.useConnectionService()) {
-            ConnectionService.abortConnections();
-        }
-        JitsiMeetOngoingConferenceService.abort(this);
-
+    protected void onDestroy() {
         super.onDestroy();
-    }
 
-    @Override
-    public void finish() {
-        leave();
-
-        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);
+        if (view != null) {
+            view.dispose();
+            view = null;
         }
 
-        return null;
+        JitsiMeetView.onHostDestroy(this);
     }
 
-    /**
-     * 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() {
+    // ReactAndroid/src/main/java/com/facebook/react/ReactActivity.java
+    @Override
+    public boolean onKeyUp(int keyCode, KeyEvent event) {
+        ReactInstanceManager reactInstanceManager;
+
+        if (!super.onKeyUp(keyCode, event)
+                && BuildConfig.DEBUG
+                && (reactInstanceManager
+                        = JitsiMeetView.getReactInstanceManager())
+                    != null
+                && keyCode == KeyEvent.KEYCODE_MENU) {
+            reactInstanceManager.showDevOptionsDialog();
+            return true;
+        }
         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) {
-        super.onNewIntent(intent);
+        JitsiMeetView.onNewIntent(intent);
+    }
 
-        JitsiMeetConferenceOptions options;
+    @Override
+    protected void onResume() {
+        super.onResume();
 
-        if ((options = getConferenceOptions(intent)) != null) {
-            join(options);
-            return;
-        }
+        defaultBackButtonImpl = new DefaultHardwareBackBtnHandlerImpl(this);
+        JitsiMeetView.onHostResume(this, defaultBackButtonImpl);
+    }
 
-        JitsiMeetActivityDelegate.onNewIntent(intent);
+    @Override
+    public void onStop() {
+        super.onStop();
+
+        JitsiMeetView.onHostPause(this);
+        defaultBackButtonImpl = null;
     }
 
     @Override
     protected void onUserLeaveHint() {
-        getJitsiView().enterPictureInPicture();
+        JitsiMeetView.onUserLeaveHint();
     }
 
-    // JitsiMeetActivityInterface
-    //
-
-    @Override
-    public void requestPermissions(String[] permissions, int requestCode, PermissionListener listener) {
-        JitsiMeetActivityDelegate.requestPermissions(this, permissions, requestCode, listener);
+    /**
+     *
+     * @see JitsiMeetView#setDefaultURL(URL)
+     */
+    public void setDefaultURL(URL defaultURL) {
+        if (view == null) {
+            this.defaultURL = defaultURL;
+        } else {
+            view.setDefaultURL(defaultURL);
+        }
     }
 
-    @Override
-    public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
-        JitsiMeetActivityDelegate.onRequestPermissionsResult(requestCode, permissions, grantResults);
+    /**
+     *
+     * @see JitsiMeetView#setPictureInPictureEnabled(boolean)
+     */
+    public void setPictureInPictureEnabled(boolean pictureInPictureEnabled) {
+        if (view == null) {
+            this.pictureInPictureEnabled
+                = Boolean.valueOf(pictureInPictureEnabled);
+        } else {
+            view.setPictureInPictureEnabled(pictureInPictureEnabled);
+        }
     }
 
-    // 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);
+    /**
+     *
+     * @see JitsiMeetView#setWelcomePageEnabled(boolean)
+     */
+    public void setWelcomePageEnabled(boolean welcomePageEnabled) {
+        if (view == null) {
+            this.welcomePageEnabled = welcomePageEnabled;
+        } else {
+            view.setWelcomePageEnabled(welcomePageEnabled);
+        }
     }
 }

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

@@ -1,193 +0,0 @@
-/*
- * 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.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jitsi.meet.sdk;
-
-import android.annotation.TargetApi;
-import android.app.Activity;
-import android.content.Intent;
-import android.os.Build;
-
-import com.calendarevents.CalendarEventsPackage;
-import com.facebook.react.ReactInstanceManager;
-import com.facebook.react.bridge.Callback;
-import com.facebook.react.bridge.ReactContext;
-import com.facebook.react.modules.core.PermissionListener;
-
-/**
- * Helper class to encapsulate the work which needs to be done on
- * {@link Activity} lifecycle methods in order for the React side to be aware of
- * it.
- */
-public class JitsiMeetActivityDelegate {
-    /**
-     * Needed for making sure this class working with the "PermissionsAndroid"
-     * React Native module.
-     */
-    private static PermissionListener permissionListener;
-    private static Callback permissionsCallback;
-
-    /**
-     * Tells whether or not the permissions request is currently in progress.
-     *
-     * @return {@code true} if the 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
-     * processing.
-     *
-     * @return {@code true} if the back-press was processed; {@code false},
-     * otherwise. If {@code false}, the application should call the
-     * {@code super}'s implementation.
-     */
-    public static void onBackPressed() {
-        ReactInstanceManager reactInstanceManager
-            = ReactInstanceManagerHolder.getReactInstanceManager();
-
-        if (reactInstanceManager != null) {
-            reactInstanceManager.onBackPressed();
-        }
-    }
-
-    /**
-     * {@link Activity} lifecycle method which should be called from
-     * {@code Activity#onDestroy} so we can do the required internal
-     * processing.
-     *
-     * @param activity {@code Activity} being destroyed.
-     */
-    public static void onHostDestroy(Activity activity) {
-        ReactInstanceManager reactInstanceManager
-            = ReactInstanceManagerHolder.getReactInstanceManager();
-
-        if (reactInstanceManager != null) {
-            reactInstanceManager.onHostDestroy(activity);
-        }
-    }
-
-    /**
-     * {@link Activity} lifecycle method which should be called from
-     * {@code Activity#onPause} so we can do the required internal processing.
-     *
-     * @param activity {@code Activity} being paused.
-     */
-    public static void onHostPause(Activity activity) {
-        ReactInstanceManager reactInstanceManager
-            = ReactInstanceManagerHolder.getReactInstanceManager();
-
-        if (reactInstanceManager != null) {
-            // Try 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);
-            }
-        }
-    }
-
-    /**
-     * {@link Activity} lifecycle method which should be called from
-     * {@code Activity#onResume} so we can do the required internal processing.
-     *
-     * @param activity {@code Activity} being resumed.
-     */
-    public static void onHostResume(Activity activity) {
-        ReactInstanceManager reactInstanceManager
-            = ReactInstanceManagerHolder.getReactInstanceManager();
-
-        if (reactInstanceManager != null) {
-            reactInstanceManager.onHostResume(activity, new DefaultHardwareBackBtnHandlerImpl(activity));
-        }
-
-        if (permissionsCallback != null) {
-            permissionsCallback.invoke();
-            permissionsCallback = null;
-        }
-    }
-
-    /**
-     * {@link Activity} lifecycle method which should be called from
-     * {@code Activity#onNewIntent} so we can do the required internal
-     * processing. Note that this is only needed if the activity's "launchMode"
-     * was set to "singleTask". This is required for deep linking to work once
-     * the application is already running.
-     *
-     * @param intent {@code Intent} instance which was received.
-     */
-    public static void onNewIntent(Intent intent) {
-        ReactInstanceManager reactInstanceManager
-            = ReactInstanceManagerHolder.getReactInstanceManager();
-
-        if (reactInstanceManager != null) {
-            reactInstanceManager.onNewIntent(intent);
-        }
-    }
-
-    public static void onRequestPermissionsResult(
-        final int requestCode,
-        final String[] permissions,
-        final int[] grantResults) {
-        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

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

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

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

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

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

@@ -1,107 +0,0 @@
-/*
- * 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,6 +1,5 @@
 /*
- * Copyright @ 2018-present 8x8, Inc.
- * Copyright @ 2017-2018 Atlassian Pty Ltd
+ * 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.
@@ -17,188 +16,569 @@
 
 package org.jitsi.meet.sdk;
 
+import android.app.Activity;
+import android.app.Application;
 import android.content.Context;
+import android.content.Intent;
+import android.net.Uri;
+import android.os.Build;
 import android.os.Bundle;
-import androidx.annotation.NonNull;
-import androidx.annotation.Nullable;
+import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
+import android.util.Log;
+import android.widget.FrameLayout;
 
-import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.ReactInstanceManager;
+import com.facebook.react.ReactRootView;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.common.LifecycleState;
+import com.facebook.react.modules.core.DefaultHardwareBackBtnHandler;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+import com.rnimmersive.RNImmersiveModule;
 
-import org.jitsi.meet.sdk.log.JitsiMeetLogger;
+import java.net.URL;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
+import java.util.WeakHashMap;
 
-import java.lang.reflect.Method;
-import java.util.Map;
-
-
-public class JitsiMeetView extends BaseReactView<JitsiMeetViewListener>
-        implements OngoingConferenceTracker.OngoingConferenceListener {
+public class JitsiMeetView extends FrameLayout {
+    /**
+     * Background color used by {@code JitsiMeetView} and the React Native root
+     * view.
+     */
+    private static final int BACKGROUND_COLOR = 0xFF111111;
 
     /**
-     * The {@code Method}s of {@code JitsiMeetViewListener} by event name i.e.
-     * redux action types.
+     * The {@link Log} tag which identifies the source of the log messages of
+     * {@code JitsiMeetView}.
      */
-    private static final Map<String, Method> LISTENER_METHODS
-        = ListenerUtils.mapListenerMethods(JitsiMeetViewListener.class);
+    private final static String TAG = JitsiMeetView.class.getSimpleName();
 
     /**
-     * The URL of the current conference.
+     * React Native bridge. The instance manager allows embedding applications
+     * to create multiple root views off the same JavaScript bundle.
      */
-    // XXX Currently, one thread writes and one thread reads, so it should be
-    // fine to have this field volatile without additional synchronization.
-    private volatile String url;
+    private static ReactInstanceManager reactInstanceManager;
 
-    /**
-     * Helper method to recursively merge 2 {@link Bundle} objects representing React Native props.
-     *
-     * @param a - The first {@link Bundle}.
-     * @param b - The second {@link Bundle}.
-     * @return The merged {@link Bundle} object.
-     */
-    private static Bundle mergeProps(@Nullable Bundle a, @Nullable Bundle b) {
-        Bundle result = new Bundle();
+    private static final Set<JitsiMeetView> views
+        = Collections.newSetFromMap(new WeakHashMap<JitsiMeetView, Boolean>());
 
-        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;
+    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)
+        );
     }
 
+    public static JitsiMeetView findViewByExternalAPIScope(
+            String externalAPIScope) {
+        synchronized (views) {
+            for (JitsiMeetView view : views) {
+                if (view.externalAPIScope.equals(externalAPIScope)) {
+                    return view;
+                }
+            }
+        }
+
+        return null;
+    }
+
+    // XXX Strictly internal use only (at the time of this writing)!
+    static ReactInstanceManager getReactInstanceManager() {
+        return reactInstanceManager;
+    }
+
+    /**
+     * Internal method to initialize the React Native instance manager. We
+     * create a single instance in order to load the JavaScript bundle a single
+     * time. All {@code ReactRootView} instances will be tied to the one and
+     * only {@code ReactInstanceManager}.
+     *
+     * @param application {@code Application} instance which is running.
+     */
+    private static void initReactInstanceManager(Application application) {
+        reactInstanceManager
+            = ReactInstanceManager.builder()
+                .setApplication(application)
+                .setBundleAssetName("index.android.bundle")
+                .setJSMainModulePath("index.android")
+                .addPackage(new com.calendarevents.CalendarEventsPackage())
+                .addPackage(new com.corbt.keepawake.KCKeepAwakePackage())
+                .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.RNFetchBlob.RNFetchBlobPackage())
+                .addPackage(new com.rnimmersive.RNImmersivePackage())
+                .addPackage(new com.zmxv.RNSound.RNSoundPackage())
+                .addPackage(new ReactPackageAdapter() {
+                    @Override
+                    public List<NativeModule> createNativeModules(
+                            ReactApplicationContext reactContext) {
+                        return JitsiMeetView.createNativeModules(reactContext);
+                    }
+                })
+                .setUseDeveloperSupport(BuildConfig.DEBUG)
+                .setInitialLifecycleState(LifecycleState.RESUMED)
+                .build();
+    }
+
+    /**
+     * 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}.
+     */
+    private static boolean loadURLStringInViews(String urlString) {
+        synchronized (views) {
+            if (!views.isEmpty()) {
+                for (JitsiMeetView view : views) {
+                    view.loadURLString(urlString);
+                }
+
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Activity lifecycle method which should be called from
+     * {@code Activity.onBackPressed} so we can do the required internal
+     * processing.
+     *
+     * @return {@code true} if the back-press was processed; {@code false},
+     * otherwise. If {@code false}, the application should call the parent's
+     * implementation.
+     */
+    public static boolean onBackPressed() {
+        if (reactInstanceManager == null) {
+            return false;
+        } else {
+            reactInstanceManager.onBackPressed();
+            return true;
+        }
+    }
+
+    /**
+     * Activity lifecycle method which should be called from
+     * {@code Activity.onDestroy} so we can do the required internal
+     * processing.
+     *
+     * @param activity {@code Activity} being destroyed.
+     */
+    public static void onHostDestroy(Activity activity) {
+        if (reactInstanceManager != null) {
+            reactInstanceManager.onHostDestroy(activity);
+        }
+    }
+
+    /**
+     * Activity lifecycle method which should be called from
+     * {@code Activity.onPause} so we can do the required internal processing.
+     *
+     * @param activity {@code Activity} being paused.
+     */
+    public static void onHostPause(Activity activity) {
+        if (reactInstanceManager != null) {
+            reactInstanceManager.onHostPause(activity);
+        }
+    }
+
+    /**
+     * Activity lifecycle method which should be called from
+     * {@code Activity.onResume} so we can do the required internal processing.
+     *
+     * @param activity {@code Activity} being resumed.
+     */
+    public static void onHostResume(Activity activity) {
+        onHostResume(activity, new DefaultHardwareBackBtnHandlerImpl(activity));
+    }
+
+    /**
+     * 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 {@code DefaultHardwareBackBtnHandler} to
+     * handle invoking the back button if no {@code JitsiMeetView} handles it.
+     */
+    public static void onHostResume(
+            Activity activity,
+            DefaultHardwareBackBtnHandler defaultBackButtonImpl) {
+        if (reactInstanceManager != null) {
+            reactInstanceManager.onHostResume(activity, defaultBackButtonImpl);
+        }
+    }
+
+    /**
+     * Activity lifecycle method which should be called from
+     * {@code Activity.onNewIntent} so we can do the required internal
+     * processing. Note that this is only needed if the activity's "launchMode"
+     * was set to "singleTask". This is required for deep linking to work once
+     * the application is already running.
+     *
+     * @param intent {@code Intent} instance which was received.
+     */
+    public static void onNewIntent(Intent intent) {
+        // 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;
+
+        if (Intent.ACTION_VIEW.equals(intent.getAction())
+                && (uri = intent.getData()) != null
+                && loadURLStringInViews(uri.toString())) {
+            return;
+        }
+
+        if (reactInstanceManager != null) {
+            reactInstanceManager.onNewIntent(intent);
+        }
+    }
+
+    /**
+     * Activity lifecycle method which should be called from
+     * {@code Activity.onUserLeaveHint} so we can do the required internal
+     * processing.
+     *
+     * This is currently not mandatory.
+     */
+    public static void onUserLeaveHint() {
+        sendEvent("onUserLeaveHint", null);
+    }
+
+    /**
+     * Helper function to send an event to JavaScript.
+     *
+     * @param eventName {@code String} containing the event name.
+     * @param params {@code WritableMap} optional ancillary data for the event.
+     */
+    private static void sendEvent(
+            String eventName,
+            @Nullable WritableMap params) {
+        if (reactInstanceManager != null) {
+            ReactContext reactContext
+                = reactInstanceManager.getCurrentReactContext();
+            if (reactContext != null) {
+                reactContext
+                    .getJSModule(
+                        DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+                    .emit(eventName, params);
+            }
+        }
+    }
+
+    /**
+     * 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 unique identifier of this {@code JitsiMeetView} within the process
+     * for the purposes of {@link ExternalAPI}. The name scope was inspired by
+     * postis which we use on Web for the similar purposes of the iframe-based
+     * external API.
+     */
+    private final String externalAPIScope;
+
+    /**
+     * {@link JitsiMeetViewListener} instance for reporting events occurring in
+     * Jitsi Meet.
+     */
+    private JitsiMeetViewListener listener;
+
+    /**
+     * 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;
+
+    /**
+     * React Native root view.
+     */
+    private ReactRootView reactRootView;
+
+    /**
+     * Whether the Welcome page is enabled.
+     */
+    private boolean welcomePageEnabled;
+
     public JitsiMeetView(@NonNull Context context) {
         super(context);
 
-        // Check if the parent Activity implements JitsiMeetActivityInterface,
-        // otherwise things may go wrong.
-        if (!(context instanceof JitsiMeetActivityInterface)) {
-            throw new RuntimeException("Enclosing Activity must implement JitsiMeetActivityInterface");
+        setBackgroundColor(BACKGROUND_COLOR);
+
+        if (reactInstanceManager == null) {
+            initReactInstanceManager(((Activity) context).getApplication());
         }
 
-        OngoingConferenceTracker.getInstance().addListener(this);
-    }
-
-    @Override
-    public void dispose() {
-        OngoingConferenceTracker.getInstance().removeListener(this);
-        super.dispose();
+        // Hook this JitsiMeetView into ExternalAPI.
+        externalAPIScope = UUID.randomUUID().toString();
+        synchronized (views) {
+            views.add(this);
+        }
     }
 
     /**
-     * Enters Picture-In-Picture mode, if possible. This method is designed to
-     * be called from the {@code Activity.onUserLeaveHint} method.
+     * Releases the React resources (specifically the {@link ReactRootView})
+     * associated with this view.
      *
-     * This is currently not mandatory, but if used will provide automatic
-     * handling of the picture in picture mode when user minimizes the app. It
-     * will be probably the most useful in case the app is using the welcome
-     * page.
+     * This method MUST be called when the Activity holding this view is
+     * destroyed, typically in the {@code onDestroy} method.
      */
-    public void enterPictureInPicture() {
-        PictureInPictureModule pipModule
-            = ReactInstanceManagerHolder.getNativeModule(
-                PictureInPictureModule.class);
-        if (pipModule != null
-                && PictureInPictureModule.isPictureInPictureSupported()
-                && !JitsiMeetActivityDelegate.arePermissionsBeingRequested()
-                && this.url != null) {
+    public void dispose() {
+        if (reactRootView != null) {
+            removeView(reactRootView);
+            reactRootView.unmountReactApplication();
+            reactRootView = null;
+        }
+    }
+
+    /**
+     * 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:
+     * {@link https://meet.jit.si}
+     *
+     * @return The default base {@code URL} or {@code null}.
+     */
+    public URL getDefaultURL() {
+        return defaultURL;
+    }
+
+    /**
+     * Gets the {@link JitsiMeetViewListener} set on this {@code JitsiMeetView}.
+     *
+     * @return The {@code JitsiMeetViewListener} set on this
+     * {@code JitsiMeetView}.
+     */
+    public JitsiMeetViewListener getListener() {
+        return listener;
+    }
+
+    /**
+     * 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 getPictureInPictureEnabled() {
+        return
+            PictureInPictureModule.isPictureInPictureSupported()
+                && (pictureInPictureEnabled == null
+                    || pictureInPictureEnabled.booleanValue());
+    }
+
+    /**
+     * 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 getWelcomePageEnabled() {
+        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());
+        }
+
+        // externalAPIScope
+        props.putString("externalAPIScope", externalAPIScope);
+
+        // pictureInPictureEnabled
+        props.putBoolean(
+            "pictureInPictureEnabled",
+            getPictureInPictureEnabled());
+
+        // url
+        if (urlObject != null) {
+            props.putBundle("url", urlObject);
+        }
+
+        // welcomePageEnabled
+        props.putBoolean("welcomePageEnabled", welcomePageEnabled);
+
+        // XXX The method loadURLObject: 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
+        // JavaScript source code. The workaround implemented bellow introduces
+        // imperativeness in React Component props by defining a unique value
+        // per loadURLObject: invocation.
+        props.putLong("timestamp", System.currentTimeMillis());
+
+        if (reactRootView == null) {
+            reactRootView = new ReactRootView(getContext());
+            reactRootView.startReactApplication(
+                reactInstanceManager,
+                "App",
+                props);
+            reactRootView.setBackgroundColor(BACKGROUND_COLOR);
+            addView(reactRootView);
+        } else {
+            reactRootView.setAppProperties(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.
+     */
+    public void loadURLString(@Nullable String urlString) {
+        Bundle urlObject;
+
+        if (urlString == null) {
+            urlObject = null;
+        } else {
+            urlObject = new Bundle();
+            urlObject.putString("url", urlString);
+        }
+        loadURLObject(urlObject);
+    }
+
+    /**
+     * Called when the window containing this view gains or loses focus.
+     *
+     * @param hasFocus If the window of this view now has focus, {@code true};
+     * otherwise, {@code false}.
+     */
+    @Override
+    public void onWindowFocusChanged(boolean hasFocus) {
+        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 {
-                pipModule.enterPictureInPicture();
+                immersive.emitImmersiveStateChangeEvent();
             } catch (RuntimeException re) {
-                JitsiMeetLogger.e(re, "Failed to enter PiP mode");
+                // 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(
+                    TAG,
+                    "RNImmersiveModule#emitImmersiveStateChangeEvent() failed!",
+                    re);
             }
         }
     }
 
     /**
-     * Joins the conference specified by the given {@link JitsiMeetConferenceOptions}. If there is
-     * already an active conference, it will be left and the new one will be joined.
-     * @param options - Description of what conference must be joined and what options will be used
-     *                when doing so.
-     */
-    public void join(@Nullable JitsiMeetConferenceOptions options) {
-        setProps(options != null ? options.asProps() : new Bundle());
-    }
-
-    /**
-     * Leaves the currently active conference.
-     */
-    public void leave() {
-        setProps(new Bundle());
-    }
-
-    /**
-     * Helper method to set the React Native props.
-     * @param newProps - New props to be set on the React Native view.
-     */
-    private void setProps(@NonNull Bundle newProps) {
-        // Merge the default options with the newly provided ones.
-        Bundle props = mergeProps(JitsiMeet.getDefaultProps(), newProps);
-
-        // XXX The setProps() method is supposed to be imperative i.e.
-        // a second invocation with one and the same URL is expected to join
-        // the respective conference again if the first invocation was followed
-        // by leaving the conference. However, React and, respectively,
-        // appProperties/initialProperties are declarative expressions i.e. one
-        // and the same URL will not trigger an automatic re-render in the
-        // JavaScript source code. The workaround implemented bellow introduces
-        // "imperativeness" in React Component props by defining a unique value
-        // per setProps() invocation.
-        props.putLong("timestamp", System.currentTimeMillis());
-
-        createReactRootView("App", props);
-    }
-
-    /**
-     * Handler for {@link OngoingConferenceTracker} events.
-     * @param conferenceUrl
-     */
-    @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;
-    }
-
-    /**
-     * Handler for {@link ExternalAPIModule} events.
+     * 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 name The name of the event.
-     * @param data The details/specifics of the event to send determined
-     * by/associated with the specified {@code name}.
+     * @param defaultURL The {@code URL} to be set as the default base URL.
+     * @see #getDefaultURL()
      */
-    @Override
-    protected void onExternalAPIEvent(String name, ReadableMap data) {
-        onExternalAPIEvent(LISTENER_METHODS, name, data);
+    public void setDefaultURL(URL defaultURL) {
+        this.defaultURL = defaultURL;
+    }
+
+    /**
+     * Sets a specific {@link JitsiMeetViewListener} on this
+     * {@code JitsiMeetView}.
+     *
+     * @param listener The {@code JitsiMeetViewListener} to set on this
+     * {@code JitsiMeetView}.
+     */
+    public void setListener(JitsiMeetViewListener listener) {
+        this.listener = listener;
+    }
+
+    /**
+     * 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 = Boolean.valueOf(pictureInPictureEnabled);
+    }
+
+    /**
+     * 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

@@ -0,0 +1,49 @@
+/*
+ * 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,6 +22,15 @@ 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.
      *
@@ -30,16 +39,11 @@ public interface JitsiMeetViewListener {
     void onConferenceJoined(Map<String, Object> data);
 
     /**
-     * Called when the active conference ends, be it because of user choice or
-     * because of a failure.
+     * Called when the conference was left, typically after hanging up.
      *
-     * @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
+     * @param data Map with a "url" key with the conference URL.
      */
-    void onConferenceTerminated(Map<String, Object> data);
+    void onConferenceLeft(Map<String, Object> data);
 
     /**
      * Called before the conference is joined.
@@ -47,4 +51,21 @@ 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/ListenerUtils.java

@@ -1,166 +0,0 @@
-/*
- * Copyright @ 2018-present Atlassian Pty Ltd
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jitsi.meet.sdk;
-
-import com.facebook.react.bridge.ReadableMap;
-import com.facebook.react.bridge.ReadableMapKeySetIterator;
-import com.facebook.react.bridge.UiThreadUtil;
-
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-import java.lang.reflect.Modifier;
-import java.util.HashMap;
-import java.util.Locale;
-import java.util.Map;
-import java.util.regex.Pattern;
-
-/**
- * Utility methods for helping with transforming {@link ExternalAPIModule}
- * events into listener methods. Used with descendants of {@link BaseReactView}.
- */
-public final class ListenerUtils {
-    /**
-     * Extracts the methods defined in a listener and creates a mapping of this
-     * form: event name -> method.
-     *
-     * @param listener - The listener whose methods we want to slurp.
-     * @return A mapping with event names - methods.
-     */
-    public static Map<String, Method> mapListenerMethods(Class listener) {
-        Map<String, Method> methods = new HashMap<>();
-
-        // Figure out the mapping between the listener methods
-        // and the events i.e. redux action types.
-        Pattern onPattern = Pattern.compile("^on[A-Z]+");
-        Pattern camelcasePattern = Pattern.compile("([a-z0-9]+)([A-Z0-9]+)");
-
-        for (Method method : listener.getDeclaredMethods()) {
-            // * The method must be public (because it is declared by an
-            //   interface).
-            // * The method must be/return void.
-            if (!Modifier.isPublic(method.getModifiers())
-                    || !Void.TYPE.equals(method.getReturnType())) {
-                continue;
-            }
-
-            // * The method name must start with "on" followed by a
-            //   capital/uppercase letter (in agreement with the camelcase
-            //   coding style customary to Java in general and the projects of
-            //   the Jitsi community in particular).
-            String name = method.getName();
-
-            if (!onPattern.matcher(name).find()) {
-                continue;
-            }
-
-            // * The method must accept/have exactly 1 parameter of a type
-            //   assignable from HashMap.
-            Class<?>[] parameterTypes = method.getParameterTypes();
-
-            if (parameterTypes.length != 1
-                    || !parameterTypes[0].isAssignableFrom(HashMap.class)) {
-                continue;
-            }
-
-            // Convert the method name to an event name.
-            name
-                = camelcasePattern.matcher(name.substring(2))
-                    .replaceAll("$1_$2")
-                    .toUpperCase(Locale.ROOT);
-            methods.put(name, method);
-        }
-
-        return methods;
-    }
-
-    /**
-     * Executes the right listener method for the given event.
-     * NOTE: This function will run asynchronously on the UI thread.
-     *
-     * @param listener - The listener on which the method will be called.
-     * @param listenerMethods - Mapping with event names and the matching
-     *                        methods.
-     * @param eventName - Name of the event.
-     * @param eventData - Data associated with the event.
-     */
-    public static void runListenerMethod(
-            final Object listener,
-            final Map<String, Method> listenerMethods,
-            final String eventName,
-            final ReadableMap eventData) {
-        // Make sure listener methods are invoked on the UI thread. It
-        // was requested by SDK consumers.
-        if (UiThreadUtil.isOnUiThread()) {
-            runListenerMethodOnUiThread(
-                listener, listenerMethods, eventName, eventData);
-        } else {
-            UiThreadUtil.runOnUiThread(new Runnable() {
-                @Override
-                public void run() {
-                    runListenerMethodOnUiThread(
-                        listener, listenerMethods, eventName, eventData);
-                }
-            });
-        }
-    }
-
-    /**
-     * Helper companion for {@link ListenerUtils#runListenerMethod} which runs
-     * in the UI thread.
-     */
-    private static void runListenerMethodOnUiThread(
-            Object listener,
-            Map<String, Method> listenerMethods,
-            String eventName,
-            ReadableMap eventData) {
-        UiThreadUtil.assertOnUiThread();
-
-        Method method = listenerMethods.get(eventName);
-        if (method != null) {
-            try {
-                method.invoke(listener, toHashMap(eventData));
-            } catch (IllegalAccessException e) {
-                throw new RuntimeException(e);
-            } catch (InvocationTargetException e) {
-                throw new RuntimeException(e);
-            }
-        }
-    }
-
-    /**
-     * Initializes a new {@code HashMap} instance with the key-value
-     * associations of a specific {@code ReadableMap}.
-     *
-     * @param readableMap the {@code ReadableMap} specifying the key-value
-     * associations with which the new {@code HashMap} instance is to be
-     * initialized.
-     * @return a new {@code HashMap} instance initialized with the key-value
-     * associations of the specified {@code readableMap}.
-     */
-    private static HashMap<String, Object> toHashMap(ReadableMap readableMap) {
-        HashMap<String, Object> hashMap = new HashMap<>();
-
-        for (ReadableMapKeySetIterator i = readableMap.keySetIterator();
-                i.hasNextKey();) {
-            String key = i.nextKey();
-
-            hashMap.put(key, readableMap.getString(key));
-        }
-
-        return hashMap;
-    }
-}

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

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

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

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

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

@@ -1,42 +1,18 @@
-/*
- * 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.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 {
-
-    public static final String NAME = "PictureInPicture";
-
-    private static final String TAG = NAME;
+public class PictureInPictureModule extends ReactContextBaseJavaModule {
+    private final static String TAG = "PictureInPicture";
 
     static boolean isPictureInPictureSupported() {
         return Build.VERSION.SDK_INT >= Build.VERSION_CODES.O;
@@ -46,47 +22,6 @@ class PictureInPictureModule
         super(reactContext);
     }
 
-    /**
-     * Enters Picture-in-Picture (mode) for the current {@link Activity}.
-     * Supported on Android API >= 26 (Oreo) only.
-     *
-     * @throws IllegalStateException if {@link #isPictureInPictureSupported()}
-     * returns {@code false} or if {@link #getCurrentActivity()} returns
-     * {@code null}.
-     * @throws RuntimeException if
-     * {@link Activity#enterPictureInPictureMode(PictureInPictureParams)} fails.
-     * That method can also throw a {@link RuntimeException} in various cases,
-     * including when the activity is not visible (paused or stopped), if the
-     * screen is locked or if the user has an activity pinned.
-     */
-    @TargetApi(Build.VERSION_CODES.O)
-    public void enterPictureInPicture() {
-        if (!isPictureInPictureSupported()) {
-            throw new IllegalStateException("Picture-in-Picture not supported");
-        }
-
-        Activity currentActivity = getCurrentActivity();
-
-        if (currentActivity == null) {
-            throw new IllegalStateException("No current Activity!");
-        }
-
-        JitsiMeetLogger.i(TAG + " Entering Picture-in-Picture");
-
-        PictureInPictureParams.Builder builder
-            = new PictureInPictureParams.Builder()
-                .setAspectRatio(new Rational(1, 1));
-
-        // https://developer.android.com/reference/android/app/Activity.html#enterPictureInPictureMode(android.app.PictureInPictureParams)
-        //
-        // The system may disallow entering picture-in-picture in various cases,
-        // including when the activity is not visible, if the screen is locked
-        // or if the user has an activity pinned.
-        if (!currentActivity.enterPictureInPictureMode(builder.build())) {
-            throw new RuntimeException("Failed to enter Picture-in-Picture");
-        }
-    }
-
     /**
      * Enters Picture-in-Picture (mode) for the current {@link Activity}.
      * Supported on Android API >= 26 (Oreo) only.
@@ -96,16 +31,37 @@ class PictureInPictureModule
      */
     @ReactMethod
     public void enterPictureInPicture(Promise promise) {
-        try {
-            enterPictureInPicture();
-            promise.resolve(null);
-        } catch (RuntimeException re) {
-            promise.reject(re);
+        if (isPictureInPictureSupported()) {
+            Activity currentActivity = getCurrentActivity();
+
+            if (currentActivity == null) {
+                promise.reject(new Exception("No current Activity!"));
+                return;
+            }
+
+            Log.d(TAG, "Entering Picture-in-Picture");
+
+            PictureInPictureParams.Builder builder
+                = new PictureInPictureParams.Builder()
+                    .setAspectRatio(new Rational(1, 1));
+            boolean r
+                = currentActivity.enterPictureInPictureMode(builder.build());
+
+            if (r) {
+                promise.resolve(null);
+            } else {
+                promise.reject(
+                    new Exception("Failed to enter Picture-in-Picture"));
+            }
+
+            return;
         }
+
+        promise.reject(new Exception("Picture-in-Picture not supported"));
     }
 
     @Override
     public String getName() {
-        return NAME;
+        return TAG;
     }
 }

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

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

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

@@ -1,171 +0,0 @@
-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;
-
-    /**
-     * 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);
-    }
-}

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

@@ -1,248 +0,0 @@
-/*
- * Copyright @ 2019-present 8x8, Inc.
- * Copyright @ 2017-2018 Atlassian Pty Ltd
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jitsi.meet.sdk;
-
-import android.app.Activity;
-import 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) {
-        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()
-        );
-    }
-
-    /**
-     * Helper function to send an event to JavaScript.
-     *
-     * @param eventName {@code String} containing the event name.
-     * @param data {@code Object} optional ancillary data for the event.
-     */
-    static void emitEvent(
-            String eventName,
-            @Nullable Object data) {
-        ReactInstanceManager reactInstanceManager
-            = ReactInstanceManagerHolder.getReactInstanceManager();
-
-        if (reactInstanceManager != null) {
-            ReactContext reactContext
-                = reactInstanceManager.getCurrentReactContext();
-
-            if (reactContext != null) {
-                reactContext
-                    .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
-                    .emit(eventName, data);
-            }
-        }
-    }
-
-    /**
-     * Finds a native React module for given class.
-     *
-     * @param nativeModuleClass the native module's class for which an instance
-     * is to be retrieved from the {@link #reactInstanceManager}.
-     * @param <T> the module's type.
-     * @return {@link NativeModule} instance for given interface type or
-     * {@code null} if no instance for this interface is available, or if
-     * {@link #reactInstanceManager} has not been initialized yet.
-     */
-    static <T extends NativeModule> T getNativeModule(
-            Class<T> nativeModuleClass) {
-        ReactContext reactContext
-            = reactInstanceManager != null
-                ? reactInstanceManager.getCurrentReactContext() : null;
-
-        return reactContext != null
-                ? 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;
-    }
-
-    /**
-     * Internal method to initialize the React Native instance manager. We
-     * create a single instance in order to load the JavaScript bundle a single
-     * time. All {@code ReactRootView} instances will be tied to the one and
-     * only {@code ReactInstanceManager}.
-     *
-     * @param activity {@code Activity} current running Activity.
-     */
-    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(activity.getApplication())
-                .setCurrentActivity(activity)
-                .setBundleAssetName("index.android.bundle")
-                .setJSMainModulePath("index.android")
-                .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();
-    }
-}

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

@@ -17,6 +17,7 @@
 package org.jitsi.meet.sdk;
 
 import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.JavaScriptModule;
 import com.facebook.react.bridge.NativeModule;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.uimanager.ViewManager;
@@ -24,9 +25,7 @@ import com.facebook.react.uimanager.ViewManager;
 import java.util.Collections;
 import java.util.List;
 
-class ReactPackageAdapter
-    implements ReactPackage {
-
+public class ReactPackageAdapter implements ReactPackage {
     @Override
     public List<NativeModule> createNativeModules(
             ReactApplicationContext reactContext) {

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

@@ -19,14 +19,15 @@ package org.jitsi.meet.sdk;
 import android.content.Context;
 import android.net.wifi.WifiInfo;
 import android.net.wifi.WifiManager;
+import android.os.Handler;
+import android.os.Looper;
+import android.util.Log;
 
 import com.facebook.react.bridge.Promise;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReactContextBaseJavaModule;
 import com.facebook.react.bridge.ReactMethod;
-import com.facebook.react.module.annotations.ReactModule;
 
-import org.jitsi.meet.sdk.log.JitsiMeetLogger;
 import org.json.JSONArray;
 import org.json.JSONObject;
 
@@ -35,37 +36,37 @@ import java.net.NetworkInterface;
 import java.net.SocketException;
 import java.net.UnknownHostException;
 import java.util.Enumeration;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
 
 /**
  * Module exposing WiFi statistics.
  *
- * Gathers rssi, signal in percentage, timestamp and the addresses of the wifi
- * device.
+ * Gathers rssi, signal in percentage, timestamp and the addresses
+ * of the wifi device.
  */
-@ReactModule(name = WiFiStatsModule.NAME)
-class WiFiStatsModule
-    extends ReactContextBaseJavaModule {
-
-    public static final String NAME = "WiFiStats";
+class WiFiStatsModule extends ReactContextBaseJavaModule {
+    /**
+     * The name of {@code WiFiStatsModule} to be used in the React Native
+     * bridge.
+     */
+    private static final String MODULE_NAME = "WiFiStats";
 
     /**
      * The {@code Log} tag {@code WiFiStatsModule} is to log messages with.
      */
-    static final String TAG = NAME;
+    static final String TAG = MODULE_NAME;
 
     /**
-     * The scale used for the signal value. A level of the signal, given in the
-     * range of 0 to SIGNAL_LEVEL_SCALE-1 (both inclusive).
+     * The scale used for the signal value.
+     * A level of the signal, given in the range
+     * of 0 to SIGNAL_LEVEL_SCALE-1 (both inclusive).
      */
     public final static int SIGNAL_LEVEL_SCALE = 101;
 
     /**
-     * {@link ExecutorService} for running all operations on a dedicated thread.
+     * {@link Handler} for running all operations on the main thread.
      */
-    private static final ExecutorService executor
-        = Executors.newSingleThreadExecutor();
+    private final Handler mainThreadHandler
+            = new Handler(Looper.getMainLooper());
 
     /**
      * Initializes a new module instance. There shall be a single instance of
@@ -85,7 +86,7 @@ class WiFiStatsModule
      */
     @Override
     public String getName() {
-        return NAME;
+        return MODULE_NAME;
     }
 
     /**
@@ -118,6 +119,7 @@ class WiFiStatsModule
             @Override
             public void run() {
                 try {
+
                     Context context
                         = getReactApplicationContext().getApplicationContext();
                     WifiManager wifiManager
@@ -144,7 +146,8 @@ class WiFiStatsModule
                     JSONObject result = new JSONObject();
                     result.put("rssi", rssi)
                         .put("signal", signalLevel)
-                        .put("timestamp", System.currentTimeMillis());
+                        .put("timestamp",
+                                String.valueOf(System.currentTimeMillis()));
 
                     JSONArray addresses = new JSONArray();
 
@@ -184,20 +187,22 @@ class WiFiStatsModule
 
                         }
                     } catch (SocketException e) {
-                        JitsiMeetLogger.e(e, TAG + " Unable to NetworkInterface.getNetworkInterfaces()");
+                        Log.wtf(TAG,
+                            "Unable to NetworkInterface.getNetworkInterfaces()"
+                        );
                     }
 
                     result.put("addresses", addresses);
                     promise.resolve(result.toString());
 
-                    JitsiMeetLogger.d(TAG + " WiFi stats: " + result.toString());
+                    Log.d(TAG, "WiFi stats: " + result.toString());
                 } catch (Throwable e) {
-                    JitsiMeetLogger.e(e, TAG + " Failed to obtain wifi stats");
+                    Log.e(TAG, "Failed to obtain wifi stats", e);
                     promise.reject(
                         new Exception("Failed to obtain wifi stats"));
                 }
             }
         };
-        executor.execute(r);
+        mainThreadHandler.post(r);
     }
 }

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

@@ -1,72 +0,0 @@
-/*
- * Copyright @ 2018-present Atlassian Pty Ltd
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jitsi.meet.sdk.incoming_call;
-
-import androidx.annotation.NonNull;
-
-public class IncomingCallInfo {
-    /**
-     * URL for the caller avatar.
-     */
-    private final String callerAvatarURL;
-
-    /**
-     * Caller's name.
-     */
-    private final String callerName;
-
-    /**
-     * Whether this is a regular call or a video call.
-     */
-    private final boolean hasVideo;
-
-    public IncomingCallInfo(
-            @NonNull String callerName,
-            @NonNull String callerAvatarURL,
-            boolean hasVideo) {
-        this.callerName = callerName;
-        this.callerAvatarURL = callerAvatarURL;
-        this.hasVideo = hasVideo;
-    }
-
-    /**
-     * Gets the caller's avatar URL.
-     * 
-     * @return - The URL as a string.
-     */
-    public String getCallerAvatarURL() {
-        return callerAvatarURL;
-    }
-
-    /**
-     * Gets the caller's name.
-     *
-     * @return - The caller's name.
-     */
-    public String getCallerName() {
-        return callerName;
-    }
-
-    /**
-     * Gets whether the call is a video call or not.
-     *
-     * @return - {@code true} if this call has video; {@code false}, otherwise.
-     */
-    public boolean hasVideo() {
-        return hasVideo;
-    }
-}