diff --git a/src/app/Http/Controllers/API/V4/OpenViduController.php b/src/app/Http/Controllers/API/V4/OpenViduController.php
index 7d0dcad6..7b34a673 100644
--- a/src/app/Http/Controllers/API/V4/OpenViduController.php
+++ b/src/app/Http/Controllers/API/V4/OpenViduController.php
@@ -1,140 +1,172 @@
 <?php
 
 namespace App\Http\Controllers\API\V4;
 
 use App\Http\Controllers\Controller;
 use App\OpenVidu\Room;
 use Illuminate\Http\Request;
 use Illuminate\Support\Facades\Auth;
 use Illuminate\Support\Facades\Validator;
 
 class OpenViduController extends Controller
 {
+    /**
+     * Close the room session.
+     *
+     * @param string $id Room identifier (name)
+     *
+     * @return \Illuminate\Http\JsonResponse
+     */
+    public function closeRoom($id)
+    {
+        $room = Room::where('name', $id)->first();
+
+        // This isn't a room, bye bye
+        if (!$room) {
+            return $this->errorResponse(404, \trans('meet.room-not-found'));
+        }
+
+        $user = Auth::guard()->user();
+
+        // Only the room owner can do it
+        if (!$user || $user->id != $room->user_id) {
+            return $this->errorResponse(403);
+        }
+
+        if (!$room->deleteSession()) {
+            return $this->errorResponse(500, \trans('meet.session-close-error'));
+        }
+
+        return response()->json([
+                'status' => 'success',
+                'message' => __('meet.session-close-success'),
+        ]);
+    }
 
     /**
      * Listing of rooms that belong to the current user.
      *
      * @return \Illuminate\Http\JsonResponse
      */
     public function index()
     {
         $user = Auth::guard()->user();
 
         $rooms = Room::where('user_id', $user->id)->orderBy('name')->get();
 
         if (count($rooms) == 0) {
             // Create a room for the user
             list($name, $domain) = explode('@', $user->email);
 
             // Room name is limited to 16 characters by the DB schema
             if (strlen($name) > 16) {
                 $name = substr($name, 0, 16);
             }
 
             while (Room::where('name', $name)->first()) {
                 $name = \App\Utils::randStr(8);
             }
 
             $room = Room::create([
                     'name' => $name,
                     'user_id' => $user->id
             ]);
 
             $rooms = collect([$room]);
         }
 
         $result = [
             'list' => $rooms,
             'count' => count($rooms),
         ];
 
         return response()->json($result);
     }
 
     /**
      * Join the room session. Each room has one owner, and the room isn't open until the owner
      * joins (and effectively creates the session).
      *
      * @param string $id Room identifier (name)
      *
      * @return \Illuminate\Http\JsonResponse
      */
     public function joinRoom($id)
     {
         $room = Room::where('name', $id)->first();
 
         // This isn't a room, bye bye
         if (!$room) {
-            return $this->errorResponse(404, \trans('meet.roomnotfound'));
+            return $this->errorResponse(404, \trans('meet.room-not-found'));
         }
 
         $user = Auth::guard()->user();
 
         // There's no existing session
         if (!$room->hasSession()) {
             // Participants can't join the room until the session is created by the owner
             if (!$user || $user->id != $room->user_id) {
-                return $this->errorResponse(423, \trans('meet.sessionnotfound'));
+                return $this->errorResponse(423, \trans('meet.session-not-found'));
             }
 
             // The room owner can create the session on request
             if (empty(request()->input('init'))) {
-                return $this->errorResponse(424, \trans('meet.sessionnotfound'));
+                return $this->errorResponse(424, \trans('meet.session-not-found'));
             }
 
             $session = $room->createSession();
 
             if (empty($session)) {
-                return $this->errorResponse(500, \trans('meet.sessioncreateerror'));
+                return $this->errorResponse(500, \trans('meet.session-create-error'));
             }
         }
 
         // Create session token for the current user/connection
         $response = $room->getSessionToken('PUBLISHER');
 
         if (empty($response)) {
-            return $this->errorResponse(500, \trans('meet.sessionjoinerror'));
+            return $this->errorResponse(500, \trans('meet.session-join-error'));
         }
 
         // Create session token for screen sharing connection
         if (!empty(request()->input('screenShare'))) {
             $add_token = $room->getSessionToken('PUBLISHER');
 
             $response['shareToken'] = $add_token['token'];
         }
 
         // Tell the UI who's the room owner
         $response['owner'] = $user && $user->id == $room->user_id;
 
-        return response()->json($response, 200);
+        return response()->json($response);
     }
 
     /**
      * Webhook as triggered from OpenVidu server
      *
      * @param \Illuminate\Http\Request $request The API request.
      *
      * @return \Illuminate\Http\Response The response
      */
     public function webhook(Request $request)
     {
         \Log::debug($request->getContent());
 
         switch ((string) $request->input('event')) {
             case 'sessionDestroyed':
                 // When all participants left the room OpenVidu dispatches sessionDestroyed
                 // event. We'll remove the session reference from the database.
                 $sessionId = $request->input('sessionId');
                 $room = Room::where('session_id', $sessionId)->first();
 
                 if ($room) {
                     $room->session_id = null;
                     $room->save();
                 }
 
                 break;
         }
 
         return response('Success', 200);
     }
 }
diff --git a/src/app/OpenVidu/Room.php b/src/app/OpenVidu/Room.php
index 9e7404ef..da291736 100644
--- a/src/app/OpenVidu/Room.php
+++ b/src/app/OpenVidu/Room.php
@@ -1,140 +1,166 @@
 <?php
 
 namespace App\OpenVidu;
 
 use App\Traits\SettingsTrait;
 use Illuminate\Database\Eloquent\Model;
 
 class Room extends Model
 {
     use SettingsTrait;
 
     protected $fillable = [
         'user_id',
         'name'
     ];
 
     protected $table = 'openvidu_rooms';
 
     /** @var \GuzzleHttp\Client|null HTTP client instance */
     private static $client = null;
 
 
     /**
      * Creates HTTP client for connections to OpenVidu server
      *
      * @return \GuzzleHttp\Client HTTP client instance
      */
     private function client()
     {
         if (!self::$client) {
             self::$client = new \GuzzleHttp\Client(
                 [
                     'http_errors' => false, // No exceptions from Guzzle
                     'base_uri' => \config('openvidu.api_url'),
                     'verify' => \config('openvidu.api_verify_tls'),
                     'auth' => [
                         \config('openvidu.api_username'),
                         \config('openvidu.api_password')
                     ]
                 ]
             );
         }
 
         return self::$client;
     }
 
     /**
      * Create a OpenVidu session
      *
      * @return array|null Session data on success, NULL otherwise
      */
     public function createSession(): ?array
     {
         $response = $this->client()->request(
             'POST',
             "sessions",
             [
                 'json' => [
                     'mediaMode' => 'ROUTED',
                     'recordingMode' => 'MANUAL'
                 ]
             ]
         );
 
         if ($response->getStatusCode() !== 200) {
             $this->session_id = null;
             $this->save();
         }
 
         $session = json_decode($response->getBody(), true);
 
         $this->session_id = $session['id'];
         $this->save();
 
         return $session;
     }
 
+    /**
+     * Delete a OpenVidu session
+     *
+     * @return bool
+     */
+    public function deleteSession(): bool
+    {
+        if (!$this->session_id) {
+            return true;
+        }
+
+        $response = $this->client()->request(
+            'DELETE',
+            "sessions/" . $this->session_id,
+        );
+
+        if ($response->getStatusCode() == 204) {
+            $this->session_id = null;
+            $this->save();
+
+            return true;
+        }
+
+        return false;
+    }
+
     /**
      * Create a OpenVidu session (connection) token
      *
      * @return array|null Token data on success, NULL otherwise
      */
     public function getSessionToken($role = 'PUBLISHER'): ?array
     {
         $response = $this->client()->request(
             'POST',
             'tokens',
             [
                 'json' => [
                     'session' => $this->session_id,
                     'role' => $role
                 ]
             ]
         );
 
         if ($response->getStatusCode() == 200) {
             $json = json_decode($response->getBody(), true);
 
             return $json;
         }
 
         return null;
     }
 
     /**
      * Check if the room has an active session
      *
      * @return bool True when the session exists, False otherwise
      */
     public function hasSession(): bool
     {
         if (!$this->session_id) {
             return false;
         }
 
         $response = $this->client()->request('GET', "sessions/{$this->session_id}");
 
         return $response->getStatusCode() == 200;
     }
 
     /**
      * The room owner.
      *
      * @return \Illuminate\Database\Eloquent\Relations\BelongsTo
      */
     public function owner()
     {
         return $this->belongsTo('\App\User', 'user_id', 'id');
     }
 
     /**
      * Any (additional) properties of this room.
      *
      * @return \Illuminate\Database\Eloquent\Relations\HasMany
      */
     public function settings()
     {
         return $this->hasMany('App\OpenVidu\RoomSetting', 'room_id');
     }
 }
diff --git a/src/resources/js/meet/app.js b/src/resources/js/meet/app.js
index 89075f84..746904d4 100644
--- a/src/resources/js/meet/app.js
+++ b/src/resources/js/meet/app.js
@@ -1,811 +1,814 @@
 import anchorme from 'anchorme'
 import { library } from '@fortawesome/fontawesome-svg-core'
 import { OpenVidu } from 'openvidu-browser'
 
 
 function Meet(container)
 {
     let OV                      // OpenVidu object to initialize a session
     let session                 // Session object where the user will connect
     let publisher               // Publisher object which the user will publish
     let audioEnabled = false    // True if the audio track of publisher is active
     let videoEnabled = false    // True if the video track of publisher is active
     let numOfVideos = 0         // Keeps track of the number of videos that are being shown
     let audioSource = ''        // Currently selected microphone
     let videoSource = ''        // Currently selected camera
     let sessionData             // Room session metadata
 
     let screenOV                // OpenVidu object to initialize a screen sharing session
     let screenSession           // Session object where the user will connect for screen sharing
     let screenPublisher         // Publisher object which the user will publish the screen sharing
 
     let publisherDefaults = {
         publishAudio: true,     // Whether to start publishing with your audio unmuted or not
         publishVideo: true,     // Whether to start publishing with your video enabled or not
         resolution: '640x480',  // The resolution of your video
         frameRate: 30,          // The frame rate of your video
         mirror: true            // Whether to mirror your local video or not
     }
 
     let cameras = []            // List of user video devices
     let microphones = []        // List of user audio devices
     let connections = {}        // Connected users in the session
 
     let containerWidth
     let containerHeight
     let chatCount = 0
     let volumeElement
     let setupProps
 
     OV = new OpenVidu()
     screenOV = new OpenVidu()
 
     // if there's anything to do, do it here.
     //OV.setAdvancedConfiguration(config)
 
     // Disconnect participant when browser's window close
     window.addEventListener('beforeunload', () => {
         leaveRoom()
     })
 
     window.addEventListener('resize', resize)
 
     // Public methods
     this.isScreenSharingSupported = isScreenSharingSupported
     this.joinRoom = joinRoom
     this.leaveRoom = leaveRoom
     this.setup = setup
     this.setupSetAudioDevice = setupSetAudioDevice
     this.setupSetVideoDevice = setupSetVideoDevice
     this.switchAudio = switchAudio
     this.switchScreen = switchScreen
     this.switchVideo = switchVideo
 
 
     /**
      * Join the room session
      *
-     * @param data Session metadata (session, token, shareToken, nickname, chatElement, menuElement)
+     * @param data Session metadata and event handlers (session, token, shareToken, nickname,
+     *             chatElement, menuElement, onDestroy)
      */
     function joinRoom(data) {
         resize();
         volumeMeterStop()
 
         data.params = {
             nickname: data.nickname, // user nickname
             // avatar: undefined        // avatar image
         }
 
         sessionData = data
 
         // Init a session
         session = OV.initSession()
 
         // On every new Stream received...
         session.on('streamCreated', event => {
             let connection = event.stream.connection
             let connectionId = connection.connectionId
             let metadata = JSON.parse(connection.data)
 
             let wrapper = addVideoWrapper(container, metadata, event.stream)
 
             // Subscribe to the Stream to receive it
             let subscriber = session.subscribe(event.stream, wrapper);
 
             // When the new video is added to DOM, update the page layout
             subscriber.on('videoElementCreated', event => {
                 numOfVideos++
                 updateLayout()
 
                 connections[connectionId] = {
                     element: wrapper
                 }
 
                 // Send the current user status to the connecting user
                 // otherwise e.g. nickname might be not up to date
                 signalUserUpdate(connection)
             })
 
             // When a video is removed from DOM, update the page layout
             subscriber.on('videoElementDestroyed', event => {
                 numOfVideos--
                 updateLayout()
 
                 delete connections[connectionId]
             })
         })
-/*
-        // On every new Stream destroyed...
-        session.on('streamDestroyed', event => {
-            // Update the page layout
-            numOfVideos--
+
+        // Handle session disconnection events
+        session.on('sessionDisconnected', event => {
+            if (data.onDestroy) {
+                data.onDestroy(event)
+            }
+
             updateLayout()
         })
-*/
+
         // Register handler for signals from other participants
         session.on('signal', signalEventHandler)
 
         // Connect with the token
         session.connect(data.token, data.params)
             .then(() => {
                 data.params.publisher = true
 
                 let wrapper = addVideoWrapper(container, data.params)
 
                 publisher.on('videoElementCreated', event => {
                     $(event.element).prop('muted', true) // Mute local video to avoid feedback
 
                     numOfVideos++
                     updateLayout()
                 })
 
                 publisher.createVideoElement(wrapper, 'PREPEND')
                 sessionData.wrapper = wrapper
 
                 // Publish the stream
                 session.publish(publisher)
             })
             .catch(error => {
                 console.error('There was an error connecting to the session: ', error.message);
             })
 
         // Prepare the chat
         setupChat()
     }
 
     /**
      * Leave the room (disconnect)
      */
     function leaveRoom() {
         if (publisher) {
             volumeMeterStop()
             publisher.publishAudio(false)
             publisher.publishVideo(false)
         }
 
         if (session) {
             session.disconnect();
             session = null
         }
 
         if (screenSession) {
             screenSession.disconnect();
             screenSession = null
         }
 
         publisher = null
     }
 
     /**
      * Sets the audio and video devices for the session.
      * This will ask user for permission to access media devices.
      *
      * @param props Setup properties (videoElement, volumeElement, success, error)
      */
     function setup(props) {
         setupProps = props
 
         publisher = OV.initPublisher(undefined, publisherDefaults)
 
         publisher.once('accessDenied', error => {
             props.error(error)
         })
 
         publisher.once('accessAllowed', async () => {
             let mediaStream = publisher.stream.getMediaStream()
             let videoStream = mediaStream.getVideoTracks()[0]
             let audioStream = mediaStream.getAudioTracks()[0]
 
             audioEnabled = !!audioStream
             videoEnabled = !!videoStream
             volumeElement = props.volumeElement
 
             publisher.addVideoElement(props.videoElement)
 
             volumeMeterStart()
 
             const devices = await OV.getDevices()
 
             devices.forEach(device => {
                 // device's props: deviceId, kind, label
                 if (device.kind == 'videoinput') {
                     cameras.push(device)
                     if (videoStream && videoStream.label == device.label) {
                         videoSource = device.deviceId
                     }
                 } else if (device.kind == 'audioinput') {
                     microphones.push(device)
                     if (audioStream && audioStream.label == device.label) {
                         audioSource = device.deviceId
                     }
                 }
             })
 
             props.success({
                 microphones,
                 cameras,
                 audioSource,
                 videoSource,
                 audioEnabled,
                 videoEnabled
             })
         })
     }
 
     /**
      * Change the publisher audio device
      *
      * @param deviceId Device identifier string
      */
     async function setupSetAudioDevice(deviceId) {
         if (!deviceId) {
             publisher.publishAudio(false)
             volumeMeterStop()
             audioEnabled = false
         } else if (deviceId == audioSource) {
             publisher.publishAudio(true)
             volumeMeterStart()
             audioEnabled = true
         } else {
             const mediaStream = publisher.stream.mediaStream
             const oldTrack = mediaStream.getAudioTracks()[0]
 
             let properties = Object.assign({}, publisherDefaults, {
                 publishAudio: true,
                 publishVideo: videoEnabled,
                 audioSource: deviceId,
                 videoSource: videoSource
             })
 
             volumeMeterStop()
 
             // Note: We're not using publisher.replaceTrack() as it wasn't working for me
 
             // Stop and remove the old track
             if (oldTrack) {
                 oldTrack.stop()
                 mediaStream.removeTrack(oldTrack)
             }
 
             // TODO: Handle errors
 
             await OV.getUserMedia(properties)
                 .then(async (newMediaStream) => {
                     publisher.stream.mediaStream = newMediaStream
                     volumeMeterStart()
                     audioEnabled = true
                     audioSource = deviceId
                 })
         }
 
         return audioEnabled
     }
 
     /**
      * Change the publisher video device
      *
      * @param deviceId Device identifier string
      */
     async function setupSetVideoDevice(deviceId) {
         if (!deviceId) {
             publisher.publishVideo(false)
             videoEnabled = false
         } else if (deviceId == videoSource) {
             publisher.publishVideo(true)
             videoEnabled = true
         } else {
             const mediaStream = publisher.stream.mediaStream
             const oldTrack = mediaStream.getAudioTracks()[0]
 
             let properties = Object.assign({}, publisherDefaults, {
                 publishAudio: audioEnabled,
                 publishVideo: true,
                 audioSource: audioSource,
                 videoSource: deviceId
             })
 
             volumeMeterStop()
 
             // Stop and remove the old track
             if (oldTrack) {
                 oldTrack.stop()
                 mediaStream.removeTrack(oldTrack)
             }
 
             // TODO: Handle errors
 
             await OV.getUserMedia(properties)
                 .then(async (newMediaStream) => {
                     publisher.stream.mediaStream = newMediaStream
                     volumeMeterStart()
                     videoEnabled = true
                     videoSource = deviceId
                 })
         }
 
         return videoEnabled
     }
 
     /**
      * Setup the chat UI
      */
     function setupChat() {
         // The UI elements are created in the vue template
         // Here we add a logic for how they work
 
         const textarea = $(sessionData.chatElement).find('textarea')
         const button = $(sessionData.menuElement).find('.link-chat')
 
         textarea.on('keydown', e => {
             if (e.keyCode == 13 && !e.shiftKey) {
                 if (textarea.val().length) {
                     signalChat(textarea.val())
                     textarea.val('')
                 }
 
                 return false
             }
         })
 
         // Add an element for the count of unread messages on the chat button
         button.append('<span class="badge badge-dark blinker">')
             .on('click', () => { button.find('.badge').text('') })
     }
 
     /**
      * Signal events handler
      */
     function signalEventHandler(signal) {
         let conn, data
 
         switch (signal.type) {
             case 'signal:userChanged':
                 if (conn = connections[signal.from.connectionId]) {
                     data = JSON.parse(signal.data)
                     $(conn.element).find('.nickname > span').text(data.nickname || '')
                     $(conn.element).find('.status-audio')[data.audioEnabled ? 'addClass' : 'removeClass']('d-none')
                     $(conn.element).find('.status-video')[data.videoEnabled ? 'addClass' : 'removeClass']('d-none')
                 }
                 break
 
             case 'signal:chat':
                 data = JSON.parse(signal.data)
                 data.id = signal.from.connectionId
                 pushChatMessage(data)
                 break
         }
     }
 
     /**
      * Send the chat message to other participants
      *
      * @param message Message string
      */
     function signalChat(message) {
         let data = {
             nickname: sessionData.params.nickname,
             message
         }
 
         session.signal({
             data: JSON.stringify(data),
             type: 'chat'
         })
     }
 
     /**
      * Add a message to the chat
      *
      * @param data Object with a message, nickname, id (of the connection, empty for self)
      */
     function pushChatMessage(data) {
         let message = $('<span>').text(data.message).text() // make the message secure
 
         // Format the message, convert emails and urls to links
         message = anchorme({
             input: message,
             options: {
                 attributes: {
                     target: "_blank"
                 },
                 // any link above 20 characters will be truncated
                 // to 20 characters and ellipses at the end
                 truncate: 20,
                 // characters will be taken out of the middle
                 middleTruncation: true
             }
             // TODO: anchorme is extensible, we could support
             //       github/phabricator's markup e.g. backticks for code samples
         })
 
         message = message.replace(/\r?\n/, '<br>')
 
         // Display the message
         let isSelf = data.id == publisher.stream.connection.connectionId
         let chat = $(sessionData.chatElement).find('.chat')
         let box = chat.find('.message').last()
 
         message = $('<div>').html(message)
 
         message.find('a').attr('rel', 'noreferrer')
 
         if (box.length && box.data('id') == data.id) {
             // A message from the same user as the last message, no new box needed
             message.appendTo(box)
         } else {
             box = $('<div class="message">').data('id', data.id)
                 .append($('<div class="nickname">').text(data.nickname || ''))
                 .append(message)
                 .appendTo(chat)
 
             if (isSelf) {
                 box.addClass('self')
             }
         }
 
         // Count unread messages
         if (!$(sessionData.chatElement).is('.open')) {
             if (!isSelf) {
                 chatCount++
             }
         } else {
             chatCount = 0
         }
 
         $(sessionData.menuElement).find('.link-chat .badge').text(chatCount ? chatCount : '')
     }
 
     /**
      * Send the user properties update signal to other participants
      *
      * @param connection Optional connection to which the signal will be sent
      *                   If not specified the signal is sent to all participants
      */
     function signalUserUpdate(connection) {
         let data = {
             audioEnabled,
             videoEnabled,
             nickname: sessionData.params.nickname
         }
 
         // TODO: The same for screen sharing session?
         session.signal({
             data: JSON.stringify(data),
             type: 'userChanged',
             to: connection ? [connection] : undefined
         })
     }
 
     /**
      * Mute/Unmute audio for current session publisher
      */
     function switchAudio() {
         audioEnabled = !audioEnabled
         publisher.publishAudio(audioEnabled)
 
         // TODO: Handle enabling audio if it was never enabled (e.g. user joined the room
         //       without giving access to his mic)
 
         $(sessionData.wrapper).find('.status-audio')[audioEnabled ? 'addClass' : 'removeClass']('d-none')
 
         signalUserUpdate()
 
         return audioEnabled
     }
 
     /**
      * Mute/Unmute video for current session publisher
      */
     function switchVideo() {
         videoEnabled = !videoEnabled
         publisher.publishVideo(videoEnabled)
 
         // TODO: Handle enabling video if it was never enabled (e.g. user joined the room
         //       without giving access to his camera)
 
         $(sessionData.wrapper).find('.status-video')[videoEnabled ? 'addClass' : 'removeClass']('d-none')
 
         signalUserUpdate()
 
         return videoEnabled
     }
 
     /**
      * Switch on/off screen sharing
      */
     function switchScreen(callback) {
         if (screenPublisher) {
             screenSession.unpublish(screenPublisher)
             screenPublisher = null
 
             if (callback) {
                 callback(false)
             }
 
             return
         }
 
         screenConnect(callback)
     }
 
     /**
      * Detect if screen sharing is supported by the browser
      */
     function isScreenSharingSupported() {
         return !!OV.checkScreenSharingCapabilities();
     }
 
     /**
      * Create a <video> element wrapper with controls
      *
      * @param container The parent element
      * @param metadata  Connection metadata
      * @param stream    Connection stream
      */
     function addVideoWrapper(container, metadata, stream) {
         // Create the element
         let wrapper = $('<div class="meet-video">').html(`
             <div class="nickname" title="Nickname">
                 <span></span>
             </div>
             <div class="controls">
                 <button class="btn btn-link link-audio d-none" title="Mute audio">` + svgIcon("volume-mute") + `</button>
                 <button class="btn btn-link link-fullscreen d-none" title="Full screen">` + svgIcon("expand") + `</button>
                 <button class="btn btn-link link-fullscreen-close d-none" title="Full screen">` + svgIcon("compress") + `</button>
             </div>
             <div class="status">
                 <span class="bg-danger status-audio d-none">` + svgIcon("microphone") + `</span>
                 <span class="bg-danger status-video d-none">` + svgIcon("video") + `</span>
             </div>`)
 
         if (metadata.publisher) {
             // Add events for nickname change
             let nickname = wrapper.addClass('publisher').find('.nickname')
             let editable = nickname.find('span').get(0)
             let editableEnable = () => {
                 editable.contentEditable = true
                 editable.focus()
             }
             let editableUpdate = () => {
                 editable.contentEditable = false
                 sessionData.params.nickname = editable.innerText
                 signalUserUpdate()
             }
 
             nickname.on('click', editableEnable)
 
             $(editable).on('blur', editableUpdate)
                 .on('click', editableEnable)
                 .on('keydown', e => {
                     // Enter or Esc
                     if (e.keyCode == 13 || e.keyCode == 27) {
                         editableUpdate()
                         return false
                     }
                 })
 
             // Status
             if (!audioEnabled) {
                 wrapper.find('.status-audio').removeClass('d-none')
             }
 
             if (!videoEnabled) {
                 wrapper.find('.status-video').removeClass('d-none')
             }
         } else {
             wrapper.find('.nickname > svg').addClass('d-none')
 
             wrapper.find('.link-audio').removeClass('d-none')
                 .on('click', e => {
                     let video = wrapper.find('video')[0]
                     video.muted = !video.muted
                     wrapper.find('.link-audio')[video.muted ? 'addClass' : 'removeClass']('text-danger')
                 })
 
             if (!stream.audioActive) {
                 wrapper.find('.status-audio').removeClass('d-none')
             }
 
             if (!stream.videoActive) {
                 wrapper.find('.status-video').removeClass('d-none')
             }
         }
 
         if (metadata.nickname) {
             wrapper.find('.nickname > span').text(metadata.nickname)
         }
 
         // Fullscreen control
         if (document.fullscreenEnabled) {
             wrapper.find('.link-fullscreen').removeClass('d-none')
                 .on('click', () => {
                     wrapper.get(0).requestFullscreen()
                 })
 
             wrapper.find('.link-fullscreen-close')
                 .on('click', () => {
                     document.exitFullscreen()
                 })
 
             wrapper.on('fullscreenchange', () => {
                 // const enabled = document.fullscreenElement
                 wrapper.find('.link-fullscreen').toggleClass('d-none')
                 wrapper.find('.link-fullscreen-close').toggleClass('d-none')
             })
         }
 
         return wrapper.appendTo(container).get(0)
     }
 
     /**
      * Window onresize event handler (updates room layout)
      */
     function resize() {
         containerWidth = container.offsetWidth
         containerHeight = container.offsetHeight
         updateLayout()
     }
 
     /**
      * Update the room "matrix" layout
      */
     function updateLayout() {
         if (!numOfVideos) {
             return
         }
 
         let css, rows, cols, height
 
         if (numOfVideos == 1) {
             cols = 1
         } else if (numOfVideos <= 4) {
             cols = 2
         } else if (numOfVideos <= 9) {
             cols = 3
         } else if (numOfVideos <= 16) {
             cols = 4
         } else if (numOfVideos <= 25) {
             cols = 5
         } else {
             cols = 6
         }
 
         rows = Math.ceil(numOfVideos / cols)
 
         if (rows < cols && containerWidth < containerHeight) {
             cols = rows
             rows = Math.ceil(numOfVideos / cols)
         }
 
         height = containerHeight / rows
         css = {
             width: (100 / cols) + '%',
             // Height must be in pixels to make object-fit:cover working
             height: height + 'px'
         }
 
         // Update the matrix
         $(container).find('.meet-video').css(css)
             .each((idx, elem) => {
                 let video = $(elem).children('video')[0]
                 if (!video) {
                     // Remove orphaned video wrappers (after video has been removed)
                     $(elem).remove()
                 } else if (video.videoWidth && video.videoHeight && video.videoWidth > video.videoHeight) {
                     // Set max-width to keep the original aspect ratio in cases
                     // when there's enough room to display the element
                     let maxWidth = height * video.videoWidth / video.videoHeight
                     $(elem).css('max-width', maxWidth)
                 }
             })
     }
 
     /**
      * Initialize screen sharing session/publisher
      */
     function screenConnect(callback) {
         if (!sessionData.shareToken) {
             return false
         }
 
         let gotSession = !!screenSession
 
         // Init screen sharing session
         if (!gotSession) {
             screenSession = screenOV.initSession();
         }
 
         let successFunc = function() {
             screenSession.publish(screenPublisher)
             if (callback) {
                 callback(true)
             }
         }
 
         let errorFunc = function() {
             screenPublisher = null
             if (callback) {
                 callback(false)
             }
         }
 
         // Init the publisher
         let params = {
             videoSource: 'screen',
             publishAudio: false
         }
 
         screenPublisher = screenOV.initPublisher(null, params)
 
         screenPublisher.once('accessAllowed', (event) => {
             if (gotSession) {
                 successFunc()
             } else {
                 screenSession.connect(sessionData.shareToken, sessionData.params)
                     .then(() => {
                         successFunc()
                     })
                     .catch(error => {
                         console.error('There was an error connecting to the session:', error.code, error.message);
                         errorFunc()
                     })
             }
         })
 
         screenPublisher.once('accessDenied', () => {
             console.info('ScreenShare: Access Denied')
             errorFunc()
         })
     }
 
     /**
      * Create an svg element (string) for a FontAwesome icon
      *
      * @todo Find if there's a "official" way to do this
      */
     function svgIcon(name, type) {
         // Note: the library will contain definitions for all icons registered elswhere
         const icon = library.definitions[type || 'fas'][name]
 
         return $(`<svg><path fill="currentColor" d="${icon[4]}"></path></svg>`)
             .attr({
                 'class': 'svg-inline--fa',
                 'aria-hidden': true,
                 focusable: false,
                 role: 'img',
                 xmlns: 'http://www.w3.org/2000/svg',
                 viewBox: `0 0 ${icon[0]} ${icon[1]}`
             })
             .get(0).outerHTML
     }
 
     function volumeChangeHandler(event) {
         let value = 100 + Math.min(0, Math.max(-100, event.value.newValue))
         let color = 'lime'
         const bar = volumeElement.firstChild
 
         if (value >= 70) {
             color = '#ff3300'
         } else if (value >= 50) {
             color = '#ff9933'
         }
 
         bar.style.height = value + '%'
         bar.style.background = color
     }
 
     function volumeMeterStart() {
         if (publisher && volumeElement) {
             publisher.on('streamAudioVolumeChange', volumeChangeHandler)
         }
     }
 
     function volumeMeterStop() {
         if (publisher && volumeElement) {
             publisher.off('streamAudioVolumeChange')
             volumeElement.firstChild.style.height = 0
         }
     }
 }
 
 export default Meet
diff --git a/src/resources/lang/en/meet.php b/src/resources/lang/en/meet.php
index 61563e1b..7958bd85 100644
--- a/src/resources/lang/en/meet.php
+++ b/src/resources/lang/en/meet.php
@@ -1,21 +1,22 @@
 <?php
 
 return [
 
     /*
     |--------------------------------------------------------------------------
     | Pagination Language Lines
     |--------------------------------------------------------------------------
     |
     | The following language lines are used by the paginator library to build
     | the simple pagination links. You are free to change them to anything
     | you want to customize your views to better match your application.
     |
     */
 
-    'roomnotfound' => 'The room does not exist.',
-    'sessionnotfound' => 'The session does not exist.',
-    'sessioncreateerror' => 'Failed to create the session.',
-    'sessionjoinerror' => 'Failed to join the session.',
-
+    'room-not-found' => 'The room does not exist.',
+    'session-not-found' => 'The session does not exist.',
+    'session-create-error' => 'Failed to create the session.',
+    'session-join-error' => 'Failed to join the session.',
+    'session-close-error' => 'Failed to close the session.',
+    'session-close-success' => 'The session has been closed successfully.',
 ];
diff --git a/src/resources/vue/Meet/Dashboard.vue b/src/resources/vue/Meet/Dashboard.vue
deleted file mode 100644
index 62120f39..00000000
--- a/src/resources/vue/Meet/Dashboard.vue
+++ /dev/null
@@ -1,20 +0,0 @@
-<template>
-    <div class="container" dusk="dashboard-component">
-        <p>This is publicly available content, user will be asked to
-            authenticate when accessing /meet/&lt;room&gt;.</p>
-        <p>Here we could put "Join or create a room" button with room name input.</p>
-    </div>
-</template>
-
-<script>
-    export default {
-        data() {
-            return {
-            }
-        },
-        mounted() {
-        },
-        methods: {
-        }
-    }
-</script>
diff --git a/src/resources/vue/Meet/Room.vue b/src/resources/vue/Meet/Room.vue
index 06b3e7ab..ad2741a4 100644
--- a/src/resources/vue/Meet/Room.vue
+++ b/src/resources/vue/Meet/Room.vue
@@ -1,290 +1,325 @@
 <template>
     <div id="meet-component">
         <div id="meet-session-toolbar" class="d-none">
             <div id="meet-session-menu">
                 <button class="btn btn-link link-audio" @click="switchSound" title="Mute audio">
                     <svg-icon icon="microphone"></svg-icon>
                 </button>
                 <button class="btn btn-link link-video" @click="switchVideo" title="Mute video">
                     <svg-icon icon="video"></svg-icon>
                 </button>
                 <button class="btn btn-link link-screen text-danger" @click="switchScreen" :disabled="!canShareScreen" title="Share screen">
                     <svg-icon icon="desktop"></svg-icon>
                 </button>
                 <button class="btn btn-link link-chat text-danger" @click="switchChat" title="Chat">
                     <svg-icon icon="align-left"></svg-icon>
                 </button>
                 <button class="btn btn-link link-fullscreen d-none" @click="switchFullscreen" title="Full screen">
                     <svg-icon icon="expand"></svg-icon>
                 </button>
                 <button class="btn btn-link link-fullscreen d-none" @click="switchFullscreen" title="Full screen">
                     <svg-icon icon="compress"></svg-icon>
                 </button>
                 <button class="btn btn-link link-logout" @click="logout" title="Leave session">
                     <svg-icon icon="power-off"></svg-icon>
                 </button>
             </div>
         </div>
 
         <div id="meet-setup" class="card container mt-5 mb-5">
             <div class="card-body">
                 <div class="card-title">Set up your session</div>
                 <div class="card-text">
                     <form class="setup-form row">
                         <div id="setup-preview" class="col-sm-6">
                             <video class="rounded"></video>
                             <div class="volume"><div class="bar"></div></div>
                         </div>
                         <div class="col-sm-6">
                             <div class="form-group">
                                 <label>Microphone</label>
                                 <select class="custom-select" id="setup-microphone" v-model="microphone" @change="setupMicrophoneChange">
                                     <option value="">None</option>
                                     <option v-for="mic in setup.microphones" :value="mic.deviceId" :key="mic.deviceId">{{ mic.label }}</option>
                                 </select>
                             </div>
                             <div class="form-group">
                                 <label>Camera</label>
                                 <select class="custom-select" id="setup-camera" v-model="camera" @change="setupCameraChange">
                                     <option value="">None</option>
                                     <option v-for="cam in setup.cameras" :value="cam.deviceId" :key="cam.deviceId">{{ cam.label }}</option>
                                 </select>
                             </div>
                             <div class="form-group mb-0">
                                 <label>Nickname</label>
                                 <input class="form-control" type="text" id="setup-nickname" v-model="nickname">
                             </div>
                         </div>
                         <div class="text-center mt-4 col-sm-12">
                             <status-message :status="roomState" :status-labels="roomStateLabels" class="mb-3"></status-message>
                             <button v-if="roomState == 'ready' || roomState == 424"
                                     type="button"
                                     @click="joinSession"
                                     class="btn btn-primary pl-5 pr-5"
                             >JOIN</button>
                             <button v-if="roomState == 423"
                                     type="button"
                                     @click="joinSession"
                                     class="btn btn-primary pl-5 pr-5"
                             >I'm the owner</button>
                         </div>
                     </form>
                 </div>
             </div>
         </div>
 
         <div id="meet-session-layout" class="d-flex d-none">
             <div id="meet-session"></div>
             <div id="meet-chat">
                 <div class="chat"></div>
                 <div class="chat-input m-2">
                     <textarea class="form-control" rows="1"></textarea>
                 </div>
             </div>
         </div>
 
         <logon-form id="meet-auth" class="d-none" :dashboard="false" v-on:success="authSuccess"></logon-form>
+
+        <div id="leave-dialog" class="modal" tabindex="-1" role="dialog">
+            <div class="modal-dialog" role="document">
+                <div class="modal-content">
+                    <div class="modal-header">
+                        <h5 class="modal-title">Room closed</h5>
+                        <button type="button" class="close" data-dismiss="modal" aria-label="Close">
+                            <span aria-hidden="true">&times;</span>
+                        </button>
+                    </div>
+                    <div class="modal-body">
+                        <p>The session has been closed by the room owner.</p>
+                    </div>
+                    <div class="modal-footer">
+                        <button type="button" class="btn btn-danger modal-action" @click="leaveRoom()">Close</button>
+                    </div>
+                </div>
+            </div>
+        </div>
     </div>
 </template>
 
 <script>
     import Meet from '../../js/meet/app.js'
     import StatusMessage from '../Widgets/StatusMessage'
     import LogonForm from '../Login'
 
     export default {
         components: {
             LogonForm,
             StatusMessage
         },
         data() {
             return {
                 setup: {
                     cameras: [],
                     microphones: [],
                 },
                 canShareScreen: false,
                 camera: '',
                 meet: null,
                 microphone: '',
                 nickname: '',
                 room: null,
                 roomState: 'init',
                 roomStateLabels: {
                     init: 'Checking the room...',
                     404: 'The room does not exist.',
                     423: 'The room is closed. Please, wait for the owner to start the session.',
                     424: 'The room is closed. It will be open for others after you join.',
                     500: 'Failed to create a session. Server error.'
                 },
                 session: {}
             }
         },
         mounted() {
             this.room = this.$route.params.room
 
             // Initialize OpenVidu and do some basic checks
             this.meet = new Meet($('#meet-session')[0]);
             this.canShareScreen = this.meet.isScreenSharingSupported()
 
             // Check the room and init the session
             this.initSession()
 
             // Setup the room UI
             this.setupSession()
         },
         beforeDestroy() {
             if (this.meet) {
-                this.leaveSession()
+                this.meet.leaveRoom()
             }
         },
         methods: {
             authSuccess() {
                 // The user (owner) authentication succeeded
                 this.roomState = 'init'
                 this.initSession()
 
                 $('#meet-setup').removeClass('d-none')
                 $('#meet-auth').addClass('d-none')
             },
             initSession(init) {
                 let params = []
 
                 if (this.canShareScreen) {
                     params.push('screenShare=1')
                 }
 
                 if (init) {
                     params.push('init=1')
                 }
 
                 axios.get('/api/v4/openvidu/rooms/' + this.room + '?' + params.join('&'))
                     .then(response => {
                         // Response data contains: session, token and shareToken
                         this.roomState = 'ready'
                         this.session = response.data
 
                         if (init) {
                             this.joinSession()
                         }
                     })
                     .catch(error => {
                         this.roomState = String(error.response.status)
                     })
 
                 if (document.fullscreenEnabled) {
                     $('#meet-session-menu').find('.link-fullscreen').first().removeClass('d-none')
                 }
             },
             joinSession() {
                 if (this.roomState == 423) {
                     $('#meet-setup').addClass('d-none')
                     $('#meet-auth').removeClass('d-none')
                     return
                 }
 
                 if (this.roomState == 424) {
                     this.initSession(true)
                     return
                 }
 
                 $('#app').addClass('meet')
                 $('#meet-setup').addClass('d-none')
                 $('#meet-session-toolbar,#meet-session-layout').removeClass('d-none')
 
                 this.session.nickname = this.nickname
                 this.session.menuElement = $('#meet-session-menu')[0]
                 this.session.chatElement = $('#meet-chat')[0]
+                this.session.onDestroy = event => {
+                    // TODO: Handle nicely other reasons: disconnect, forceDisconnectByUser,
+                    //       forceDisconnectByServer, networkDisconnect?
+                    if (event.reason == 'sessionClosedByServer') {
+                        $('#leave-dialog').modal()
+                    }
+                }
 
                 this.meet.joinRoom(this.session)
             },
-            leaveSession() {
-                this.meet.leaveRoom()
-            },
-            logout() {
-                this.leaveSession()
+            leaveRoom() {
+                $('#leave-dialog').modal('hide')
 
                 // FIXME: Where exactly the user should land? Currently he'll land
                 //        on dashboard (if he's logged in) or login form (if he's not).
 
                 window.location = window.config['app.url']
             },
+            logout() {
+                if (this.session.owner) {
+                    axios.post('/api/v4/openvidu/rooms/' + this.room + '/close')
+                        .then(response => {
+                            this.meet.leaveRoom()
+                            this.leaveRoom()
+                        })
+                } else {
+                    this.meet.leaveRoom()
+                    this.leaveRoom()
+                }
+            },
             setMenuItem(type, state) {
                 $('#meet-session-menu').find('.link-' + type)[state ? 'removeClass' : 'addClass']('text-danger')
             },
             setupSession() {
                 this.meet.setup({
                     videoElement: $('#setup-preview video')[0],
                     volumeElement: $('#setup-preview .volume')[0],
                     success: setup => {
                         this.setup = setup
                         this.microphone = setup.audioSource
                         this.camera = setup.videoSource
 
                         this.setMenuItem('audio', setup.audioEnabled)
                         this.setMenuItem('video', setup.videoEnabled)
                     },
                     error: error => {
                         // TODO: display nice error to the user
                         // FIXME: It looks like OpenVidu requires audio or video,
                         //        otherwise it will not connect to the session?
 
                         this.setMenuItem('audio', false)
                         this.setMenuItem('video', false)
                     }
                 })
             },
             setupCameraChange() {
                 this.meet.setupSetVideoDevice(this.camera).then(enabled => {
                     this.setMenuItem('video', enabled)
                 })
             },
             setupMicrophoneChange() {
                 this.meet.setupSetAudioDevice(this.microphone).then(enabled => {
                     this.setMenuItem('audio', enabled)
                 })
             },
             switchChat() {
                 let chat = $('#meet-chat')
                 let enabled = chat.is('.open')
 
                 this.setMenuItem('chat', !enabled)
                 chat.toggleClass('open')
 
                 if (!enabled) {
                     chat.find('textarea').focus()
                 }
             },
             switchFullscreen() {
                 const element = this.$el
 
                 $(element).off('fullscreenchange').on('fullscreenchange', (e) => {
                     let enabled = document.fullscreenElement == element
                     let buttons = $('#meet-session-menu').find('.link-fullscreen')
 
                     buttons.first()[enabled ? 'addClass' : 'removeClass']('d-none')
                     buttons.last()[!enabled ? 'addClass' : 'removeClass']('d-none')
                 })
 
                 if (document.fullscreenElement) {
                     document.exitFullscreen()
                 } else {
                     element.requestFullscreen()
                 }
             },
             switchSound() {
                 const enabled = this.meet.switchAudio()
                 this.setMenuItem('audio', enabled)
             },
             switchVideo() {
                 const enabled = this.meet.switchVideo()
                 this.setMenuItem('video', enabled)
             },
             switchScreen() {
                 this.meet.switchScreen(enabled => {
                     this.setMenuItem('screen', enabled)
                 })
             }
         }
     }
 </script>
diff --git a/src/routes/api.php b/src/routes/api.php
index 4caadedd..475ae1f9 100644
--- a/src/routes/api.php
+++ b/src/routes/api.php
@@ -1,127 +1,128 @@
 <?php
 
 use Illuminate\Http\Request;
 
 /*
 |--------------------------------------------------------------------------
 | API Routes
 |--------------------------------------------------------------------------
 |
 | Here is where you can register API routes for your application. These
 | routes are loaded by the RouteServiceProvider within a group which
 | is assigned the "api" middleware group. Enjoy building your API!
 |
 */
 
 Route::group(
     [
         'middleware' => 'api',
         'prefix' => 'auth'
     ],
     function ($router) {
         Route::post('login', 'API\AuthController@login');
 
         Route::group(
             ['middleware' => 'auth:api'],
             function ($router) {
                 Route::get('info', 'API\AuthController@info');
                 Route::post('logout', 'API\AuthController@logout');
                 Route::post('refresh', 'API\AuthController@refresh');
             }
         );
     }
 );
 
 Route::group(
     [
         'domain' => \config('app.domain'),
         'middleware' => 'api',
         'prefix' => 'auth'
     ],
     function ($router) {
         Route::post('password-reset/init', 'API\PasswordResetController@init');
         Route::post('password-reset/verify', 'API\PasswordResetController@verify');
         Route::post('password-reset', 'API\PasswordResetController@reset');
 
         Route::get('signup/plans', 'API\SignupController@plans');
         Route::post('signup/init', 'API\SignupController@init');
         Route::post('signup/verify', 'API\SignupController@verify');
         Route::post('signup', 'API\SignupController@signup');
     }
 );
 
 Route::group(
     [
         'domain' => \config('app.domain'),
         'middleware' => 'auth:api',
         'prefix' => 'v4'
     ],
     function () {
         Route::apiResource('domains', API\V4\DomainsController::class);
         Route::get('domains/{id}/confirm', 'API\V4\DomainsController@confirm');
         Route::get('domains/{id}/status', 'API\V4\DomainsController@status');
 
         Route::apiResource('entitlements', API\V4\EntitlementsController::class);
         Route::apiResource('packages', API\V4\PackagesController::class);
         Route::apiResource('skus', API\V4\SkusController::class);
         Route::apiResource('users', API\V4\UsersController::class);
         Route::get('users/{id}/status', 'API\V4\UsersController@status');
 
         Route::apiResource('wallets', API\V4\WalletsController::class);
         Route::get('wallets/{id}/transactions', 'API\V4\WalletsController@transactions');
         Route::get('wallets/{id}/receipts', 'API\V4\WalletsController@receipts');
         Route::get('wallets/{id}/receipts/{receipt}', 'API\V4\WalletsController@receiptDownload');
 
         Route::post('payments', 'API\V4\PaymentsController@store');
         Route::get('payments/mandate', 'API\V4\PaymentsController@mandate');
         Route::post('payments/mandate', 'API\V4\PaymentsController@mandateCreate');
         Route::put('payments/mandate', 'API\V4\PaymentsController@mandateUpdate');
         Route::delete('payments/mandate', 'API\V4\PaymentsController@mandateDelete');
 
         Route::get('openvidu/rooms', 'API\V4\OpenViduController@index');
+        Route::post('openvidu/rooms/{id}/close', 'API\V4\OpenViduController@closeRoom');
     }
 );
 
 // Note: In Laravel 7.x we could just use withoutMiddleware() instead of a separate group
 Route::group(
     [
         'domain' => \config('app.domain'),
         'prefix' => 'v4'
     ],
     function () {
         Route::get('openvidu/rooms/{id}', 'API\V4\OpenViduController@joinRoom');
     }
 );
 
 Route::group(
     [
         'domain' => \config('app.domain'),
     ],
     function () {
         Route::post('webhooks/payment/{provider}', 'API\V4\PaymentsController@webhook');
         Route::post('webhooks/meet/openvidu', 'API\V4\OpenViduController@webhook');
     }
 );
 
 Route::group(
     [
         'domain' => 'admin.' . \config('app.domain'),
         'middleware' => ['auth:api', 'admin'],
         'prefix' => 'v4',
     ],
     function () {
         Route::apiResource('domains', API\V4\Admin\DomainsController::class);
         Route::get('domains/{id}/confirm', 'API\V4\Admin\DomainsController@confirm');
 
         Route::apiResource('entitlements', API\V4\Admin\EntitlementsController::class);
         Route::apiResource('packages', API\V4\Admin\PackagesController::class);
         Route::apiResource('skus', API\V4\Admin\SkusController::class);
         Route::apiResource('users', API\V4\Admin\UsersController::class);
         Route::post('users/{id}/suspend', 'API\V4\Admin\UsersController@suspend');
         Route::post('users/{id}/unsuspend', 'API\V4\Admin\UsersController@unsuspend');
         Route::apiResource('wallets', API\V4\Admin\WalletsController::class);
         Route::post('wallets/{id}/one-off', 'API\V4\Admin\WalletsController@oneOff');
         Route::get('wallets/{id}/transactions', 'API\V4\Admin\WalletsController@transactions');
         Route::apiResource('discounts', API\V4\Admin\DiscountsController::class);
     }
 );
diff --git a/src/tests/Feature/Controller/OpenViduTest.php b/src/tests/Feature/Controller/OpenViduTest.php
index 7e24f06d..6a7ae8b0 100644
--- a/src/tests/Feature/Controller/OpenViduTest.php
+++ b/src/tests/Feature/Controller/OpenViduTest.php
@@ -1,115 +1,181 @@
 <?php
 
 namespace Tests\Feature\Controller;
 
 use App\Http\Controllers\API\V4\OpenViduController;
 use App\OpenVidu\Room;
 use Tests\TestCase;
 
 class OpenViduTest extends TestCase
 {
     /**
      * Test listing user rooms
      *
      * @group openvidu
      */
     public function testIndex(): void
     {
         $john = $this->getTestUser('john@kolab.org');
         $jack = $this->getTestUser('jack@kolab.org');
         Room::where('user_id', $jack->id)->delete();
 
         // Unauth access not allowed
         $response = $this->get("api/v4/openvidu/rooms");
         $response->assertStatus(401);
 
         // John has one room
         $response = $this->actingAs($john)->get("api/v4/openvidu/rooms");
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertSame(1, $json['count']);
         $this->assertCount(1, $json['list']);
         $this->assertSame('john', $json['list'][0]['name']);
 
         // John has no room, but it will be auto-created
         $response = $this->actingAs($jack)->get("api/v4/openvidu/rooms");
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertSame(1, $json['count']);
         $this->assertCount(1, $json['list']);
         $this->assertSame('jack', $json['list'][0]['name']);
     }
 
     /**
      * Test joining the room
      *
      * @group openvidu
      */
-    public function testJoin(): void
+    public function testJoinRoom(): void
     {
         $john = $this->getTestUser('john@kolab.org');
         $jack = $this->getTestUser('jack@kolab.org');
         $room = Room::where('name', 'john')->first();
         $room->session_id = null;
         $room->save();
 
-        // Unauth access not allowed (yet)
+        // Unauth access, no session yet
         $response = $this->get("api/v4/openvidu/rooms/{$room->name}");
-        $response->assertStatus(401);
+        $response->assertStatus(423);
 
         // Non-existing room name
         $response = $this->actingAs($john)->get("api/v4/openvidu/rooms/non-existing");
         $response->assertStatus(404);
 
         // Non-owner, no session yet
         $response = $this->actingAs($jack)->get("api/v4/openvidu/rooms/{$room->name}");
         $response->assertStatus(423);
 
-        // Room owner
+        // Room owner, no session yet
         $response = $this->actingAs($john)->get("api/v4/openvidu/rooms/{$room->name}");
+        $response->assertStatus(424);
+
+        $response = $this->actingAs($john)->get("api/v4/openvidu/rooms/{$room->name}?init=1");
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $session_id = $room->fresh()->session_id;
 
         $this->assertSame('PUBLISHER', $json['role']);
         $this->assertSame($session_id, $json['session']);
         $this->assertTrue(is_string($session_id) && !empty($session_id));
         $this->assertTrue(strpos($json['token'], 'wss://') === 0);
         $this->assertTrue(!array_key_exists('shareToken', $json));
 
         $john_token = $json['token'];
 
         // Non-owner, now the session exists
         $response = $this->actingAs($jack)->get("api/v4/openvidu/rooms/{$room->name}");
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertSame('PUBLISHER', $json['role']);
         $this->assertSame($session_id, $json['session']);
         $this->assertTrue(strpos($json['token'], 'wss://') === 0);
         $this->assertTrue($json['token'] != $john_token);
         $this->assertTrue(!array_key_exists('shareToken', $json));
+    }
 
-        $jack_token = $json['token'];
+    /**
+     * Test joining the room
+     *
+     * @group openvidu
+     * @depends testJoinRoom
+     */
+    public function testJoinRoomGuest(): void
+    {
+        // There's no asy way to logout the user in the same test after
+        // using actingAs(). That's why this is moved to a separate test
+        $room = Room::where('name', 'john')->first();
 
-        // request with screenShare token
-        $response = $this->actingAs($john)->get("api/v4/openvidu/rooms/{$room->name}?screenShare=1");
+        // Guest, request with screenShare token
+        $response = $this->get("api/v4/openvidu/rooms/{$room->name}?screenShare=1");
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertSame('PUBLISHER', $json['role']);
-        $this->assertSame($session_id, $json['session']);
+        $this->assertSame($room->session_id, $json['session']);
         $this->assertTrue(strpos($json['token'], 'wss://') === 0);
-        $this->assertTrue($json['token'] != $john_token);
         $this->assertTrue(strpos($json['shareToken'], 'wss://') === 0);
-        $this->assertTrue($json['shareToken'] != $john_token && $json['shareToken'] != $json['token']);
+        $this->assertTrue($json['shareToken'] != $json['token']);
+    }
+
+    /**
+     * Test closing the room (session)
+     *
+     * @group openvidu
+     * @depends testJoinRoom
+     */
+    public function testCloseRoom(): void
+    {
+        $john = $this->getTestUser('john@kolab.org');
+        $jack = $this->getTestUser('jack@kolab.org');
+        $room = Room::where('name', 'john')->first();
+
+        // Unauth access not allowed
+        $response = $this->post("api/v4/openvidu/rooms/{$room->name}/close", []);
+        $response->assertStatus(401);
+
+        // Non-existing room name
+        $response = $this->actingAs($john)->post("api/v4/openvidu/rooms/non-existing/close", []);
+        $response->assertStatus(404);
+
+        // Non-owner
+        $response = $this->actingAs($jack)->post("api/v4/openvidu/rooms/{$room->name}/close", []);
+        $response->assertStatus(403);
+
+        // Room owner
+        $response = $this->actingAs($john)->post("api/v4/openvidu/rooms/{$room->name}/close", []);
+        $response->assertStatus(200);
+
+        $json = $response->json();
+
+        $this->assertNull($room->fresh()->session_id);
+        $this->assertSame('success', $json['status']);
+        $this->assertSame("The session has been closed successfully.", $json['message']);
+        $this->assertCount(2, $json);
+
+        // TODO: Test if the session is removed from the OpenVidu server too
+
+        // Test error handling when it's not possible to delete the session on
+        // the OpenVidu server (use fake session_id)
+        $room->session_id = 'aaa';
+        $room->save();
+
+        $response = $this->actingAs($john)->post("api/v4/openvidu/rooms/{$room->name}/close", []);
+        $response->assertStatus(500);
+
+        $json = $response->json();
+
+        $this->assertSame('aaa', $room->fresh()->session_id);
+        $this->assertSame('error', $json['status']);
+        $this->assertSame("Failed to close the session.", $json['message']);
+        $this->assertCount(2, $json);
     }
 }