| /* |
| * 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; |
| |
| import java.io.File; |
| import java.util.Collection; |
| import java.util.Date; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| 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.data.basic.AuthLevelmanagement; |
| import org.openmeetings.app.data.basic.Sessionmanagement; |
| import org.openmeetings.app.data.conference.Roommanagement; |
| import org.openmeetings.app.data.flvrecord.FlvRecordingDaoImpl; |
| import org.openmeetings.app.data.flvrecord.FlvRecordingLogDaoImpl; |
| import org.openmeetings.app.data.flvrecord.FlvRecordingMetaDataDaoImpl; |
| import org.openmeetings.app.data.flvrecord.FlvRecordingMetaDeltaDaoImpl; |
| import org.openmeetings.app.data.flvrecord.beans.FLVRecorderObject; |
| import org.openmeetings.app.data.flvrecord.converter.FlvInterviewConverterTask; |
| import org.openmeetings.app.data.flvrecord.converter.FlvInterviewReConverterTask; |
| import org.openmeetings.app.data.flvrecord.converter.FlvRecorderConverterTask; |
| import org.openmeetings.app.data.flvrecord.listener.BaseStreamListener; |
| import org.openmeetings.app.data.flvrecord.listener.StreamAudioListener; |
| import org.openmeetings.app.data.flvrecord.listener.StreamVideoListener; |
| import org.openmeetings.app.data.user.Usermanagement; |
| import org.openmeetings.app.data.user.dao.UsersDaoImpl; |
| import org.openmeetings.app.persistence.beans.flvrecord.FlvRecording; |
| import org.openmeetings.app.persistence.beans.flvrecord.FlvRecordingLog; |
| import org.openmeetings.app.persistence.beans.flvrecord.FlvRecordingMetaData; |
| import org.openmeetings.app.remote.red5.ClientListManager; |
| import org.openmeetings.app.remote.red5.ScopeApplicationAdapter; |
| import org.openmeetings.utils.math.CalendarPatterns; |
| import org.red5.logging.Red5LoggerFactory; |
| import org.red5.server.api.IConnection; |
| import org.red5.server.api.Red5; |
| import org.red5.server.api.scope.IScope; |
| 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.IStreamListener; |
| import org.red5.server.stream.ClientBroadcastStream; |
| import org.slf4j.Logger; |
| import org.springframework.beans.factory.annotation.Autowired; |
| |
| public class FLVRecorderService implements IPendingServiceCallback { |
| |
| private static final Logger log = Red5LoggerFactory.getLogger( |
| FLVRecorderService.class, OpenmeetingsVariables.webAppRootKey); |
| |
| /** |
| * Stores a reference to all available listeners |
| * we need that reference, as the internal references stored |
| * with the red5 stream object might be gone when the user |
| * closes the browser. |
| * But each listener has an asynchronous component that needs to be closed |
| * no matter how the user leaves the application! |
| */ |
| private static final Map<Long,BaseStreamListener> streamListeners = new HashMap<Long,BaseStreamListener>(); |
| |
| // Spring Beans |
| @Autowired |
| private ClientListManager clientListManager; |
| @Autowired |
| private FlvRecordingDaoImpl flvRecordingDaoImpl; |
| @Autowired |
| private FlvRecordingMetaDataDaoImpl flvRecordingMetaDataDao; |
| @Autowired |
| private UsersDaoImpl usersDaoImpl; |
| @Autowired |
| private Roommanagement roommanagement; |
| @Autowired |
| private FlvRecorderConverterTask flvRecorderConverterTask; |
| @Autowired |
| private FlvInterviewConverterTask flvInterviewConverterTask; |
| @Autowired |
| private FlvInterviewReConverterTask flvInterviewReConverterTask; |
| @Autowired |
| private FlvRecordingLogDaoImpl flvRecordingLogDaoImpl; |
| @Autowired |
| private Sessionmanagement sessionManagement; |
| @Autowired |
| private Usermanagement userManagement; |
| @Autowired |
| private ScopeApplicationAdapter scopeApplicationAdapter; |
| @Autowired |
| private AuthLevelmanagement authLevelManagement; |
| @Autowired |
| private FlvRecordingMetaDeltaDaoImpl flvRecordingMetaDeltaDao; |
| @Autowired |
| private FlvRecordingMetaDataDaoImpl flvRecordingMetaDataDaoImpl = null; |
| |
| public void resultReceived(IPendingServiceCall arg0) { |
| } |
| |
| public RoomClient checkForRecording() { |
| try { |
| |
| IConnection current = Red5.getConnectionLocal(); |
| String streamid = current.getClient().getId(); |
| |
| log.debug("getCurrentRoomClient -2- " + streamid); |
| |
| RoomClient currentClient = this.clientListManager |
| .getClientByStreamId(streamid); |
| |
| HashMap<String, RoomClient> roomClientList = this.clientListManager |
| .getClientListByRoom(currentClient.getRoom_id()); |
| |
| for (Iterator<String> iter = roomClientList.keySet().iterator(); iter |
| .hasNext();) { |
| |
| RoomClient rcl = roomClientList.get(iter.next()); |
| |
| if (rcl.getIsRecording()) { |
| |
| return rcl; |
| |
| } |
| |
| } |
| |
| return null; |
| |
| } catch (Exception err) { |
| err.printStackTrace(); |
| log.error("[checkForRecording]", err); |
| } |
| return null; |
| } |
| |
| private static String generateFileName(Long flvRecording_id, String streamid) |
| throws Exception { |
| String dateString = CalendarPatterns |
| .getTimeForStreamId(new java.util.Date()); |
| return "rec_" + flvRecording_id + "_stream_" + streamid + "_" |
| + dateString; |
| |
| } |
| |
| public String recordMeetingStream(String roomRecordingName, String comment, |
| Boolean isInterview) { |
| try { |
| |
| log.debug(":: recordMeetingStream ::"); |
| |
| IConnection current = Red5.getConnectionLocal(); |
| RoomClient currentClient = this.clientListManager |
| .getClientByStreamId(current.getClient().getId()); |
| Long room_id = currentClient.getRoom_id(); |
| |
| Date now = new Date(); |
| |
| // Receive flvRecordingId |
| Long flvRecordingId = this.flvRecordingDaoImpl.addFlvRecording("", |
| roomRecordingName, null, currentClient.getUser_id(), |
| room_id, now, null, currentClient.getUser_id(), comment, |
| currentClient.getStreamid(), currentClient.getVWidth(), |
| currentClient.getVHeight(), isInterview); |
| |
| // Update Client and set Flag |
| currentClient.setIsRecording(true); |
| currentClient.setFlvRecordingId(flvRecordingId); |
| this.clientListManager.updateClientByStreamId(current.getClient() |
| .getId(), currentClient); |
| |
| // get all stream and start recording them |
| 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()); |
| |
| // Send every user a notification that the recording did start |
| if (!rcl.getIsAVClient()) { |
| ((IServiceCapableConnection) conn).invoke( |
| "startedRecording", |
| new Object[] { currentClient }, this); |
| } |
| |
| // If its the recording client we need another type |
| // of Meta Data |
| if (rcl.getIsScreenClient()) { |
| |
| if (rcl.getFlvRecordingId() != null |
| && rcl.isScreenPublishStarted()) { |
| |
| String streamName_Screen = generateFileName( |
| flvRecordingId, rcl |
| .getStreamPublishName() |
| .toString()); |
| |
| Long flvRecordingMetaDataId = this.flvRecordingMetaDataDao |
| .addFlvRecordingMetaData( |
| flvRecordingId, |
| rcl.getFirstname() + " " |
| + rcl.getLastname(), |
| now, false, false, true, |
| streamName_Screen, |
| rcl.getInterviewPodId()); |
| |
| // Start FLV Recording |
| recordShow(conn, |
| rcl.getStreamPublishName(), |
| streamName_Screen, |
| flvRecordingMetaDataId, true, |
| isInterview); |
| |
| // Add Meta Data |
| rcl.setFlvRecordingMetaDataId(flvRecordingMetaDataId); |
| |
| this.clientListManager |
| .updateClientByStreamId( |
| rcl.getStreamid(), rcl); |
| |
| } |
| |
| } else if |
| // if the user does publish av, a, v |
| // But we only record av or a, video only is not |
| // interesting |
| (rcl.getIsAVClient() && |
| (rcl.getAvsettings().equals("av") |
| || rcl.getAvsettings().equals("a") |
| || rcl.getAvsettings().equals("v"))) { |
| |
| String streamName = generateFileName( |
| flvRecordingId, |
| String.valueOf(rcl.getBroadCastID()) |
| .toString()); |
| |
| // Add Meta Data |
| boolean isAudioOnly = false; |
| if (rcl.getAvsettings().equals("a")) { |
| isAudioOnly = true; |
| } |
| |
| boolean isVideoOnly = false; |
| if (rcl.getAvsettings().equals("v")) { |
| isVideoOnly = true; |
| } |
| |
| Long flvRecordingMetaDataId = this.flvRecordingMetaDataDao |
| .addFlvRecordingMetaData( |
| flvRecordingId, |
| rcl.getFirstname() + " " |
| + rcl.getLastname(), |
| now, isAudioOnly, isVideoOnly, |
| false, streamName, |
| rcl.getInterviewPodId()); |
| |
| rcl.setFlvRecordingMetaDataId(flvRecordingMetaDataId); |
| |
| this.clientListManager.updateClientByStreamId( |
| rcl.getStreamid(), rcl); |
| |
| // Start FLV recording |
| recordShow(conn, |
| String.valueOf(rcl.getBroadCastID()) |
| .toString(), streamName, |
| flvRecordingMetaDataId, false, |
| isInterview); |
| |
| } |
| |
| } |
| } |
| } |
| } |
| |
| return roomRecordingName; |
| |
| } catch (Exception err) { |
| log.error("[recordMeetingStream]", err); |
| } |
| return null; |
| } |
| |
| /** |
| * Start recording the published stream for the specified broadcast-Id |
| * |
| * @param conn |
| * @param broadcastid |
| * @param streamName |
| * @param flvRecordingMetaDataId |
| * @throws Exception |
| */ |
| private synchronized void recordShow(IConnection conn, String broadcastid, |
| String streamName, Long flvRecordingMetaDataId, |
| boolean isScreenData, Boolean isInterview) throws Exception { |
| try { |
| log.debug("Recording show for: " + conn.getScope().getContextPath()); |
| log.debug("Name of CLient and Stream to be recorded: " |
| + broadcastid); |
| // log.debug("Application.getInstance()"+Application.getInstance()); |
| log.debug("Scope " + conn); |
| log.debug("Scope " + conn.getScope()); |
| // Get a reference to the current broadcast stream. |
| ClientBroadcastStream stream = (ClientBroadcastStream) scopeApplicationAdapter |
| .getBroadcastStream(conn.getScope(), broadcastid); |
| |
| if (stream == null) { |
| log.debug("Unable to get stream: " + streamName); |
| return; |
| } |
| // Save the stream to disk. |
| if (isScreenData) { |
| |
| StreamVideoListener streamScreenListener = new StreamVideoListener(streamName, |
| conn.getScope(), flvRecordingMetaDataId, isScreenData, |
| isInterview, flvRecordingMetaDataDao); |
| |
| streamListeners.put(flvRecordingMetaDataId, streamScreenListener); |
| |
| stream.addStreamListener(streamScreenListener); |
| } else { |
| |
| log.debug("### stream " + stream); |
| log.debug("### streamName " + streamName); |
| log.debug("### conn.getScope() " + conn.getScope()); |
| log.debug("### flvRecordingMetaDataId " |
| + flvRecordingMetaDataId); |
| log.debug("### isScreenData " + isScreenData); |
| log.debug("### isInterview " + isInterview); |
| |
| StreamAudioListener streamAudioListener = new StreamAudioListener(streamName, |
| conn.getScope(), flvRecordingMetaDataId, isScreenData, |
| isInterview, flvRecordingMetaDeltaDao, flvRecordingMetaDataDao); |
| |
| streamListeners.put(flvRecordingMetaDataId, streamAudioListener); |
| |
| stream.addStreamListener(streamAudioListener); |
| } |
| // Just for Debug Purpose |
| // stream.saveAs(streamName+"_DEBUG", false); |
| } catch (Exception e) { |
| log.error("Error while saving stream: " + streamName, e); |
| } |
| } |
| |
| /** |
| * Stops recording the publishing stream for the specified IConnection. |
| * |
| * @param conn |
| */ |
| public synchronized void stopRecordingShow(IConnection conn, String broadcastId, |
| Long flvRecordingMetaDataId) { |
| try { |
| |
| if (flvRecordingMetaDataId == null) { |
| //this should be fixed, can be useful for debugging, after all this is an error |
| //but we don't want the application to completely stop the process |
| log.error("flvRecordingMetaDataId is null"); |
| } |
| |
| log.debug("** stopRecordingShow: " + conn); |
| log.debug("### Stop recording show for broadcastId: " + broadcastId |
| + " || " + conn.getScope().getContextPath()); |
| |
| Object streamToClose = scopeApplicationAdapter.getBroadcastStream( |
| conn.getScope(), broadcastId); |
| |
| BaseStreamListener listenerAdapter = streamListeners.get(flvRecordingMetaDataId); |
| |
| log.debug("Stream Closing :: " + flvRecordingMetaDataId); |
| |
| ClientBroadcastStream stream = (ClientBroadcastStream) streamToClose; |
| |
| //the stream can be null if the user just closes the browser |
| //without canceling the recording before leaving |
| if (stream != null) { |
| //Iterate through all stream listeners and stop the appropriate |
| if (stream.getStreamListeners() != null) { |
| |
| for (IStreamListener iStreamListener : stream |
| .getStreamListeners()) { |
| stream.removeStreamListener(iStreamListener); |
| } |
| } |
| } |
| |
| if (listenerAdapter == null) { |
| |
| log.debug("Stream Not Found :: " + flvRecordingMetaDataId); |
| log.debug("Available Streams :: "+streamListeners.size()); |
| |
| for (Long entryKey : streamListeners.keySet()) { |
| log.debug("Stored flvRecordingMetaDataId in Map: "+ entryKey); |
| } |
| |
| //Manually call finish on the stream so that there is no endless loop waiting |
| //in the FlvRecorderConverter waiting for the stream to finish |
| //this would normally happen in the Listener |
| FlvRecordingMetaData flvRecordingMetaData = flvRecordingMetaDataDaoImpl. |
| getFlvRecordingMetaDataById(flvRecordingMetaDataId); |
| flvRecordingMetaData.setStreamReaderThreadComplete(true); |
| flvRecordingMetaDataDaoImpl.updateFlvRecordingMetaData(flvRecordingMetaData); |
| |
| throw new IllegalStateException("Could not find Listener to stop! flvRecordingMetaDataId "+flvRecordingMetaDataId); |
| } |
| |
| listenerAdapter.closeStream(); |
| streamListeners.remove(flvRecordingMetaDataId); |
| |
| |
| } catch (Exception err) { |
| log.error("[stopRecordingShow]", err); |
| } |
| } |
| |
| public Long stopRecordAndSave(IScope scope, RoomClient currentClient, |
| Long storedFlvRecordingId) { |
| try { |
| log.debug("stopRecordAndSave " + currentClient.getUsername() + "," |
| + currentClient.getUserip()); |
| |
| // get all stream and stop recording them |
| Collection<Set<IConnection>> conCollection = scope.getConnections(); |
| for (Set<IConnection> conset : conCollection) { |
| for (IConnection conn : conset) { |
| if (conn != null) { |
| if (conn instanceof IServiceCapableConnection) { |
| |
| RoomClient rcl = clientListManager.getClientByStreamId( |
| conn.getClient().getId()); |
| |
| // FIXME: Check if this function is really in use at |
| // the moment |
| // if (!rcl.getIsScreenClient()) { |
| // ((IServiceCapableConnection) |
| // conn).invoke("stoppedRecording",new Object[] { |
| // currentClient }, this); |
| // } |
| |
| log.debug("is this users still alive? stop it :" + rcl); |
| |
| if (rcl.getIsScreenClient()) { |
| |
| if (rcl.getFlvRecordingId() != null |
| && rcl.isScreenPublishStarted()) { |
| |
| // Stop FLV Recording |
| stopRecordingShow(conn, |
| rcl.getStreamPublishName(), |
| rcl.getFlvRecordingMetaDataId()); |
| |
| // Update Meta Data |
| this.flvRecordingMetaDataDao |
| .updateFlvRecordingMetaDataEndDate( |
| rcl.getFlvRecordingMetaDataId(), |
| new Date()); |
| } |
| |
| } else if (rcl.getIsAVClient() |
| && (rcl.getAvsettings().equals("av") |
| || rcl.getAvsettings().equals("a") |
| || rcl.getAvsettings().equals("v"))) { |
| |
| stopRecordingShow(conn, |
| String.valueOf(rcl.getBroadCastID()) |
| .toString(), |
| rcl.getFlvRecordingMetaDataId()); |
| |
| // Update Meta Data |
| this.flvRecordingMetaDataDao |
| .updateFlvRecordingMetaDataEndDate( |
| rcl.getFlvRecordingMetaDataId(), |
| new Date()); |
| |
| } |
| |
| } |
| } |
| } |
| } |
| |
| // Store to database |
| Long flvRecordingId = currentClient.getFlvRecordingId(); |
| |
| // In the Case of an Interview the stopping client does not mean |
| // that its actually the recording client |
| if (storedFlvRecordingId != null) { |
| flvRecordingId = storedFlvRecordingId; |
| } |
| |
| if (flvRecordingId != null) { |
| |
| this.flvRecordingDaoImpl.updateFlvRecordingEndTime( |
| flvRecordingId, new Date(), |
| currentClient.getOrganization_id()); |
| |
| // Reset values |
| currentClient.setFlvRecordingId(null); |
| currentClient.setIsRecording(false); |
| |
| this.clientListManager.updateClientByStreamId( |
| currentClient.getStreamid(), currentClient); |
| |
| log.debug("this.flvRecorderConverterTask ", |
| this.flvRecorderConverterTask); |
| |
| FlvRecording flvRecording = this.flvRecordingDaoImpl |
| .getFlvRecordingById(flvRecordingId); |
| |
| if (flvRecording.getIsInterview() == null |
| || !flvRecording.getIsInterview()) { |
| |
| this.flvRecorderConverterTask |
| .startConversionThread(flvRecordingId); |
| |
| } else { |
| |
| this.flvInterviewConverterTask |
| .startConversionThread(flvRecordingId); |
| |
| } |
| |
| } |
| |
| } catch (Exception err) { |
| |
| log.error("[-- stopRecordAndSave --]", err); |
| } |
| return new Long(-1); |
| } |
| |
| public RoomClient checkLzRecording() { |
| try { |
| IConnection current = Red5.getConnectionLocal(); |
| String streamid = current.getClient().getId(); |
| |
| log.debug("getCurrentRoomClient -2- " + streamid); |
| |
| RoomClient currentClient = this.clientListManager |
| .getClientByStreamId(streamid); |
| |
| log.debug("getCurrentRoomClient -#########################- " |
| + currentClient.getRoom_id()); |
| |
| 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.getIsRecording()) { |
| return rcl; |
| } |
| |
| } |
| |
| } catch (Exception err) { |
| log.error("[checkLzRecording]", err); |
| } |
| return null; |
| } |
| |
| public void stopRecordingShowForClient(IConnection conn, RoomClient rcl) { |
| try { |
| // this cannot be handled here, as to stop a stream and to leave a |
| // room is not |
| // the same type of event. |
| // StreamService.addRoomClientEnterEventFunc(rcl, roomrecordingName, |
| // rcl.getUserip(), false); |
| log.debug("### stopRecordingShowForClient: " + rcl); |
| |
| if (rcl.getIsScreenClient()) { |
| |
| if (rcl.getFlvRecordingId() != null |
| && rcl.isScreenPublishStarted()) { |
| |
| // Stop FLV Recording |
| // FIXME: Is there really a need to stop it manually if the |
| // user just |
| // stops the stream? |
| stopRecordingShow(conn, rcl.getStreamPublishName(), |
| rcl.getFlvRecordingMetaDataId()); |
| |
| // Update Meta Data |
| this.flvRecordingMetaDataDao |
| .updateFlvRecordingMetaDataEndDate( |
| rcl.getFlvRecordingMetaDataId(), new Date()); |
| } |
| |
| } else if (rcl.getIsAVClient() && |
| (rcl.getAvsettings().equals("a") |
| || rcl.getAvsettings().equals("v") |
| || rcl.getAvsettings().equals("av"))) { |
| |
| // FIXME: Is there really a need to stop it manually if the user |
| // just stops the stream? |
| stopRecordingShow(conn, String.valueOf(rcl.getBroadCastID()), |
| rcl.getFlvRecordingMetaDataId()); |
| |
| // Update Meta Data |
| this.flvRecordingMetaDataDao |
| .updateFlvRecordingMetaDataEndDate( |
| rcl.getFlvRecordingMetaDataId(), new Date()); |
| } |
| |
| } catch (Exception err) { |
| log.error("[stopRecordingShowForClient]", err); |
| } |
| } |
| |
| public void addRecordingByStreamId(IConnection conn, String streamId, |
| RoomClient rcl, Long flvRecordingId) { |
| try { |
| |
| FlvRecording flvRecording = this.flvRecordingDaoImpl |
| .getFlvRecordingById(flvRecordingId); |
| |
| Date now = new Date(); |
| |
| // If its the recording client we need another type of Meta Data |
| if (rcl.getIsScreenClient()) { |
| |
| if (rcl.getFlvRecordingId() != null |
| && rcl.isScreenPublishStarted()) { |
| |
| String streamName_Screen = generateFileName(flvRecordingId, |
| rcl.getStreamPublishName().toString()); |
| |
| log.debug("############## ADD SCREEN OF SHARER :: " |
| + rcl.getStreamPublishName()); |
| |
| Long flvRecordingMetaDataId = this.flvRecordingMetaDataDao |
| .addFlvRecordingMetaData( |
| flvRecordingId, |
| rcl.getFirstname() + " " |
| + rcl.getLastname(), now, false, |
| false, true, streamName_Screen, |
| rcl.getInterviewPodId()); |
| |
| // Start FLV Recording |
| recordShow(conn, rcl.getStreamPublishName(), |
| streamName_Screen, flvRecordingMetaDataId, true, |
| flvRecording.getIsInterview()); |
| |
| // Add Meta Data |
| rcl.setFlvRecordingMetaDataId(flvRecordingMetaDataId); |
| |
| this.clientListManager.updateClientByStreamId( |
| rcl.getStreamid(), rcl); |
| |
| } |
| |
| } else if |
| // if the user does publish av, a, v |
| // But we only record av or a, video only is not interesting |
| (rcl.getIsAVClient() && |
| (rcl.getAvsettings().equals("av") |
| || rcl.getAvsettings().equals("a") |
| || rcl.getAvsettings().equals("v"))) { |
| |
| String streamName = generateFileName(flvRecordingId, String |
| .valueOf(rcl.getBroadCastID()).toString()); |
| |
| // Add Meta Data |
| boolean isAudioOnly = false; |
| if (rcl.getAvsettings().equals("a")) { |
| isAudioOnly = true; |
| } |
| boolean isVideoOnly = false; |
| if (rcl.getAvsettings().equals("v")) { |
| isVideoOnly = true; |
| } |
| |
| Long flvRecordingMetaDataId = this.flvRecordingMetaDataDao |
| .addFlvRecordingMetaData(flvRecordingId, |
| rcl.getFirstname() + " " + rcl.getLastname(), |
| now, isAudioOnly, isVideoOnly, false, |
| streamName, rcl.getInterviewPodId()); |
| |
| // Start FLV recording |
| recordShow(conn, String.valueOf(rcl.getBroadCastID()) |
| .toString(), streamName, flvRecordingMetaDataId, false, |
| flvRecording.getIsInterview()); |
| |
| rcl.setFlvRecordingMetaDataId(flvRecordingMetaDataId); |
| |
| this.clientListManager.updateClientByStreamId( |
| rcl.getStreamid(), rcl); |
| |
| } |
| |
| } catch (Exception err) { |
| log.error("[addRecordingByStreamId]", err); |
| } |
| } |
| |
| public FlvRecording getFlvRecordingWithMetaData(String SID, |
| Long flvRecordingId) { |
| try { |
| Long users_id = sessionManagement.checkSession(SID); |
| Long user_level = userManagement.getUserLevelByID(users_id); |
| if (authLevelManagement.checkUserLevel(user_level)) { |
| |
| FlvRecording flvRecording = this.flvRecordingDaoImpl |
| .getFlvRecordingById(flvRecordingId); |
| |
| flvRecording |
| .setFlvRecordingMetaData(this.flvRecordingMetaDataDao |
| .getFlvRecordingMetaDataByRecording(flvRecordingId)); |
| |
| if (flvRecording.getInsertedBy() != null) { |
| flvRecording.setCreator(this.usersDaoImpl |
| .getUser(flvRecording.getInsertedBy())); |
| } |
| |
| if (flvRecording.getRoom_id() != null) { |
| flvRecording.setRoom(this.roommanagement |
| .getRoomById(flvRecording.getRoom_id())); |
| } |
| |
| flvRecording.setFlvRecordingLog(this.flvRecordingLogDaoImpl |
| .getFLVRecordingLogByRecordingId(flvRecordingId)); |
| |
| return flvRecording; |
| |
| } |
| } catch (Exception err) { |
| log.error("[getFlvRecordingWithMetaData] ", err); |
| err.printStackTrace(); |
| } |
| return null; |
| } |
| |
| public List<FlvRecordingLog> getFlvRecordingLog(String SID, |
| Long flvRecordingId) { |
| try { |
| Long users_id = sessionManagement.checkSession(SID); |
| Long user_level = userManagement.getUserLevelByID(users_id); |
| if (authLevelManagement.checkUserLevel(user_level)) { |
| |
| return this.flvRecordingLogDaoImpl |
| .getFLVRecordingLogByRecordingId(flvRecordingId); |
| |
| } |
| } catch (Exception err) { |
| log.error("[getFlvRecordingLog] ", err); |
| err.printStackTrace(); |
| } |
| return null; |
| } |
| |
| public Long deleteFLVOrFolder(String SID, Long flvRecordingId) { |
| try { |
| Long users_id = sessionManagement.checkSession(SID); |
| Long user_level = userManagement.getUserLevelByID(users_id); |
| |
| System.out.println("deleteFLVOrFolder " + flvRecordingId); |
| |
| if (authLevelManagement.checkUserLevel(user_level)) { |
| |
| log.debug("deleteFLVOrFolder " + flvRecordingId); |
| |
| this.flvRecordingDaoImpl.deleteFlvRecording(flvRecordingId); |
| |
| return flvRecordingId; |
| } |
| } catch (Exception err) { |
| log.error("[deleteFLVOrFolder] ", err); |
| } |
| return null; |
| } |
| |
| public List<FlvRecording> getFLVExplorerByParent(String SID, |
| Long parentFileExplorerItemId, Boolean isOwner) { |
| try { |
| Long users_id = sessionManagement.checkSession(SID); |
| Long user_level = userManagement.getUserLevelByID(users_id); |
| if (authLevelManagement.checkUserLevel(user_level)) { |
| |
| log.debug("parentFileExplorerItemId " |
| + parentFileExplorerItemId); |
| |
| if (parentFileExplorerItemId == 0) { |
| if (isOwner) { |
| |
| return this.flvRecordingDaoImpl.getFlvRecordingByOwner( |
| users_id, parentFileExplorerItemId); |
| |
| } else { |
| |
| return this.flvRecordingDaoImpl |
| .getFlvRecordingsPublic(); |
| |
| } |
| } else { |
| |
| return this.flvRecordingDaoImpl |
| .getFlvRecordingByParent(parentFileExplorerItemId); |
| } |
| |
| } |
| } catch (Exception err) { |
| log.error("[getFLVExplorerByParent] ", err); |
| } |
| return null; |
| } |
| |
| public Long addFolder(String SID, Long parentFileExplorerItemId, |
| String fileName, Boolean isOwner, Long organization_id) { |
| try { |
| Long users_id = sessionManagement.checkSession(SID); |
| Long user_level = userManagement.getUserLevelByID(users_id); |
| if (authLevelManagement.checkUserLevel(user_level)) { |
| |
| log.debug("addFolder " + parentFileExplorerItemId); |
| |
| if (parentFileExplorerItemId == 0 && isOwner) { |
| |
| return this.flvRecordingDaoImpl.addFlvFolderRecording("", |
| fileName, null, // FileSize |
| users_id, null, null, null, // Long room_id, Date |
| // recordStart, Date |
| // recordEnd |
| users_id, // OwnerID => only set if its directly |
| // root in Owner Directory, other |
| // Folders and Files |
| // maybe are also in a Home directory but just |
| // because their parent is |
| "", parentFileExplorerItemId, organization_id); |
| |
| } else { |
| |
| return this.flvRecordingDaoImpl.addFlvFolderRecording("", |
| fileName, null, // FileSize |
| users_id, null, null, null, // Long room_id, Date |
| // recordStart, Date |
| // recordEnd |
| null, // OwnerID => only set if its directly root in |
| // Owner Directory, other Folders and Files |
| // maybe are also in a Home directory but just |
| // because their parent is |
| "", parentFileExplorerItemId, organization_id); |
| |
| } |
| |
| } |
| } catch (Exception err) { |
| log.error("[addFolder] ", err); |
| } |
| return null; |
| } |
| |
| public Long moveFile(String SID, Long flvRecordingId, |
| Long newParentFileExplorerItemId, Boolean isOwner, |
| Boolean moveToHome) { |
| try { |
| Long users_id = sessionManagement.checkSession(SID); |
| Long user_level = userManagement.getUserLevelByID(users_id); |
| |
| if (authLevelManagement.checkUserLevel(user_level)) { |
| |
| log.debug("moveFile " + flvRecordingId); |
| |
| this.flvRecordingDaoImpl.moveFile(flvRecordingId, |
| newParentFileExplorerItemId, isOwner, users_id); |
| |
| FlvRecording flvRecording = this.flvRecordingDaoImpl |
| .getFlvRecordingById(flvRecordingId); |
| |
| if (moveToHome) { |
| // set this file and all subfiles and folders the ownerId |
| this.setFileToOwnerOrRoomByParent(flvRecording, users_id); |
| |
| } else { |
| // set this file and all subfiles and folders the room_id |
| this.setFileToOwnerOrRoomByParent(flvRecording, null); |
| |
| } |
| } |
| } catch (Exception err) { |
| log.error("[moveFile] ", err); |
| } |
| return null; |
| } |
| |
| private void setFileToOwnerOrRoomByParent(FlvRecording flvRecording, |
| Long usersId) { |
| try { |
| |
| flvRecording.setOwnerId(usersId); |
| |
| this.flvRecordingDaoImpl.updateFlvRecording(flvRecording); |
| |
| List<FlvRecording> subFLVItems = this.flvRecordingDaoImpl |
| .getFlvRecordingByParent(flvRecording.getFlvRecordingId()); |
| |
| for (FlvRecording subFLVItem : subFLVItems) { |
| this.setFileToOwnerOrRoomByParent(subFLVItem, usersId); |
| } |
| |
| } catch (Exception err) { |
| log.error("[setFileToOwnerOrRoomByParent] ", err); |
| } |
| } |
| |
| public Long updateFileOrFolderName(String SID, Long flvRecordingId, |
| String fileName) { |
| try { |
| Long users_id = sessionManagement.checkSession(SID); |
| Long user_level = userManagement.getUserLevelByID(users_id); |
| if (authLevelManagement.checkUserLevel(user_level)) { |
| |
| log.debug("updateFileOrFolderName " + flvRecordingId); |
| |
| this.flvRecordingDaoImpl.updateFileOrFolderName(flvRecordingId, |
| fileName); |
| |
| return flvRecordingId; |
| } |
| } catch (Exception err) { |
| log.error("[updateFileOrFolderName] ", err); |
| } |
| return null; |
| } |
| |
| public FLVRecorderObject getFLVExplorerByRoom(String SID, |
| Long organization_id) { |
| try { |
| Long users_id = sessionManagement.checkSession(SID); |
| Long user_level = userManagement.getUserLevelByID(users_id); |
| if (authLevelManagement.checkUserLevel(user_level)) { |
| |
| FLVRecorderObject fileExplorerObject = new FLVRecorderObject(); |
| |
| // User Home Recordings |
| List<FlvRecording> homeFlvRecordings = this.flvRecordingDaoImpl |
| .getFlvRecordingRootByOwner(users_id); |
| long homeFileSize = 0; |
| |
| for (FlvRecording homeFlvRecording : homeFlvRecordings) { |
| homeFileSize += this |
| .getSizeOfDirectoryAndSubs(homeFlvRecording); |
| } |
| |
| fileExplorerObject.setUserHome(homeFlvRecordings); |
| fileExplorerObject.setUserHomeSize(homeFileSize); |
| |
| // Public Recordings by Organization |
| List<FlvRecording> publicFlvRecordings = this.flvRecordingDaoImpl |
| .getFlvRecordingRootByPublic(organization_id); |
| long publicFileSize = 0; |
| |
| for (FlvRecording publicFlvRecording : publicFlvRecordings) { |
| publicFileSize += this |
| .getSizeOfDirectoryAndSubs(publicFlvRecording); |
| } |
| fileExplorerObject.setRoomHome(publicFlvRecordings); |
| fileExplorerObject.setRoomHomeSize(publicFileSize); |
| |
| return fileExplorerObject; |
| |
| } |
| } catch (Exception err) { |
| log.error("[getFileExplorerByRoom] ", err); |
| } |
| return null; |
| } |
| |
| private long getSizeOfDirectoryAndSubs(FlvRecording baseFlvRecording) { |
| try { |
| |
| long fileSize = 0; |
| |
| File tFile = new File(ScopeApplicationAdapter.webAppPath |
| + File.separatorChar + OpenmeetingsVariables.STREAMS_DIR + File.separatorChar |
| + "hibernate" + File.separatorChar |
| + baseFlvRecording.getFileHash()); |
| if (tFile.exists()) { |
| fileSize += tFile.length(); |
| } |
| |
| File dFile = new File(ScopeApplicationAdapter.webAppPath |
| + File.separatorChar + OpenmeetingsVariables.STREAMS_DIR + File.separatorChar |
| + "hibernate" + File.separatorChar |
| + baseFlvRecording.getAlternateDownload()); |
| if (dFile.exists()) { |
| fileSize += dFile.length(); |
| } |
| |
| File iFile = new File(ScopeApplicationAdapter.webAppPath |
| + File.separatorChar + OpenmeetingsVariables.STREAMS_DIR + File.separatorChar |
| + "hibernate" + File.separatorChar |
| + baseFlvRecording.getPreviewImage()); |
| if (iFile.exists()) { |
| fileSize += iFile.length(); |
| } |
| |
| List<FlvRecording> flvRecordings = this.flvRecordingDaoImpl |
| .getFlvRecordingByParent(baseFlvRecording |
| .getFlvRecordingId()); |
| |
| for (FlvRecording flvRecording : flvRecordings) { |
| fileSize += this.getSizeOfDirectoryAndSubs(flvRecording); |
| } |
| |
| return fileSize; |
| |
| } catch (Exception err) { |
| log.error("[getSizeOfDirectoryAndSubs] ", err); |
| } |
| return 0; |
| } |
| |
| public Long restartConversion(String SID, Long flvRecordingId, |
| Integer leftSideLoud, Integer rightSideLoud, Integer leftSideTime, |
| Integer rightSideTime) { |
| try { |
| Long users_id = sessionManagement.checkSession(SID); |
| Long user_level = userManagement.getUserLevelByID(users_id); |
| if (authLevelManagement.checkUserLevel(user_level)) { |
| |
| log.debug("updateFileOrFolderName " + flvRecordingId); |
| |
| FlvRecording flvRecording = this.flvRecordingDaoImpl |
| .getFlvRecordingById(flvRecordingId); |
| |
| flvRecording.setPreviewImage(null); |
| |
| flvRecording.setProgressPostProcessing(0); |
| |
| this.flvRecordingDaoImpl.updateFlvRecording(flvRecording); |
| |
| if (flvRecording.getIsInterview() == null |
| || !flvRecording.getIsInterview()) { |
| flvRecorderConverterTask.startConversionThread(flvRecordingId); |
| } else { |
| flvInterviewReConverterTask.startConversionThread( |
| flvRecordingId, leftSideLoud, rightSideLoud, |
| leftSideTime, rightSideTime); |
| } |
| } |
| } catch (Exception err) { |
| log.error("[restartInterviewConversion] ", err); |
| } |
| return null; |
| } |
| |
| } |
