Resolves issue #69 with double audio recordings

This commit is contained in:
Denny
2016-05-30 07:25:50 -04:00
parent d520f43265
commit 90324404b2

View File

@@ -49,9 +49,9 @@ import filter.FilterSet;
public class ChannelProcessingManager implements ChannelEventListener public class ChannelProcessingManager implements ChannelEventListener
{ {
private final static Logger mLog = LoggerFactory.getLogger( ChannelProcessingManager.class ); private final static Logger mLog = LoggerFactory.getLogger(ChannelProcessingManager.class);
private Map<Integer,ProcessingChain> mProcessingChains = new HashMap<>(); private Map<Integer, ProcessingChain> mProcessingChains = new HashMap<>();
private List<Listener<AudioPacket>> mAudioPacketListeners = new CopyOnWriteArrayList<>(); private List<Listener<AudioPacket>> mAudioPacketListeners = new CopyOnWriteArrayList<>();
private List<Listener<Message>> mMessageListeners = new CopyOnWriteArrayList<>(); private List<Listener<Message>> mMessageListeners = new CopyOnWriteArrayList<>();
@@ -63,12 +63,12 @@ public class ChannelProcessingManager implements ChannelEventListener
private RecorderManager mRecorderManager; private RecorderManager mRecorderManager;
private SourceManager mSourceManager; private SourceManager mSourceManager;
public ChannelProcessingManager( ChannelModel channelModel, public ChannelProcessingManager(ChannelModel channelModel,
ChannelMapModel channelMapModel, ChannelMapModel channelMapModel,
AliasModel aliasModel, AliasModel aliasModel,
EventLogManager eventLogManager, EventLogManager eventLogManager,
RecorderManager recorderManager, RecorderManager recorderManager,
SourceManager sourceManager ) SourceManager sourceManager)
{ {
mChannelModel = channelModel; mChannelModel = channelModel;
mChannelMapModel = channelMapModel; mChannelMapModel = channelMapModel;
@@ -82,66 +82,63 @@ public class ChannelProcessingManager implements ChannelEventListener
* Indicates if a processing chain is constructed for the channel and that * Indicates if a processing chain is constructed for the channel and that
* the processing chain is currently processing. * the processing chain is currently processing.
*/ */
public boolean isProcessing( Channel channel ) private boolean isProcessing(Channel channel)
{ {
if( mProcessingChains.containsKey( channel.getChannelID() ) ) return mProcessingChains.containsKey(channel.getChannelID()) &&
{ mProcessingChains.get(channel.getChannelID()).isProcessing();
return mProcessingChains.get( channel.getChannelID() ).isProcessing();
}
return false;
} }
/** /**
* Returns the current processing chain associated with the channel, or * Returns the current processing chain associated with the channel, or
* null if a processing chain is not currently setup for the channel * null if a processing chain is not currently setup for the channel
*/ */
public ProcessingChain getProcessingChain( Channel channel ) public ProcessingChain getProcessingChain(Channel channel)
{ {
return mProcessingChains.get( channel.getChannelID() ); return mProcessingChains.get(channel.getChannelID());
} }
@Override @Override
public synchronized void channelChanged( ChannelEvent event ) public synchronized void channelChanged(ChannelEvent event)
{ {
Channel channel = event.getChannel(); Channel channel = event.getChannel();
switch( event.getEvent() ) switch (event.getEvent())
{ {
case REQUEST_ENABLE: case REQUEST_ENABLE:
if( !mProcessingChains.containsKey( channel.getChannelID() ) || if (!mProcessingChains.containsKey(channel.getChannelID()) ||
!mProcessingChains.get( channel.getChannelID() ).isProcessing() ) !mProcessingChains.get(channel.getChannelID()).isProcessing())
{ {
startProcessing( event ); startProcessing(event);
} }
break; break;
case REQUEST_DISABLE: case REQUEST_DISABLE:
if( channel.getEnabled() ) if (channel.getEnabled())
{ {
switch( channel.getChannelType() ) switch (channel.getChannelType())
{ {
case STANDARD: case STANDARD:
stopProcessing( channel, true ); stopProcessing(channel, true);
break; break;
case TRAFFIC: case TRAFFIC:
//Don't remove traffic channel processing chains //Don't remove traffic channel processing chains
//until explicitly deleted, so that we can reuse them //until explicitly deleted, so that we can reuse them
stopProcessing( channel, false ); stopProcessing(channel, false);
break;
default: default:
break; break;
} }
} }
case NOTIFICATION_DELETE: case NOTIFICATION_DELETE:
if( channel.getEnabled() ) if (channel.getEnabled())
{ {
stopProcessing( channel, true ); stopProcessing(channel, true);
} }
break; break;
case NOTIFICATION_CONFIGURATION_CHANGE: case NOTIFICATION_CONFIGURATION_CHANGE:
if( isProcessing( channel ) ) if (isProcessing(channel))
{ {
stopProcessing( channel, false ); stopProcessing(channel, false);
startProcessing( event ); startProcessing(event);
} }
break; break;
default: default:
@@ -149,14 +146,14 @@ public class ChannelProcessingManager implements ChannelEventListener
} }
} }
private void startProcessing( ChannelEvent event ) private void startProcessing(ChannelEvent event)
{ {
Channel channel = event.getChannel(); Channel channel = event.getChannel();
ProcessingChain processingChain = mProcessingChains.get( channel.getChannelID() ); ProcessingChain processingChain = mProcessingChains.get(channel.getChannelID());
//If we're already processing, ignore the request //If we're already processing, ignore the request
if( processingChain != null && processingChain.isProcessing() ) if (processingChain != null && processingChain.isProcessing())
{ {
return; return;
} }
@@ -166,132 +163,127 @@ public class ChannelProcessingManager implements ChannelEventListener
try try
{ {
source = mSourceManager.getSource( channel.getSourceConfiguration(), source = mSourceManager.getSource(channel.getSourceConfiguration(),
channel.getDecodeConfiguration().getDecoderType().getChannelBandwidth() ); channel.getDecodeConfiguration().getDecoderType().getChannelBandwidth());
} }
catch( SourceException se ) catch (SourceException se)
{ {
mLog.debug( "Error obtaining source for channel [" + channel.getName() + "]", se ); mLog.debug("Error obtaining source for channel [" + channel.getName() + "]", se);
} }
if( source == null ) if (source == null)
{ {
channel.setEnabled( false ); channel.setEnabled(false);
mChannelModel.broadcast( mChannelModel.broadcast(
new ChannelEvent( channel, Event.NOTIFICATION_ENABLE_REJECTED ) ); new ChannelEvent(channel, Event.NOTIFICATION_ENABLE_REJECTED));
return; return;
} }
if( processingChain == null ) if (processingChain == null)
{ {
processingChain = new ProcessingChain( channel.getName(), processingChain = new ProcessingChain(channel.getName(),
channel.getChannelType() ); channel.getChannelType());
/* Register global listeners */ /* Register global listeners */
for( Listener<AudioPacket> listener: mAudioPacketListeners ) for (Listener<AudioPacket> listener : mAudioPacketListeners)
{ {
processingChain.addAudioPacketListener( listener ); processingChain.addAudioPacketListener(listener);
} }
for( Listener<Message> listener: mMessageListeners ) for (Listener<Message> listener : mMessageListeners)
{ {
processingChain.addMessageListener( listener ); processingChain.addMessageListener(listener);
} }
/* Processing Modules */ /* Processing Modules */
List<Module> modules = DecoderFactory.getModules( mChannelModel, List<Module> modules = DecoderFactory.getModules(mChannelModel,
mChannelMapModel, this, mAliasModel, channel ); mChannelMapModel, this, mAliasModel, channel);
processingChain.addModules( modules ); processingChain.addModules(modules);
/* Setup message activity model with filtering */ /* Setup message activity model with filtering */
FilterSet<Message> messageFilter = DecoderFactory.getMessageFilters( modules ); FilterSet<Message> messageFilter = DecoderFactory.getMessageFilters(modules);
MessageActivityModel messageModel = new MessageActivityModel( messageFilter ); MessageActivityModel messageModel = new MessageActivityModel(messageFilter);
processingChain.setMessageActivityModel( messageModel ); processingChain.setMessageActivityModel(messageModel);
/* Setup event logging */ /* Setup event logging */
List<Module> loggers = mEventLogManager.getLoggers( List<Module> loggers = mEventLogManager.getLoggers(
channel.getEventLogConfiguration(), channel.getName() ); channel.getEventLogConfiguration(), channel.getName());
if( !loggers.isEmpty() ) if (!loggers.isEmpty())
{ {
processingChain.addModules( loggers ); processingChain.addModules(loggers);
} }
/* Setup recorders */ /* Setup recorders */
List<RecorderType> recorders = channel.getRecordConfiguration().getRecorders(); List<RecorderType> recorders = channel.getRecordConfiguration().getRecorders();
if( !recorders.isEmpty() ) if (!recorders.isEmpty())
{ {
if( recorders.contains( RecorderType.AUDIO ) )
{
processingChain.addAudioPacketListener( mRecorderManager );
}
/* Add baseband recorder */ /* Add baseband recorder */
if( ( recorders.contains( RecorderType.BASEBAND ) && if ((recorders.contains(RecorderType.BASEBAND) &&
channel.getChannelType() == ChannelType.STANDARD ) ) channel.getChannelType() == ChannelType.STANDARD))
{ {
processingChain.addModule( mRecorderManager.getBasebandRecorder( processingChain.addModule(mRecorderManager.getBasebandRecorder(
channel.toString() ) ); channel.toString()));
} }
/* Add traffic channel baseband recorder */ /* Add traffic channel baseband recorder */
if( recorders.contains( RecorderType.TRAFFIC_BASEBAND ) && if (recorders.contains(RecorderType.TRAFFIC_BASEBAND) &&
channel.getChannelType() == ChannelType.TRAFFIC ) channel.getChannelType() == ChannelType.TRAFFIC)
{ {
processingChain.addModule( mRecorderManager processingChain.addModule(mRecorderManager
.getBasebandRecorder( channel.toString() ) ); .getBasebandRecorder(channel.toString()));
} }
} }
/* Inject channel metadata that will be inserted into audio packets /* Inject channel metadata that will be inserted into audio packets
* for the recorder manager and streaming */ * for the recorder manager and streaming */
processingChain.broadcast( processingChain.broadcast(
new Metadata( MetadataType.SYSTEM, channel.getSystem() ) ); new Metadata(MetadataType.SYSTEM, channel.getSystem()));
processingChain.broadcast( processingChain.broadcast(
new Metadata( MetadataType.SITE_ID, channel.getSite() ) ); new Metadata(MetadataType.SITE_ID, channel.getSite()));
processingChain.broadcast( processingChain.broadcast(
new Metadata( MetadataType.CHANNEL_NAME, channel.getName() ) ); new Metadata(MetadataType.CHANNEL_NAME, channel.getName()));
} }
processingChain.setSource( source ); processingChain.setSource(source);
if( event instanceof TrafficChannelEvent ) if (event instanceof TrafficChannelEvent)
{ {
TrafficChannelEvent trafficChannelEvent = (TrafficChannelEvent)event; TrafficChannelEvent trafficChannelEvent = (TrafficChannelEvent) event;
processingChain.getChannelState().configureAsTrafficChannel( processingChain.getChannelState().configureAsTrafficChannel(
trafficChannelEvent.getTrafficChannelManager(), trafficChannelEvent.getTrafficChannelManager(),
trafficChannelEvent.getCallEvent() ); trafficChannelEvent.getCallEvent());
} }
processingChain.start(); processingChain.start();
channel.setEnabled( true ); channel.setEnabled(true);
mProcessingChains.put( channel.getChannelID(), processingChain ); mProcessingChains.put(channel.getChannelID(), processingChain);
mChannelModel.broadcast( mChannelModel.broadcast(
new ChannelEvent( channel, Event.NOTIFICATION_PROCESSING_START ) ); new ChannelEvent(channel, Event.NOTIFICATION_PROCESSING_START));
} }
private void stopProcessing( Channel channel, boolean remove ) private void stopProcessing(Channel channel, boolean remove)
{ {
channel.setEnabled( false ); channel.setEnabled(false);
if( mProcessingChains.containsKey( channel.getChannelID() ) ) if (mProcessingChains.containsKey(channel.getChannelID()))
{ {
ProcessingChain chain = mProcessingChains.get( channel.getChannelID() ); ProcessingChain chain = mProcessingChains.get(channel.getChannelID());
chain.stop(); chain.stop();
mChannelModel.broadcast( new ChannelEvent( channel, Event.NOTIFICATION_PROCESSING_STOP ) ); mChannelModel.broadcast(new ChannelEvent(channel, Event.NOTIFICATION_PROCESSING_STOP));
if( remove ) if (remove)
{ {
mProcessingChains.remove( channel.getChannelID() ); mProcessingChains.remove(channel.getChannelID());
chain.dispose(); chain.dispose();
} }
@@ -302,33 +294,33 @@ public class ChannelProcessingManager implements ChannelEventListener
* Adds a message listener that will be added to all channels to receive * Adds a message listener that will be added to all channels to receive
* any messages. * any messages.
*/ */
public void addAudioPacketListener( Listener<AudioPacket> listener ) public void addAudioPacketListener(Listener<AudioPacket> listener)
{ {
mAudioPacketListeners.add( listener ); mAudioPacketListeners.add(listener);
} }
/** /**
* Removes a message listener. * Removes a message listener.
*/ */
public void removeAudioPacketListener( Listener<AudioPacket> listener ) public void removeAudioPacketListener(Listener<AudioPacket> listener)
{ {
mAudioPacketListeners.remove( listener ); mAudioPacketListeners.remove(listener);
} }
/** /**
* Adds a message listener that will be added to all channels to receive * Adds a message listener that will be added to all channels to receive
* any messages. * any messages.
*/ */
public void addMessageListener( Listener<Message> listener ) public void addMessageListener(Listener<Message> listener)
{ {
mMessageListeners.add( listener ); mMessageListeners.add(listener);
} }
/** /**
* Removes a message listener. * Removes a message listener.
*/ */
public void removeMessageListener( Listener<Message> listener ) public void removeMessageListener(Listener<Message> listener)
{ {
mMessageListeners.remove( listener ); mMessageListeners.remove(listener);
} }
} }