/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License") + you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.openmeetings.app.remote.red5;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.openmeetings.app.OpenmeetingsVariables;
import org.openmeetings.app.conference.session.RoomClient;
import org.openmeetings.app.conference.whiteboard.BrowserStatus;
import org.openmeetings.app.conference.whiteboard.RoomStatus;
import org.openmeetings.app.conference.whiteboard.WhiteboardManagement;
import org.openmeetings.app.data.basic.Configurationmanagement;
import org.openmeetings.app.data.basic.Sessionmanagement;
import org.openmeetings.app.data.calendar.daos.MeetingMemberDaoImpl;
import org.openmeetings.app.data.calendar.management.AppointmentLogic;
import org.openmeetings.app.data.conference.Roommanagement;
import org.openmeetings.app.data.logs.ConferenceLogDaoImpl;
import org.openmeetings.app.data.user.Usermanagement;
import org.openmeetings.app.data.user.dao.UsersDaoImpl;
import org.openmeetings.app.persistence.beans.basic.Configuration;
import org.openmeetings.app.persistence.beans.calendar.Appointment;
import org.openmeetings.app.persistence.beans.calendar.MeetingMember;
import org.openmeetings.app.persistence.beans.rooms.Rooms;
import org.openmeetings.app.persistence.beans.user.Users;
import org.openmeetings.app.remote.FLVRecorderService;
import org.openmeetings.app.remote.WhiteBoardService;
import org.openmeetings.utils.math.CalendarPatterns;
import org.red5.client.net.rtmp.ClientExceptionHandler;
import org.red5.logging.Red5LoggerFactory;
import org.red5.server.adapter.ApplicationAdapter;
import org.red5.server.api.IClient;
import org.red5.server.api.IConnection;
import org.red5.server.api.Red5;
import org.red5.server.api.scope.IBasicScope;
import org.red5.server.api.scope.IBroadcastScope;
import org.red5.server.api.scope.IScope;
import org.red5.server.api.scope.ScopeType;
import org.red5.server.api.service.IPendingServiceCall;
import org.red5.server.api.service.IPendingServiceCallback;
import org.red5.server.api.service.IServiceCapableConnection;
import org.red5.server.api.stream.IBroadcastStream;
import org.red5.server.api.stream.IStreamListener;
import org.red5.server.api.stream.IStreamPacket;
import org.red5.server.net.rtmp.event.IRTMPEvent;
import org.red5.server.stream.StreamingProxy;
import org.red5.server.stream.message.RTMPMessage;
import org.slf4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
public class ScopeApplicationAdapter extends ApplicationAdapter implements
IPendingServiceCallback {
private static final Logger log = Red5LoggerFactory.getLogger(
ScopeApplicationAdapter.class,
OpenmeetingsVariables.webAppRootKey);
@Autowired
private ClientListManager clientListManager;
@Autowired
private EmoticonsManager emoticonsManager;
@Autowired
private WhiteBoardService whiteBoardService;
@Autowired
private FLVRecorderService flvRecorderService;
@Autowired
private Configurationmanagement cfgManagement;
@Autowired
private AppointmentLogic appointmentLogic;
@Autowired
private Sessionmanagement sessionManagement;
@Autowired
private Usermanagement userManagement;
@Autowired
private Roommanagement roommanagement;
@Autowired
private ConferenceLogDaoImpl conferenceLogDao;
@Autowired
private UsersDaoImpl usersDao;
@Autowired
private MeetingMemberDaoImpl meetingMemberDao;
private Map<String, StreamingProxy> streamingProxyMap = new HashMap<String, StreamingProxy>();
// This is the Folder where all executables are written
// for windows platform
public static String batchFileDir = "webapps" + File.separatorChar + "ROOT"
+ File.separatorChar + "jod" + File.separatorChar;
public static String lineSeperator = System.getProperty("line.separator");
// The Global WebApp Path
public static String webAppPath = "";
public static String configDirName = "conf";
public static String profilesPrefix = "profile_";
public static String configKeyCryptClassName = null;
public static Boolean whiteboardDrawStatus = null;
private static long broadCastCounter = 0;
public static boolean initComplete = false;
public synchronized void resultReceived(IPendingServiceCall arg0) {
// TODO Auto-generated method stub
}
@Override
public synchronized boolean appStart(IScope scope) {
try {
webAppPath = scope.getResource("/").getFile().getAbsolutePath();
batchFileDir = webAppPath + File.separatorChar + OpenmeetingsVariables.STREAMS_DIR
+ File.separatorChar;
log.debug("webAppPath : " + webAppPath);
log.debug("batchFileFir : " + batchFileDir);
// Only load this Class one time
// Initially this value might by empty, because the DB is empty yet
Configuration conf = cfgManagement.getConfKey(3, "crypt_ClassName");
if (conf != null) {
ScopeApplicationAdapter.configKeyCryptClassName = conf
.getConf_value();
}
// init your handler here
// The scheduled Jobs did go into the Spring-Managed Beans, see
// schedulerJobs.service.xml
// Spring Definition does not work here, its too early, Instance is
// not set yet
emoticonsManager.loadEmot(scope);
for (String scopeName : scope.getScopeNames()) {
log.debug("scopeName :: " + scopeName);
}
ScopeApplicationAdapter.initComplete = true;
clientListManager.removeAllClients();
// OpenXGHttpClient.getInstance().openSIPgUserCreateTest();
// OpenXGWrapperClient.getInstance().testConnection();
// OpenXGClient.getInstance().testConnection();
// ServerSocketMinaProcess serverSocketMinaProcess = new
// ServerSocketMinaProcess();
// serverSocketMinaProcess.doInitSocket();
} catch (Exception err) {
log.error("[appStart]", err);
}
return true;
}
@Override
public boolean roomConnect(IConnection conn, Object[] params) {
log.debug("roomConnect : ");
try {
IServiceCapableConnection service = (IServiceCapableConnection) conn;
String streamId = conn.getClient().getId();
boolean isAVClient = false;
if (params.length == 1) {
isAVClient = Boolean.parseBoolean(params[0].toString());
}
log.debug("### Client connected to OpenMeetings, register Client StreamId: "
+ streamId + " scope " + conn.getScope().getName()+ " isAVClient "+isAVClient);
log.debug("params "+params);
// Set StreamId in Client
service.invoke("setId", new Object[] { streamId }, this);
String swfURL = "";
if (conn.getConnectParams().get("swfUrl") != null) {
swfURL = conn.getConnectParams().get("swfUrl").toString();
}
RoomClient rcm = this.clientListManager.addClientListItem(streamId,
conn.getScope().getName(), conn.getRemotePort(),
conn.getRemoteAddress(), swfURL, isAVClient);
// Log the User
conferenceLogDao.addConferenceLog("ClientConnect",
rcm.getUser_id(), streamId, null, rcm.getUserip(),
rcm.getScope(), rcm.getExternalUserId(),
rcm.getExternalUserType(), rcm.getMail(),
rcm.getFirstname(), rcm.getLastname());
} catch (Exception err) {
log.error("roomJoin", err);
}
return true;
}
@SuppressWarnings({ "rawtypes", "unchecked" })
public synchronized Map screenSharerAction(Map map) {
try {
IConnection current = Red5.getConnectionLocal();
RoomClient currentClient = this.clientListManager
.getClientByStreamId(current.getClient().getId());
Map returnMap = new HashMap();
returnMap.put("result", "stopAll");
log.debug("----------- ");
if (currentClient != null) {
if (Boolean.valueOf(map.get("stopStreaming").toString())) {
log.debug("start streamPublishStart Is Screen Sharing -- Stop ");
//Send message to all users
syncMessageToCurrentScope("stopRed5ScreenSharing", currentClient, false);
if (currentClient.isStartRecording()) {
returnMap.put("result", "stopSharingOnly");
}
currentClient.setStartStreaming(false);
currentClient.setScreenPublishStarted(false);
clientListManager.updateClientByStreamId(
currentClient.getStreamid(), currentClient);
}
if (Boolean.valueOf(map.get("stopRecording").toString())) {
if (currentClient.isStartStreaming()) {
returnMap.put("result", "stopRecordingOnly");
}
//Send message to all users
syncMessageToCurrentScope("stopRecordingMessage", currentClient, false);
flvRecorderService.stopRecordAndSave(
current.getScope(), currentClient, null);
currentClient.setStartRecording(false);
currentClient.setIsRecording(false);
clientListManager.updateClientByStreamId(
currentClient.getStreamid(), currentClient);
}
if (Boolean.valueOf(map.get("stopPublishing").toString())) {
streamPublishingStop();
if (currentClient.getIsScreenClient() && currentClient.isStartStreaming()) {
returnMap.put("result", "stopPublishingOnly");
}
}
}
return returnMap;
} catch (Exception err) {
log.error("[screenSharerAction]", err);
}
return null;
}
public List<RoomClient> checkRed5ScreenSharing() {
try {
IConnection current = Red5.getConnectionLocal();
String streamid = current.getClient().getId();
log.debug("checkScreenSharing -2- " + streamid);
List<RoomClient> screenSharerList = new LinkedList<RoomClient>();
RoomClient currentClient = this.clientListManager
.getClientByStreamId(streamid);
HashMap<String, RoomClient> roomList = this.clientListManager
.getClientListByRoomAll(currentClient.getRoom_id());
for (Iterator<String> iter = roomList.keySet().iterator(); iter
.hasNext();) {
RoomClient rcl = roomList.get(iter.next());
if (rcl.isStartStreaming()) {
screenSharerList.add(rcl);
}
}
return screenSharerList;
} catch (Exception err) {
log.error("[checkScreenSharing]", err);
}
return null;
}
@SuppressWarnings({ "rawtypes", "unchecked" })
public synchronized Map setConnectionAsSharingClient(Map map) {
try {
IConnection current = Red5.getConnectionLocal();
// IServiceCapableConnection service = (IServiceCapableConnection)
// current;
log.debug("### setConnectionAsSharingClient: ");
RoomClient currentClient = this.clientListManager
.getClientByStreamId(current.getClient().getId());
if (currentClient != null) {
boolean startRecording = Boolean.valueOf(map.get(
"startRecording").toString());
boolean startStreaming = Boolean.valueOf(map.get(
"startStreaming").toString());
currentClient.setRoom_id(Long.parseLong(current.getScope()
.getName()));
// Set this connection to be a RTMP-Java Client
currentClient.setIsScreenClient(true);
currentClient.setUser_id(Long.parseLong(map.get("user_id")
.toString()));
if (startStreaming) {
currentClient.setStartStreaming(true);
}
if (startRecording) {
currentClient.setStartRecording(true);
}
currentClient.setOrganization_id(Long.parseLong(map.get(
"organization_id").toString()));
this.clientListManager.updateClientByStreamId(current
.getClient().getId(), currentClient);
Map returnMap = new HashMap();
returnMap.put("alreadyPublished", false);
// if is already started screen sharing, then there is no need
// to start it again
if (currentClient.isScreenPublishStarted()) {
returnMap.put("alreadyPublished", true);
}
currentClient.setVX(Integer.parseInt(map.get("screenX")
.toString()));
currentClient.setVY(Integer.parseInt(map.get("screenY")
.toString()));
currentClient.setVWidth(Integer.parseInt(map.get("screenWidth")
.toString()));
currentClient.setVHeight(Integer.parseInt(map.get(
"screenHeight").toString()));
log.debug("screen x,y,width,height " + currentClient.getVX()
+ " " + currentClient.getVY() + " "
+ currentClient.getVWidth() + " "
+ currentClient.getVHeight());
log.debug("publishName :: " + map.get("publishName"));
currentClient.setStreamPublishName(map.get("publishName")
.toString());
RoomClient currentScreenUser = this.clientListManager
.getClientByPublicSID(currentClient
.getStreamPublishName(), false);
currentClient.setFirstname(currentScreenUser.getFirstname());
currentClient.setLastname(currentScreenUser.getLastname());
// This is duplicated, but its not sure that in the meantime
// somebody requests this Client Object Info
this.clientListManager.updateClientByStreamId(current
.getClient().getId(), currentClient);
if (startStreaming) {
returnMap.put("modus", "startStreaming");
log.debug("start streamPublishStart Is Screen Sharing ");
//Send message to all users
syncMessageToCurrentScope("newRed5ScreenSharing", currentClient, false);
} else if (startRecording) {
returnMap.put("modus", "startRecording");
String recordingName = "Recording "
+ CalendarPatterns
.getDateWithTimeByMiliSeconds(new Date());
flvRecorderService.recordMeetingStream(recordingName, "", false);
} else if (Boolean.valueOf(map.get("startPublishing").toString())) {
if (streamPublishingStart("" + map.get("publishingHost")
, "" + map.get("publishingApp")
, "" + map.get("publishingId")))
{
returnMap.put("modus", "startPublishing");
}
}
return returnMap;
} else {
throw new Exception("Could not find Screen Sharing Client "
+ current.getClient().getId());
}
} catch (Exception err) {
log.error("[setConnectionAsSharingClient]", err);
}
return null;
}
public synchronized List<Integer> listRoomBroadcast() {
List<Integer> broadcastList = new ArrayList<Integer>();
IConnection current = Red5.getConnectionLocal();
String streamid = current.getClient().getId();
Collection<Set<IConnection>> conCollection = current.getScope().getConnections();
for (Set<IConnection> conset : conCollection) {
for (IConnection conn : conset) {
if (conn != null) {
RoomClient rcl = this.clientListManager
.getClientByStreamId(conn
.getClient().getId());
if (rcl == null) {
// continue;
} else if (rcl.getIsScreenClient() != null
&& rcl.getIsScreenClient()) {
// continue;
} else {
if (!streamid.equals(rcl.getStreamid())) {
// It is not needed to send back
// that event to the actuall
// Moderator
// as it will be already triggered
// in the result of this Function
// in the Client
broadcastList.add(Long.valueOf(rcl.getBroadCastID()).intValue());
}
}
}
}
}
return broadcastList;
}
/**
* this function is invoked directly after initial connecting
*
* @return
*/
public synchronized String getPublicSID() {
IConnection current = Red5.getConnectionLocal();
RoomClient currentClient = this.clientListManager
.getClientByStreamId(current.getClient().getId());
currentClient.setIsAVClient(false);
clientListManager.updateClientByStreamId(current.getClient().getId(),
currentClient);
return currentClient.getPublicSID();
}
/**
* this function is invoked after a reconnect
*
* @param newPublicSID
*/
public synchronized Boolean overwritePublicSID(String newPublicSID) {
try {
IConnection current = Red5.getConnectionLocal();
RoomClient currentClient = this.clientListManager
.getClientByStreamId(current.getClient().getId());
if (currentClient == null) {
return false;
}
currentClient.setPublicSID(newPublicSID);
this.clientListManager.updateClientByStreamId(current.getClient()
.getId(), currentClient);
return true;
} catch (Exception err) {
log.error("[overwritePublicSID]", err);
}
return null;
}
/**
* Logic must be before roomDisconnect cause otherwise you cannot throw a
* message to each one
*
*/
@Override
public void roomLeave(IClient client, IScope room) {
try {
log.debug("roomLeave " + client.getId() + " "
+ room.getClients().size() + " " + room.getContextPath()
+ " " + room.getName());
RoomClient currentClient = this.clientListManager
.getClientByStreamId(client.getId());
// The Room Client can be null if the Client left the room by using
// logicalRoomLeave
if (currentClient != null) {
log.debug("currentClient IS NOT NULL");
this.roomLeaveByScope(currentClient, room, true);
}
} catch (Exception err) {
log.error("[roomLeave]", err);
}
}
/**
* this means a user has left a room but only logically, he didn't leave the
* app he just left the room
*
* FIXME: Is this really needed anymore if you re-connect to another scope?
*
* Exit Room by Application
*
*/
public synchronized void logicalRoomLeave() {
log.debug("logicalRoomLeave ");
try {
IConnection current = Red5.getConnectionLocal();
String streamid = current.getClient().getId();
log.debug(streamid + " is leaving");
RoomClient currentClient = this.clientListManager
.getClientByStreamId(streamid);
this.roomLeaveByScope(currentClient, current.getScope(), true);
} catch (Exception err) {
log.error("[logicalRoomLeave]", err);
}
}
/**
* Removes the Client from the List, stops recording, adds the Room-Leave
* event to running recordings, clear Polls and removes Client from any list
*
* This function is kind of private/protected as the client won't be able
* to call it with proper values.
*
* @param currentClient
* @param currentScope
*/
public synchronized void roomLeaveByScope(RoomClient currentClient,
IScope currentScope, boolean removeUserFromSessionList) {
try {
log.debug("currentClient " + currentClient);
log.debug("currentScope " + currentScope);
// log.debug("currentClient "+currentClient.getRoom_id());
Long room_id = currentClient.getRoom_id();
// Log the User
conferenceLogDao.addConferenceLog("roomLeave",
currentClient.getUser_id(), currentClient.getStreamid(),
room_id, currentClient.getUserip(), "",
currentClient.getExternalUserId(),
currentClient.getExternalUserType(),
currentClient.getMail(), currentClient.getFirstname(),
currentClient.getLastname());
// Remove User from Sync List's
if (room_id != null) {
this.whiteBoardService.removeUserFromAllLists(currentScope,
currentClient);
}
log.debug("removing USername " + currentClient.getUsername() + " "
+ currentClient.getConnectedSince() + " streamid: "
+ currentClient.getStreamid());
// stop and save any recordings
if (currentClient.getIsRecording()) {
log.debug("*** roomLeave Current Client is Recording - stop that");
// StreamService.stopRecordAndSave(currentScope,
// currentClient.getRoomRecordingName(), currentClient);
this.flvRecorderService.stopRecordAndSave(currentScope,
currentClient, null);
// set to true and overwrite the default one cause otherwise no
// notification is send
currentClient.setIsRecording(true);
}
// Notify all clients of the same currentScope (room) with domain
// and room except the current disconnected cause it could throw an exception
log.debug("currentScope " + currentScope);
if (currentScope != null && currentScope.getConnections() != null) {
// Notify Users of the current Scope
Collection<Set<IConnection>> conCollection = currentScope
.getConnections();
for (Set<IConnection> conset : conCollection) {
for (IConnection cons : conset) {
if (cons != null) {
if (cons instanceof IServiceCapableConnection) {
log.debug("sending roomDisconnect to " + cons
+ " client id "
+ cons.getClient().getId());
RoomClient rcl = this.clientListManager
.getClientByStreamId(cons.getClient()
.getId());
/*
* Check if the Client does still exist on the
* list
*/
if (rcl != null) {
/*
* Do not send back to sender, but actually
* all other clients should receive this
* message swagner 01.10.2009
*/
if (!currentClient.getStreamid().equals(
rcl.getStreamid())) {
// add Notification if another user isrecording
log.debug("###########[roomLeave]");
if (rcl.getIsRecording()) {
log.debug("*** roomLeave Any Client is Recording - stop that");
this.flvRecorderService
.stopRecordingShowForClient(
cons, currentClient);
}
//If the user was a avclient, we do not broadcast a message about that to everybody
if (currentClient.getIsAVClient()) {
continue;
}
if (rcl.getIsScreenClient() != null && rcl
.getIsScreenClient()) {
// screen sharing clients do not receive events
continue;
} else if (rcl.getIsAVClient()) {
// AVClients or potential AVClients do not receive events
continue;
}
// Send to all connected users
((IServiceCapableConnection) cons)
.invoke("roomDisconnect",
new Object[] { currentClient },this);
log.debug("sending roomDisconnect to " + cons);
}
} else {
log.debug("For this StreamId: "
+ cons.getClient().getId()
+ " There is no Client in the List anymore");
}
}
}
}
}
}
if (removeUserFromSessionList) {
this.clientListManager.removeClient(currentClient.getStreamid());
}
} catch (Exception err) {
log.error("[roomLeaveByScope]", err);
}
}
/**
* This method handles the Event after a stream has been added all connected
* Clients in the same room will get a notification
*
* @return void
*
*/
@Override
public synchronized void streamPublishStart(IBroadcastStream stream) {
try {
IConnection current = Red5.getConnectionLocal();
String streamid = current.getClient().getId();
RoomClient currentClient = this.clientListManager
.getClientByStreamId(streamid);
//We make a second object the has the reference to the object
//that we will use to send to all participents
RoomClient clientObjectSendToSync = currentClient;
// Notify all the clients that the stream had been started
log.debug("start streamPublishStart broadcast start: "
+ stream.getPublishedName() + " CONN " + current);
// In case its a screen sharing we start a new Video for that
if (currentClient.getIsScreenClient()) {
currentClient.setScreenPublishStarted(true);
this.clientListManager.updateClientByStreamId(current
.getClient().getId(), currentClient);
}
//If its an audio/video client then send the session object with the full
//data to everybody
else if (currentClient.getIsAVClient()) {
clientObjectSendToSync = this.clientListManager.getClientByPublicSID(
currentClient.getPublicSID(), false);
}
log.debug("newStream SEND: "+currentClient);
// Notify all users of the same Scope
// We need to iterate through the streams to catch if anybody is recording
Collection<Set<IConnection>> conCollection = current.getScope()
.getConnections();
for (Set<IConnection> conset : conCollection) {
for (IConnection conn : conset) {
if (conn != null) {
if (conn instanceof IServiceCapableConnection) {
RoomClient rcl = this.clientListManager
.getClientByStreamId(conn.getClient()
.getId());
if (rcl == null) {
log.debug("RCL IS NULL newStream SEND");
continue;
}
log.debug("check send to "+rcl);
if (rcl.getPublicSID() == "") {
log.debug("publicSID IS NULL newStream SEND");
continue;
}
if (rcl.getIsRecording()) {
log.debug("RCL getIsRecording newStream SEND");
this.flvRecorderService
.addRecordingByStreamId(current,
streamid, currentClient,
rcl.getFlvRecordingId());
}
if (rcl.getIsAVClient()) {
log.debug("RCL getIsAVClient newStream SEND");
continue;
}
if (rcl.getIsScreenClient() == null || rcl.getIsScreenClient()) {
log.debug("RCL getIsScreenClient newStream SEND");
continue;
}
if (rcl.getPublicSID().equals(currentClient.getPublicSID())) {
log.debug("RCL publicSID is equal newStream SEND");
continue;
}
log.debug("RCL SEND is equal newStream SEND "+rcl.getPublicSID()+" || "+rcl.getUserport());
IServiceCapableConnection iStream = (IServiceCapableConnection) conn;
iStream.invoke("newStream",
new Object[] { clientObjectSendToSync },
this);
}
}
}
}
} catch (Exception err) {
log.error("[streamPublishStart]", err);
}
}
public IBroadcastScope getBroadcastScope(IScope scope, String name) {
IBasicScope basicScope = scope.getBasicScope(ScopeType.BROADCAST, name);
if (!(basicScope instanceof IBroadcastScope)) {
return null;
} else {
return (IBroadcastScope) basicScope;
}
}
public boolean streamPublishingStart(String host, String app, String id) {
final boolean[] result = {true};
final IConnection conn = Red5.getConnectionLocal();
RoomClient rc = clientListManager.getClientByStreamId(conn.getClient().getId());
String publishName = rc.getStreamPublishName();
if (rc.getIsScreenClient() && rc.isStartStreaming()) {
IScope scope = conn.getScope();
IBroadcastStream stream = getBroadcastStream(scope, publishName);
IBroadcastScope bsScope = getBroadcastScope(scope, publishName);
final StreamingProxy proxy = new StreamingProxy();
proxy.setHost(host);
proxy.setApp(app);
proxy.setPort(1935);
proxy.init();
proxy.setExceptionHandler(new ClientExceptionHandler() {
public void handleException(Throwable throwable) {
result[0] = false;
HashMap<String, Object> params = new HashMap<String, Object>();
params.put("stopPublishing", true);
params.put("error", throwable.getMessage());
((IServiceCapableConnection)conn).invoke(
"screenSharerAction"
, new Object[] { params }
, ScopeApplicationAdapter.this);
}
});
bsScope.subscribe(proxy, null);
proxy.start(id, "live", null);
streamingProxyMap.put(publishName, proxy);
stream.addStreamListener(new IStreamListener() {
public void packetReceived(IBroadcastStream stream, IStreamPacket packet) {
try {
RTMPMessage m = RTMPMessage.build((IRTMPEvent)packet, packet.getTimestamp());
proxy.pushMessage(null, m);
} catch (Exception e) {
log.error("Exception while sending proxy message", e);
}
}
});
}
return result[0];
}
public void streamPublishingStop() {
IConnection current = Red5.getConnectionLocal();
RoomClient rc = clientListManager.getClientByStreamId(current.getClient().getId());
String publishName = rc.getStreamPublishName();
if (rc.getIsScreenClient() && publishName != null) {
IScope scope = current.getScope();
IBroadcastStream stream = getBroadcastStream(scope, publishName);
StreamingProxy proxy = streamingProxyMap.remove(publishName);
if (proxy != null) {
proxy.stop();
IBroadcastScope bsScope = getBroadcastScope(scope, stream.getPublishedName());
if (bsScope != null) {
bsScope.unsubscribe(proxy);
}
}
}
}
/**
* This method handles the Event after a stream has been removed all
* connected Clients in the same room will get a notification
*
* @return void
*
*/
@Override
public synchronized void streamBroadcastClose(IBroadcastStream stream) {
// Notify all the clients that the stream had been closed
log.debug("start streamBroadcastClose broadcast close: "
+ stream.getPublishedName());
try {
streamPublishingStop();
IConnection current = Red5.getConnectionLocal();
RoomClient rcl = clientListManager.getClientByStreamId(current.getClient().getId());
sendClientBroadcastNotifications(stream, "closeStream", rcl);
} catch (Exception e) {
log.error("[streamBroadcastClose]", e);
}
}
/**
* This method handles the notification room-based
*
* @return void
*
*/
private synchronized void sendClientBroadcastNotifications(
IBroadcastStream stream, String clientFunction, RoomClient rc) {
try {
// Store the local so that we do not send notification to ourself
// back
IConnection current = Red5.getConnectionLocal();
String streamid = current.getClient().getId();
RoomClient currentClient = this.clientListManager
.getClientByStreamId(streamid);
if (currentClient == null) {
// In case the client has already left(kicked) this message
// might be thrown later then the RoomLeave
// event and the currentClient is already gone
// The second Use-Case where the currentClient is maybe null is
// if we remove the client because its a Zombie/Ghost
return;
}
// Notify all the clients that the stream had been started
log.debug("sendClientBroadcastNotifications: "
+ stream.getPublishedName());
log.debug("sendClientBroadcastNotifications : " + currentClient
+ " " + currentClient.getStreamid());
// Notify all clients of the same scope (room)
Collection<Set<IConnection>> conCollection = current.getScope()
.getConnections();
for (Set<IConnection> conset : conCollection) {
for (IConnection conn : conset) {
if (conn != null) {
if (conn instanceof IServiceCapableConnection) {
if (conn.equals(current)) {
// there is a Bug in the current implementation
// of the appDisconnect
if (clientFunction.equals("closeStream")) {
RoomClient rcl = this.clientListManager
.getClientByStreamId(conn
.getClient().getId());
if (clientFunction.equals("closeStream")
&& rcl.getIsRecording()) {
log.debug("*** stopRecordingShowForClient Any Client is Recording - stop that");
// StreamService.stopRecordingShowForClient(conn,
// currentClient,
// rcl.getRoomRecordingName(), false);
this.flvRecorderService
.stopRecordingShowForClient(
conn, currentClient);
}
// Don't notify current client
current.ping();
}
continue;
} else {
RoomClient rcl = this.clientListManager
.getClientByStreamId(conn.getClient()
.getId());
if (rcl != null) {
if (rcl.getIsScreenClient() != null
&& rcl.getIsScreenClient()) {
// continue;
} else {
log.debug("is this users still alive? :"
+ rcl);
// conn.ping();
IServiceCapableConnection iStream = (IServiceCapableConnection) conn;
// log.info("IServiceCapableConnection ID "
// + iStream.getClient().getId());
iStream.invoke(clientFunction,
new Object[] { rc }, this);
}
log.debug("sending notification to " + conn
+ " ID: ");
// if this close stream event then stop the
// recording of this stream
if (clientFunction.equals("closeStream")
&& rcl.getIsRecording()) {
log.debug("*** +++++++ ######## sendClientBroadcastNotifications Any Client is Recording - stop that");
// StreamService.stopRecordingShowForClient(conn,
// currentClient,
// rcl.getRoomRecordingName(), false);
this.flvRecorderService
.stopRecordingShowForClient(
conn, currentClient);
}
}
}
}
}
}
}
} catch (Exception err) {
log.error("[sendClientBroadcastNotifications]", err);
}
}
/**
* Adds a Moderator by its publicSID
*
* @param publicSID
* @return
*/
public synchronized Long addModerator(String publicSID) {
try {
log.debug("*..*addModerator publicSID: " + publicSID);
// String streamid = current.getClient().getId();
RoomClient currentClient = this.clientListManager
.getClientByPublicSID(publicSID, false);
if (currentClient == null) {
return -1L;
}
Long room_id = currentClient.getRoom_id();
currentClient.setIsMod(true);
// Put the mod-flag to true for this client
this.clientListManager.updateClientByStreamId(
currentClient.getStreamid(), currentClient);
List<RoomClient> currentMods = this.clientListManager
.getCurrentModeratorByRoom(room_id);
//Send message to all users
syncMessageToCurrentScope("setNewModeratorByList", currentMods, true);
} catch (Exception err) {
log.error("[addModerator]", err);
}
return -1L;
}
@SuppressWarnings("unchecked")
public void setNewCursorPosition(Object item) {
try {
IConnection current = Red5.getConnectionLocal();
String streamid = current.getClient().getId();
RoomClient currentClient = this.clientListManager
.getClientByStreamId(streamid);
// log.debug("[setNewCursorPosition]"+item);
@SuppressWarnings("rawtypes")
Map cursor = (Map) item;
cursor.put("streamPublishName",
currentClient.getStreamPublishName());
// log.debug("[setNewCursorPosition x]"+cursor.get("cursor_x"));
// log.debug("[setNewCursorPosition y]"+cursor.get("cursor_y"));
// log.debug("[setNewCursorPosition publicSID]"+cursor.get("publicSID"));
// Notify all users of the same Scope
Collection<Set<IConnection>> conCollection = current.getScope()
.getConnections();
for (Set<IConnection> conset : conCollection) {
for (IConnection conn : conset) {
if (conn != null) {
if (conn instanceof IServiceCapableConnection) {
if (conn.equals(current)) {
continue;
} else {
RoomClient rcl = this.clientListManager
.getClientByStreamId(conn.getClient()
.getId());
if (rcl == null) {
// continue;
} else if (rcl.getIsScreenClient() != null
&& rcl.getIsScreenClient()) {
// continue;
} else {
// log.debug("is this users still alive? :"+rcl);
// Check if the Client is in the same room
// and same domain
IServiceCapableConnection iStream = (IServiceCapableConnection) conn;
// log.info("IServiceCapableConnection ID "
// + iStream.getClient().getId());
iStream.invoke("newRed5ScreenCursor",
new Object[] { cursor }, this);
// log.debug("send Notification to");
}
}
}
}
}
}
} catch (Exception err) {
log.error("[setNewCursorPosition]", err);
}
}
public synchronized Long removeModerator(String publicSID) {
try {
log.debug("*..*addModerator publicSID: " + publicSID);
IConnection current = Red5.getConnectionLocal();
// String streamid = current.getClient().getId();
RoomClient currentClient = this.clientListManager
.getClientByPublicSID(publicSID, false);
if (currentClient == null) {
return -1L;
}
Long room_id = currentClient.getRoom_id();
currentClient.setIsMod(false);
// Put the mod-flag to true for this client
this.clientListManager.updateClientByStreamId(
currentClient.getStreamid(), currentClient);
List<RoomClient> currentMods = this.clientListManager
.getCurrentModeratorByRoom(room_id);
// Notify all clients of the same scope (room)
Collection<Set<IConnection>> conCollection = current.getScope()
.getConnections();
for (Set<IConnection> conset : conCollection) {
for (IConnection conn : conset) {
if (conn != null) {
RoomClient rcl = this.clientListManager
.getClientByStreamId(conn.getClient().getId());
if (rcl == null) {
// continue;
} else if (rcl.getIsScreenClient() != null
&& rcl.getIsScreenClient()) {
// continue;
} else {
log.debug("Send Flag to Client: "
+ rcl.getUsername());
if (conn instanceof IServiceCapableConnection) {
((IServiceCapableConnection) conn).invoke(
"setNewModeratorByList",
new Object[] { currentMods }, this);
log.debug("sending setNewModeratorByList to "
+ conn);
}
}
}
}
}
} catch (Exception err) {
log.error("[addModerator]", err);
}
return -1L;
}
public synchronized Long setBroadCastingFlag(String publicSID,
boolean value, Integer interviewPodId) {
try {
log.debug("*..*setBroadCastingFlag publicSID: " + publicSID);
IConnection current = Red5.getConnectionLocal();
// String streamid = current.getClient().getId();
RoomClient currentClient = this.clientListManager
.getClientByPublicSID(publicSID, false);
if (currentClient == null) {
return -1L;
}
currentClient.setIsBroadcasting(value);
currentClient.setInterviewPodId(interviewPodId);
// Put the mod-flag to true for this client
this.clientListManager.updateClientByStreamId(
currentClient.getStreamid(), currentClient);
// Notify all clients of the same scope (room)
Collection<Set<IConnection>> conCollection = current.getScope()
.getConnections();
for (Set<IConnection> conset : conCollection) {
for (IConnection conn : conset) {
if (conn != null) {
RoomClient rcl = this.clientListManager
.getClientByStreamId(conn.getClient().getId());
if (rcl == null) {
continue;
} else if (rcl.getIsScreenClient() != null
&& rcl.getIsScreenClient()) {
continue;
} else if (rcl.getIsAVClient()) {
continue;
}
log.debug("Send Flag to Client: "
+ rcl.getUsername());
if (conn instanceof IServiceCapableConnection) {
((IServiceCapableConnection) conn).invoke(
"setNewBroadCastingFlag",
new Object[] { currentClient }, this);
log.debug("sending setNewBroadCastingFlag to "
+ conn);
}
}
}
}
} catch (Exception err) {
log.error("[setBroadCastingFlag]", err);
}
return -1L;
}
public synchronized Long giveExclusiveAudio(String publicSID) {
try {
log.debug("*..*giveExclusiveAudio publicSID: " + publicSID);
IConnection current = Red5.getConnectionLocal();
// String streamid = current.getClient().getId();
RoomClient currentClient = this.clientListManager
.getClientByPublicSID(publicSID, false);
if (currentClient == null) {
return -1L;
}
// Put the mod-flag to true for this client
currentClient.setMicMuted(false);
this.clientListManager.updateClientByStreamId(
currentClient.getStreamid(), currentClient);
// Notify all clients of the same scope (room)
Collection<Set<IConnection>> conCollection = current.getScope()
.getConnections();
for (Set<IConnection> conset : conCollection) {
for (IConnection conn : conset) {
if (conn != null) {
RoomClient rcl = this.clientListManager
.getClientByStreamId(conn.getClient().getId());
if (rcl == null) {
// continue;
} else if (rcl.getIsScreenClient() != null
&& rcl.getIsScreenClient()) {
// continue;
} else {
if (rcl != currentClient) {
rcl.setMicMuted(true);
this.clientListManager.updateClientByStreamId(
rcl.getStreamid(), rcl);
}
log.debug("Send Flag to Client: "
+ rcl.getUsername());
if (conn instanceof IServiceCapableConnection) {
((IServiceCapableConnection) conn).invoke(
"receiveExclusiveAudioFlag",
new Object[] { currentClient }, this);
log.debug("sending receiveExclusiveAudioFlag to "
+ conn);
}
}
}
}
}
} catch (Exception err) {
log.error("[giveExclusiveAudio]", err);
}
return -1L;
}
public synchronized Long switchMicMuted(String publicSID, boolean mute) {
try {
log.debug("*..*switchMicMuted publicSID: " + publicSID);
RoomClient currentClient = this.clientListManager
.getClientByPublicSID(publicSID, false);
if (currentClient == null) {
return -1L;
}
currentClient.setMicMuted(mute);
this.clientListManager.updateClientByStreamId(
currentClient.getStreamid(), currentClient);
HashMap<Integer, Object> newMessage = new HashMap<Integer, Object>();
newMessage.put(0, "updateMuteStatus");
newMessage.put(1, currentClient);
this.sendMessageWithClient(newMessage);
} catch (Exception err) {
log.error("[switchMicMuted]", err);
}
return 0L;
}
public synchronized Boolean getMicMutedByPublicSID(String publicSID) {
try {
RoomClient currentClient = this.clientListManager.getClientByPublicSID(publicSID, false);
if (currentClient == null) {
return true;
}
//Put the mod-flag to true for this client
Boolean muted = currentClient.getMicMuted();
if (null == muted) {
muted = true;
}
return muted;
} catch (Exception err) {
log.error("[getMicMutedByPublicSID]",err);
}
return true;
}
/**
* Invoked by a User whenever he want to become moderator this is needed,
* cause if the room has no moderator yet there is no-one he can ask to get
* the moderation, in case its a Non-Moderated Room he should then get the
* Moderation without any confirmation needed
*
* @return Long 1 => means get Moderation, 2 => ask Moderator for
* Moderation, 3 => wait for Moderator
*/
public synchronized Long applyForModeration(String publicSID) {
try {
RoomClient currentClient = this.clientListManager
.getClientByPublicSID(publicSID, false);
List<RoomClient> currentModList = this.clientListManager
.getCurrentModeratorByRoom(currentClient.getRoom_id());
if (currentModList.size() > 0) {
return 2L;
} else {
// No moderator in this room at the moment
Rooms room = roommanagement.getRoomById(currentClient
.getRoom_id());
if (room.getIsModeratedRoom()) {
return 3L;
} else {
return 1L;
}
}
} catch (Exception err) {
log.error("[applyForModeration]", err);
}
return -1L;
}
/**
* there will be set an attribute called "broadCastCounter" this is the name
* this user will publish his stream
*
* @return long broadCastId
*/
public synchronized long getBroadCastId() {
try {
IConnection current = Red5.getConnectionLocal();
String streamid = current.getClient().getId();
RoomClient currentClient = this.clientListManager
.getClientByStreamId(streamid);
currentClient.setBroadCastID(broadCastCounter++);
this.clientListManager.updateClientByStreamId(streamid,
currentClient);
return currentClient.getBroadCastID();
} catch (Exception err) {
log.error("[getBroadCastId]", err);
}
return -1;
}
/**
* this must be set _after_ the Video/Audio-Settings have been chosen (see
* editrecordstream.lzx) but _before_ anything else happens, it cannot be
* applied _after_ the stream has started! avsettings can be: av - video and
* audio a - audio only v - video only n - no a/v only static image
* furthermore
*
* @param avsetting
* @param newMessage
* @return
*/
public synchronized RoomClient setUserAVSettings(String avsettings,
Object newMessage, Integer vWidth, Integer vHeight,
long room_id, String publicSID, Integer interviewPodId) {
try {
IConnection current = Red5.getConnectionLocal();
String streamid = current.getClient().getId();
RoomClient currentClient = this.clientListManager
.getClientByStreamId(streamid);
currentClient.setAvsettings(avsettings);
currentClient.setRoom_id(room_id);
currentClient.setPublicSID(publicSID);
currentClient.setIsAVClient(true);
currentClient.setVWidth(vWidth);
currentClient.setVHeight(vHeight);
currentClient.setInterviewPodId(interviewPodId);
// Long room_id = currentClient.getRoom_id();
this.clientListManager.updateAVClientByStreamId(streamid,
currentClient);
HashMap<String, Object> hsm = new HashMap<String, Object>();
hsm.put("client", currentClient);
hsm.put("message", newMessage);
Collection<Set<IConnection>> conCollection = current.getScope()
.getConnections();
for (Set<IConnection> conset : conCollection) {
for (IConnection conn : conset) {
if (conn != null) {
if (conn instanceof IServiceCapableConnection) {
RoomClient rcl = this.clientListManager
.getClientByStreamId(conn.getClient()
.getId());
if (rcl == null) {
// continue;
} else if (rcl.getIsScreenClient() != null
&& rcl.getIsScreenClient()) {
// continue;
} else {
((IServiceCapableConnection) conn).invoke(
"sendVarsToMessageWithClient",
new Object[] { hsm }, this);
}
}
}
}
}
return currentClient;
} catch (Exception err) {
log.error("[setUserAVSettings]", err);
}
return null;
}
/*
* checks if the user is allowed to apply for Moderation
*/
public synchronized Boolean checkRoomValues(Long room_id) {
try {
// appointed meeting or moderated Room?
Rooms room = roommanagement.getRoomById(room_id);
// not really - default logic
if (room.getAppointment() == null || room.getAppointment() == false) {
if (room.getIsModeratedRoom()) {
// if this is a Moderated Room then the Room can be only
// locked off by the Moderator Bit
List<RoomClient> clientModeratorListRoom = this.clientListManager
.getCurrentModeratorByRoom(room_id);
// If there is no Moderator yet and we are asking for it
// then deny it
// cause at this moment, the user should wait untill a
// Moderator enters the Room
if (clientModeratorListRoom.size() == 0) {
return false;
} else {
return true;
}
} else {
return true;
}
} else {
// FIXME: TODO: For Rooms that are created as Appointment we
// have to check that too
// but I don't know yet the Logic behind it - swagner 19.06.2009
return true;
}
} catch (Exception err) {
log.error("[checkRoomValues]", err);
}
return false;
}
/**
* This function is called once a User enters a Room
*
* It contains several different mechanism depending on what roomtype and
* what options are available for the room to find out if the current user
* will be a moderator of that room or not<br/>
* <br/>
* Some rules:<br/>
* <ul>
* <li>If it is a room that was created through the calendar, the user that
* organized the room will be moderator, the param Boolean becomeModerator
* will be ignored then</li>
* <li>In regular rooms you can use the param Boolean becomeModerator to set
* any user to become a moderator of the room</li>
* </ul>
* <br/>
* If a new moderator is detected a Push Call to all current users of the
* room is invoked "setNewModeratorByList" to notify them of the new
* moderator<br/>
* <br/>
* And the end of the mechanism a push call with the new client-object
* and all the informations about the new user is send to every user of the
* current conference room<br/>
* <br/>
* @param room_id
* @param colorObj
* @return
*/
public synchronized RoomStatus setRoomValues(Long room_id,
Boolean becomeModerator, Boolean isSuperModerator,
Long organization_id, String colorObj) {
try {
// Return Object
RoomStatus roomStatus = new RoomStatus();
IConnection current = Red5.getConnectionLocal();
String streamid = current.getClient().getId();
RoomClient currentClient = this.clientListManager
.getClientByStreamId(streamid);
currentClient.setRoom_id(room_id);
currentClient.setIsAVClient(false);
currentClient.setRoomEnter(new Date());
currentClient.setOrganization_id(organization_id);
currentClient.setUsercolor(colorObj);
// Inject externalUserId if nothing is set yet
if (currentClient.getExternalUserId() == null) {
Users us = usersDao.getUser(currentClient.getUser_id());
if (us != null) {
currentClient.setExternalUserId(us.getExternalUserId());
currentClient.setExternalUserType(us.getExternalUserType());
}
}
// This can be set without checking for Moderation Flag
currentClient.setIsSuperModerator(isSuperModerator);
this.clientListManager.updateClientByStreamId(streamid,
currentClient);
Rooms room = roommanagement.getRoomById(room_id);
if (room.getShowMicrophoneStatus()) {
currentClient.setCanGiveAudio(true);
}
// Log the User
conferenceLogDao.addConferenceLog("roomEnter",
currentClient.getUser_id(), streamid, room_id,
currentClient.getUserip(), "",
currentClient.getExternalUserId(),
currentClient.getExternalUserType(),
currentClient.getMail(), currentClient.getFirstname(),
currentClient.getLastname());
log.debug("##### setRoomValues : " + currentClient);
// Check for Moderation LogicalRoom ENTER
HashMap<String, RoomClient> clientListRoom = this.clientListManager
.getRoomClients(room_id);
// appointed meeting or moderated Room? => Check Max Users first
if (room.getNumberOfPartizipants() != null
&& clientListRoom.size() > room.getNumberOfPartizipants()) {
roomStatus.setRoomFull(true);
return roomStatus;
}
// default logic for non regular rooms
if (room.getAppointment() == null || room.getAppointment() == false) {
if (room.getIsModeratedRoom()) {
// if this is a Moderated Room then the Room can be only
// locked off by the Moderator Bit
// List<RoomClient> clientModeratorListRoom =
// this.clientListManager.getCurrentModeratorByRoom(room_id);
// If there is no Moderator yet we have to check if the
// current User has the Bit set to true to
// become one, otherwise he won't get Moderation and has to
// wait
if (becomeModerator) {
currentClient.setIsMod(true);
// There is a need to send an extra Event here, cause at
// this moment there could be
// already somebody in the Room waiting
// Update the Client List
this.clientListManager.updateClientByStreamId(streamid,
currentClient);
List<RoomClient> modRoomList = this.clientListManager
.getCurrentModeratorByRoom(currentClient.getRoom_id());
//Sync message to everybody
syncMessageToCurrentScope("setNewModeratorByList", modRoomList, false);
} else {
// The current User is not a Teacher/Admin or whatever
// Role that should get the
// Moderation
currentClient.setIsMod(false);
}
} else {
// If this is a normal Room Moderator rules : first come,
// first draw ;-)
log.debug("setRoomValues : Room"
+ room_id
+ " not appointed! Moderator rules : first come, first draw ;-)");
if (clientListRoom.size() == 1) {
log.debug("Room is empty so set this user to be moderation role");
currentClient.setIsMod(true);
} else {
log.debug("Room is already somebody so set this user not to be moderation role");
if (becomeModerator) {
currentClient.setIsMod(true);
// Update the Client List
this.clientListManager.updateClientByStreamId(
streamid, currentClient);
List<RoomClient> modRoomList = this.clientListManager
.getCurrentModeratorByRoom(currentClient
.getRoom_id());
// There is a need to send an extra Event here,
// cause at this moment there could be
// already somebody in the Room waiting -swagner check this comment, 20.01.2012
//Sync message to everybody
syncMessageToCurrentScope("setNewModeratorByList", modRoomList, false);
} else {
// The current User is not a Teacher/Admin or
// whatever Role that should get the Moderation
currentClient.setIsMod(false);
}
}
}
// Update the Client List
this.clientListManager.updateClientByStreamId(streamid,
currentClient);
} else {
// If this is an Appointment then the Moderator will be set to
// the Invitor
Appointment ment = appointmentLogic
.getAppointmentByRoom(room_id);
List<MeetingMember> members = meetingMemberDao
.getMeetingMemberByAppointmentId(ment
.getAppointmentId());
Long userIdInRoomClient = currentClient.getUser_id();
boolean found = false;
boolean moderator_set = false;
// Check if current user is set to moderator
for (int i = 0; i < members.size(); i++) {
MeetingMember member = members.get(i);
// only persistent users can schedule a meeting
// user-id is only set for registered users
if (member.getUserid() != null) {
log.debug("checking user " + member.getFirstname()
+ " for moderator role - ID : "
+ member.getUserid().getUser_id());
if (member.getUserid().getUser_id()
.equals(userIdInRoomClient)) {
found = true;
if (member.getInvitor()) {
log.debug("User "
+ userIdInRoomClient
+ " is moderator due to flag in MeetingMember record");
currentClient.setIsMod(true);
// Update the Client List
this.clientListManager.updateClientByStreamId(
streamid, currentClient);
List<RoomClient> modRoomList = this.clientListManager
.getCurrentModeratorByRoom(currentClient
.getRoom_id());
// There is a need to send an extra Event here, cause at this moment
// there could be already somebody in the Room waiting
//Sync message to everybody
syncMessageToCurrentScope("setNewModeratorByList", modRoomList, false);
moderator_set = true;
this.clientListManager.updateClientByStreamId(
streamid, currentClient);
break;
} else {
log.debug("User "
+ userIdInRoomClient
+ " is NOT moderator due to flag in MeetingMember record");
currentClient.setIsMod(false);
this.clientListManager.updateClientByStreamId(
streamid, currentClient);
break;
}
} else {
if (member.getInvitor())
moderator_set = true;
}
} else {
if (member.getInvitor())
moderator_set = true;
}
}
if (!found) {
log.debug("User "
+ userIdInRoomClient
+ " could not be found as MeetingMember -> definitely no moderator");
currentClient.setIsMod(false);
this.clientListManager.updateClientByStreamId(streamid,
currentClient);
} else {
// if current user is part of the member list, but moderator
// couldn't be retrieved : first come, first draw!
if (clientListRoom.size() == 1 && moderator_set == false) {
log.debug("");
currentClient.setIsMod(true);
// Update the Client List
this.clientListManager.updateClientByStreamId(streamid,
currentClient);
List<RoomClient> modRoomList = this.clientListManager
.getCurrentModeratorByRoom(currentClient
.getRoom_id());
// There is a need to send an extra Event here, cause at
// this moment there could be
// already somebody in the Room waiting
//Sync message to everybody
syncMessageToCurrentScope("setNewModeratorByList", modRoomList, false);
this.clientListManager.updateClientByStreamId(streamid,
currentClient);
}
}
}
//Sync message to everybody
syncMessageToCurrentScope("addNewUser", currentClient, false);
//Status object for Shared Browsing
BrowserStatus browserStatus = (BrowserStatus) current.getScope()
.getAttribute("browserStatus");
if (browserStatus == null) {
browserStatus = new BrowserStatus();
}
// RoomStatus roomStatus = new RoomStatus();
// FIXME: Rework Client Object to DTOs
roomStatus.setClientMap(clientListRoom);
roomStatus.setBrowserStatus(browserStatus);
return roomStatus;
} catch (Exception err) {
log.error("[setRoomValues]", err);
}
return null;
}
/**
* This method is invoked when the user has disconnected and reconnects to
* the Gateway with the new scope
*
* @param SID
* @param userId
* @param username
* @param firstname
* @param lastname
* @param picture_uri
* @return
*/
public synchronized RoomClient setUsernameReconnect(String SID,
Long userId, String username, String firstname, String lastname,
String picture_uri) {
try {
IConnection current = Red5.getConnectionLocal();
String streamid = current.getClient().getId();
RoomClient currentClient = this.clientListManager
.getClientByStreamId(streamid);
currentClient.setUsername(username);
currentClient.setUser_id(userId);
currentClient.setPicture_uri(picture_uri);
currentClient.setUserObject(userId, username, firstname, lastname);
// Update Session Data
sessionManagement.updateUserWithoutSession(SID, userId);
Users user = userManagement.getUserById(userId);
if (user != null) {
currentClient.setExternalUserId(user.getExternalUserId());
currentClient.setExternalUserType(user.getExternalUserType());
}
// only fill this value from User-Record
// cause invited users have non
// you cannot set the firstname,lastname from the UserRecord
Users us = usersDao.getUser(userId);
if (us != null && us.getPictureuri() != null) {
// set Picture-URI
currentClient.setPicture_uri(us.getPictureuri());
}
this.clientListManager.updateClientByStreamId(streamid,
currentClient);
return currentClient;
} catch (Exception err) {
log.error("[setUsername]", err);
}
return null;
}
/**
* this is set initial directly after login/loading language
*
* @param userId
* @param username
* @param firstname
* @param lastname
* @param orgdomain
* @return
*/
public synchronized RoomClient setUsernameAndSession(String SID,
Long userId, String username, String firstname, String lastname) {
try {
IConnection current = Red5.getConnectionLocal();
String streamid = current.getClient().getId();
RoomClient currentClient = this.clientListManager
.getClientByStreamId(streamid);
currentClient.setUsername(username);
currentClient.setUser_id(userId);
currentClient.setUserObject(userId, username, firstname, lastname);
// Update Session Data
log.debug("UDPATE SESSION " + SID + ", " + userId);
sessionManagement.updateUserWithoutSession(SID, userId);
Users user = userManagement.getUserById(userId);
if (user != null) {
currentClient.setExternalUserId(user.getExternalUserId());
currentClient.setExternalUserType(user.getExternalUserType());
}
// only fill this value from User-Record
// cause invited users have non
// you cannot set the firstname,lastname from the UserRecord
Users us = usersDao.getUser(userId);
if (us != null && us.getPictureuri() != null) {
// set Picture-URI
currentClient.setPicture_uri(us.getPictureuri());
}
this.clientListManager.updateClientByStreamId(streamid,
currentClient);
return currentClient;
} catch (Exception err) {
log.error("[setUsername]", err);
}
return null;
}
/**
* used by the Screen-Sharing Servlet to trigger events
*
* @param room_id
* @param message
* @return
*/
public synchronized HashMap<String, RoomClient> sendMessageByRoomAndDomain(
Long room_id, Object message) {
HashMap<String, RoomClient> roomClientList = new HashMap<String, RoomClient>();
try {
log.debug("sendMessageByRoomAndDomain " + room_id);
IScope globalScope = getContext().getGlobalScope();
IScope webAppKeyScope = globalScope
.getScope(OpenmeetingsVariables.webAppRootKey);
log.debug("webAppKeyScope " + webAppKeyScope);
IScope scopeHibernate = webAppKeyScope.getScope(room_id.toString());
// IScope scopeHibernate = webAppKeyScope.getScope("hibernate");
if (scopeHibernate != null) {
Collection<Set<IConnection>> conCollection = webAppKeyScope
.getScope(room_id.toString()).getConnections();
for (Set<IConnection> conset : conCollection) {
for (IConnection conn : conset) {
if (conn != null) {
RoomClient rcl = this.clientListManager
.getClientByStreamId(conn.getClient()
.getId());
if (rcl == null) {
// continue;
} else if (rcl.getIsScreenClient() != null
&& rcl.getIsScreenClient()) {
// continue;
} else {
if (conn instanceof IServiceCapableConnection) {
// RoomClient rcl =
// this.clientListManager.getClientByStreamId(conn.getClient().getId());
((IServiceCapableConnection) conn).invoke(
"newMessageByRoomAndDomain",
new Object[] { message }, this);
// log.debug("sending newMessageByRoomAndDomain to "
// + conn);
}
}
}
}
}
} else {
log.debug("sendMessageByRoomAndDomain servlet not yet started - roomID : '"
+ room_id + "'");
}
} catch (Exception err) {
log.error("[getClientListBYRoomAndDomain]", err);
}
return roomClientList;
}
public synchronized List<RoomClient> getCurrentModeratorList() {
try {
log.debug("*..*getCurrentModerator id: ");
IConnection current = Red5.getConnectionLocal();
RoomClient currentClient = this.clientListManager
.getClientByStreamId(current.getClient().getId());
Long room_id = currentClient.getRoom_id();
// log.debug("Who is this moderator? "+currentMod);
return this.clientListManager.getCurrentModeratorByRoom(room_id);
} catch (Exception err) {
log.error("[getCurrentModerator]", err);
}
return null;
}
/**
* This Function is triggered from the Whiteboard
*
* @param whiteboardObj
* @return
*/
@SuppressWarnings({ "rawtypes", "unchecked" })
public synchronized void sendVars(ArrayList whiteboardObjParam) {
//
try {
// In previous version this has been always a Map, now its a List
// so I re-wrapp that class to be a Map again.
// swagner 13.02.2009
// log.debug("*..*sendVars1: " + whiteboardObjParam);
// log.debug("*..*sendVars2: " + whiteboardObjParam.getClass());
// log.debug("*..*sendVars3: " +
// whiteboardObjParam.getClass().getName());
Map whiteboardObj = new HashMap();
int i = 0;
for (Iterator iter = whiteboardObjParam.iterator(); iter.hasNext();) {
Object obj = iter.next();
// log.debug("obj"+obj);
whiteboardObj.put(i, obj);
i++;
}
// Map whiteboardObj = (Map) whiteboardObjParam;
// Check if this User is the Mod:
IConnection current = Red5.getConnectionLocal();
RoomClient currentClient = this.clientListManager
.getClientByStreamId(current.getClient().getId());
if (currentClient == null) {
return;
}
Long room_id = currentClient.getRoom_id();
String action = whiteboardObj.get(2).toString();
// log.debug("***** sendVars: " + actionObject.get(0));
if (action != null && action.equals("whiteboardObj")) {
// Update Whiteboard Object
List actionObject = (List) whiteboardObj.get(3);
WhiteboardManagement.getInstance().updateWhiteboardObject(
room_id, actionObject);
} else if (action != null && action.equals("moveMap")) {
// Update Whiteboard Object
List actionObject = (List) whiteboardObj.get(3);
WhiteboardManagement.getInstance().updateWhiteboardObjectPos(
room_id, actionObject);
} else {
// Store event in list
WhiteboardManagement.getInstance().addWhiteBoardObject(room_id,
whiteboardObj);
}
boolean showDrawStatus = getWhiteboardDrawStatus();
// Notify all Clients of that Scope (Room)
Collection<Set<IConnection>> conCollection = current.getScope()
.getConnections();
for (Set<IConnection> conset : conCollection) {
for (IConnection conn : conset) {
if (conn != null) {
if (conn instanceof IServiceCapableConnection) {
if (conn.getClient().getId()
.equals(current.getClient().getId())) {
continue;
}
RoomClient rcl = this.clientListManager
.getSyncClientByStreamId(conn.getClient()
.getId());
if (rcl == null) {
continue;
}
if (!currentClient.getStreamid().equals(
rcl.getStreamid())) {
((IServiceCapableConnection) conn)
.invoke("sendVarsToWhiteboard",
new Object[] {
(showDrawStatus ? currentClient
: null),
whiteboardObj }, this);
}
}
}
}
}
} catch (Exception err) {
log.error("[sendVars]", err);
}
}
/**
* This Function is triggered from the Whiteboard
*
* @param whiteboardObj
* @return
*/
@SuppressWarnings({ "rawtypes", "unchecked" })
public synchronized void sendVarsByWhiteboardId(
ArrayList whiteboardObjParam, Long whiteboardId) {
//
try {
Map whiteboardObj = new HashMap();
int i = 0;
for (Iterator iter = whiteboardObjParam.iterator(); iter.hasNext();) {
Object obj = iter.next();
// log.debug("obj"+obj);
whiteboardObj.put(i, obj);
i++;
}
// Check if this User is the Mod:
IConnection current = Red5.getConnectionLocal();
RoomClient currentClient = this.clientListManager
.getClientByStreamId(current.getClient().getId());
if (currentClient == null) {
return;
}
Long room_id = currentClient.getRoom_id();
// log.debug("***** sendVars: " + whiteboardObj);
// Store event in list
String action = whiteboardObj.get(2).toString();
if (action.equals("deleteMindMapNodes")) {
// Simulate Single Delete Events for z-Index
List actionObject = (List) whiteboardObj.get(3);
List<List> itemObjects = (List) actionObject.get(3);
Map whiteboardTempObj = new HashMap();
whiteboardTempObj.put(2, "delete");
for (List itemObject : itemObjects) {
List<Object> tempActionObject = new LinkedList<Object>();
tempActionObject.add("mindmapnode");
tempActionObject.add(itemObject.get(0)); // z-Index -8
tempActionObject.add(null); // simulate -7
tempActionObject.add(null); // simulate -6
tempActionObject.add(null); // simulate -5
tempActionObject.add(null); // simulate -4
tempActionObject.add(null); // simulate -3
tempActionObject.add(null); // simulate -2
tempActionObject.add(itemObject.get(1)); // Object-Name -1
whiteboardTempObj.put(3, tempActionObject);
WhiteboardManagement.getInstance().addWhiteBoardObjectById(
room_id, whiteboardTempObj, whiteboardId);
}
} else {
WhiteboardManagement.getInstance().addWhiteBoardObjectById(
room_id, whiteboardObj, whiteboardId);
}
// This is no longer necessary
// boolean ismod = currentClient.getIsMod();
// log.debug("*..*ismod: " + ismod);
// if (ismod) {
Map<String, Object> sendObject = new HashMap<String, Object>();
sendObject.put("id", whiteboardId);
sendObject.put("param", whiteboardObjParam);
boolean showDrawStatus = getWhiteboardDrawStatus();
// Notify all Clients of that Scope (Room)
Collection<Set<IConnection>> conCollection = current.getScope()
.getConnections();
for (Set<IConnection> conset : conCollection) {
for (IConnection conn : conset) {
if (conn != null) {
if (conn instanceof IServiceCapableConnection) {
if (conn.getClient().getId()
.equals(current.getClient().getId())) {
continue;
}
RoomClient rcl = this.clientListManager
.getSyncClientByStreamId(conn.getClient()
.getId());
if (rcl == null) {
continue;
}
if (!currentClient.getStreamid().equals(
rcl.getStreamid())) {
((IServiceCapableConnection) conn).invoke(
"sendVarsToWhiteboardById",
new Object[] {
showDrawStatus ? currentClient
: null, sendObject },
this);
}
}
}
}
}
// return numberOfUsers;
// } else {
// // log.debug("*..*you are not allowed to send: "+ismod);
// return -1;
// }
} catch (Exception err) {
log.error("[sendVarsByWhiteboardId]", err);
}
}
public synchronized int sendVarsModeratorGeneral(Object vars) {
log.debug("*..*sendVars: " + vars);
try {
IConnection current = Red5.getConnectionLocal();
RoomClient currentClient = this.clientListManager
.getClientByStreamId(current.getClient().getId());
// Long room_id = currentClient.getRoom_id();
log.debug("***** id: " + currentClient.getStreamid());
boolean ismod = currentClient.getIsMod();
if (ismod) {
log.debug("CurrentScope :" + current.getScope().getName());
// Send to all Clients of the same Scope
Collection<Set<IConnection>> conCollection = current.getScope()
.getConnections();
for (Set<IConnection> conset : conCollection) {
for (IConnection conn : conset) {
if (conn != null) {
if (conn instanceof IServiceCapableConnection) {
RoomClient rcl = this.clientListManager
.getClientByStreamId(conn.getClient()
.getId());
if (rcl == null) {
// continue;
} else if (rcl.getIsScreenClient() != null
&& rcl.getIsScreenClient()) {
// continue;
} else {
// log.debug("*..*idremote: " +
// rcl.getStreamid());
// log.debug("*..*my idstreamid: " +
// currentClient.getStreamid());
if (!currentClient.getStreamid().equals(
rcl.getStreamid())) {
((IServiceCapableConnection) conn)
.invoke("sendVarsToModeratorGeneral",
new Object[] { vars },
this);
// log.debug("sending sendVarsToModeratorGeneral to "
// + conn);
}
}
}
}
}
}
return 1;
} else {
// log.debug("*..*you are not allowed to send: "+ismod);
return -1;
}
} catch (Exception err) {
log.error("[sendVarsModeratorGeneral]", err);
}
return -1;
}
public synchronized int sendMessage(Object newMessage) {
try {
syncMessageToCurrentScope("sendVarsToMessage", newMessage, false);
} catch (Exception err) {
log.error("[sendMessage]", err);
}
return 1;
}
public synchronized int sendMessageAll(Object newMessage) {
try {
syncMessageToCurrentScope("sendVarsToMessage", newMessage, true);
} catch (Exception err) {
log.error("[sendMessage]", err);
}
return 1;
}
/**
* send status for shared browsing to all members except self
* @param newMessage
* @return
*/
@SuppressWarnings({ "rawtypes" })
public synchronized int sendBrowserMessageToMembers(Object newMessage) {
try {
IConnection current = Red5.getConnectionLocal();
List newMessageList = (List) newMessage;
String action = newMessageList.get(0).toString();
BrowserStatus browserStatus = (BrowserStatus) current.getScope()
.getAttribute("browserStatus");
if (browserStatus == null) {
browserStatus = new BrowserStatus();
}
if (action.equals("initBrowser") || action.equals("newBrowserURL")) {
browserStatus.setBrowserInited(true);
browserStatus.setCurrentURL(newMessageList.get(1).toString());
} else if (action.equals("closeBrowserURL")) {
browserStatus.setBrowserInited(false);
}
current.getScope().setAttribute("browserStatus", browserStatus);
syncMessageToCurrentScope("sendVarsToMessage", newMessage, false);
} catch (Exception err) {
log.error("[sendMessage]", err);
}
return 1;
}
/**
* wrapper method
* @param newMessage
* @return
*/
public synchronized int sendMessageToMembers(Object newMessage) {
try {
//Sync to all users of current scope
syncMessageToCurrentScope("sendVarsToMessage", newMessage, false);
} catch (Exception err) {
log.error("[sendMessage]", err);
}
return 1;
}
/**
* General sync mechanism for all messages that are send from within the
* scope of the current client, but:
* <ul>
* <li>optionally do not send to self (see param: sendSelf)</li>
* <li>do not send to clients that are screen sharing clients</li>
* <li>do not send to clients that are audio/video clients (or potentially ones)</li>
* <li>do not send to connections where no RoomClient is registered</li>
* </ul>
*
* @param remoteMethodName
* @param newMessage
* @param sendSelf
* @return
*/
public synchronized int syncMessageToCurrentScope(String remoteMethodName, Object newMessage, boolean sendSelf) {
try {
IConnection current = Red5.getConnectionLocal();
// Send to all Clients of that Scope(Room)
Collection<Set<IConnection>> conCollection = current.getScope()
.getConnections();
for (Set<IConnection> conset : conCollection) {
for (IConnection conn : conset) {
if (conn != null) {
if (conn instanceof IServiceCapableConnection) {
RoomClient rcl = this.clientListManager
.getClientByStreamId(conn.getClient().getId());
if (rcl == null) {
// RoomClient can be null if there are network problems
continue;
} else if (rcl.getIsScreenClient() != null && rcl
.getIsScreenClient()) {
// screen sharing clients do not receive events
continue;
} else if (rcl.getIsAVClient()) {
// AVClients or potential AVClients do not receive events
continue;
} else if (current.getClient().getId().equals(
conn.getClient().getId()) && !sendSelf) {
//Do not send back to self
continue;
}
((IServiceCapableConnection) conn).invoke(
remoteMethodName, new Object[] { newMessage }, this);
}
}
}
}
} catch (Exception err) {
log.error("[syncMessageToCurrentScope]", err);
}
return 1;
}
/**
* wrapper method
* @param newMessage
* @return
*/
public synchronized int sendMessageWithClient(Object newMessage) {
try {
sendMessageWithClientWithSyncObject(newMessage, true);
} catch (Exception err) {
log.error("[sendMessageWithClient] ", err);
return -1;
}
return 1;
}
/**
* wrapper method
* @param newMessage
* @param sync
* @return
*/
public synchronized int sendMessageWithClientWithSyncObject(Object newMessage, boolean sync) {
try {
IConnection current = Red5.getConnectionLocal();
RoomClient currentClient = this.clientListManager
.getClientByStreamId(current.getClient().getId());
HashMap<String, Object> hsm = new HashMap<String, Object>();
hsm.put("client", currentClient);
hsm.put("message", newMessage);
//Sync to all users of current scope
syncMessageToCurrentScope("sendVarsToMessageWithClient", hsm, sync);
} catch (Exception err) {
log.error("[sendMessageWithClient] ", err);
return -1;
}
return 1;
}
/**
* Function is used to send the kick Trigger at the moment,
* it sends a general message to a specific clientId
*
* @param newMessage
* @param clientId
* @return
*/
public synchronized int sendMessageById(Object newMessage, String clientId,
IScope scope) {
try {
log.debug("### sendMessageById ###" + clientId);
HashMap<String, Object> hsm = new HashMap<String, Object>();
hsm.put("message", newMessage);
// broadcast Message to specific user with id inside the same Scope
Collection<Set<IConnection>> conCollection = scope.getConnections();
for (Set<IConnection> conset : conCollection) {
for (IConnection conn : conset) {
if (conn != null) {
if (conn instanceof IServiceCapableConnection) {
RoomClient rcl = this.clientListManager
.getClientByStreamId(conn.getClient()
.getId());
if (rcl == null) {
// continue;
} else if (rcl.getIsScreenClient() != null
&& rcl.getIsScreenClient()) {
// continue;
} else {
// log.debug("### sendMessageById 1 ###"+clientId);
// log.debug("### sendMessageById 2 ###"+conn.getClient().getId());
if (conn.getClient().getId().equals(clientId)) {
((IServiceCapableConnection) conn).invoke(
"sendVarsToMessageWithClient",
new Object[] { hsm }, this);
// log.debug("sendingsendVarsToMessageWithClient ByID to "
// + conn);
}
}
}
}
}
}
} catch (Exception err) {
log.error("[sendMessageWithClient] ", err);
return -1;
}
return 1;
}
/**
* Sends a message to a user in the same room by its clientId
*
* @param newMessage
* @param clientId
* @return
*/
public synchronized int sendMessageWithClientById(Object newMessage,
String clientId) {
try {
IConnection current = Red5.getConnectionLocal();
RoomClient currentClient = this.clientListManager
.getClientByStreamId(current.getClient().getId());
log.debug("### sendMessageWithClientById ###" + clientId);
HashMap<String, Object> hsm = new HashMap<String, Object>();
hsm.put("client", currentClient);
hsm.put("message", newMessage);
// broadcast Message to specific user with id inside the same Scope
Collection<Set<IConnection>> conCollection = current.getScope()
.getConnections();
for (Set<IConnection> conset : conCollection) {
for (IConnection conn : conset) {
if (conn != null) {
RoomClient rcl = this.clientListManager
.getClientByStreamId(conn.getClient().getId());
if (rcl == null) {
// continue;
} else if (rcl.getIsScreenClient() != null
&& rcl.getIsScreenClient()) {
// continue;
} else {
if (conn instanceof IServiceCapableConnection) {
// log.debug("### sendMessageWithClientById 1 ###"+clientId);
// log.debug("### sendMessageWithClientById 2 ###"+conn.getClient().getId());
if (conn.getClient().getId().equals(clientId)) {
((IServiceCapableConnection) conn).invoke(
"sendVarsToMessageWithClient",
new Object[] { hsm }, this);
// log.debug("sendingsendVarsToMessageWithClient ByID to "
// + conn);
}
}
}
}
}
}
} catch (Exception err) {
log.error("[sendMessageWithClient] ", err);
return -1;
}
return 1;
}
public synchronized void sendMessageWithClientByPublicSID(Object message,
String publicSID) {
try {
// ApplicationContext appCtx = getContext().getApplicationContext();
IScope globalScope = getContext().getGlobalScope();
IScope webAppKeyScope = globalScope
.getScope(OpenmeetingsVariables.webAppRootKey);
// log.debug("webAppKeyScope "+webAppKeyScope);
// Get Room Id to send it to the correct Scope
RoomClient currentClient = this.clientListManager
.getClientByPublicSID(publicSID, false);
if (currentClient == null) {
throw new Exception(
"Could not Find RoomClient on List publicSID: "
+ publicSID);
}
// default Scope Name
String scopeName = "hibernate";
if (currentClient.getRoom_id() != null) {
scopeName = currentClient.getRoom_id().toString();
}
IScope scopeHibernate = webAppKeyScope.getScope(scopeName);
// log.debug("scopeHibernate "+scopeHibernate);
if (scopeHibernate != null) {
// Notify the clients of the same scope (room) with user_id
Collection<Set<IConnection>> conCollection = webAppKeyScope
.getScope(scopeName).getConnections();
for (Set<IConnection> conset : conCollection) {
for (IConnection conn : conset) {
if (conn != null) {
RoomClient rcl = this.clientListManager
.getClientByStreamId(conn.getClient()
.getId());
if (rcl != null) {
if (rcl.getIsScreenClient() != null
&& rcl.getIsScreenClient()) {
// continue;
} else {
// log.debug("rcl "+rcl+" rcl.getUser_id(): "+rcl.getPublicSID()+" publicSID: "+publicSID+
// " IS EQUAL? "+rcl.getPublicSID().equals(publicSID));
if (rcl.getPublicSID().equals(publicSID)) {
// log.debug("IS EQUAL ");
((IServiceCapableConnection) conn)
.invoke("newMessageByRoomAndDomain",
new Object[] { message },
this);
log.debug("newMessageByRoomAndDomain RPC:newMessageByRoomAndDomain"
+ message);
}
}
}
}
}
}
} else {
// Scope not yet started
}
} catch (Exception err) {
log.error("[sendMessageWithClient] ", err);
err.printStackTrace();
}
}
public synchronized void sendMessageWithClientByPublicSIDOrUser(
Object message, String publicSID, Long user_id) {
try {
// ApplicationContext appCtx = getContext().getApplicationContext();
IScope globalScope = getContext().getGlobalScope();
IScope webAppKeyScope = globalScope
.getScope(OpenmeetingsVariables.webAppRootKey);
// log.debug("webAppKeyScope "+webAppKeyScope);
// Get Room Id to send it to the correct Scope
RoomClient currentClient = this.clientListManager
.getClientByPublicSID(publicSID, false);
if (currentClient == null) {
currentClient = this.clientListManager
.getClientByUserId(user_id);
}
Collection<Set<IConnection>> conCollection = null;
if (currentClient == null) {
// Must be from a previous session, search for user in current
// scope
IConnection current = Red5.getConnectionLocal();
// Notify all Clients of that Scope (Room)
conCollection = current.getScope().getConnections();
} else {
// default Scope Name
String scopeName = "hibernate";
if (currentClient.getRoom_id() != null) {
scopeName = currentClient.getRoom_id().toString();
}
IScope scopeHibernate = webAppKeyScope.getScope(scopeName);
if (scopeHibernate != null) {
conCollection = webAppKeyScope.getScope(scopeName)
.getConnections();
}
}
// log.debug("scopeHibernate "+scopeHibernate);
// Notify the clients of the same scope (room) with user_id
for (Set<IConnection> conset : conCollection) {
for (IConnection conn : conset) {
if (conn != null) {
RoomClient rcl = this.clientListManager
.getClientByStreamId(conn.getClient().getId());
if (rcl != null) {
if (rcl.getIsScreenClient() != null
&& rcl.getIsScreenClient()) {
// continue;
} else {
// log.debug("rcl "+rcl+" rcl.getUser_id(): "+rcl.getPublicSID()+" publicSID: "+publicSID+
// " IS EQUAL? "+rcl.getPublicSID().equals(publicSID));
if (rcl.getPublicSID().equals(publicSID)) {
// log.debug("IS EQUAL ");
((IServiceCapableConnection) conn).invoke(
"newMessageByRoomAndDomain",
new Object[] { message }, this);
log.debug("sendMessageWithClientByPublicSID RPC:newMessageByRoomAndDomain"
+ message);
} else if (user_id != 0
&& rcl.getUser_id() != null
&& rcl.getUser_id().equals(user_id)) {
((IServiceCapableConnection) conn).invoke(
"newMessageByRoomAndDomain",
new Object[] { message }, this);
log.debug("sendMessageWithClientByPublicSID RPC:newMessageByRoomAndDomain"
+ message);
}
}
}
}
}
}
} catch (Exception err) {
log.error("[sendMessageWithClient] ", err);
err.printStackTrace();
}
}
public synchronized Boolean getInterviewRecordingStatus() {
try {
IConnection current = Red5.getConnectionLocal();
Collection<Set<IConnection>> conCollection = current.getScope()
.getConnections();
for (Set<IConnection> conset : conCollection) {
for (IConnection conn : conset) {
if (conn != null) {
RoomClient rcl = this.clientListManager
.getClientByStreamId(conn.getClient().getId());
if (rcl.getIsRecording() != null
&& rcl.getIsRecording()) {
return true;
}
}
}
}
return false;
} catch (Exception err) {
log.error("[getInterviewRecordingStatus]", err);
}
return null;
}
public synchronized Boolean startInterviewRecording() {
try {
IConnection current = Red5.getConnectionLocal();
Collection<Set<IConnection>> conCollection = current.getScope()
.getConnections();
for (Set<IConnection> conset : conCollection) {
for (IConnection conn : conset) {
if (conn != null) {
RoomClient rcl = this.clientListManager
.getClientByStreamId(conn.getClient().getId());
if (rcl.getIsRecording() != null
&& rcl.getIsRecording()) {
return false;
}
}
}
}
RoomClient current_rcl = this.clientListManager
.getClientByStreamId(current.getClient().getId());
// Also set the Recording Flag to Record all Participants that enter
// later
current_rcl.setIsRecording(true);
this.clientListManager.updateClientByStreamId(current.getClient()
.getId(), current_rcl);
Map<String, String> interviewStatus = new HashMap<String, String>();
interviewStatus.put("action", "start");
for (Set<IConnection> conset : conCollection) {
for (IConnection conn : conset) {
if (conn != null) {
RoomClient rcl = this.clientListManager
.getClientByStreamId(conn.getClient().getId());
if (rcl == null) {
continue;
} else if (rcl.getIsAVClient()) {
continue;
} else if (rcl.getIsScreenClient() != null && rcl.getIsScreenClient()) {
continue;
}
((IServiceCapableConnection) conn).invoke(
"interviewStatus",
new Object[] { interviewStatus }, this);
log.debug("-- interviewStatus" + interviewStatus);
}
}
}
String recordingName = "Interview "
+ CalendarPatterns.getDateWithTimeByMiliSeconds(new Date());
this.flvRecorderService
.recordMeetingStream(recordingName, "", true);
return true;
} catch (Exception err) {
log.debug("[startInterviewRecording]", err);
}
return null;
}
@SuppressWarnings({ "rawtypes" })
public synchronized Boolean sendRemoteCursorEvent(String streamid,
Map messageObj) {
try {
IConnection current = Red5.getConnectionLocal();
Collection<Set<IConnection>> conCollection = current.getScope()
.getConnections();
for (Set<IConnection> conset : conCollection) {
for (IConnection conn : conset) {
if (conn != null) {
RoomClient rcl = this.clientListManager
.getClientByStreamId(conn.getClient().getId());
if (rcl == null) {
// continue;
} else if (rcl.getIsScreenClient() != null
&& rcl.getIsScreenClient()) {
if (rcl.getStreamid() != null
&& rcl.getStreamid().equals(streamid)) {
((IServiceCapableConnection) conn).invoke(
"sendRemoteCursorEvent",
new Object[] { messageObj }, this);
log.debug("sendRemoteCursorEvent messageObj"
+ messageObj);
}
}
}
}
}
} catch (Exception err) {
log.debug("[sendRemoteCursorEvent]", err);
}
return null;
}
//FIXME: legacy code, needs to be removed
public boolean checkSharerSession() {
return true;
}
/**
* Stop the recording of the streams and send event to connected users of scope
*
* @return
*/
public synchronized Boolean stopInterviewRecording() {
try {
IConnection current = Red5.getConnectionLocal();
boolean found = false;
Long flvRecordingId = null;
Collection<Set<IConnection>> conCollection = current.getScope()
.getConnections();
for (Set<IConnection> conset : conCollection) {
for (IConnection conn : conset) {
if (conn != null) {
RoomClient rcl = this.clientListManager
.getClientByStreamId(conn.getClient().getId());
if (rcl.getIsRecording() != null
&& rcl.getIsRecording()) {
rcl.setIsRecording(false);
flvRecordingId = rcl.getFlvRecordingId();
rcl.setFlvRecordingId(null);
// Reset the Recording Flag to Record all
// Participants that enter later
this.clientListManager.updateClientByStreamId(conn
.getClient().getId(), rcl);
found = true;
}
}
}
}
if (!found) {
return false;
}
RoomClient currentClient = this.clientListManager
.getClientByStreamId(current.getClient().getId());
this.flvRecorderService.stopRecordAndSave(scope, currentClient,
flvRecordingId);
Map<String, String> interviewStatus = new HashMap<String, String>();
interviewStatus.put("action", "stop");
for (Set<IConnection> conset : conCollection) {
for (IConnection conn : conset) {
if (conn != null) {
((IServiceCapableConnection) conn).invoke(
"interviewStatus",
new Object[] { interviewStatus }, this);
log.debug("sendMessageWithClientByPublicSID interviewStatus"
+ interviewStatus);
}
}
}
return true;
} catch (Exception err) {
log.debug("[startInterviewRecording]", err);
}
return null;
}
/**
* Get all ClientList Objects of that room and domain Used in
* lz.applyForModeration.lzx
*
* @return
*/
public synchronized HashMap<String, RoomClient> getClientListScope() {
HashMap<String, RoomClient> roomClientList = new HashMap<String, RoomClient>();
try {
IConnection current = Red5.getConnectionLocal();
RoomClient currentClient = this.clientListManager
.getClientByStreamId(current.getClient().getId());
return this.clientListManager.getClientListByRoom(currentClient.getRoom_id());
} catch (Exception err) {
log.debug("[getClientListScope]", err);
}
return roomClientList;
}
private boolean getWhiteboardDrawStatus() {
if (ScopeApplicationAdapter.whiteboardDrawStatus == null) {
String drawStatus = cfgManagement.getConfValue("show.whiteboard.draw.status", String.class, "0");
ScopeApplicationAdapter.whiteboardDrawStatus = "1".equals(drawStatus);
}
return ScopeApplicationAdapter.whiteboardDrawStatus;
}
public String getCryptKey() {
try {
if (ScopeApplicationAdapter.configKeyCryptClassName == null) {
Configuration conf = cfgManagement.getConfKey(3,
"crypt_ClassName");
if (conf != null) {
ScopeApplicationAdapter.configKeyCryptClassName = conf
.getConf_value();
}
}
return ScopeApplicationAdapter.configKeyCryptClassName;
} catch (Exception err) {
log.error("[getCryptKey]", err);
}
return null;
}
public String getExclusiveAudioKeyCode() {
Configuration conf = cfgManagement.getConfKey(3, "exclusive.audio.keycode");
if (null != conf) {
return conf.getConf_value();
} else {
return null;
}
}
public synchronized IScope getRoomScope(String room) {
try {
IScope globalScope = getContext().getGlobalScope();
IScope webAppKeyScope = globalScope
.getScope(OpenmeetingsVariables.webAppRootKey);
String scopeName = "hibernate";
// If set then its a NON default Scope
if (room.length() != 0) {
scopeName = room;
}
IScope scopeHibernate = webAppKeyScope.getScope(scopeName);
return scopeHibernate;
} catch (Exception err) {
log.error("[getRoomScope]", err);
}
return null;
}
/*
* SIP transport methods
*/
public synchronized void updateSipTransport() {
IConnection current = Red5.getConnectionLocal();
String streamid = current.getClient().getId();
RoomClient currentClient = this.clientListManager.getClientByStreamId(streamid);
log.debug("getSipConferenceMembersNumber: " + roommanagement.getSipConferenceMembersNumber(currentClient.getRoom_id()));
String newNumber = "("+Integer.toString(roommanagement.getSipConferenceMembersNumber(currentClient.getRoom_id())-1)+")";
if(!newNumber.equals(currentClient.getLastname())) {
currentClient.setLastname(newNumber);
this.clientListManager.updateClientByStreamId(streamid, currentClient);
log.debug("updateSipTransport: {}, {}, {}, {}", new Object[]{currentClient.getPublicSID(),
currentClient.getRoom_id(), currentClient.getFirstname(), currentClient.getLastname()});
sendMessageWithClient(new String[]{"personal",currentClient.getFirstname(),currentClient.getLastname()});
}
}
/**
* Perform call to specified phone number and join to conference
* @param number to call
*/
public synchronized void joinToConfCall(String number) {
IConnection current = Red5.getConnectionLocal();
String streamid = current.getClient().getId();
RoomClient currentClient = this.clientListManager.getClientByStreamId(streamid);
Rooms rooms = roommanagement.getRoomById(currentClient.getRoom_id());
log.debug("asterisk -rx \"originate Local/" + number + "@rooms extension " + rooms.getSipNumber() + "@rooms\"");
try {
Runtime.getRuntime().exec(new String[]{"asterisk", "-rx", "originate Local/" + number + "@rooms extension " + rooms.getSipNumber() + "@rooms"});
} catch (IOException e) {
log.error("Executing asterisk originate error: ", e);
}
}
public synchronized String getSipNumber(Long room_id) {
Rooms rooms = roommanagement.getRoomById(room_id);
if(rooms != null) {
log.debug("getSipNumber: room_id: {}, sipNumber: {}", new Object[]{room_id, rooms.getSipNumber()});
return rooms.getSipNumber();
}
return null;
}
public synchronized void setSipTransport(Long room_id, String publicSID, String broadCastId) {
IConnection current = Red5.getConnectionLocal();
String streamid = current.getClient().getId();
// Notify all clients of the same scope (room)
RoomClient currentClient = this.clientListManager.getClientByStreamId(streamid);
currentClient.setRoom_id(room_id);
currentClient.setRoomEnter(new Date());
currentClient.setFirstname("SIP Transport");
currentClient.setLastname("("+Integer.toString(roommanagement.getSipConferenceMembersNumber(room_id)-1)+")");
currentClient.setBroadCastID(Long.parseLong(broadCastId));
currentClient.setIsBroadcasting(true);
currentClient.setPublicSID(publicSID);
currentClient.setAvsettings("av");
currentClient.setVWidth(120);
currentClient.setVHeight(90);
this.clientListManager.updateClientByStreamId(streamid, currentClient);
Collection<Set<IConnection>> conCollection = current
.getScope().getConnections();
for (Set<IConnection> conset : conCollection) {
for (IConnection conn : conset) {
if (conn != null) {
RoomClient rcl = this.clientListManager.getClientByStreamId(conn.getClient().getId());
if (rcl == null) {
// continue;
} else if (rcl.getIsScreenClient() != null
&& rcl.getIsScreenClient()) {
// continue;
} else {
if (!streamid.equals(rcl.getStreamid())) {
// It is not needed to send back
// that event to the actuall
// Moderator
// as it will be already triggered
// in the result of this Function
// in the Client
if (conn instanceof IServiceCapableConnection) {
((IServiceCapableConnection) conn).invoke("addNewUser", new Object[]{currentClient}, this);
((IServiceCapableConnection) conn).invoke("newStream", new Object[]{currentClient}, this);
log.debug("sending setSipTransport to "
+ conn);
}
}
}
}
}
}
}
}