| /* |
| * 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.util.Collection; |
| import java.util.Date; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.LinkedList; |
| import java.util.List; |
| |
| import org.openmeetings.app.OpenmeetingsVariables; |
| import org.openmeetings.app.conference.session.RoomClient; |
| import org.openmeetings.app.data.beans.basic.SearchResult; |
| import org.openmeetings.utils.crypt.ManageCryptStyle; |
| import org.red5.logging.Red5LoggerFactory; |
| import org.slf4j.Logger; |
| import org.springframework.beans.factory.annotation.Autowired; |
| |
| public class ClientListManager { |
| private static HashMap<String, RoomClient> clientList = new HashMap<String, RoomClient>(); |
| |
| private static final Logger log = Red5LoggerFactory.getLogger( |
| ClientListManager.class, OpenmeetingsVariables.webAppRootKey); |
| |
| @Autowired |
| private ManageCryptStyle manageCryptStyle; |
| |
| /** |
| * Get current clients and extends the room client with its potential |
| * audio/video client and settings |
| * |
| * @param room_id |
| * @return |
| */ |
| public HashMap<String, RoomClient> getRoomClients(Long room_id) { |
| try { |
| |
| HashMap<String, RoomClient> roomClientList = new HashMap<String, RoomClient>(); |
| HashMap<String, RoomClient> clientListRoom = this.getClientListByRoom(room_id); |
| for (Iterator<String> iter = clientListRoom.keySet().iterator(); iter |
| .hasNext();) { |
| String key = iter.next(); |
| RoomClient rcl = this.getClientByStreamId(key); |
| |
| if (rcl.getIsAVClient()) { |
| continue; |
| } |
| |
| // Add user to List |
| roomClientList.put(key, rcl); |
| } |
| |
| return roomClientList; |
| } catch (Exception err) { |
| log.error("[getRoomClients]", err); |
| } |
| return null; |
| } |
| |
| public synchronized RoomClient addClientListItem(String streamId, |
| String scopeName, Integer remotePort, String remoteAddress, |
| String swfUrl, boolean isAVClient) { |
| try { |
| |
| // Store the Connection into a bean and add it to the HashMap |
| RoomClient rcm = new RoomClient(); |
| rcm.setConnectedSince(new Date()); |
| rcm.setStreamid(streamId); |
| rcm.setScope(scopeName); |
| long thistime = new Date().getTime(); |
| rcm.setPublicSID(manageCryptStyle.getInstanceOfCrypt() |
| .createPassPhrase(String.valueOf(thistime).toString())); |
| |
| rcm.setUserport(remotePort); |
| rcm.setUserip(remoteAddress); |
| rcm.setSwfurl(swfUrl); |
| rcm.setIsMod(new Boolean(false)); |
| rcm.setCanDraw(new Boolean(false)); |
| rcm.setIsAVClient(isAVClient); |
| |
| if (clientList.containsKey(streamId)) { |
| log.error("Tried to add an existing Client " + streamId); |
| return null; |
| } |
| |
| clientList.put(rcm.getStreamid(), rcm); |
| |
| log.debug(" :: addClientListItem :: " + rcm.getRoomClientId()); |
| |
| return rcm; |
| } catch (Exception err) { |
| log.error("[addClientListItem]", err); |
| } |
| return null; |
| } |
| |
| public synchronized Collection<RoomClient> getAllClients() { |
| return clientList.values(); |
| } |
| |
| public synchronized RoomClient getClientByStreamId(String streamId) { |
| try { |
| if (!clientList.containsKey(streamId)) { |
| log.debug("Tried to get a non existing Client " + streamId); |
| return null; |
| } |
| return clientList.get(streamId); |
| } catch (Exception err) { |
| log.error("[getClientByStreamId]", err); |
| } |
| return null; |
| } |
| |
| /** |
| * Additionally checks if the client receives sync events |
| * |
| * Sync events will no be broadcasted to: |
| * - Screensharing users |
| * - Audio/Video connections only |
| * |
| * @param streamId |
| * @return |
| */ |
| public synchronized RoomClient getSyncClientByStreamId(String streamId) { |
| try { |
| if (!clientList.containsKey(streamId)) { |
| log.debug("Tried to get a non existing Client " + streamId); |
| return null; |
| } |
| |
| RoomClient rcl = clientList.get(streamId); |
| |
| if (rcl == null) { |
| return null; |
| } |
| |
| if (rcl.getIsScreenClient() != null && rcl.getIsScreenClient()) { |
| return null; |
| } |
| |
| return clientList.get(streamId); |
| } catch (Exception err) { |
| log.error("[getClientByStreamId]", err); |
| } |
| return null; |
| } |
| |
| |
| public synchronized RoomClient getClientByPublicSID(String publicSID, Boolean isAVClient) { |
| try { |
| for (Iterator<String> iter = clientList.keySet().iterator(); iter |
| .hasNext();) { |
| RoomClient rcl = clientList.get(iter.next()); |
| |
| if (!rcl.getPublicSID().equals(publicSID)) { |
| continue; |
| } |
| if (rcl.getIsAVClient() != isAVClient) { |
| continue; |
| } |
| |
| return rcl; |
| } |
| } catch (Exception err) { |
| log.error("[getClientByPublicSID]", err); |
| } |
| return null; |
| } |
| |
| public synchronized RoomClient getClientByUserId(Long userId) { |
| try { |
| for (Iterator<String> iter = clientList.keySet().iterator(); iter |
| .hasNext();) { |
| RoomClient rcl = clientList.get(iter.next()); |
| if (rcl.getUser_id().equals(userId)) { |
| return rcl; |
| } |
| } |
| } catch (Exception err) { |
| log.error("[getClientByPublicSID]", err); |
| } |
| return null; |
| } |
| |
| /** |
| * Update the session object of the audio/video-connection and additionally swap the |
| * values to the session object of the user that holds the full session object |
| * @param streamId |
| * @param rcm |
| * @return |
| */ |
| public synchronized Boolean updateAVClientByStreamId(String streamId, |
| RoomClient rcm) { |
| try { |
| |
| //get the corresponding user session object and update the settings |
| RoomClient rclUsual = getClientByPublicSID(rcm.getPublicSID(), false); |
| if (rclUsual != null) { |
| rclUsual.setBroadCastID(rcm.getBroadCastID()); |
| rclUsual.setAvsettings(rcm.getAvsettings()); |
| rclUsual.setVHeight(rcm.getVHeight()); |
| rclUsual.setVWidth(rcm.getVWidth()); |
| rclUsual.setVX(rcm.getVX()); |
| rclUsual.setVY(rcm.getVY()); |
| if (clientList.containsKey(rclUsual.getStreamid())) { |
| clientList.put(rclUsual.getStreamid(), rclUsual); |
| } else { |
| log.debug("Tried to update a non existing Client " + rclUsual.getStreamid()); |
| } |
| } |
| |
| updateClientByStreamId(streamId, rcm); |
| } catch (Exception err) { |
| log.error("[updateAVClientByStreamId]", err); |
| } |
| return null; |
| } |
| |
| public synchronized Boolean updateClientByStreamId(String streamId, |
| RoomClient rcm) { |
| try { |
| if (clientList.containsKey(streamId)) { |
| clientList.put(streamId, rcm); |
| return true; |
| } else { |
| log.debug("Tried to update a non existing Client " + streamId); |
| return false; |
| } |
| } catch (Exception err) { |
| log.error("[updateClientByStreamId]", err); |
| } |
| return null; |
| } |
| |
| public synchronized Boolean removeClient(String streamId) { |
| try { |
| if (clientList.containsKey(streamId)) { |
| clientList.remove(streamId); |
| // log.debug(":: removeClient ::"+clientList.size()); |
| return true; |
| } else { |
| log.debug("Tried to remove a non existing Client " + streamId); |
| return false; |
| } |
| } catch (Exception err) { |
| log.error("[removeClient]", err); |
| } |
| return null; |
| } |
| |
| /** |
| * Get all ClientList Objects of that room and domain This Function is |
| * needed cause it is invoked internally AFTER the current user has been |
| * already removed from the ClientList to see if the Room is empty again and |
| * the PollList can be removed |
| * |
| * @return |
| */ |
| // FIXME seems like there is no need to return HashMap |
| public synchronized HashMap<String, RoomClient> getClientListByRoom( |
| Long room_id) { |
| HashMap<String, RoomClient> roomClientList = new HashMap<String, RoomClient>(); |
| try { |
| for (Iterator<String> iter = clientList.keySet().iterator(); iter |
| .hasNext();) { |
| String key = iter.next(); |
| RoomClient rcl = clientList.get(key); |
| |
| // client initialized and same room |
| if (rcl.getRoom_id() == null || !room_id.equals(rcl.getRoom_id())) { |
| continue; |
| } |
| if (rcl.getIsScreenClient() == null || |
| rcl.getIsScreenClient()) { |
| continue; |
| } |
| if (rcl.getIsAVClient()) { |
| continue; |
| } |
| |
| //Only parse really those users out that are really a full session object |
| //and no pseudo session object like the audio/video or screen sharing connection |
| roomClientList.put(key, rcl); |
| |
| } |
| } catch (Exception err) { |
| log.error("[getClientListByRoom]", err); |
| } |
| return roomClientList; |
| } |
| |
| |
| |
| // FIXME seems to be copy/pasted with previous one |
| public synchronized HashMap<String, RoomClient> getClientListByRoomAll( |
| Long room_id) { |
| HashMap<String, RoomClient> roomClientList = new HashMap<String, RoomClient>(); |
| try { |
| for (Iterator<String> iter = clientList.keySet().iterator(); iter |
| .hasNext();) { |
| String key = iter.next(); |
| // log.debug("getClientList key: "+key); |
| RoomClient rcl = clientList.get(key); |
| |
| if (rcl.getRoom_id() != null |
| && rcl.getRoom_id().equals(room_id)) { |
| // same room |
| roomClientList.put(key, rcl); |
| } |
| } |
| } catch (Exception err) { |
| log.error("[getClientListByRoom]", err); |
| } |
| return roomClientList; |
| } |
| |
| /** |
| * get the current Moderator in this room |
| * |
| * @param roomname |
| * @return |
| */ |
| public synchronized List<RoomClient> getCurrentModeratorByRoom(Long room_id) { |
| |
| List<RoomClient> rclList = new LinkedList<RoomClient>(); |
| for (Iterator<String> iter = clientList.keySet().iterator(); iter |
| .hasNext();) { |
| String key = iter.next(); |
| RoomClient rcl = clientList.get(key); |
| // |
| log.debug("*..*unsetModerator ClientList key: " + rcl.getStreamid()); |
| // |
| // Check if the Client is in the same room |
| if (room_id != null && room_id.equals(rcl.getRoom_id()) |
| && rcl.getIsMod()) { |
| log.debug("found client who is the Moderator: " + rcl); |
| rclList.add(rcl); |
| } |
| } |
| |
| return rclList; |
| } |
| |
| public synchronized SearchResult<RoomClient> getListByStartAndMax(int start, int max, |
| String orderby, boolean asc) { |
| SearchResult<RoomClient> sResult = new SearchResult<RoomClient>(); |
| sResult.setObjectName(RoomClient.class.getName()); |
| sResult.setRecords(Long.valueOf(clientList.size()).longValue()); |
| LinkedList<RoomClient> myList = new LinkedList<RoomClient>(); |
| |
| int i = 0; |
| // TODO Auto-generated method stub |
| Iterator<String> iter = clientList.keySet().iterator(); |
| while (iter.hasNext()) { |
| String key = iter.next(); |
| if (i >= start) { |
| myList.add(clientList.get(key)); |
| } |
| if (i > max) { |
| break; |
| } |
| i++; |
| } |
| sResult.setResult(myList); |
| |
| return sResult; |
| } |
| |
| public synchronized void removeAllClients() { |
| try { |
| clientList.clear(); |
| } catch (Exception err) { |
| log.error("[removeAllClients]", err); |
| } |
| } |
| } |