Initial commit

.eslintignore

+# The build artifacts of the jitsi-meet project.
+build/*
+
+# ESLint will by default ignore its own configuration file. However, there does
+# not seem to be a reason why we will want to risk being inconsistent with our
+# remaining JavaScript source code.
+!.eslintrc.js

.eslintrc.js

+module.exports = {
+    'env': {
+        'browser': true,
+        'commonjs': true,
+        'es6': true
+    },
+    'extends': 'eslint:recommended',
+    'globals': {
+        // The globals that (1) are accessed but not defined within many of our
+        // files, (2) are certainly defined, and (3) we would like to use
+        // without explicitly specifying them (using a comment) inside of our
+        // files.
+        '__filename': false
+    },
+    'parserOptions': {
+        'ecmaFeatures': {
+            'experimentalObjectRestSpread': true
+        },
+        'sourceType': 'module'
+    },
+    'rules': {
+        'new-cap': [
+            'error',
+            {
+                'capIsNew': false // Behave like JSHint's newcap.
+            }
+        ],
+        // While it is considered a best practice to avoid using methods on
+        // console in JavaScript that is designed to be executed in the browser
+        // and ESLint includes the rule among its set of recommended rules, (1)
+        // the general practice is to strip such calls before pushing to
+        // production and (2) we prefer to utilize console in lib-jitsi-meet
+        // (and jitsi-meet).
+        'no-console': 'off',
+        'semi': 'error'
+    }
+};

.gitignore

+*.swp
+.*.tmp
+.remote-sync.json
+.sync-config.cson
+.electron-gyp
+.npmrc
+
+.DS_Store
+
+# node.js
+#
+node_modules/
+npm-debug.log

.jshintignore

+node_modules

.jshintrc

+{
+  "node": true,
+
+  "curly": true,
+  "latedef": true,
+  "quotmark": true,
+  "undef": true,
+  "unused": true,
+  "trailing": true
+}

LICENSE

+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   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.

README.md

+Jitsi Meet Electron
+====
+Electron application for [Jitsi Meet](https://github.com/jitsi/jitsi-meet).
+
+## Configuration
+You can change the Jitsi Meet deployment url with the jitsiMeetURL property
+from config.js
+
+## Building the sources
+```bash
+npm run build
+```
+
+## Statring the application
+```bash
+npm start
+```
+
+## Discuss
+Please use the [Jitsi dev mailing list](http://lists.jitsi.org/pipermail/dev/) to discuss feature requests before opening an issue on Github.

config.js

+module.exports = {
+    jitsiMeetURL: "https://hristo.jitsi.net/"
+};

electron_npm_rebuild

+# Electron's version.
+export npm_config_target=1.4.7
+# The architecture of Electron, can be ia32 or x64.
+export npm_config_arch=x64
+export npm_config_target_arch=x64
+# Download headers for Electron.
+export npm_config_disturl=https://atom.io/download/electron
+# Tell node-pre-gyp that we are building for Electron.
+export npm_config_runtime=electron
+# Tell node-pre-gyp to build module from source code.
+export npm_config_build_from_source=true
+
+
+HOME=./.electron-gyp npm install

main.js

+//Electron includes
+const electron = require("electron");
+const APP = electron.app;
+const BrowserWindow = electron.BrowserWindow;
+
+const path = require("path");
+const url = require("url");
+
+/**
+ * URL for index.html which will be our entry point.
+ */
+const indexURL = url.format({
+    pathname: path.join(__dirname, "windows", "jitsi-meet", "index.html"),
+    protocol: "file:",
+    slashes: true
+});
+
+/**
+ * The window object that will load the iframe with Jitsi Meet.
+ * IMPORTANT: Must be defined as global in order to not be garbage collected
+ * acidentally.
+ */
+let jitsiMeetWindow = null;
+
+/**
+ * Sets the APP object listeners.
+ */
+function setAPPListeners () {
+    APP.on("ready", createJitsiMeetWindow);
+    APP.on("window-all-closed", () => {
+        // Don"t quit the application for Mac OS
+        if (process.platform !== "darwin") {
+            APP.quit();
+        }
+    });
+    APP.on("activate", () => {
+        if (jitsiMeetWindow === null) {
+            createJitsiMeetWindow();
+        }
+    });
+}
+
+/**
+ * Opens new window with index.html(Jitsi Meet is loaded in iframe there).
+ */
+function createJitsiMeetWindow () {
+    jitsiMeetWindow = new BrowserWindow({width: 800, height: 600});
+    jitsiMeetWindow.loadURL(indexURL);
+
+    jitsiMeetWindow.on("closed", () => {
+        jitsiMeetWindow = null;
+    });
+}
+
+//Start the application:
+setAPPListeners();

modules/remotecontrol/index.js

+let robot = require("robotjs");
+
+/**
+ * Attaching to the window for debug purposes.
+ * We should remove this in production.
+ */
+window.robot = robot;
+
+/**
+ * Width/Heught for the screen.
+ */
+const {width, height} = robot.getScreenSize();
+
+/**
+ * Mouse button mapping between the values in remote-control-event and robotjs
+ * methods.
+ */
+const MOUSE_BUTTONS = {
+    1: "left",
+    2: "middle",
+    3: "right"
+};
+
+/**
+ * Mouse actions mapping between the values in remote-control-event and robotjs
+ * methods.
+ */
+const MOUSE_ACTIONS_FROM_EVENT_TYPE = {
+    "mousedown": "down",
+    "mouseup": "up"
+};
+
+/**
+ * Key actions mapping between the values in remote-control-event and robotjs
+ * methods.
+ */
+const KEY_ACTIONS_FROM_EVENT_TYPE = {
+    "keydown": "down",
+    "keyup": "up"
+};
+
+/**
+ * The status ("up"/"down") of the mouse button.
+ * FIXME: Assuming that one button at a time can be pressed. Haven't noticed
+ * any issues but maybe we should store the status for every mouse button
+ * that we are processing.
+ */
+let mouseButtonStatus = "up";
+
+/**
+ * Parses the remote-control-events and executes them via robotjs.
+ */
+class RemoteControl {
+    /**
+     * Construcs new instance.
+     * @constructor
+     */
+    constructor() {
+        this.started = false;
+    }
+
+    /**
+     * Starts processing the events.
+     */
+    start() {
+        this.started = true;
+    }
+
+    /**
+     * Stops processing the events.
+     */
+    stop() {
+        this.started = false;
+    }
+
+    /**
+     * Executes the passed event.
+     * @param {Object} event the remote-control-event.
+     */
+    executeRemoteControlEvent(event) {
+        if(!this.started) {
+            return;
+        }
+        switch(event.type) {
+            case "mousemove":
+                const x = event.x * width, y = event.y * height;
+                if(mouseButtonStatus === "down") {
+                    robot.dragMouse(x, y);
+                } else {
+                    robot.moveMouse(x, y);
+                }
+                break;
+            case "mousedown":
+            case "mouseup":
+                mouseButtonStatus = MOUSE_ACTIONS_FROM_EVENT_TYPE[event.type];
+                robot.mouseToggle(
+                    mouseButtonStatus,
+                    (event.button ? MOUSE_BUTTONS[event.button] : undefined));
+                break;
+            case "mousedblclick":
+                robot.mouseClick(
+                    (event.button ? MOUSE_BUTTONS[event.button] : undefined),
+                    true);
+                break;
+            case "mousescroll":
+                //FIXME: implement horizontal scrolling 
+                if(event.y !== 0) {
+                    robot.scrollMouse(
+                        Math.abs(event.y),
+                        event.y > 0 ? "down" : "up"
+                    );
+                }
+                break;
+            case "keydown":
+            case "keyup":
+                robot.keyToggle(event.key,
+                    KEY_ACTIONS_FROM_EVENT_TYPE[event.type], event.modifiers);
+                break;
+            default:
+                console.error("Unknown event type!");
+        }
+    }
+}
+
+module.exports = new RemoteControl();

modules/screensharing/index.js

+const electron = require("electron");
+/**
+ * Adds screen sharing support. Prompts the user to choose screen, window or
+ * tab to share (not implemented yet). And passes the chosen source to caller
+ * of the method.
+ * @param {Function} callback the success callback
+ * @param {Function} errorCallback the callback for errors
+ */
+function obtainDesktopStream (callback, errorCallback) {
+    //FIXME: add more types
+    electron.desktopCapturer.getSources({types: ['screen']},
+        (error, sources) => {
+            if (error) {
+                errorCallback(error);
+                return;
+            }
+            //FIXME: Implement window picker instead of choosing always the
+            // first sourceId
+            callback(sources[0].id);
+        });
+}
+
+module.exports = function setupScreenSharingForWindow(pWindow) {
+    pWindow.JitsiMeetElectron = {obtainDesktopStream};
+};

package.json

+{
+  "name": "jitsi-meet-electron",
+  "version": "0.0.0",
+  "description": "Electron application for Jitsi Meet",
+  "main": "main.js",
+  "scripts": {
+    "start": "electron .",
+    "build": "./electron_npm_rebuild",
+    "clean": "rm -r node_modules .electron-gyp",
+    "lint": "eslint .",
+    "validate": "npm ls"
+  },
+  "pre-commit": [
+    "lint"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/jitsi/jitsi-meet-electron"
+  },
+  "keywords": [
+    "jingle",
+    "webrtc",
+    "xmpp",
+    "electron",
+    "jitsi-meet"
+  ],
+  "author": "",
+  "readmeFilename": "README.md",
+  "license": "Apache-2.0",
+  "dependencies": {
+    "robotjs": "hristoterezov/robotjs",
+    "postis": "^2.2.0"
+  },
+  "devDependencies": {
+    "electron": "1.4.7",
+    "eslint": ">=3",
+    "eslint-plugin-jsdoc": "*",
+    "precommit-hook": "3.0.0"
+  }
+}

windows/jitsi-meet/index.html

+<!DOCTYPE html>
+<html>
+    <head>
+        <style>
+            body, html {
+                margin: 0;
+                height: 100%;
+                overflow: hidden;
+            }
+            body {
+                -webkit-app-region: drag
+            }
+            iframe {
+                width: 100%;
+                height: 100%;
+                border: 0 none;
+            }
+        </style>
+    </head>
+    <body>
+        <script>
+            require('./render.js');
+        </script>
+    </body>
+</html>

windows/jitsi-meet/render.js

+const remoteControl = require("../../modules/remotecontrol");
+let postis = require("postis");
+const setupScreenSharingForWindow = require("../../modules/screensharing");
+const config = require("../../config.js");
+
+/**
+ * The postis channel.
+ */
+let channel;
+
+/**
+ * Cteates the iframe that will load Jitsi Meet.
+ */
+let iframe = document.createElement('iframe');
+iframe.src = config.jitsiMeetURL;
+iframe.allowFullscreen = true;
+iframe.onload = onload;
+document.body.appendChild(iframe);
+
+/**
+ * Initializes the remote control functionality.
+ */
+function initRemoteControl() {
+    remoteControl.start();
+    channel.ready(() =>
+        channel.listen('remote-control-event',
+            event => remoteControl.executeRemoteControlEvent(event))
+    );
+}
+
+/**
+ * Handles loaded event for iframe:
+ * Enables screen sharing functionality to the iframe webpage.
+ * Initializes postis.
+ * Initializes remote control.
+ */
+function onload() {
+    setupScreenSharingForWindow(iframe.contentWindow);
+    channel = postis({
+        window: iframe.contentWindow,
+