基于Jitsi的网页视频通话项目

Jitsi-meet.js如下:

(function e(t, n, r) {
    function s(o, u) {
        if (!n[o]) {
            if (!t[o]) {
                var a = typeof require == "function" && require;
                if (!u && a)
                    return a(o, !0);
                if (i)
                    return i(o, !0);
                var f = new Error("Cannot find module '" + o + "'");
                throw f.code = "MODULE_NOT_FOUND", f
            }
            var l = n[o] = {
                exports : {}
            };
            t[o][0].call(l.exports, function(e) {
                var n = t[o][1][e];
                return s(n ? n : e)
            }, l, l.exports, e, t, n, r)
        }
        return n[o].exports
    }
    var i = typeof require == "function" && require;
    for (var o = 0; o < r.length; o++)
        s(r[o]);
    return s
})
        (
                {
                    1 : [
                            function(require, module, exports) {
                                'use strict';
                                var _createClass = function() {
                                    function defineProperties(target, props) {
                                        for (var i = 0; i < props.length; i++) {
                                            var descriptor = props[i];
                                            descriptor.enumerable = descriptor.enumerable || false;
                                            descriptor.configurable = true;
                                            if ("value" in descriptor)
                                                descriptor.writable = true;
                                            Object.defineProperty(target,descriptor.key, descriptor);
                                        }
                                    }
                                    return function(Constructor, protoProps,staticProps) {
                                        if (protoProps)
                                            defineProperties(Constructor.prototype,protoProps);
                                        if (staticProps)
                                            defineProperties(Constructor,staticProps);
                                        return Constructor;
                                    };
                                }();

                                function _classCallCheck(instance, Constructor) {
                                    if (!(instance instanceof Constructor)) {
                                        throw new TypeError("Cannot call a class as a function");
                                    }
                                }

                                function _possibleConstructorReturn(self, call) {
                                if (!self) {
                                    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
                                    }
                                    return call&& (typeof call === "object" || typeof call === "function")?call:self;
                                }

                                function _inherits(subClass, superClass) {
                                    if (typeof superClass !== "function"&& superClass !== null) {
                                        throw new TypeError(
                        "Super expression must either be null or a function, not "+typeof superClass);
                                    }
                                    subClass.prototype = Object.create(
                                            superClass && superClass.prototype,
                                            {
                                                constructor : {
                                                    value : subClass,
                                                    enumerable : false,
                                                    writable : true,
                                                    configurable : true
                                                }
                                            });
                        if (superClass)
                         Object.setPrototypeOf?Object.setPrototypeOf(subClass,superClass):subClass.__proto__ = superClass;
                                }

                                var EventEmitter = require('events').EventEmitter;
                                var loadScript = require('load-script2');

                                var JitsiMeet = function(_EventEmitter) {
                                    _inherits(JitsiMeet, _EventEmitter);

                                    function JitsiMeet(baseUrl) {
                                        _classCallCheck(this, JitsiMeet);

                                        var _this = _possibleConstructorReturn(
                                        this,(JitsiMeet.__proto__ || Object.getPrototypeOf(JitsiMeet)).call(this));

                                        _this._baseUrl = new window.URL(baseUrl);
                                        _this._ready = false;

                                        setTimeout(function() {
                                            return _this._loadApi();
                                        });
                                        return _this;
                                    }

                                    _createClass(
                                            JitsiMeet,
                                            [
                                                {
                                                  key : '_loadApi',
                                                    value : function _loadApi() {
                                                    var _this2 = this;
                                                    if (window.JitsiMeetExternalAPI) {
                                                                // Already
                                                                // loaded
                                                        this._ready = true;
                                                        this.emit('ready');
                                                        return;
                                                            }
                                            var apiUrl = this._baseUrl.href+ 'external_api.js';
                                                loadScript(
                                                    apiUrl,
                                                        function(err) {
                                                            if (err) {
                                             console.error('Error loading external API from '+ apiUrl);
                                                        _this2.emit('initError');}
                                                      else {
                                                            _this2._ready = true;
                                                          _this2.emit('ready');
                                                                        }
                                                                    });
                                                        }
                                                    },
                                                    {
                                                key : 'join',
                                                value : function join(room, selector,options) {
                                                    if (!this._ready) {
                                                        throw new Error('The library is not ready yet!');
                                                        }
                                            return new JitsiMeetConference(
                                                    this._baseUrl,'' + room,selector,options);
                                                        }
                                                    }, {
                                                        key : 'ready',
                                                        get : function get() {
                                                            return this._ready;
                                                        }
                                                    } ]);
                                    return JitsiMeet;
                                }(EventEmitter);

                                var JitsiMeetConference = function(_EventEmitter2) {
                                    _inherits(JitsiMeetConference,_EventEmitter2);
                                    function JitsiMeetConference(baseUrl, room,selector, options) {
                                        _classCallCheck(this,JitsiMeetConference);
                                        var _this3 = _possibleConstructorReturn(
                    this,(JitsiMeetConference.__proto__ || Object.getPrototypeOf(JitsiMeetConference)).call(this));
                                        _this3._roomUrl = '' + baseUrl.href+ room;
                    _this3._node = typeof selector === 'string' ? document.querySelector(selector): selector;
                                        // XXX Fixup config overrides
                                    var config = Object.assign({},options.config);
                                    config.startAudioMuted = 9999; // make sure we always start unmuted
                                    config.startVideoMuted = 9999; 
                                    config.enableRecording = false; // fix bug when customizing toolbars
                                    fixupConfigObject(config);
                                    var interfaceConfig = Object.assign({},options.interfaceConfig);
                                    fixupConfigObject(interfaceConfig);
                                        _this3._api = new window.JitsiMeetExternalAPI(
                                          baseUrl.host, // domain
                                          room, undefined, undefined, _this3._node, // HTML DOM element
                                                config, interfaceConfig,
                                                baseUrl.protocol !== 'https:' // No SSL?
                                        );
                                        // XXX workarounds
                                        //_this3._api.iframeHolder.style.height = '100%';
                                        //_this3._api.iframeHolder.style.width = '100%';
                                        //_this3._api.frame.style.border = 0;
                                        _this3._avatarUrl = '';
                                        _this3._displayName = '';
                                        _this3._email = '';
                                        _this3._audioMuted = false;
                                        _this3._videoMuted = false;
                                        _this3._shareScreen = false;
                                        // Setup event listeners
                                        _this3._api.addEventListeners({
                                            videoConferenceJoined : _this3._onVideoConferenceJoined.bind(_this3),
                                            videoConferenceLeft : _this3._onVideoConferenceLeft.bind(_this3),
                                            readyToClose : _this3._onReadyToClose.bind(_this3)
                                                });
                                        return _this3;
                                    }

                                    _createClass(
                                            JitsiMeetConference,
                                            [
                                                {
                                                  key : 'hangup',
                                                    value : function hangup() {
                                                        this._api.hangup();
                                                        }
                                                    },
                                                    {
                                                        key : 'dispose',
                                                        value : function dispose() {
                                                            if (this._api !== null) {
                                                                this._api.dispose();
                                                                this._api = null;
                                                            }
                                                        }
                                                    },
                                                    {
                                                        key : '_onVideoConferenceJoined',
                                                        value : function _onVideoConferenceJoined() {
                                                            this.emit('joined');
                                                        }
                                                    },
                                                    {
                                                        key : '_onVideoConferenceLeft',
                                                        value : function _onVideoConferenceLeft() {
                                                            this.emit('left');
                                                        }
                                                    },
                                                    {
                                                        key : '_onReadyToClose',
                                                        value : function _onReadyToClose() {
                                                            this.dispose();
                                                        }
                                                    },
                                                    {
                                                        key : 'avatarUrl',
                                                        get : function get() {
                                                            return this._avatarUrl;
                                                        },
                                                        set : function set(value) {
                                                            this._avatarUrl = value;
                                                            this._api.executeCommand('avatarUrl',value);
                                                        }
                                                    },
                                                    {
                                                        key : 'displayName',
                                                        get : function get() {
                                                            return this._displayName;
                                                        },
                                                    set : function set(value) {
                                                    this._displayName = value;
                                                    this._api.executeCommand('displayName',value);
                                                        }
                                                    },
                                                    {
                                                        key : 'email',
                                                        get : function get() {
                                                            return this._email;
                                                        },
                                                        set : function set(
                                                                value) {
                                                            this._email = value;
                                                            this._api.executeCommand('email',value);
                                                        }
                                                    },
                                                    {
                                                        key : 'roomUrl',
                                                        get : function get() {
                                                            return this._roomUrl;
                                                        }
                                                    },
                                                    {
                                                        key : 'audioMuted',
                                                        get : function get() {
                                                            return this._audioMuted;
                                                        },
                                                        set : function set(
                                                                muted) {
                                                            if (this._audioMuted === muted) {
                                                                return;
                                                            }

                                                            this._audioMuted = muted;
                                                            this._api.executeCommand('toggleAudio');
                                                        }
                                                    },
                                                    {
                                                        key : 'videoMuted',
                                                        get : function get() {
                                                            return this._videoMuted;
                                                        },
                                                        set : function set(
                                                                muted) {
                                                            if (this._videoMuted === muted) {
                                                                return;
                                                            }

                                                            this._videoMuted = muted;
                                                            this._api.executeCommand('toggleVideo');
                                                        }
                                                    },
                                                    {
                                                        key : 'shareScreen',
                                                        get : function get() {
                                                            return this._shareScreen;
                                                        },
                                                        set : function set(
                                                                share) {
                                                            if (this._shareScreen === share) {
                                                                return;
                                                            }
                                                            this._shareScreen = share;
                                                            this._api.executeCommand('toggleShareScreen');
                                                        }
                                                    } ]);
                                    return JitsiMeetConference;
                                }(EventEmitter);

                                function fixupConfigObject(config) {
                                    for ( var key in config) {
                                        if (typeof key !== 'string') {
                                            continue;
                                        }
                                        try {
                                            config[key] = encodeURIComponent(JSON
                                                    .stringify(config[key]));
                                        } catch (e) {
                                            console.warn('Error encoding '+ key + ': ' + e);
                                            delete config[key];
                                        }
                                    }
                                }
                                module.exports = JitsiMeet;

                                // Export also to the window object if running
                                // in a browser.
                                if (typeof window !== 'undefined') {
                                    window.JitsiMeet = JitsiMeet;
                                }
                            }, {
                                "events" : 2,
                                "load-script2" : 3
                            } ],2:[
                            function(require, module, exports) {
                                function EventEmitter() {
                                    this._events = this._events || {};
                                    this._maxListeners = this._maxListeners|| undefined;
                                }
                                module.exports = EventEmitter;
                                // Backwards-compat with node 0.10.x
                                EventEmitter.EventEmitter = EventEmitter;
                                EventEmitter.prototype._events = undefined;
                                EventEmitter.prototype._maxListeners = undefined;
                                // By default EventEmitters will print a warning
                                // if more than 10 listeners are
                                // added to it. This is a useful default which
                                // helps finding memory leaks.
                                EventEmitter.defaultMaxListeners = 10;
                                // Obviously not all Emitters should be limited
                                // to 10. This function allows
                                // that to be increased. Set to zero for
                                // unlimited.
                                EventEmitter.prototype.setMaxListeners = function(
                                        n) {
                                    if (!isNumber(n) || n < 0 || isNaN(n))
                                        throw TypeError('n must be a positive number');
                                    this._maxListeners = n;
                                    return this;
                                };
                                EventEmitter.prototype.emit = function(type) {
                                    var er, handler, len, args, i, listeners;
                                    if (!this._events)
                                        this._events = {};
                                    // If there is no 'error' event listener
                                    // then throw.
                                    if (type === 'error') {
                                        if (!this._events.error|| (isObject(this._events.error) && !this._events.error.length)) {
                                            er = arguments[1];
                                            if (er instanceof Error) {
                                                throw er; // Unhandled 'error'
                                                            // event
                                            } else {
                                                // At least give some kind of
                                                // context to the user
                                var err = new Error('Uncaught, unspecified "error" event. ('+ er + ')');
                                        err.context = er;
                                        throw err;
                                            }
                                        }
                                    }
                                    handler = this._events[type];
                                    if (isUndefined(handler))
                                        return false;
                                    if (isFunction(handler)) {
                                        switch (arguments.length) {
                                        // fast cases
                                        case 1:
                                            handler.call(this);
                                            break;
                                        case 2:
                                            handler.call(this, arguments[1]);
                                            break;
                                        case 3:
                                            handler.call(this, arguments[1],
                                                    arguments[2]);
                                            break;
                                        // slower
                                        default:
                                            args = Array.prototype.slice.call(arguments, 1);
                                            handler.apply(this, args);
                                        }
                                    } else if (isObject(handler)) {
                                        args = Array.prototype.slice.call(arguments, 1);
                                        listeners = handler.slice();
                                        len = listeners.length;
                                        for (i = 0; i < len; i++)
                                            listeners[i].apply(this, args);
                                    }
                                    return true;
                                };
                                EventEmitter.prototype.addListener = function(type, listener) {
                                    var m;
                                    if (!isFunction(listener))
                                        throw TypeError('listener must be a function');
                                    if (!this._events)
                                        this._events = {};
                                    // To avoid recursion in the case that type
                                    // === "newListener"! Before
                                    // adding it to the listeners, first emit
                                    // "newListener".
                                    if (this._events.newListener)
                                        this.emit('newListener',type,isFunction(listener.listener) ? listener.listener: listener);
                                    if (!this._events[type])
                                        // Optimize the case of one listener.
                                        // Don't need the extra array object.
                                        this._events[type] = listener;
                                    else if (isObject(this._events[type]))
                                        // If we've already got an array, just
                                        // append.
                                        this._events[type].push(listener);
                                    else
                                        // Adding the second element, need to
                                        // change to array.
                                    this._events[type] = [this._events[type], listener ];
                                    // Check for listener leak
                                    if (isObject(this._events[type])&& !this._events[type].warned) {
                                        if (!isUndefined(this._maxListeners)) {
                                            m = this._maxListeners;
                                        } else {
                                            m = EventEmitter.defaultMaxListeners;
                                        }
                                        if (m&& m > 0&& this._events[type].length > m) {
                                            this._events[type].warned = true;
                                            console.error(
  '(node) warning: possible EventEmitter memory '+ 'leak detected. %d listeners added. '+ 'Use emitter.setMaxListeners() to increase limit.',
                                            this._events[type].length);
                                            if (typeof console.trace === 'function') {
                                                // not supported in IE 10
                                                console.trace();
                                            }
                                        }
                                    }
                                    return this;
                                };
                                EventEmitter.prototype.on = EventEmitter.prototype.addListener;
                                EventEmitter.prototype.once = function(type,
                                        listener) {
                                    if (!isFunction(listener))
                                        throw TypeError('listener must be a function');
                                    var fired = false;
                                    function g() {
                                        this.removeListener(type, g);
                                        if (!fired) {
                                            fired = true;
                                            listener.apply(this, arguments);
                                        }
                                    }
                                    g.listener = listener;
                                    this.on(type, g);
                                    return this;
                                };
                                // emits a 'removeListener' event iff the listener was removed
                                EventEmitter.prototype.removeListener = function(type, listener) {
                                    var list, position, length, i;
                                    if (!isFunction(listener))
                                        throw TypeError('listener must be a function');
                                    if (!this._events || !this._events[type])
                                        return this;
                                    list = this._events[type];
                                    length = list.length;
                                    position = -1;
                                    if (list === listener
                                            || (isFunction(list.listener) && list.listener === listener)) {
                                        delete this._events[type];
                                        if (this._events.removeListener)
                                            this.emit('removeListener', type,listener);
                                    } else if (isObject(list)) {
                                        for (i = length; i-- > 0;) {
                                            if (list[i] === listener
                                                    || (list[i].listener && list[i].listener === listener)) {
                                                position = i;
                                                break;
                                            }
                                        }
                                        if (position < 0)
                                            return this;
                                        if (list.length === 1) {
                                            list.length = 0;
                                            delete this._events[type];
                                        } else {
                                            list.splice(position, 1);
                                        }
                                        if (this._events.removeListener)
                                            this.emit('removeListener', type,
                                                    listener);
                                    }
                                    return this;
                                };
                                EventEmitter.prototype.removeAllListeners = function(type) {
                                    var key, listeners;
                                    if (!this._events)
                                        return this;
                                    // not listening for removeListener, no need to emit
                                    if (!this._events.removeListener) {
                                        if (arguments.length === 0)
                                            this._events = {};
                                        else if (this._events[type])
                                            delete this._events[type];
                                        return this;
                                    }
                                    // emit removeListener for all listeners on all events
                                    if (arguments.length === 0) {
                                        for (key in this._events) {
                                            if (key === 'removeListener')
                                                continue;
                                            this.removeAllListeners(key);
                                        }
                                        this
                                                .removeAllListeners('removeListener');
                                        this._events = {};
                                        return this;
                                    }

                                    listeners = this._events[type];

                                    if (isFunction(listeners)) {
                                        this.removeListener(type, listeners);
                                    } else if (listeners) {
                                        // LIFO order
                                        while (listeners.length)
                                            this.removeListener(
                                            type,listeners[listeners.length - 1]);
                                    }
                                    delete this._events[type];
                                    return this;
                                };
                                EventEmitter.prototype.listeners = function(
                                        type) {
                                    var ret;
                                    if (!this._events || !this._events[type])
                                        ret = [];
                                    else if (isFunction(this._events[type]))
                                        ret = [ this._events[type] ];
                                    else
                                        ret = this._events[type].slice();
                                    return ret;
                                };
                                EventEmitter.prototype.listenerCount = function(
                                        type) {
                                    if (this._events) {
                                        var evlistener = this._events[type];

                                        if (isFunction(evlistener))
                                            return 1;
                                        else if (evlistener)
                                            return evlistener.length;
                                    }
                                    return 0;
                                };
                                EventEmitter.listenerCount = function(emitter,type) {
                                    return emitter.listenerCount(type);
                                };
                                function isFunction(arg) {
                                    return typeof arg === 'function';
                                }
                                function isNumber(arg) {
                                    return typeof arg === 'number';
                                }
                                function isObject(arg) {
                                    return typeof arg === 'object'
                                            && arg !== null;
                                }
                                function isUndefined(arg) {
                                    return arg === void 0;
                                }
                            }, {} ],3 : [
                            function(require, module, exports) {
                                module.exports = load
                                function load(src, cb) {
                                    var head = document.head || document.getElementsByTagName('head')[0]
                                    var script = document.createElement('script')
                                    script.type = 'text/javascript'
                                    script.async = true
                                    script.src = src
                                    if (cb) {
                                        script.onload = function() {
                                            script.onerror = script.onload = null
                                            cb(null, script)
                                        }
                                        script.onerror = function() {
                                            script.onerror = script.onload = null
                                            cb(new Error('Failed to load '+ src), script)
                                        }
                                    }
                                    head.appendChild(script)
                                }
                            }, {} ]
                }, {}, [ 1 ]);

Jitsi.html代码如下:

<!DOCTYPE html>
<html>
    <head>
        <meta charset="utf-8">
        <meta http-equiv="content-type" content="text/html;charset=utf-8">
          <style type="text/css">
            #meet {
                position: absolute;
                bottom: 0;
                right: 0;
                width: 100%;
                height: 100%;
                overflow: hidden;
            } 
        </style><!-- 此处配置视频在整个页面的大小 -->
    </head>
    <body>
        <div id="meet"></div><!-- css与js要对这个div进行操作时就能通过id来找到这个div -->
        <script src="script/jitsi-meet.js"></script>
        <script>
            var meet = new JitsiMeet('https://meet.jit.si');
            meet.on('ready', function() {
                var interfaceConfig = { 
                    //filmStripOnly: true,
                    DEFAULT_REMOTE_DISPLAY_NAME: 'John Doe',
                };
                var options = {};
                options.interfaceConfig = interfaceConfig;
                var conference = meet.join('Test1234', '#meet', options);
                conference.on('joined', function() {
                    console.log('We are in!');
                });
            });
        </script>
    </body>
</html>

上面的两个文件是整个项目的所有文件。在eclipse上编译运行,在浏览器上可以用localhost访问,但是输入本机ip地址无法获取音频和视频:
图片说明
我尝试过在tomcat服务器上运行其他的.html文件,用localhost和ip地址都可以访问,请各位大佬帮忙看看,帮助我理解一下上面的.js文件,解决这个问题。先谢谢大家了!

2个回答

谢谢大家哈,我找到原因了:浏览器不支持http协议的ip地址访问,把项目配置成hhtps访问就可以啦!

题主可以搜索下 navigator.getusermedia 获取摄像头 和话筒权限, 需要localhost 或者域名是https的

qq_39088036
圣保罗弟弟 感谢!
8 个月之前 回复
Csdn user default icon
上传中...
上传图片
插入图片
抄袭、复制答案,以达到刷声望分或其他目的的行为,在CSDN问答是严格禁止的,一经发现立刻封号。是时候展现真正的技术了!