Initial commit of redesigned internal processing and audio management.

Note: Several of the decoders are currently non-functioning in this
commit.  If you want the latest functioning codebase, please checkout
the commit prior to this one.  All decoders will eventually be updated
with this new architecture.

Currently broken:
- Logging and recording
- Aux decoders (Fleetsync/MDC/LoJack/Tait)
- LTR/Passport decoders

Changes in this commit:
- Module architecture for decoders and components with central
provisioning by the DecoderFactory
- Transition from Complex sample stream processing to float buffer
processing for improved memory management
- Redesigned filter structures - to support buffers and streams
- Resolved several memory leak issues
- Universal sharing of the thread pool manager
- Added centralized audio management with call/user prioritization and
new gui with mute/volume controls
- Embedded audio metadata for eventual streaming support
- Redesigned ProcessingChain to support independent re-use
- Added new TrafficChannelManager to handle traffic channel allocations
- Traffic Channel pool size and Call timeout available in P25 and
MPT1327 configs
- Redesigned channel and decoder gui components

src/module/decode/event/ActivitySummaryFrame.java

@@ -0,0 +1,77 @@
+/*******************************************************************************
+ *     SDR Trunk 
+ *     Copyright (C) 2014 Dennis Sheirer
+ * 
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU General Public License as published by
+ *     the Free Software Foundation, either version 3 of the License, or
+ *     (at your option) any later version.
+ * 
+ *     This program is distributed in the hope that it will be useful,
+ *     but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *     GNU General Public License for more details.
+ * 
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>
+ ******************************************************************************/
+package module.decode.event;
+
+import java.awt.Component;
+import java.awt.EventQueue;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.lang.reflect.InvocationTargetException;
+
+import javax.swing.JButton;
+import javax.swing.JFrame;
+import javax.swing.JScrollPane;
+import javax.swing.JTextArea;
+
+import net.miginfocom.swing.MigLayout;
+
+public class ActivitySummaryFrame extends JFrame
+{
+    private static final long serialVersionUID = 1L;
+
+    public ActivitySummaryFrame( String summary )
+    {
+    	this( summary, null );
+    }
+    
+	public ActivitySummaryFrame( String summary, Component displayOver )
+	{
+		setTitle( "Activity Summary" );
+		setLocationRelativeTo( displayOver );
+		setSize( 400, 400 );
+    	setDefaultCloseOperation( JFrame.DISPOSE_ON_CLOSE );
+    	setLayout( new MigLayout( "", "[grow,fill]", "[grow,fill][]" ) );
+
+    	JTextArea summaryText = new JTextArea( summary );
+		
+		JScrollPane scroller = new JScrollPane( summaryText );
+		scroller.setViewportView( summaryText );
+		
+		add( scroller, "wrap" );
+		
+		JButton close = new JButton( "Close" );
+		close.addActionListener( new ActionListener() 
+		{
+			@Override
+            public void actionPerformed( ActionEvent e )
+            {
+				dispose();
+            }
+		} );
+		
+		add( close );
+
+		EventQueue.invokeLater( new Runnable() 
+        {
+            public void run()
+            {
+        		setVisible( true );
+            }
+        } );
+	}
+}

src/module/decode/event/ActivitySummaryProvider.java

@@ -0,0 +1,26 @@
+/*******************************************************************************
+ *     SDR Trunk 
+ *     Copyright (C) 2014 Dennis Sheirer
+ * 
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU General Public License as published by
+ *     the Free Software Foundation, either version 3 of the License, or
+ *     (at your option) any later version.
+ * 
+ *     This program is distributed in the hope that it will be useful,
+ *     but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *     GNU General Public License for more details.
+ * 
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>
+ ******************************************************************************/
+package module.decode.event;
+
+import message.Message;
+import sample.Listener;
+
+public interface ActivitySummaryProvider extends Listener<Message>
+{
+	public String getActivitySummary();
+}

src/module/decode/event/CallEvent.java

@@ -0,0 +1,312 @@
+/*******************************************************************************
+ *     SDR Trunk 
+ *     Copyright (C) 2014 Dennis Sheirer
+ * 
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU General Public License as published by
+ *     the Free Software Foundation, either version 3 of the License, or
+ *     (at your option) any later version.
+ * 
+ *     This program is distributed in the hope that it will be useful,
+ *     but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *     GNU General Public License for more details.
+ * 
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>
+ ******************************************************************************/
+package module.decode.event;
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
+import module.decode.DecoderType;
+import alias.Alias;
+import alias.AliasList;
+import alias.MetadataType;
+
+public abstract class CallEvent implements Comparable<CallEvent>
+{
+	protected long mEventStart = System.currentTimeMillis();
+	protected long mEventEnd;
+	
+	private SimpleDateFormat mSDF = new SimpleDateFormat( "yyyyMMdd','HHmmss" );
+
+	protected DecoderType mDecoderType;
+	protected CallEventType mCallEventType;
+	protected AliasList mAliasList;
+	protected String mFromID;
+	protected String mToID;
+	protected String mDetails;
+	
+	private boolean mValid = true;
+	
+	public CallEvent( DecoderType decoder,
+					  CallEventType callEventType, 
+					  AliasList aliasList,
+					  String fromID,
+					  String toID,
+					  String details )
+	{
+		mDecoderType = decoder;
+		mCallEventType = callEventType;
+		mAliasList = aliasList;
+		mFromID = fromID;
+		mToID = toID;
+		mDetails = details;
+	}
+	
+	/**
+	 * Indicates if this event is valid.  Use this method to mark a previously
+	 * dispatched event as invalid and resend it so that any downstream 
+	 * processing can remove the invalid event.
+	 */
+	public void setValid( boolean valid )
+	{
+		mValid = valid;
+	}
+
+	public boolean isValid()
+	{
+		return mValid;
+	}
+	
+	public void setEnd( long end )
+	{
+		mEventEnd = end;
+	}
+	
+	public void end()
+	{
+		setEnd( System.currentTimeMillis() );
+	}
+	
+	public DecoderType getDecoderType()
+	{
+		return mDecoderType;
+	}
+	
+	public CallEventType getCallEventType()
+	{
+		return mCallEventType;
+	}
+	
+	public void setCallEventType( CallEventType type )
+	{
+		mCallEventType = type;
+	}
+
+	public AliasList getAliasList()
+	{
+		return mAliasList;
+	}
+	
+	public void setAliasList( AliasList aliasList )
+	{
+	    mAliasList = aliasList;
+	}
+	
+	public boolean hasAliasList()
+	{
+		return mAliasList != null;
+	}
+	
+	public long getEventStartTime()
+	{
+		return mEventStart;
+	}
+	
+	public long getEventEndTime()
+	{
+		return mEventEnd;
+	}
+	
+	public String getFromID()
+	{
+		return mFromID;
+	}
+	
+	public boolean hasFromID()
+	{
+		return mFromID != null;
+	}
+	
+	public MetadataType getFromIDType()
+	{
+		return MetadataType.FROM_TALKGROUP;
+	}
+	
+	public void setFromID( String id )
+	{
+		mFromID = id;
+	}
+	
+	public String getToID()
+	{
+		return mToID;
+	}
+	
+	public boolean hasToID()
+	{
+		return mToID != null;
+	}
+	
+	public void setToID( String id )
+	{
+		mToID = id;
+	}
+
+	public MetadataType getToIDType()
+	{
+		return MetadataType.TO;
+	}
+	
+	public String getDetails()
+	{
+		return mDetails;
+	}
+	
+	public void setDetails( String details )
+	{
+		mDetails = details;
+	}
+	
+	public abstract Alias getFromIDAlias();
+	
+	public abstract Alias getToIDAlias();
+	
+	public abstract String getChannel();
+
+	public abstract long getFrequency();
+	
+	public static String getCSVHeader()
+	{
+		return "START_DATE,START_TIME,END_DATE,END_TIME,"
+				+ "DECODER,EVENT,FROM,FROM_ALIAS,TO,TO_ALIAS,"
+				+ "CHANNEL,FREQUENCY,DETAILS";
+	}
+	
+	public String toCSV()
+	{
+		StringBuilder sb = new StringBuilder();
+
+		sb.append( "'" );
+		sb.append( mSDF.format( new Date( getEventStartTime() ) ) );
+		sb.append( "','" );
+		if( mEventEnd != 0 )
+		{
+			sb.append( mSDF.format( new Date( getEventEndTime() ) ) );
+		}
+		else
+		{
+			sb.append( "','" );
+		}
+		sb.append( "','" );
+		sb.append( getDecoderType().toString() );
+		sb.append( "','" );
+		sb.append( getCallEventType().toString() );
+		sb.append( "'," );
+		if( getFromID() != null )
+		{
+			sb.append( "'" );
+			sb.append( getFromID() );
+			sb.append( "'" );
+		}
+		sb.append( "," );
+		
+		Alias fromAlias = getFromIDAlias();
+		
+		if( fromAlias != null )
+		{
+			sb.append( "'" );
+			sb.append( fromAlias.getName() );
+			sb.append( "'" );
+		}
+		sb.append( "," );
+
+		if( getToID() != null )
+		{
+			sb.append( "'" );
+			sb.append( getToID() );
+			sb.append( "'" );
+		}
+		sb.append( "," );
+		
+		Alias toAlias = getToIDAlias();
+		
+		if( toAlias != null )
+		{
+			sb.append( "'" );
+			sb.append( toAlias.getName() );
+			sb.append( "'" );
+		}
+		sb.append( ",'" );
+		sb.append( getChannel() );
+		sb.append( "','" );
+		sb.append( getFrequency() );
+		sb.append( "'," );
+		if( getDetails() != null )
+		{
+			sb.append( "'" );
+			sb.append( getDetails() );
+			sb.append( "'" );
+		}
+		
+		return sb.toString();
+	}
+	
+	public enum CallEventType
+	{
+		ANNOUNCEMENT( "Announcement" ),
+		CALL( "Call" ),
+		CALL_ALERT( "Call Alert" ),
+		CALL_END( "Call End" ),
+		CALL_DETECT( "Call Detect" ),
+		CALL_UNIQUE_ID( "UID Call" ),
+		CALL_NO_TUNER( "Call - No Tuner" ),
+		CALL_TIMEOUT( "Call Timeout" ),
+		COMMAND( "Command" ),
+		DATA_CALL( "Data Call" ),
+		DEREGISTER( "Deregister" ),
+		EMERGENCY( "EMERGENCY" ),
+		ENCRYPTED_CALL( "Encrypted Call" ),
+		FUNCTION( "Function" ),
+		GPS( "GPS" ),
+		ID_ANI( "ANI" ),
+		ID_UNIQUE( "Unique ID" ),
+		PAGE( "Page" ),
+		QUERY( "Query" ),
+		REGISTER( "Register" ),
+		REGISTER_ESN( "ESN" ),
+		RESPONSE( "Response" ),
+		SDM( "Short Data Message" ),
+		STATION_ID( "Station ID" ),
+		STATUS( "Status" ),
+		TELEPHONE_CALL( "Telephone Call" ),
+		UNKNOWN( "Unknown" ),
+		INVALID( "Invalid" );
+		
+		private String mLabel;
+		
+		private CallEventType( String label )
+		{
+			mLabel = label;
+		}
+		
+		public String getLabel()
+		{
+			return mLabel;
+		}
+		
+		public String toString()
+		{
+			return mLabel;
+		}
+	}
+
+	@Override
+	public int compareTo( CallEvent other )
+	{
+		return Long.compare( mEventStart, other.getEventStartTime() );
+	}
+}

src/module/decode/event/CallEventAliasCellRenderer.java

@@ -0,0 +1,72 @@
+/*******************************************************************************
+ *     SDR Trunk 
+ *     Copyright (C) 2014 Dennis Sheirer
+ * 
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU General Public License as published by
+ *     the Free Software Foundation, either version 3 of the License, or
+ *     (at your option) any later version.
+ * 
+ *     This program is distributed in the hope that it will be useful,
+ *     but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *     GNU General Public License for more details.
+ * 
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>
+ ******************************************************************************/
+package module.decode.event;
+
+import javax.swing.ImageIcon;
+import javax.swing.table.DefaultTableCellRenderer;
+
+import settings.SettingsManager;
+import alias.Alias;
+
+/**
+ * Custom renderer for JTable cells that contain Alias objects.  Renders the
+ * alias name, and if there is an icon name, attempts to get that icon from
+ * the settings manager and render it.
+ */
+public class CallEventAliasCellRenderer extends DefaultTableCellRenderer
+{
+	private SettingsManager mSettingsManager;
+	
+	public CallEventAliasCellRenderer( SettingsManager settingsManager )
+	{
+		super();
+		mSettingsManager = settingsManager;
+	}
+	
+	public void setValue( Object obj )
+	{
+		if( obj != null && obj instanceof Alias )
+		{
+			Alias alias = (Alias)obj;
+			
+			setText( alias.getName() );
+			
+			ImageIcon icon = getIcon( alias, 12 );
+			
+			if( icon != null )
+			{
+				setIcon( icon );
+			}
+		}
+		else
+		{
+			setText( " " );
+			setIcon( null );
+		}
+	}
+	
+	private ImageIcon getIcon( Alias alias, int height )
+	{
+		if( mSettingsManager != null && alias != null )
+		{
+			return mSettingsManager.getImageIcon( alias.getIconName(), height );
+		}
+		
+		return null;
+	}
+}

src/module/decode/event/CallEventModel.java

@@ -0,0 +1,223 @@
+/*******************************************************************************
+ *     SDR Trunk 
+ *     Copyright (C) 2014,2015 Dennis Sheirer
+ * 
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU General Public License as published by
+ *     the Free Software Foundation, either version 3 of the License, or
+ *     (at your option) any later version.
+ * 
+ *     This program is distributed in the hope that it will be useful,
+ *     but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *     GNU General Public License for more details.
+ * 
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>
+ ******************************************************************************/
+package module.decode.event;
+
+import java.text.DecimalFormat;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.List;
+
+import javax.swing.table.AbstractTableModel;
+
+import module.decode.event.CallEvent.CallEventType;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import sample.Listener;
+
+public class CallEventModel extends AbstractTableModel implements Listener<CallEvent>
+{
+    private static final long serialVersionUID = 1L;
+
+	private final static Logger mLog = LoggerFactory.getLogger( CallEventModel.class );
+
+	private static DecimalFormat mFrequencyFormatter = 
+			new DecimalFormat( "0.000000" );
+    
+    public static final int TIME = 0;
+    public static final int EVENT = 1;
+    public static final int FROM_ID = 2;
+    public static final int FROM_ALIAS = 3;
+    public static final int TO_ID = 4;
+    public static final int TO_ALIAS = 5;
+    public static final int CHANNEL = 6;
+    public static final int FREQUENCY = 7;
+    public static final int DETAILS = 8;
+
+	protected int mMaxMessages = 500;
+
+	protected List<CallEvent> mEvents = new ArrayList<CallEvent>();
+
+	protected String[] mHeaders = new String[] { "Time",
+												 "Event",
+												 "From",
+												 "Alias",
+												 "To",
+												 "Alias",
+												 "Channel",
+												 "Frequency",
+												 "Details" };
+
+	private SimpleDateFormat mSDFTime = new SimpleDateFormat( "HH:mm:ss" );
+	
+	private boolean mNewMessagesFirst = true;
+	
+	public CallEventModel()
+	{
+	}
+	
+	public void dispose()
+	{
+		mEvents.clear();
+	}
+	
+	public void reset()
+	{
+		mEvents.clear();
+		
+		fireTableDataChanged();
+	}
+	
+	public int getMaxMessageCount()
+	{
+		return mMaxMessages;
+	}
+
+	public void setMaxMessageCount( int count )
+	{
+		mMaxMessages = count;
+	}
+
+	/**
+	 * Adds, updates or deletes the event from the model.  Producers can send
+	 * the same call event multiple times to indicate that information in the
+	 * event is updated.  Producers can also mark the event as invalid and the
+	 * event will be removed from the model.
+	 */
+	public void receive( final CallEvent event )
+	{
+	//TODO: reverse this so that the new events go to the end and the oldest
+		//events are at the beginning ... use the getObjectAt() to control 
+		//correct access to the ordering imposed.
+		
+		if( event.isValid() )
+		{
+			if( !mEvents.contains( event ) )
+			{
+				mEvents.add( 0, event );
+				
+				fireTableRowsInserted( 0, 0 );
+
+				prune();
+			}
+			else
+			{
+				int row = mEvents.indexOf( event );
+				
+				fireTableRowsUpdated( row, row );
+			}
+		}
+		else
+		{
+			if( mEvents.contains( event ) )
+			{
+				int row = mEvents.indexOf( event );
+				
+				mEvents.remove( event );
+				
+				fireTableRowsDeleted( row, row );
+			}
+		}
+	}
+	
+	private void prune()
+	{
+		while( mEvents.size() > mMaxMessages )
+		{
+			int index = mEvents.size() - 1;
+			mEvents.remove( index );
+			
+			fireTableRowsDeleted( index, index );
+		}
+	}
+
+	@Override
+    public int getRowCount()
+    {
+		return mEvents.size();
+    }
+
+	@Override
+    public int getColumnCount()
+    {
+	    return mHeaders.length;
+    }
+
+	public String getColumnName( int column ) 
+	{
+        return mHeaders[ column ];
+    }
+	
+	@Override
+    public Object getValueAt( int rowIndex, int columnIndex )
+    {
+		synchronized( mEvents )
+		{
+			switch( columnIndex )
+			{
+				case TIME:
+					StringBuilder sb = new StringBuilder();
+					
+					sb.append( mSDFTime.format( 
+							mEvents.get( rowIndex ).getEventStartTime() ) );
+					
+					if( mEvents.get( rowIndex ).getEventEndTime() != 0 )
+					{
+						sb.append( " - " );
+						sb.append( mSDFTime.format( 
+								mEvents.get( rowIndex ).getEventEndTime() ) );
+					}
+					else if( mEvents.get( rowIndex )
+							.getCallEventType() == CallEventType.CALL )
+					{
+						sb.append( " - In Progress" );
+					}
+					
+					return sb.toString();
+				case EVENT:
+					return mEvents.get( rowIndex ).getCallEventType();
+				case FROM_ID:
+					return mEvents.get( rowIndex ).getFromID();
+				case FROM_ALIAS:
+					return mEvents.get( rowIndex ).getFromIDAlias();
+				case TO_ID:
+					return mEvents.get( rowIndex ).getToID();
+				case TO_ALIAS:
+					return mEvents.get( rowIndex ).getToIDAlias();
+				case CHANNEL:
+					return mEvents.get( rowIndex ).getChannel();
+				case FREQUENCY:
+					long frequency = mEvents.get( rowIndex ).getFrequency();
+					
+					if( frequency != 0 )
+					{
+						return mFrequencyFormatter.format( (double)frequency / 1E6d );
+					}
+					else
+					{
+						return null;
+					}
+				case DETAILS:
+					return mEvents.get( rowIndex ).getDetails();
+			}
+		}
+		
+		return null;
+    }
+}

src/module/decode/event/CallEventPanel.java

@@ -0,0 +1,105 @@
+/*******************************************************************************
+ *     SDR Trunk 
+ *     Copyright (C) 2014 Dennis Sheirer
+ * 
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU General Public License as published by
+ *     the Free Software Foundation, either version 3 of the License, or
+ *     (at your option) any later version.
+ * 
+ *     This program is distributed in the hope that it will be useful,
+ *     but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *     GNU General Public License for more details.
+ * 
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>
+ ******************************************************************************/
+package module.decode.event;
+
+import javax.swing.JPanel;
+import javax.swing.JScrollPane;
+import javax.swing.JTable;
+
+import net.miginfocom.swing.MigLayout;
+import controller.channel.Channel;
+import controller.channel.ChannelEvent;
+import controller.channel.ChannelEvent.Event;
+import controller.channel.ChannelEventListener;
+
+public class CallEventPanel extends JPanel implements ChannelEventListener
+{
+    private static final long serialVersionUID = 1L;
+
+    private JScrollPane mEmptyScroller;
+    private Channel mDisplayedChannel;
+
+	public CallEventPanel()
+	{
+    	setLayout( new MigLayout("insets 0 0 0 0 ", "[grow,fill]", "[grow,fill]") );
+
+    	JTable table = new JTable( new CallEventModel() );
+    	table.setAutoCreateRowSorter( true );
+    	table.setAutoResizeMode( JTable.AUTO_RESIZE_LAST_COLUMN );
+    	mEmptyScroller = new JScrollPane( table );
+    	
+    	add( mEmptyScroller );
+	}
+//	if( mCallEventTable == null )
+//	{
+//		mCallEventTable = new JTable( mCallEventModel );
+//		mCallEventTable.setAutoCreateRowSorter( true );
+//		mCallEventTable.setAutoResizeMode( JTable.AUTO_RESIZE_LAST_COLUMN );
+//
+//		CallEventAliasCellRenderer renderer = 
+//				new CallEventAliasCellRenderer( mProcessingChain
+//						.getResourceManager().getSettingsManager() );
+//		
+//		mCallEventTable.getColumnModel().getColumn( 3 )
+//						.setCellRenderer( renderer );
+//
+//		mCallEventTable.getColumnModel().getColumn( 5 )
+//						.setCellRenderer( renderer );
+//	}
+//	
+//	return mCallEventTable;
+
+	@Override
+    public void channelChanged( ChannelEvent event )
+    {
+		if( event.getEvent() == Event.CHANGE_SELECTED && 
+			event.getChannel().isSelected() )
+		{
+			if( mDisplayedChannel == null || 
+				( mDisplayedChannel != null && 
+				  mDisplayedChannel != event.getChannel() ) )
+			{
+				removeAll();
+				
+				JScrollPane scroller = new JScrollPane( new JTable(
+						event.getChannel().getCallEventModel() ) );
+
+				add( scroller );
+				
+				mDisplayedChannel = event.getChannel();
+				
+				revalidate();
+				repaint();
+			}
+		}
+		else if( event.getEvent() == Event.CHANNEL_PROCESSING_STOPPED ||
+				 event.getEvent() == Event.CHANNEL_DISABLED )
+		{
+			if( mDisplayedChannel != null && 
+				mDisplayedChannel == event.getChannel() )
+			{
+				mDisplayedChannel = null;
+				removeAll();
+				add( mEmptyScroller );
+
+				revalidate();
+				repaint();
+			}
+		}
+    }
+}

src/module/decode/event/ICallEventProvider.java

@@ -0,0 +1,9 @@
+package module.decode.event;
+
+import sample.Listener;
+
+public interface ICallEventProvider
+{
+	public void setCallEventListener( Listener<CallEvent> listener );
+	public void removeCallEventListener();
+}

src/module/decode/event/MessageActivityModel.java

@@ -0,0 +1,190 @@
+/*******************************************************************************
+ *     SDR Trunk 
+ *     Copyright (C) 2014 Dennis Sheirer
+ * 
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU General Public License as published by
+ *     the Free Software Foundation, either version 3 of the License, or
+ *     (at your option) any later version.
+ * 
+ *     This program is distributed in the hope that it will be useful,
+ *     but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *     GNU General Public License for more details.
+ * 
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>
+ ******************************************************************************/
+package module.decode.event;
+
+import java.awt.EventQueue;
+import java.text.SimpleDateFormat;
+import java.util.LinkedList;
+
+import javax.swing.table.AbstractTableModel;
+
+import message.Message;
+import sample.Listener;
+import filter.FilterSet;
+
+public class MessageActivityModel extends AbstractTableModel
+								  implements Listener<Message>
+{
+    private static final long serialVersionUID = 1L;
+    private static final int sTIME = 0;
+    private static final int sPROTOCOL = 1;
+    private static final int sERROR_STATUS = 2;
+    private static final int sMESSAGE = 3;
+    private static final int sMESSAGE_BITS = 4;
+
+	protected int mMaxMessages = 500;
+	protected LinkedList<Message> mMessages = new LinkedList<Message>();
+
+	protected int[] mColumnWidths = { 110, 110, 110, -1, -1 };
+
+	protected String[] mHeaders = new String[] { "Time",
+												 "Protocol",
+												 "Error Check",
+												 "Message",
+												 "Binary" };
+
+	private SimpleDateFormat mSDFTime = new SimpleDateFormat( "HH:mm:ss" );
+	
+	private boolean mNewMessagesFirst = true;
+	
+	private FilterSet<Message> mMessageFilter;
+	
+	public MessageActivityModel( FilterSet<Message> messageFilter )
+	{
+		mMessageFilter = messageFilter;
+	}
+	
+	public MessageActivityModel()
+	{
+	}
+	
+	/**
+	 * Clears all messages from history
+	 */
+	public void clear()
+	{
+		EventQueue.invokeLater( new Runnable()
+		{
+			@Override
+            public void run()
+            {
+				int messageCount = mMessages.size();
+				
+				mMessages.clear();
+
+				fireTableRowsDeleted( 0, messageCount - 1 );
+            }
+		});
+	}
+	
+	public FilterSet<Message> getMessageFilter()
+	{
+		return mMessageFilter;
+	}
+	
+	public void dispose()
+	{
+		mMessages.clear();
+	}
+	
+	public int[] getColumnWidths()
+	{
+		return mColumnWidths;
+	}
+	
+	public void setColumnWidths( int[] widths )
+	{
+		if( widths.length != 5 )
+		{
+			throw new IllegalArgumentException( "MessageActivityModel - "
+					+ "column widths array should have 5 elements" );
+		}
+		else
+		{
+			mColumnWidths = widths;
+		}
+	}
+	
+	public int getMaxMessageCount()
+	{
+		return mMaxMessages;
+	}
+
+	public void setMaxMessageCount( int count )
+	{
+		mMaxMessages = count;
+	}
+	
+	public void receive( final Message message )
+	{
+		if( message.isValid() && mMessageFilter.passes( message ) )
+		{
+			EventQueue.invokeLater( new Runnable() 
+			{
+				@Override
+	            public void run()
+	            {
+					mMessages.addFirst( message );
+
+					MessageActivityModel.this.fireTableRowsInserted( 0, 0 );
+
+					prune();
+	            }
+			} );
+		}
+	}
+	
+	private void prune()
+	{
+		while( mMessages.size() > mMaxMessages )
+		{
+			mMessages.removeLast();
+			
+			super.fireTableRowsDeleted( mMessages.size() - 1, mMessages.size() - 1 );
+		}
+	}
+
+	@Override
+    public int getRowCount()
+    {
+		return mMessages.size();
+    }
+
+	@Override
+    public int getColumnCount()
+    {
+	    return mHeaders.length;
+    }
+
+	public String getColumnName( int column ) 
+	{
+        return mHeaders[ column ];
+    }
+	
+	@Override
+    public Object getValueAt( int rowIndex, int columnIndex )
+    {
+		Message message = mMessages.get( rowIndex );
+		
+		switch( columnIndex )
+		{
+			case sTIME:
+				return mSDFTime.format( message.getDateReceived() );
+			case sPROTOCOL:
+				return message.getProtocol();
+			case sERROR_STATUS:
+				return message.getErrorStatus();
+			case sMESSAGE:
+				return message.getMessage();
+			case sMESSAGE_BITS:
+				return message.getBinaryMessage();
+		}
+		
+		return null;
+    }
+}

src/module/decode/event/MessageActivityPanel.java

@@ -0,0 +1,310 @@
+/*******************************************************************************
+ *     SDR Trunk 
+ *     Copyright (C) 2014 Dennis Sheirer
+ * 
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU General Public License as published by
+ *     the Free Software Foundation, either version 3 of the License, or
+ *     (at your option) any later version.
+ * 
+ *     This program is distributed in the hope that it will be useful,
+ *     but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *     GNU General Public License for more details.
+ * 
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>
+ ******************************************************************************/
+package module.decode.event;
+
+import java.awt.EventQueue;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.awt.event.MouseEvent;
+import java.awt.event.MouseListener;
+
+import javax.swing.JButton;
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+import javax.swing.JOptionPane;
+import javax.swing.JPanel;
+import javax.swing.JScrollPane;
+import javax.swing.JSlider;
+import javax.swing.JTable;
+import javax.swing.SwingUtilities;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;
+
+import message.Message;
+import net.miginfocom.swing.MigLayout;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.jidesoft.swing.JideButton;
+import com.jidesoft.swing.JideSplitButton;
+
+import controller.channel.Channel;
+import controller.channel.ChannelEvent;
+import controller.channel.ChannelEvent.Event;
+import controller.channel.ChannelEventListener;
+import filter.FilterEditorPanel;
+import filter.FilterSet;
+
+public class MessageActivityPanel extends JPanel implements ChannelEventListener
+{
+    private static final long serialVersionUID = 1L;
+
+	private final static Logger mLog = 
+			LoggerFactory.getLogger( MessageActivityPanel.class );
+
+	private static MessageActivityModel EMPTY_MODEL = new MessageActivityModel();
+    
+    private JTable mMessageTable;
+    
+    private Channel mDisplayedChannel;
+    
+    private MessageManagementPanel mManagementPanel = new MessageManagementPanel();
+
+	public MessageActivityPanel()
+	{
+    	setLayout( new MigLayout("insets 0 0 0 0", "[][grow,fill]", "[]0[grow,fill]") );
+
+    	add( mManagementPanel, "span,growx" );
+
+    	mMessageTable = new JTable( EMPTY_MODEL );
+    	
+    	add( new JScrollPane( mMessageTable ), "span,grow" );
+	}
+
+	@Override
+    public void channelChanged( ChannelEvent event )
+    {
+		boolean changed = false;
+		
+		if( event.getEvent() == Event.CHANGE_SELECTED && 
+			event.getChannel().isSelected() )
+		{
+			if( mDisplayedChannel == null || 
+				( mDisplayedChannel != null && 
+				  mDisplayedChannel != event.getChannel() ) )
+			{
+				mDisplayedChannel = event.getChannel();
+
+				mMessageTable.setModel( event.getChannel().getMessageActivityModel() );
+
+				if( mDisplayedChannel != null )
+				{
+					mManagementPanel.enable();
+				}
+				else
+				{
+					mManagementPanel.disable();
+				}
+				
+				changed = true;
+			}
+		}
+		else if( event.getEvent() == Event.CHANNEL_PROCESSING_STOPPED ||
+				 event.getEvent() == Event.CHANNEL_DISABLED )
+		{
+			if( mDisplayedChannel != null && 
+				mDisplayedChannel == event.getChannel() )
+			{
+				mDisplayedChannel = null;
+
+				mMessageTable.setModel( EMPTY_MODEL );
+
+				mManagementPanel.disable();
+
+				changed = true;
+			}
+		}
+
+		if( changed )
+		{
+			revalidate();
+			repaint();
+		}
+    }
+	
+	public class MessageManagementPanel extends JPanel
+	{
+        private static final long serialVersionUID = 1L;
+
+        private MessageHistoryButton mHistoryButton = new MessageHistoryButton();
+        private MessageFilterButton mFilterButton = new MessageFilterButton();
+        
+        public MessageManagementPanel()
+        {
+        	setLayout( new MigLayout("insets 2 2 5 5", "[]5[left,grow]", "") );
+
+        	disable();
+        	
+        	add( mFilterButton );
+        	add( mHistoryButton );
+        }
+        
+        public void enable()
+        {
+        	mHistoryButton.setEnabled( true );
+        	mFilterButton.setEnabled( true );
+        }
+        
+        public void disable()
+        {
+        	mHistoryButton.setEnabled( false );
+        	mFilterButton.setEnabled( false );
+        }
+	}
+	
+	public class MessageHistoryButton extends JideSplitButton
+	{
+        private static final long serialVersionUID = 1L;
+        
+        public MessageHistoryButton()
+        {
+        	super( "Clear" );
+        	
+        	JPanel historyPanel = new JPanel();
+        	
+        	historyPanel.add( new JLabel( "Message History:" ) );
+        	
+        	final JSlider slider = new JSlider();
+        	slider.setMinimum( 0 );
+        	slider.setMaximum( 2000 );
+        	slider.setMajorTickSpacing( 500 );
+        	slider.setPaintTicks( true );
+        	slider.setPaintLabels( true );
+        	
+        	slider.addMouseListener( new MouseListener() 
+        	{
+				@Override
+                public void mouseClicked( MouseEvent arg0 )
+                {
+					if( SwingUtilities.isLeftMouseButton( arg0 ) &&
+						arg0.getClickCount() == 2 )
+					{
+						slider.setValue( 500 ); //default
+					}
+                }
+
+                public void mouseEntered( MouseEvent arg0 ) {}
+                public void mouseExited( MouseEvent arg0 ) {}
+                public void mousePressed( MouseEvent arg0 ) {}
+                public void mouseReleased( MouseEvent arg0 ) {}
+        	} );
+        	
+        	if( mDisplayedChannel != null )
+        	{
+            	slider.setValue( mDisplayedChannel.getMessageActivityModel()
+            			.getMaxMessageCount() );
+        	}
+        	else
+        	{
+        		slider.setValue( 500 );
+        	}
+        	
+        	slider.addChangeListener( new ChangeListener() 
+        	{
+				@Override
+                public void stateChanged( ChangeEvent arg0 )
+                {
+					if( mDisplayedChannel != null )
+					{
+						mDisplayedChannel.getMessageActivityModel()
+						.setMaxMessageCount( slider.getValue() );
+					}
+                }
+        	});
+
+        	historyPanel.add( slider );
+        	
+        	add( historyPanel );
+
+        	/* Clear messages */
+        	addActionListener( new ActionListener()
+			{
+				@Override
+				public void actionPerformed( ActionEvent e )
+				{
+					if( mDisplayedChannel != null )
+					{
+						mDisplayedChannel.getMessageActivityModel().clear();
+					}
+				}
+			} );
+        }
+	}
+
+	public class MessageFilterButton extends JideButton
+	{
+        private static final long serialVersionUID = 1L;
+        
+        public MessageFilterButton()
+        {
+        	super( "Filter" );
+        	
+        	addActionListener( new ActionListener()
+			{
+				@Override
+				public void actionPerformed( ActionEvent arg0 )
+				{
+					if( mDisplayedChannel == null )
+					{
+						JOptionPane.showMessageDialog( MessageFilterButton.this, 
+							"Please enable and select a decoding channel to "
+							+ "adjust the channel's message display filter" );
+					}
+					else
+					{
+						final JFrame editor = new JFrame();
+						
+						editor.setTitle( "Message Filter Editor" );
+						editor.setSize( 600, 400 );
+						editor.setLocationRelativeTo( MessageFilterButton.this );
+						editor.setDefaultCloseOperation( JFrame.DISPOSE_ON_CLOSE );
+						editor.setLayout( new MigLayout( "", "[grow,fill]", 
+								"[grow,fill][][]" ) );
+
+						@SuppressWarnings( "unchecked" )
+                        FilterSet<Message> filter = (FilterSet<Message>)
+								mDisplayedChannel.getMessageActivityModel()
+									.getMessageFilter();
+						
+						FilterEditorPanel<Message> panel = 
+								new FilterEditorPanel<Message>( filter );
+						
+						JScrollPane scroller = new JScrollPane( panel );
+						scroller.setViewportView( panel );
+						
+						editor.add( scroller, "wrap" );
+						
+						editor.add( new JLabel( "Right-click to select/deselect "
+								+ "all nodes" ), "wrap" );
+						
+						JButton close = new JButton( "Close" );
+						close.addActionListener( new ActionListener() 
+						{
+							@Override
+				            public void actionPerformed( ActionEvent e )
+				            {
+								editor.dispose();
+				            }
+						} );
+						
+						editor.add( close );
+
+						EventQueue.invokeLater( new Runnable() 
+				        {
+				            public void run()
+				            {
+				            	editor.setVisible( true );
+				            }
+				        } );
+					}
+				}
+			} );
+        }
+	}
+}

src/module/decode/event/MessageDetailsProvider.java

@@ -0,0 +1,80 @@
+/*******************************************************************************
+ *     SDR Trunk 
+ *     Copyright (C) 2014 Dennis Sheirer
+ * 
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU General Public License as published by
+ *     the Free Software Foundation, either version 3 of the License, or
+ *     (at your option) any later version.
+ * 
+ *     This program is distributed in the hope that it will be useful,
+ *     but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *     GNU General Public License for more details.
+ * 
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>
+ ******************************************************************************/
+package module.decode.event;
+
+import alias.Alias;
+
+/**
+ * Getter methods to support the Message Activity Table/Model
+ */
+public interface MessageDetailsProvider
+{
+	/**
+	 * Indicates if the message is valid and has passed crc/integrity checks
+	 */
+	public abstract boolean isValid();
+
+	/**
+	 * Status of the CRC check of the message
+	 */
+	public abstract String getErrorStatus();
+
+	/**
+	 * Parsed Message
+	 * @return
+	 */
+	public abstract String getMessage();
+
+	/**
+	 * Raw ( 0 & 1 ) message bits
+	 */
+	public abstract String getBinaryMessage();
+	
+
+	/**
+	 * Decoded protocol
+	 */
+	public abstract String getProtocol();
+	
+	/**
+	 * Event - call, data, idle, etc.
+	 */
+	public abstract String getEventType();
+	
+	/**
+	 * Formatted from identifier
+	 */
+	public abstract String getFromID();
+
+	/**
+	 * From identifier alias (from AliasManager)
+	 */
+	public abstract Alias getFromIDAlias();
+	
+	/**
+	 * Formatted to identifier
+	 */
+	public abstract String getToID();
+	
+	/**
+	 * To identifier alias (from AliasManager)
+	 * @return
+	 */
+	public abstract Alias getToIDAlias();
+	
+}