-
+
diff --git a/core/modules/meet/client/meet-low-level.js b/core/modules/meet/client/meet-low-level.js
index 378e1568b..3c60c632f 100644
--- a/core/modules/meet/client/meet-low-level.js
+++ b/core/modules/meet/client/meet-low-level.js
@@ -1,258 +1,480 @@
-/* eslint-disable prefer-rest-params */
+import { getTrackType, updateTrack, attachLocalTracks, replaceLocalTrack } from './tracks/utils'
-// https://jitsi.github.io/handbook/docs/dev-guide/dev-guide-ljm-api/
+window.addEventListener('DOMContentLoaded', () => {
+ jitsiMeetJS = undefined
+ if (!Meteor.settings.public.meet) return
-window.addEventListener('load', () => registerModules(['meetLowLevelTracks']))
+ const head = document.querySelector('head')
-Template.meetLowLevelTracks.events({
- 'click .js-fullscreen': function () {
- Session.set(
- 'meetLowLevelFullscreenTrackId',
- Session.get('meetLowLevelFullscreenTrackId') === this.getId() ? undefined : this.getId()
- )
- },
-})
+ const scriptLowLevel = document.createElement('script')
+ scriptLowLevel.src = `https://${Meteor.settings.public.meet.serverURL}/libs/lib-jitsi-meet.min.js`
+ head.appendChild(scriptLowLevel)
-Template.meetLowLevelTracks.helpers({
- track() {
- return meet.tracks.find((t) => t.getId() === `${this}`)
- },
- sessionMeetLowLevelTracks() {
- return Session.get('meetLowLevelTracks')
- },
+ scriptLowLevel.onload = () => {
+ jitsiMeetJS = window.JitsiMeetJS
+ }
})
-Template.meetLowLevelVideoTrack.helpers({
- name() {
- const participant = meet.room.getParticipants().find((p) => p.getId() === this.getParticipantId())
- return participant?.getDisplayName() || Meteor.user().profile.name || ''
- },
+Template.meetLowLevel.onCreated(function () {
+ this.avatarURL = new ReactiveVar()
+ this.connection = new ReactiveVar(undefined)
+ this.localTracks = new ReactiveVar([])
+ this.remoteTracks = new ReactiveVar({})
+ meetLowLevel.template = this
+
+ this.autorun(() => {
+ if (!Meteor.userId()) return
+ const user = Meteor.user({ fields: { 'profile.avatar': 1 } })
+ if (user) this.avatarURL.set(generateRandomAvatarURLForUser(user))
+ })
+
+ this.autorun(() => {
+ const user = Meteor.user({ fields: { 'profile.videoRecorder': 1 } })
+
+ if (!user || !jitsiMeetJS) return
+ jitsiMeetJS
+ .createLocalTracks({
+ devices: ['video'],
+ cameraDeviceId: user?.profile?.videoRecorder,
+ })
+ .then((tracks) => replaceLocalTrack(this, tracks[0]))
+ .catch((err) => console.error('An error occured while creating local tracks', err))
+ })
+
+ this.autorun(() => {
+ const user = Meteor.user({ fields: { 'profile.audioRecorder': 1 } })
+
+ if (!user || !jitsiMeetJS) return
+ jitsiMeetJS
+ .createLocalTracks({
+ devices: ['audio'],
+ micDeviceId: user?.profile?.audioRecorder,
+ })
+ .then((tracks) => replaceLocalTrack(this, tracks[0]))
+ .catch((err) => console.error('An error occured while creating local tracks', err))
+ })
+
+ this.autorun(() => {
+ if (this.connection.get() && Session.get('isJitsiMeetOpen')) {
+ meetLowLevel.disconnect()
+ }
+ })
+
+ window.addEventListener(eventTypes.onUsersComeCloser, (e) => onUsersComeCloser(e, this))
+ window.addEventListener(eventTypes.onUsersMovedAway, (e) => onUsersMovedAway(e, this))
+ window.addEventListener(eventTypes.onUserPropertyUpdated, (e) => onUserPropertyUpdated(e, this))
})
-const trackAttach = () => {
- const track = Template.currentData()
- const el = $(`#${track.getId()} .st`)[0]
- // force muted property to be sync with attribute
- el.muted = el.getAttribute('muted')
- track.attach(el)
-}
+Template.meetLowLevel.onDestroyed(() => {
+ window.removeEventListener(eventTypes.onUsersComeCloser, (e) => onUsersComeCloser(e, this))
+ window.removeEventListener(eventTypes.onUsersMovedAway, (e) => onUsersMovedAway(e, this))
+ window.removeEventListener(eventTypes.onUserPropertyUpdated, (e) => onUserPropertyUpdated(e, this))
+})
-Template.meetLowLevelAudioTrack.onRendered(trackAttach)
-Template.meetLowLevelVideoTrack.onRendered(trackAttach)
+Template.meetLowLevel.helpers({
+ avatarURL() {
+ return Template.instance().avatarURL.get()
+ },
+ isActive() {
+ const isActive = Template.instance().connection.get() !== undefined && meetLowLevel.getCallCount() > 0
-const trackDetach = () => {
- const track = Template.currentData()
- track.detach($(`#${track.getId()} .st`)[0])
-}
+ Session.set('isLowLevelActive', isActive)
+ return isActive
+ },
+ remoteTracks() {
+ // Check a better way to remove undefined tracks
+ return Object.values(Template.instance().remoteTracks.get()).filter((track) => track.audio && track.camera)
+ },
+ isLocalVideoActive() {
+ const user = Meteor.user({ fields: { 'profile.shareVideo': 1 } })
-Template.meetLowLevelAudioTrack.onDestroyed(trackDetach)
-Template.meetLowLevelVideoTrack.onDestroyed(trackDetach)
+ if (!user || !user.profile) return
+ return user.profile.shareVideo && Template.instance().localTracks.get().length > 0
+ },
+ isSharingScreen() {
+ const localTracks = Template.instance().localTracks.get()
-meetLowLevel = {
- lowLevel: true,
+ return localTracks?.find((t) => t.getType() === 'video' && t.getVideoType() === 'desktop')
+ },
+ fullscreenTrack() {
+ const fullscreenTrackId = Session.get('fullscreenTrackId')
+
+ if (!Session.get('fullscreenTrackId')) return
+ let fullscreenTrack
+ const remoteTracks = Object.values(Template.instance().remoteTracks.get())
+
+ remoteTracks?.forEach((tracks) => {
+ const tracksMap = Object.values(tracks)
+ tracksMap.forEach((track) => {
+ if (track && typeof track !== 'string' && track.getId() === fullscreenTrackId) {
+ fullscreenTrack = track
+ }
+ })
+ })
- api: undefined,
- connection: undefined,
- room: undefined,
+ return fullscreenTrack
+ },
+})
- tracks: [],
+/*
+ ** Events listeners
+ */
+
+const onUsersComeCloser = (e, template) => {
+ const { users } = e.detail
+
+ if (jitsiMeetJS && !template.connection.get() && !meetLowLevel.connectionStarted) {
+ meetLowLevel.connectionStarted = true
+
+ Meteor.call('getUserRoomName', users[0]._id, (err, roomName) => {
+ if (!roomName) {
+ const usersIds = users.map((user) => user._id).concat(Meteor.userId())
+ Meteor.call('computeMeetLowLevelRoomName', usersIds, (err, computedRoomName) => {
+ if (!computedRoomName) {
+ lp.notif.error('Unable to load a room, please try later')
+ return
+ }
+
+ meetLowLevel.roomName = computedRoomName
+ meetLowLevel.connect()
+ })
+ } else {
+ meetLowLevel.roomName = roomName
+ Meteor.call('updateUserRoomName', roomName)
+ meetLowLevel.connect()
+ }
+ })
+ }
+
+ users.forEach((user) => {
+ if (!meetLowLevel.usersInCall[user._id]) {
+ meetLowLevel.usersInCall[user._id] = {
+ callStartDate: Date.now(),
+ }
+ Meteor.call('analyticsDiscussionAttend', {
+ peerUserId: user._id,
+ usersAttendingCount: meetLowLevel.getCallCount(),
+ })
+ }
+ })
+}
- isJoined: false,
+const onUsersMovedAway = (e, template) => {
+ const { users } = e.detail
+
+ users.forEach((user) => {
+ if (meetLowLevel.usersInCall[user._id]) {
+ const duration = (Date.now() - meetLowLevel.usersInCall[user._id].callStartDate) / 1000
+ Meteor.call('analyticsDiscussionEnd', {
+ peerUserId: user._id,
+ duration,
+ usersAttendingCount: meetLowLevel.getCallCount(template),
+ })
+ delete meetLowLevel.usersInCall[user._id]
+ }
+ })
- onTrackAdded(track) {
- log('onTrackAdded', arguments)
+ if (template.connection.get() && meetLowLevel.getCallCount() === 0) {
+ meetLowLevel.disconnect()
+ }
+}
- meet.tracks.push(track)
- Session.set(
- 'meetLowLevelTracks',
- meet.tracks.map((t) => t.getId())
- )
- },
+const onUserPropertyUpdated = async (e, template) => {
+ const { propertyName, propertyValue } = e.detail
+ const localTracks = template.localTracks.get()
+
+ if (!localTracks || localTracks.length === 0 || !propertyName) return
+
+ if (propertyName === 'shareAudio') {
+ updateTrack('audio', localTracks)
+ } else if (propertyName === 'shareVideo') {
+ updateTrack('video', localTracks)
+ } else if (propertyName === 'shareScreen') {
+ if (propertyValue) {
+ await jitsiMeetJS.createLocalTracks({ devices: ['desktop'] }).then((tracks) => {
+ const currentDesktopTrack = localTracks.find((t) => t.getVideoType() === 'desktop')
+ const screenNode = document.querySelector('#video-screen-me')
+ const track = tracks[0] // Since we just ask for desktop, we will only have one item
+
+ track.attach(screenNode)
+
+ // If it's the first time we share screen, we should add it to the conference
+ if (!currentDesktopTrack) {
+ meetLowLevel.room.addTrack(track)
+ } else {
+ // Otherwise, we should replace since because Meet will not trigger 'TRACK_REMOVED' when we dispose the desktop track
+ meetLowLevel.room.replaceTrack(currentDesktopTrack, track)
+ }
+
+ localTracks.push(track)
+ template.localTracks.set(localTracks)
+ })
+ } else {
+ const filteredLocalTracks = localTracks.filter((track) => {
+ // While we remove the desktop track, we dispose it at the same time
+ if (track.getVideoType() === 'desktop') {
+ track.dispose()
+ return false
+ }
+ return true
+ })
+
+ template.localTracks.set(filteredLocalTracks)
+ }
+ }
+}
- onTrackRemoved(track) {
- log('onTrackRemoved', arguments)
+/*
+ ** LowMeetJs
+ */
+
+const getOptions = () => {
+ const serverURL = Meteor.settings.public.meet.serverURL
+
+ if (!serverURL) return
+ const [domain, sub] = serverURL.split('/')
+
+ return {
+ // Connection
+ hosts: {
+ domain: serverURL,
+ muc: `conference.${sub}.${domain}`,
+ focus: `focus.${domain}`,
+ },
+ serviceUrl: `wss://${serverURL}/xmpp-websocket?room=${meetLowLevel.roomName}`,
+ websocketKeepAliveUrl: `https://${serverURL}/_unlock?room=${meetLowLevel.roomName}`,
+
+ // Enable Peer-to-Peer for 1-1 calls
+ p2p: {
+ enabled: false,
+ },
+
+ // Video quality / constraints
+ constraints: {
+ video: {
+ height: {
+ ideal: 720,
+ max: 720,
+ min: 180,
+ },
+ width: {
+ ideal: 1280,
+ max: 1280,
+ min: 320,
+ },
+ },
+ },
+ channelLastN: 25,
+
+ // Logging
+ logging: {
+ // Default log level
+ defaultLogLevel: 'trace',
+
+ // The following are too verbose in their logging with the default level
+ 'modules/RTC/TraceablePeerConnection.js': 'info',
+ 'modules/statistics/CallStats.js': 'info',
+ 'modules/xmpp/strophe.util.js': 'log',
+ },
+
+ // End marker, disregard
+ __end: true,
+ }
+}
- meet.tracks = _.without(meet.tracks, track)
- Session.set(
- 'meetLowLevelTracks',
- meet.tracks.map((t) => t.getId())
- )
+export const meetLowLevel = {
+ connectionStarted: false,
+ room: undefined,
+ roomName: undefined,
+ usersInCall: {},
+ template: undefined,
+
+ async connect() {
+ if (!this.template.connection.get()) {
+ const options = getOptions()
+ const user = Meteor.user({ fields: { 'profile.audioRecorder': 1, 'profile.videoRecorder': 1 } })
+
+ jitsiMeetJS.init(options)
+ jitsiMeetJS.setLogLevel(jitsiMeetJS.logLevels.ERROR)
+
+ await jitsiMeetJS
+ .createLocalTracks({
+ devices: ['audio', 'video'],
+ cameraDeviceId: user?.profile?.videoRecorder,
+ micDeviceId: user?.profile?.audioRecorder,
+ })
+ .then((tracks) => {
+ updateTrack('video', tracks)
+ updateTrack('audio', tracks)
+ attachLocalTracks(tracks)
+ this.template.localTracks.set(tracks)
+ })
+ .catch((err) => console.error('An error occured while creating local tracks', err))
+
+ Meteor.call('computeRoomToken', this.roomName, (err, token) => {
+ const connection = new jitsiMeetJS.JitsiConnection(null, token, options)
+
+ connection.addEventListener(jitsiMeetJS.events.connection.CONNECTION_ESTABLISHED, () => {
+ this.onConnectionSuccess()
+ })
+ connection.addEventListener(jitsiMeetJS.events.connection.CONNECTION_FAILED, () => {
+ this.onConnectionFailed()
+ })
+ connection.addEventListener(jitsiMeetJS.events.connection.CONNECTION_DISCONNECTED, () => {
+ this.onConnectionDisconnected()
+ })
+
+ connection.connect()
+ this.template.connection.set(connection)
+ })
+ }
},
- onUserLeft(participantId) {
- log('user left', arguments)
+ async disconnect() {
+ this.connectionStarted = false
+ Meteor.call('updateUserRoomName', undefined)
+ if (this.room?.room) {
+ try {
+ this.room.leave()
+ } catch (err) {
+ console.log('Error while leaving', err)
+ }
+ }
- meet.tracks = meet.tracks.filter((t) => t.getParticipantId() !== participantId)
- Session.set(
- 'meetLowLevelTracks',
- meet.tracks.map((t) => t.getId())
- )
- },
+ const connection = this.template.connection.get()
- onConnectionSuccess() {
- log('onConnectionSuccess', arguments)
-
- meet.room = meet.connection.initJitsiConference(kebabCase(meet.roomName), {})
- meet.room.on(window.JitsiMeetJS.events.conference.TRACK_ADDED, meet.onTrackAdded)
- meet.room.on(window.JitsiMeetJS.events.conference.TRACK_REMOVED, meet.onTrackRemoved)
- meet.room.on(window.JitsiMeetJS.events.conference.CONFERENCE_JOINED, meet.onConferenceJoined)
- meet.room.on(window.JitsiMeetJS.events.conference.USER_JOINED, () => {
- log('user join', arguments)
+ connection.disconnect()
+ connection.removeEventListener(jitsiMeetJS.events.connection.CONNECTION_ESTABLISHED, () => {
+ this.onConnectionSuccess()
+ })
+ connection.removeEventListener(jitsiMeetJS.events.connection.CONNECTION_FAILED, () => {
+ this.onConnectionFailed()
+ })
+ connection.removeEventListener(jitsiMeetJS.events.connection.CONNECTION_DISCONNECTED, () => {
+ this.onConnectionDisconnected()
})
- meet.room.on(window.JitsiMeetJS.events.conference.USER_LEFT, meet.onUserLeft)
-
- meet.room.setDisplayName(Meteor.user().profile.name)
- meet.room.join()
+ this.room = undefined
+ this.template.connection.set(undefined)
},
- onConnectionFailed() {
- log('onConnectionFailed', arguments)
+ getCallCount() {
+ return Object.keys(this.usersInCall).length
},
- onDisconnected() {
- log('onDisconnected', arguments)
- },
-
- onConferenceJoined() {
- log('onConferenceJoined', arguments)
- meet.isJoined = true
- meet.tracks.forEach((track) => {
- if (!track.isLocal()) return
- meet.room.addTrack(track)
- })
+ /*
+ ** LowMeetJs events listeners
+ */
+ onTrackAdded(track) {
+ // Since we attach local tracks separately, we do not need attach it again
+ if (track.isLocal()) return
+
+ const participantId = track.getParticipantId()
+ const _remoteTracks = this.template.remoteTracks.get()
+
+ if (!_remoteTracks[participantId]) _remoteTracks[participantId] = {}
+
+ if (track.getType() === 'video') {
+ // When receiving a 'desktop' track, Jitsi doesn't immediately set the correct type, leading to confusion with our own tracks.
+ // Initially, a 'desktop' track is classified as a 'camera' type, but after a few seconds, it is eventually updated to a 'desktop' track type.
+ // This inconsistency is quite frustrating, and since we haven't found a suitable solution, it's better to introduce a timeout before setting the track type to 'video'.
+ // Cf: https://community.jitsi.org/t/identifying-new-track-as-desktop/118232/2
+
+ setTimeout(() => {
+ _remoteTracks[participantId][getTrackType(track)] = track
+ this.template.remoteTracks.set(_remoteTracks)
+ }, 1000)
+ } else {
+ _remoteTracks[participantId][getTrackType(track)] = track
+ this.template.remoteTracks.set(_remoteTracks)
+ }
},
- open(roomName = Meteor.settings.public.meet.roomDefaultName) {
- meet.api = window.JitsiMeetJS
-
- meet.api.init()
-
- meet.api.setLogLevel(meet.api.logLevels.ERROR)
-
- meet.tracks = []
- Session.set(
- 'meetLowLevelTracks',
- meet.tracks.map((t) => t.getId())
- )
-
- Session.set('meetLowLevelFullscreenTrackId', undefined)
-
- meet.connection = new meet.api.JitsiConnection(null, null, {
- hosts: {
- domain: Meteor.settings.public.meet.serverURL,
- muc: 'conference.jitsi.lemverse.com',
- },
- bosh: `${Meteor.absoluteUrl()}http-bind`,
- })
+ onTrackRemoved(track) {
+ const _remoteTracks = this.template.remoteTracks.get()
+ const participantId = track.getParticipantId()
- meet.connection.addEventListener(
- window.JitsiMeetJS.events.connection.CONNECTION_ESTABLISHED,
- meet.onConnectionSuccess
- )
- meet.connection.addEventListener(
- window.JitsiMeetJS.events.connection.CONNECTION_FAILED,
- meet.onConnectionFailed
- )
- meet.connection.addEventListener(
- window.JitsiMeetJS.events.connection.CONNECTION_DISCONNECTED,
- meet.onDisconnected
- )
-
- meet.roomName = roomName
-
- meet.connection.connect()
- },
+ if (_remoteTracks[participantId]) {
+ _remoteTracks[participantId][getTrackType(track)] = null
- async close() {
- meet.connection.removeEventListener(
- window.JitsiMeetJS.events.connection.CONNECTION_ESTABLISHED,
- meet.onConnectionSuccess
- )
- meet.connection.removeEventListener(
- window.JitsiMeetJS.events.connection.CONNECTION_FAILED,
- meet.onConnectionFailed
- )
- meet.connection.removeEventListener(
- window.JitsiMeetJS.events.connection.CONNECTION_DISCONNECTED,
- meet.onDisconnected
- )
-
- await Promise.all(meet.tracks.filter((t) => t.isLocal()).map((t) => t.dispose()))
-
- meet.tracks = []
- Session.set(
- 'meetLowLevelTracks',
- meet.tracks.map((t) => t.getId())
- )
-
- if (meet.room) {
- await meet.room.leave()
- meet.room = undefined
+ if (_remoteTracks[participantId].length === 0) delete _remoteTracks[participantId]
+ this.template.remoteTracks.set(_remoteTracks)
}
- if (meet.connection) {
- meet.connection.disconnect()
- meet.connection = undefined
- }
- if (meet.api) meet.api = undefined
-
- meet.isJoined = false
},
- show() {
- throw new Error('"show" is not implemented')
- },
+ onConferenceJoined() {
+ console.log('conference joined!')
- fullscreen() {
- throw new Error('"fullscreen" is not implemented')
+ // If the user is the only user in the conference, disconnect from the conference.
+ if (this.getCallCount() === 0) {
+ this.disconnect()
+ }
},
- mute() {
- const track = meet.tracks.find((t) => t.isLocal() && t.getType() === 'audio')
- if (!track) return
- track.dispose()
+ onConferenceLeft() {
+ console.log('conference left!')
},
- onLocalTracksCreated(tracks) {
- tracks.forEach((track) => {
- if (!meet.isJoined) return
- meet.room.addTrack(track)
- })
- },
+ onUserJoined(userId, participant) {
+ console.log('user joined!', userId)
+ const _remoteTracks = this.template.remoteTracks.get()
- unmute() {
- window.JitsiMeetJS.createLocalTracks({
- micDeviceId: Meteor?.user()?.profile?.audioRecorder,
- devices: ['audio'],
- }).then(meet.onLocalTracksCreated)
+ if (!_remoteTracks[userId]) _remoteTracks[userId] = {}
+ _remoteTracks[userId].displayName = participant.getDisplayName()
+ this.template.remoteTracks.set(_remoteTracks)
},
- hide() {
- const track = meet.tracks.find((t) => t.isLocal() && t.getType() === 'video' && t.getVideoType() === 'camera')
- if (!track) return
- track.dispose()
+ onConnectionSuccess() {
+ console.log('Successfully connected')
+ const user = Meteor.user({ fields: { 'profile.name': 1 } })
+
+ if (!this.room) {
+ this.room = this.template.connection.get().initJitsiConference(this.roomName, {})
+ const _localTracks = this.template.localTracks.get()
+
+ // Add local tracks before joining
+ for (let i = 0; i < _localTracks.length; i++) {
+ this.room.addTrack(_localTracks[i])
+ }
+
+ // Setup event listeners
+ this.room.on(jitsiMeetJS.events.conference.TRACK_ADDED, (track) => this.onTrackAdded(track))
+ this.room.on(jitsiMeetJS.events.conference.TRACK_REMOVED, (track) => this.onTrackRemoved(track))
+ this.room.on(jitsiMeetJS.events.conference.CONFERENCE_JOINED, () => {
+ this.onConferenceJoined()
+ })
+ this.room.on(jitsiMeetJS.events.conference.CONFERENCE_LEFT, () => {
+ this.onConferenceLeft()
+ })
+ this.room.on(jitsiMeetJS.events.conference.USER_JOINED, (userId, participant) =>
+ this.onUserJoined(userId, participant)
+ )
+ this.room.on(jitsiMeetJS.events.conference.USER_LEFT, (id) => console.log('user left!', id))
+
+ // Join
+ this.room.setDisplayName(user?.profile?.name)
+ this.room.join()
+ this.room.setSenderVideoConstraint(720) // Send at most 720p
+ this.room.setReceiverVideoConstraint(360) // Receive at most 360p for each participant
+ }
},
- unhide() {
- window.JitsiMeetJS.createLocalTracks({
- cameraDeviceId: Meteor?.user()?.profile?.videoRecorder,
- devices: ['video'],
- }).then(meet.onLocalTracksCreated)
+ onConnectionFailed() {
+ console.error('connection failed!')
},
- shareScreen() {
- window.JitsiMeetJS.createLocalTracks({
- devices: ['desktop'],
- }).then(meet.onLocalTracksCreated)
- },
+ onConnectionDisconnected() {
+ console.log('connection disconnected')
- unshareScreen() {
- const track = meet.tracks.find((t) => t.isLocal() && t.getType() === 'video' && t.getVideoType() === 'desktop')
- if (!track) return
- track.dispose()
- },
+ const _localTracks = this.template.localTracks.get()
+
+ for (let i = 0; i < _localTracks.length; i++) {
+ _localTracks[i].dispose()
+ }
- userName(name) {
- meet.room.setDisplayName(name)
+ this.template.localTracks.set([])
+ this.template.remoteTracks.set({})
+ this.usersInCall = []
+ toggleUserProperty('shareScreen', false)
},
}
diff --git a/core/modules/meet/client/meet-low-level.scss b/core/modules/meet/client/meet-low-level.scss
index 8c9e0ed9e..13e9ad11d 100644
--- a/core/modules/meet/client/meet-low-level.scss
+++ b/core/modules/meet/client/meet-low-level.scss
@@ -1,40 +1,166 @@
-.meet-low-level-tracks {
+@import '../../../client/variables';
+
+.remote-users {
+ max-height: calc(100vh - 210px);
+ position: fixed;
+ top: 10px;
+ right: 10px;
+ z-index: 50;
+ width: 280px;
+ overflow-y: scroll;
+
+ video:not(.fullscreen) {
+ object-fit: cover;
+ }
+}
+
+.remote-users::-webkit-scrollbar {
+ display: none;
+}
+
+.remote-user {
+ animation: slideIn 0.5s ease-out 0s forwards;
+}
+
+.fullscreen-container {
+ z-index: 10;
position: absolute;
+ width: calc(100% - 300px) !important;
top: 0;
- max-height: 100vh;
- left: 20%;
- right: 20%;
- overflow: scroll;
- flex-wrap: wrap;
- display: flex;
- justify-content: space-evenly;
- z-index: 1;
-
- .hide {
- display: none;
- }
+ left: 0;
+ height: 100%;
+ overflow: hidden;
- &.fullscreen {
- right: 0;
- left: 80%;
+ .fullscreen {
+ height: 100%;
+ width: 100%;
+ position: relative;
+ display: flex;
+ justify-content: center;
+ align-items: center;
- .remote-stream.active {
- position: fixed;
+ .fullscreen-background {
+ position: absolute;
top: 0;
left: 0;
- width: calc(80% - 10px);
- height: calc(100vh - 10px);
-
- .webcam {
- width: 100%;
- height: 100%;
-
- video {
- width: 100%;
- height: 100%;
- object-fit: scale-down;
- }
+ width: 100%;
+ height: 100%;
+ background-color: $new-dark-secondary;
+
+ video {
+ width: 100% !important;
+ height: 100% !important;
+ object-fit: cover !important;
+ filter: blur(30px);
+ -webkit-filter: blur(30px);
}
}
+
+ .main {
+ position: relative;
+ object-fit: contain !important;
+ display: flex;
+ align-items: center;
+ justify-content: center;
+ width: 100%;
+ height: auto;
+
+ video {
+ width: 100% !important;
+ height: auto !important;
+ }
+ }
+ }
+}
+
+.container-stream-me {
+ transform: translateX(110%);
+ transition: transform 0.5s ease-out;
+ position: fixed;
+ z-index: 50;
+ bottom: 10px;
+ right: 10px;
+
+ @include media-max('phone-down') {
+ transform: translate(300px);
+ transition: transform 0.5s;
+
+ &.visible {
+ transform: translate(0);
+ }
+
+ &.videoActive {
+ transform: translate(240px);
+
+ &.visible {
+ transform: translate(0);
+ }
+ }
+ }
+
+ &.active {
+ background-color: rgba($main-color, 1);
+ border-radius: 15px;
+ transform: translateX(0);
+ }
+
+ .stream-me {
+ position: relative;
+ width: 280px;
+ height: 180px;
+ background-color: rgba($main-color, 0.9);
+ border-radius: 15px;
+ z-index: 30;
+ overflow: hidden;
+ background-size: cover;
+
+ video {
+ width: 100%;
+ height: 180px;
+ border-radius: 10px;
+ display: none;
+ object-fit: cover;
+ transform: scale(-1, 1);
+ }
+
+ &.active-video video {
+ display: block;
+ }
+ }
+
+ .stream-screen-me {
+ display: none;
+ position: absolute;
+ bottom: 25px;
+ right: 16px;
+ width: 340px;
+ height: 200px;
+ background-color: #292929;
+ background-image: url('loader-white.gif');
+ background-size: 30%;
+ background-position: 50%;
+ background-repeat: no-repeat;
+ border-radius: 15px;
+ overflow: hidden;
+ z-index: 28;
+
+ &.active {
+ display: block;
+ }
+
+ video {
+ width: 100%;
+ object-fit: fill;
+ height: 100%;
+ }
+ }
+}
+
+@keyframes slideIn {
+ 0% {
+ transform: translateX(110%);
+ }
+ 100% {
+ transform: translateX(0);
}
}
diff --git a/core/modules/meet/client/meet.js b/core/modules/meet/client/meet.js
index ae1e33cf6..527250037 100644
--- a/core/modules/meet/client/meet.js
+++ b/core/modules/meet/client/meet.js
@@ -198,12 +198,6 @@ meetHighLevel = {
// We don't have a link between Jitsi and lemverse to identify the user at the moment. Waiting for the activation of the prosody plugin
const userEmitter = Meteor.users.findOne({ 'profile.name': nick })
if (!userEmitter) return
-
- userManager.onPeerDataReceived({
- emitter: userEmitter._id,
- data: this.convertActionToEmojis(message),
- type: 'text',
- })
})
this.api.addEventListener('participantLeft', () => {
@@ -212,8 +206,6 @@ meetHighLevel = {
this.show(true)
- peer.disable()
-
if (window.electron) {
const { setupScreenSharingRender } = window.electron.jitsiMeetElectronUtils
setupScreenSharingRender(this.api)
@@ -273,7 +265,6 @@ meetHighLevel = {
this.api?.dispose()
this.api = undefined
this.show(false)
- peer.enable()
window.dispatchEvent(new CustomEvent(eventTypes.onMeetEnded))
},
diff --git a/core/modules/meet/client/tracks/remote-audio-track.hbs.html b/core/modules/meet/client/tracks/remote-audio-track.hbs.html
new file mode 100644
index 000000000..6117318fc
--- /dev/null
+++ b/core/modules/meet/client/tracks/remote-audio-track.hbs.html
@@ -0,0 +1,11 @@
+
+
+ {{#if isMuted}}
+
+ {{/if}}
+
+
diff --git a/core/modules/meet/client/tracks/remote-audio-track.js b/core/modules/meet/client/tracks/remote-audio-track.js
new file mode 100644
index 000000000..929cc2e47
--- /dev/null
+++ b/core/modules/meet/client/tracks/remote-audio-track.js
@@ -0,0 +1,17 @@
+import { trackAttach, trackDetach } from './utils'
+
+Template.remoteAudioTrack.onCreated(function () {
+ this.isMuted = new ReactiveVar(false)
+})
+
+Template.remoteAudioTrack.onRendered(function () {
+ this.autorun(() => trackAttach(this))
+})
+
+Template.remoteAudioTrack.onDestroyed(function () {
+ this.autorun(() => trackDetach(this))
+})
+
+Template.remoteAudioTrack.helpers({
+ isMuted: () => Template.instance().isMuted.get(),
+})
diff --git a/core/modules/meet/client/tracks/remote-audio-track.scss b/core/modules/meet/client/tracks/remote-audio-track.scss
new file mode 100644
index 000000000..caff0b736
--- /dev/null
+++ b/core/modules/meet/client/tracks/remote-audio-track.scss
@@ -0,0 +1,22 @@
+.remote-audio {
+ position: relative;
+
+ .mute {
+ position: absolute;
+ z-index: 10;
+ top: 5px;
+ right: 35px;
+ font-size: 24px;
+
+ div:nth-child(1) {
+ position: absolute;
+ z-index: 11;
+ }
+
+ div:nth-child(2) {
+ position: absolute;
+ z-index: 12;
+ transform: scale(0.65);
+ }
+ }
+}
diff --git a/core/modules/meet/client/tracks/remote-desktop-track.hbs.html b/core/modules/meet/client/tracks/remote-desktop-track.hbs.html
new file mode 100644
index 000000000..b5d7d2660
--- /dev/null
+++ b/core/modules/meet/client/tracks/remote-desktop-track.hbs.html
@@ -0,0 +1,5 @@
+
+
+
+
+
diff --git a/core/modules/meet/client/tracks/remote-desktop-track.js b/core/modules/meet/client/tracks/remote-desktop-track.js
new file mode 100644
index 000000000..59506b2b6
--- /dev/null
+++ b/core/modules/meet/client/tracks/remote-desktop-track.js
@@ -0,0 +1,28 @@
+import { trackAttach, trackDetach } from './utils'
+
+Template.remoteDesktopTrack.onCreated(function () {
+ this.isMuted = new ReactiveVar(false)
+})
+
+Template.remoteDesktopTrack.onRendered(function () {
+ this.autorun(() => trackAttach(this))
+})
+
+Template.remoteDesktopTrack.onDestroyed(function () {
+ this.autorun(() => trackDetach(this))
+})
+
+Template.remoteDesktopTrack.events({
+ 'click .js-screenshare': function (event) {
+ event.preventDefault()
+ event.stopPropagation()
+ const { track } = Template.currentData()
+
+ if (!track) return
+ Session.set('fullscreenTrackId', Session.get('fullscreenTrackId') === track.getId() ? null : track.getId())
+ },
+})
+
+Template.remoteDesktopTrack.helpers({
+ isMuted: () => Template.instance().isMuted.get(),
+})
diff --git a/core/modules/meet/client/tracks/remote-fullscreen-track.hbs.html b/core/modules/meet/client/tracks/remote-fullscreen-track.hbs.html
new file mode 100644
index 000000000..115615e30
--- /dev/null
+++ b/core/modules/meet/client/tracks/remote-fullscreen-track.hbs.html
@@ -0,0 +1,12 @@
+
+
+
diff --git a/core/modules/meet/client/tracks/remote-fullscreen-track.js b/core/modules/meet/client/tracks/remote-fullscreen-track.js
new file mode 100644
index 000000000..64d30f6bb
--- /dev/null
+++ b/core/modules/meet/client/tracks/remote-fullscreen-track.js
@@ -0,0 +1,21 @@
+import { trackAttach, trackDetach } from './utils'
+
+Template.remoteFullscreen.onCreated(function () {
+ this.isMuted = new ReactiveVar(false)
+})
+
+Template.remoteFullscreen.onRendered(function () {
+ this.autorun(() => {
+ const { track } = Template.currentData()
+ trackAttach(this, `${track.getParticipantId()}-fullscreen`)
+ trackAttach(this, `${track.getParticipantId()}-fullscreenBackground`)
+ })
+})
+
+Template.remoteFullscreen.onDestroyed(function () {
+ this.autorun(() => {
+ const { track } = Template.currentData()
+ trackDetach(this, `${track.getParticipantId()}-fullscreen`)
+ trackDetach(this, `${track.getParticipantId()}-fullscreenBackground`)
+ })
+})
diff --git a/core/modules/meet/client/tracks/remote-video-track.hbs.html b/core/modules/meet/client/tracks/remote-video-track.hbs.html
new file mode 100644
index 000000000..3bad706ca
--- /dev/null
+++ b/core/modules/meet/client/tracks/remote-video-track.hbs.html
@@ -0,0 +1,12 @@
+
+
+
{{displayName}}
+
+ {{#if isMuted}}
+
+ {{/if}}
+
+ {{#if desktopTrack}} {{> remoteDesktopTrack track=desktopTrack}} {{/if}}
+
+
diff --git a/core/modules/meet/client/tracks/remote-video-track.js b/core/modules/meet/client/tracks/remote-video-track.js
new file mode 100644
index 000000000..29bdd6e74
--- /dev/null
+++ b/core/modules/meet/client/tracks/remote-video-track.js
@@ -0,0 +1,33 @@
+import { trackAttach, trackDetach } from './utils'
+
+Template.remoteVideoTrack.onCreated(function () {
+ this.isMuted = new ReactiveVar(false)
+})
+
+Template.remoteVideoTrack.onRendered(function () {
+ this.autorun(() => trackAttach(this))
+})
+
+Template.remoteVideoTrack.onDestroyed(function () {
+ this.autorun(() => trackDetach(this))
+})
+
+Template.remoteVideoTrack.events({
+ 'click .webcam': function (event) {
+ event.preventDefault()
+ event.stopPropagation()
+ const { track } = Template.currentData()
+
+ if (!track) return
+ Session.set('fullscreenTrackId', Session.get('fullscreenTrackId') === track.getId() ? null : track.getId())
+ },
+})
+
+Template.remoteVideoTrack.helpers({
+ isMuted: () => Template.instance().isMuted.get(),
+ avatar: () =>
+ generateRandomAvatarURLForUser({
+ _id: 'usr_a',
+ profile: { name: 'Guest', avatar: 'cat' },
+ }),
+})
diff --git a/core/client/ui/remote-stream.scss b/core/modules/meet/client/tracks/remote-video-track.scss
similarity index 57%
rename from core/client/ui/remote-stream.scss
rename to core/modules/meet/client/tracks/remote-video-track.scss
index 44891945a..5251accc6 100644
--- a/core/client/ui/remote-stream.scss
+++ b/core/modules/meet/client/tracks/remote-video-track.scss
@@ -1,6 +1,6 @@
-@import '../_variables';
+@import '../../../../client/variables';
-.remote-stream {
+.remote-video {
z-index: 5;
position: relative;
width: 280px;
@@ -8,8 +8,6 @@
background-color: rgba($main-color, 0.9);
border-radius: 15px;
background-size: cover;
- background-repeat: no-repeat;
- background-position: 50% 50%;
overflow-x: hidden;
margin-bottom: 10px;
@@ -57,28 +55,9 @@
}
.webcam {
+ cursor: pointer;
width: 100%;
height: 100%;
- cursor: pointer;
-
- .mute {
- position: absolute;
- z-index: 10;
- top: 5px;
- right: 35px;
- font-size: 24px;
-
- div:nth-child(1) {
- position: absolute;
- z-index: 11;
- }
-
- div:nth-child(2) {
- position: absolute;
- z-index: 12;
- transform: scale(0.65);
- }
- }
img,
video {
@@ -130,54 +109,3 @@
}
}
}
-
-.fullscreen-modal {
- position: absolute !important;
- inset: 0 !important;
- transform: unset !important;
- width: calc(100% - 300px) !important;
- height: 100% !important;
- max-height: unset !important;
- max-width: unset !important;
- border-radius: 0px !important;
-
- .fullscreen {
- height: 100%;
- width: 100%;
- position: relative;
- display: flex;
- justify-content: center;
- align-items: center;
-
- .fullscreen-background {
- position: absolute;
- top: 0;
- left: 0;
- width: 100%;
- height: 100%;
- filter: blur(10px);
- -webkit-filter: blur(30px);
-
- video {
- width: 100% !important;
- height: 100% !important;
- object-fit: cover !important;
- }
- }
-
- .main {
- position: relative;
- object-fit: contain !important;
- display: flex;
- align-items: center;
- justify-content: center;
- width: 100%;
- height: auto;
-
- video {
- width: 100% !important;
- height: auto !important;
- }
- }
- }
-}
diff --git a/core/modules/meet/client/tracks/utils.js b/core/modules/meet/client/tracks/utils.js
new file mode 100644
index 000000000..b75393a2e
--- /dev/null
+++ b/core/modules/meet/client/tracks/utils.js
@@ -0,0 +1,82 @@
+import { meetLowLevel } from '../meet-low-level'
+
+const updateTrackMuteState = (track, template) => {
+ if (template.isMuted) {
+ template.isMuted.set(track.isMuted())
+ }
+}
+
+const getTrackType = (track) => {
+ if (track.getType() === 'audio') return 'audio'
+ else if (track.getType() === 'video') return track.getVideoType()
+}
+
+const getTrackId = (track) => `${track.getParticipantId()}-${getTrackType(track)}`
+
+const updateTrack = (type, tracks) => {
+ if (!Meteor.userId()) return
+
+ const user = Meteor.user({ fields: { 'profile.shareAudio': 1, 'profile.shareVideo': 1 } })
+ const track = tracks.find((t) => t.getType() === type)
+
+ if (!track) return
+ if (type === 'audio') user?.profile?.shareAudio ? track.unmute() : track.mute()
+ else if (type === 'video') user?.profile?.shareVideo ? track.unmute() : track.mute()
+}
+
+const attachLocalTracks = (tracks) => {
+ tracks.forEach((track) => {
+ if (track.getType() === 'video') {
+ const videoNode = document.querySelector('#video-stream-me')
+ track.attach(videoNode)
+ }
+ })
+}
+
+const replaceLocalTrack = (template, newTrack) => {
+ const localTracks = template.localTracks.get()
+
+ if (localTracks) {
+ template.localTracks.set(
+ localTracks.map((track) => {
+ if (track.getType() === newTrack.getType()) {
+ // Replace old tracks by the new one
+ meetLowLevel.room.replaceTrack(track, newTrack)
+ return newTrack
+ }
+ return track
+ })
+ )
+ attachLocalTracks([newTrack])
+ }
+}
+
+const trackAttach = (template, trackId) => {
+ const { track } = Template.currentData() // Do not replace it to use 'template' props, need use global 'Template' to get the track
+
+ if (!track) return
+ const el = document.getElementById(trackId || getTrackId(track))
+
+ if (template.isMuted) {
+ template.isMuted.set(track.isMuted())
+ }
+
+ track.addEventListener(jitsiMeetJS.events.track.TRACK_MUTE_CHANGED, () => updateTrackMuteState(track, template))
+
+ if (!el) return
+ track.attach(el)
+}
+
+const trackDetach = (template, trackId) => {
+ const { track } = Template.currentData()
+
+ if (!track) return
+ const el = document.getElementById(trackId || getTrackId(track))
+
+ track.removeEventListener(jitsiMeetJS.events.track.TRACK_MUTE_CHANGED, () => updateTrackMuteState(track, template))
+
+ if (!el) return
+ track.detach(el)
+}
+
+export { trackAttach, trackDetach, getTrackType, updateTrack, attachLocalTracks, replaceLocalTrack }
diff --git a/core/modules/meet/server/meet.js b/core/modules/meet/server/meet.js
index 929d6fcd4..774c198f0 100644
--- a/core/modules/meet/server/meet.js
+++ b/core/modules/meet/server/meet.js
@@ -1,9 +1,8 @@
import * as jwt from 'jsonwebtoken'
+import crypto from 'crypto'
import { canAccessZone } from '../../../lib/misc'
-const { randomUUID } = require('crypto')
-
const computeRoomName = (zone) => {
check(zone._id, Match.Id)
@@ -11,7 +10,7 @@ const computeRoomName = (zone) => {
let { uuid } = zone
if (!uuid) {
- uuid = randomUUID()
+ uuid = crypto.randomUUID()
Zones.update(zone._id, { $set: { uuid } })
}
@@ -50,7 +49,25 @@ const computeRoomToken = (user, roomName, moderator = false) => {
)
}
+const updateUserRoomName = (roomName) => {
+ const updateObject = roomName ? { $set: { 'meet.roomName': roomName } } : { $unset: { 'meet.roomName': 1 } }
+ Meteor.users.update(Meteor.userId(), updateObject)
+}
+
Meteor.methods({
+ computeRoomToken(roomName) {
+ check(roomName, Match.Maybe(String))
+ const user = Meteor.user()
+ if (!user) return
+
+ log('computeRoomToken: start', { roomName })
+ const token = computeRoomToken(user, roomName)
+ log('computeRoomToken: end', { roomName })
+
+ return token
+ },
+
+ // Meet conference
computeMeetRoomAccess(zoneId) {
if (!this.userId) return undefined
check(zoneId, Match.Id)
@@ -75,6 +92,49 @@ Meteor.methods({
return { roomName, token }
},
+
+ // Meet low level
+ updateUserRoomName(roomName) {
+ check(roomName, Match.Maybe(String))
+ const user = Meteor.user()
+ if (user.meet.roomName === roomName) return
+
+ log('updateUserRoomName: start', { roomName })
+ updateUserRoomName(roomName)
+ log('updateUserRoomName: end', { roomName })
+ },
+ getUserRoomName(userId) {
+ check(userId, Match.OneOf(null, Match.Id))
+ const user = Meteor.users.findOne({ _id: userId || Meteor.userId() }, { fields: { 'meet.roomName': 1 } })
+ if (!user) return
+
+ log('getUserRoomName: start', { userId: userId })
+ return user.meet?.roomName
+ log('getUserRoomName: end', { userId: userId })
+ },
+ computeMeetLowLevelRoomName(usersIds) {
+ if (!this.userId) return undefined
+ check(usersIds, Array)
+
+ log('computeMeetLowLevelRoomName: start', { usersIds })
+
+ const salt = Meteor.settings.meet.salt
+ const meetRoomName = usersIds
+ .sort((a, b) => a.localeCompare(b))
+ .join('-')
+ .toLowerCase()
+
+ const hmac = crypto.createHmac('sha1', salt)
+ hmac.setEncoding('base64')
+ hmac.write(meetRoomName)
+ hmac.end()
+ hashedMeetRoomName = hmac.read().toLowerCase()
+
+ updateUserRoomName(hashedMeetRoomName)
+ log('computeMeetLowLevelRoomName: end', { meetRoomName: hashedMeetRoomName })
+
+ return hashedMeetRoomName
+ },
})
export { computeRoomName, computeRoomToken }
diff --git a/core/modules/messages/client/messages.js b/core/modules/messages/client/messages.js
index 027f6c2db..97bd69d1a 100644
--- a/core/modules/messages/client/messages.js
+++ b/core/modules/messages/client/messages.js
@@ -52,33 +52,6 @@ messagesModule = {
Session.set('messagesChannel', channel) // set console in the new channel
},
- async sendWebRTCMessage(channel, content) {
- try {
- let showPopInOverEmitter = true
- if (channel.includes('zon_')) {
- // only show the pop-in over the character when the targeted channel is the active zone
- const zone = zoneManager.currentZone(Meteor.user())
- if (!zone || zone._id !== channel) return
-
- await sendDataToUsersInZone('text', { content, channel }, Meteor.userId())
- } else {
- const userIds = userProximitySensor.filterNearUsers(channel.split(';'))
- showPopInOverEmitter = !!userIds.length
- await sendDataToUsers('text', { content, channel }, Meteor.userId(), userIds)
- }
-
- // simulate a message from himself to show a pop-in over user's head
- if (showPopInOverEmitter)
- userManager.onPeerDataReceived({
- emitter: Meteor.userId(),
- data: { content, channel },
- type: 'text',
- })
- } catch (err) {
- if (err.message !== 'no-targets') lp.notif.error(err)
- }
- },
-
async sendMessage(channel, content, file) {
if (content.length >= messageMaxLength) throw new Error(`The message is too long (> ${messageMaxLength} chars)`)
content = lp.purify(content).trim()
@@ -103,8 +76,6 @@ messagesModule = {
})
)
- if (!channel.includes('qst_') && content.length) this.sendWebRTCMessage(channel, content)
-
return messageId
},
diff --git a/core/modules/punch-ability/client/punch-ability.js b/core/modules/punch-ability/client/punch-ability.js
index fe9f5199a..cdd1fafb4 100644
--- a/core/modules/punch-ability/client/punch-ability.js
+++ b/core/modules/punch-ability/client/punch-ability.js
@@ -21,16 +21,6 @@ const punch = (users) => {
}
window.addEventListener('load', () => {
- window.addEventListener(eventTypes.onPeerDataReceived, (e) => {
- const { data, userEmitter } = e.detail
- if (data.type !== 'punch') return
-
- if (!userProximitySensor.isUserNear(userEmitter)) return
- playPunchAnimation()
-
- userManager.getCharacter(Meteor.userId())?.onDamage()
- })
-
hotkeys('x', { scope: scopes.player }, (e) => {
const user = Meteor.user({
fields: { _id: 1, 'profile.levelId': 1, roles: 1 },
diff --git a/core/modules/shout-ability/client/shout-ability.js b/core/modules/shout-ability/client/shout-ability.js
index f21324af2..f8b20d5aa 100644
--- a/core/modules/shout-ability/client/shout-ability.js
+++ b/core/modules/shout-ability/client/shout-ability.js
@@ -26,18 +26,6 @@ window.addEventListener('load', () => {
track.stop()
})
- hotkeys('r', { keyup: true, scope: scopes.player }, (event) => {
- if (event.repeat) return
-
- const user = Meteor.user({
- fields: { _id: 1, 'profile.levelId': 1, roles: 1 },
- })
-
- if (!user || !canUseLevelFeature(user, 'shout', true)) return
-
- userVoiceRecorderAbility.recordVoice(event.type === 'keydown', sendAudioChunksToUsersInZone)
- })
-
const onMenuOptionSelected = (e) => {
const { option } = e.detail
const user = Meteor.user({
diff --git a/core/modules/textual-communication-tools/client/textual-communication-tools.js b/core/modules/textual-communication-tools/client/textual-communication-tools.js
index 0fde5ab79..22efa26b7 100644
--- a/core/modules/textual-communication-tools/client/textual-communication-tools.js
+++ b/core/modules/textual-communication-tools/client/textual-communication-tools.js
@@ -66,26 +66,13 @@ const onMenuOptionSelected = (e) => {
}
}
-const onPeerDataReceived = (e) => {
- const { data, meta } = e.detail
- if (data.type !== 'text') return
- if (!meta['pop-in']) return
-
- meta['pop-in'].on('click', () => {
- if (!data.data.channel) return
- openMessagingInterface(data.data.channel)
- })
-}
-
Template.textualCommunicationTools.onCreated(() => {
messagesModule.init()
window.addEventListener(eventTypes.onMenuOptionSelected, onMenuOptionSelected)
- window.addEventListener(eventTypes.onPeerDataReceived, onPeerDataReceived)
})
Template.textualCommunicationTools.onDestroyed(() => {
window.removeEventListener(eventTypes.onMenuOptionSelected, onMenuOptionSelected)
- window.removeEventListener(eventTypes.onPeerDataReceived, onPeerDataReceived)
})
Template.textualCommunicationTools.helpers({
diff --git a/core/server/accounts.js b/core/server/accounts.js
index b3fc0ca32..0d14654f7 100644
--- a/core/server/accounts.js
+++ b/core/server/accounts.js
@@ -28,6 +28,9 @@ Accounts.validateNewUser(() => true)
Accounts.onLogin((param) => {
const user = Meteor.users.findOne(param.user._id)
+ // We should be sure that user room name is reset on login
+ Meteor.call('updateUserRoomName', undefined)
+
log('onLogin: start', {
userId: user._id,
ip: param.connection?.httpHeaders?.['x-forwarded-for'],
diff --git a/core/server/analytics.js b/core/server/analytics.js
index 39f774b01..9599e71de 100644
--- a/core/server/analytics.js
+++ b/core/server/analytics.js
@@ -94,63 +94,6 @@ Meteor.methods({
users_attending_count: properties.usersAttendingCount,
})
},
- analyticsStreamStarted(properties) {
- const { userId } = this
- if (!userId) return
-
- check(properties, {
- peerUserId: String,
- streamId: String,
- kind: String,
- })
- analytics.track(userId, 'π Stream started', {
- stream_id: properties.streamId,
- peer_user_id: properties.peerUserId,
- kind: properties.kind,
- })
- },
- analyticsStreamEstablished(properties) {
- const { userId } = this
- if (!userId) return
-
- check(properties, {
- peerUserId: String,
- streamId: String,
- kind: String,
- elapsed: Number,
- })
- analytics.track(userId, 'β
Stream established', {
- stream_id: properties.streamId,
- peer_user_id: properties.peerUserId,
- kind: properties.kind,
- elapsed: properties.elapsed,
- })
- },
- analyticsMissingTrack(properties) {
- const { userId } = this
- if (!userId) return
-
- check(properties, {
- peerUserId: String,
- streamId: String,
- kind: String,
- })
-
- analytics.track(userId, 'β Missing track', {
- stream_id: properties.streamId,
- peer_user_id: properties.peerUserId,
- kind: properties.kind,
- })
- },
- analyticsCredentialsExpired() {
- const { userId } = this
- if (!userId) return
-
- const user = Meteor.user()
- analytics.track(userId, 'βΒ Credentials expired', {
- level_id: user.profile.levelId,
- })
- },
analyticsDiscussionEnd(properties) {
const { userId } = this
if (!userId) return
diff --git a/core/server/lemverse.js b/core/server/lemverse.js
index bac38e32e..312c4771a 100644
--- a/core/server/lemverse.js
+++ b/core/server/lemverse.js
@@ -1,34 +1,10 @@
-import { PeerServer } from 'peer'
import crypto from 'crypto'
-if (Meteor.settings.peer.server.start) {
- // eslint-disable-next-line new-cap
- PeerServer({
- ...Meteor.settings.peer.server,
- path: Meteor.settings.peer.path,
- })
-}
-
Accounts.emailTemplates.from = Meteor.settings.email.from
AccountsGuest.enabled = true
AccountsGuest.forced = true
AccountsGuest.name = true
-const getTURNCredentialsExpiration = () => {
- const duration = Meteor.settings.peer?.client.credentialDuration || 86400
- return parseInt(Date.now() / 1000, 10) + duration
-}
-
-const generateTURNCredentials = (name, secret) => {
- const username = [getTURNCredentialsExpiration(), name].join(':')
- const hmac = crypto.createHmac('sha1', secret)
- hmac.setEncoding('base64')
- hmac.write(username)
- hmac.end()
-
- return { username, password: hmac.read() }
-}
-
Meteor.publish('tiles', function (levelId) {
check(levelId, Match.Maybe(String))
if (!this.userId) return undefined
@@ -46,30 +22,6 @@ Meteor.publish('characters', function () {
return Characters.find()
})
-Meteor.methods({
- getPeerConfig() {
- if (!this.userId) throw new Meteor.Error('missing-user', 'A valid user is required')
- const { url, config, port, secret } = Meteor.settings.peer.client
- const { username, password: credential } = generateTURNCredentials(this.userId, secret)
-
- const iceServers = config.iceServers.map(({ urls, auth }) => {
- if (!auth) return { urls }
- return { urls, username, credential }
- })
-
- return {
- url,
- port,
- path: Meteor.settings.peer.path,
- expiration: getTURNCredentialsExpiration(),
- config: {
- ...config,
- iceServers,
- },
- }
- },
-})
-
lp.defer(() => {
if (Levels.find().count() > 0) return