/** Starts/stops the recording of the call when this button is pressed. */
@Override
public void buttonPressed() {
if (call != null) {
// start recording
if (isSelected()) {
boolean startedRecording = false;
try {
startedRecording = startRecording();
} finally {
if (!startedRecording && (recorder != null)) {
try {
recorder.stop();
} finally {
recorder = null;
}
}
setSelected(startedRecording);
}
}
// stop recording
else if (recorder != null) {
try {
recorder.stop();
} finally {
recorder = null;
setSelected(false);
}
}
}
}
/**
* Determines whether a specific format is supported by the <tt>Recorder</tt> represented by this
* <tt>RecordButton</tt>.
*
* @param format the format which is to be checked whether it is supported by the
* <tt>Recorder</tt> represented by this <tt>RecordButton</tt>
* @return <tt>true</tt> if the specified <tt>format</tt> is supported by the <tt>Recorder</tt>
* represented by this <tt>RecordButton</tt>; otherwise, <tt>false</tt>
*/
private boolean isSupportedFormat(String format) {
Recorder recorder;
try {
recorder = getRecorder();
} catch (OperationFailedException ofex) {
logger.error("Failed to get Recorder", ofex);
return false;
}
List<String> supportedFormats = recorder.getSupportedFormats();
return (supportedFormats != null) && supportedFormats.contains(format);
}
/**
* Starts recording {@link #call} creating {@link #recorder} first and asking the user for the
* recording format and file if they are not configured in the "Call Recording" configuration
* form.
*
* @return <tt>true</tt> if the recording has been started successfully; otherwise, <tt>false</tt>
*/
private boolean startRecording() {
String savedCallsPath = configuration.getString(Recorder.SAVED_CALLS_PATH);
String callFormat;
// Ask the user where to save the call.
if ((savedCallsPath == null) || (savedCallsPath.length() == 0)) {
/*
* Delay the initialization of callFileChooser in order to delay the
* creation of the recorder.
*/
if (callFileChooser == null) {
callFileChooser =
GenericFileDialog.create(
null,
resources.getI18NString("plugin.callrecordingconfig.SAVE_CALL"),
SipCommFileChooser.SAVE_FILE_OPERATION);
callFileChooser.addFilter(
new SipCommFileFilter() {
@Override
public boolean accept(File f) {
return f.isDirectory() || isSupportedFormat(f);
}
@Override
public String getDescription() {
StringBuilder description = new StringBuilder();
description.append("Recorded call");
Recorder recorder;
try {
recorder = getRecorder();
} catch (OperationFailedException ofex) {
logger.error("Failed to get Recorder", ofex);
recorder = null;
}
if (recorder != null) {
List<String> supportedFormats = recorder.getSupportedFormats();
if (supportedFormats != null) {
description.append(" (");
boolean firstSupportedFormat = true;
for (String supportedFormat : supportedFormats) {
if (firstSupportedFormat) firstSupportedFormat = false;
else description.append(", ");
description.append("*.");
description.append(supportedFormat);
}
description.append(')');
}
}
return description.toString();
}
});
}
// Offer a default name for the file to record into.
callFileChooser.setStartPath(createDefaultFilename(null));
File selectedFile = callFileChooser.getFileFromDialog();
if (selectedFile != null) {
callFilename = selectedFile.getAbsolutePath();
/*
* If the user specified no extension (which seems common on Mac
* OS X at least) i.e. no format, then it is not obvious that we
* have to override the set Recorder.CALL_FORMAT.
*/
callFormat = SoundFileUtils.getExtension(selectedFile);
if ((callFormat != null) && (callFormat.length() != 0)) {
/*
* If the use has specified an extension and thus a format
* which is not supported, use a default format instead.
*/
if (!isSupportedFormat(selectedFile)) {
/*
* If what appears to be an extension seems a lot like
* an extension, then it should be somewhat safer to
* replace it.
*/
if (SoundFileUtils.isSoundFile(selectedFile)) {
callFilename = callFilename.substring(0, callFilename.lastIndexOf('.'));
}
String configuredFormat = configuration.getString(Recorder.FORMAT);
callFormat =
(configuredFormat != null && configuredFormat.length() != 0)
? configuredFormat
: SoundFileUtils.DEFAULT_CALL_RECORDING_FORMAT;
callFilename += '.' + callFormat;
}
configuration.setProperty(Recorder.FORMAT, callFormat);
}
} else {
// user canceled the recording
return false;
}
} else {
callFilename = createDefaultFilename(savedCallsPath);
callFormat = SoundFileUtils.getExtension(new File(callFilename));
}
Throwable exception = null;
try {
Recorder recorder = getRecorder();
if (recorder != null) {
if ((callFormat == null) || (callFormat.length() <= 0))
callFormat = SoundFileUtils.DEFAULT_CALL_RECORDING_FORMAT;
recorder.start(callFormat, callFilename);
}
this.recorder = recorder;
} catch (IOException ioex) {
exception = ioex;
} catch (MediaException mex) {
exception = mex;
} catch (OperationFailedException ofex) {
exception = ofex;
}
if ((recorder == null) || (exception != null)) {
logger.error(
"Failed to start recording call " + call + " into file " + callFilename, exception);
return false;
} else return true;
}
/**
* Attempts to enable or disable media recording for this <tt>Conference</tt>.
*
* @param recording whether to enable or disable recording.
* @return the state of the media recording for this <tt>Conference</tt> after the attempt to
* enable (or disable).
*/
public boolean setRecording(boolean recording) {
if (recording != this.recording) {
if (recording) {
// try enable recording
if (logger.isDebugEnabled()) {
logger.debug("Starting recording for conference with id=" + getID());
}
String path = getRecordingPath();
boolean failedToStart = !checkRecordingDirectory(path);
if (!failedToStart) {
RecorderEventHandler handler = getRecorderEventHandler();
if (handler == null) failedToStart = true;
}
if (!failedToStart) {
EndpointRecorder endpointRecorder = getEndpointRecorder();
if (endpointRecorder == null) {
failedToStart = true;
} else {
for (Endpoint endpoint : getEndpoints()) endpointRecorder.updateEndpoint(endpoint);
}
}
/*
* The Recorders of the Contents need to share a single
* Synchronizer, we take it from the first Recorder.
*/
boolean first = true;
Synchronizer synchronizer = null;
for (Content content : contents) {
MediaType mediaType = content.getMediaType();
if (!MediaType.VIDEO.equals(mediaType) && !MediaType.AUDIO.equals(mediaType)) {
continue;
}
if (!failedToStart) failedToStart = !content.setRecording(true, path);
if (failedToStart) break;
if (first) {
first = false;
synchronizer = content.getRecorder().getSynchronizer();
} else {
Recorder recorder = content.getRecorder();
if (recorder != null) recorder.setSynchronizer(synchronizer);
}
content.feedKnownSsrcsToSynchronizer();
}
if (failedToStart) {
recording = false;
logger.warn("Failed to start media recording for conference " + getID());
}
}
// either we were asked to disable recording, or we failed to
// enable it
if (!recording) {
if (logger.isDebugEnabled()) {
logger.debug("Stopping recording for conference with id=" + getID());
}
for (Content content : contents) {
MediaType mediaType = content.getMediaType();
if (MediaType.AUDIO.equals(mediaType) || MediaType.VIDEO.equals(mediaType)) {
content.setRecording(false, null);
}
}
if (recorderEventHandler != null) recorderEventHandler.close();
recorderEventHandler = null;
recordingPath = null;
recordingDirectory = null;
if (endpointRecorder != null) endpointRecorder.close();
endpointRecorder = null;
}
this.recording = recording;
}
return this.recording;
}
