mirror of
https://github.com/DSheirer/sdrtrunk.git
synced 2026-11-12 08:37:25 -05:00
e41e430e45
-Adds new LoJack AliasID allowing user to specify a lojack function and 5-character reply code with wildcards. -Removes SiteID as an alias option for LoJack. Valid Alias IDs for LoJack now are: -LoJack Alias ID: for function and reply code combinations -ESN ID: for transponder addresses
581 lines
12 KiB
Java
581 lines
12 KiB
Java
/*******************************************************************************
|
|
* 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 alias;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.HashMap;
|
|
import java.util.Map;
|
|
|
|
import javax.xml.bind.annotation.XmlAttribute;
|
|
import javax.xml.bind.annotation.XmlRootElement;
|
|
import javax.xml.bind.annotation.XmlSeeAlso;
|
|
|
|
import module.decode.lj1200.LJ1200Message.Function;
|
|
|
|
import org.slf4j.Logger;
|
|
import org.slf4j.LoggerFactory;
|
|
|
|
import alias.action.AliasAction;
|
|
import alias.action.beep.BeepAction;
|
|
import alias.action.clip.ClipAction;
|
|
import alias.action.script.ScriptAction;
|
|
import alias.id.esn.Esn;
|
|
import alias.id.fleetsync.FleetsyncID;
|
|
import alias.id.fleetsync.StatusID;
|
|
import alias.id.lojack.LoJackFunctionAndID;
|
|
import alias.id.mdc.MDC1200ID;
|
|
import alias.id.mobileID.Min;
|
|
import alias.id.mpt1327.MPT1327ID;
|
|
import alias.id.siteID.SiteID;
|
|
import alias.id.talkgroup.TalkgroupID;
|
|
import alias.id.uniqueID.UniqueID;
|
|
import alias.priority.Priority;
|
|
import alias.record.NonRecordable;
|
|
import audio.metadata.MetadataType;
|
|
|
|
@XmlSeeAlso( { Alias.class,
|
|
|
|
/* Alias ID's */
|
|
AliasID.class,
|
|
FleetsyncID.class,
|
|
Esn.class,
|
|
Group.class,
|
|
LoJackFunctionAndID.class,
|
|
MDC1200ID.class,
|
|
Min.class,
|
|
MPT1327ID.class,
|
|
UniqueID.class,
|
|
SiteID.class,
|
|
StatusID.class,
|
|
TalkgroupID.class,
|
|
|
|
/* Alias Attributes */
|
|
NonRecordable.class,
|
|
Priority.class,
|
|
|
|
/* Alias Actions */
|
|
AliasAction.class,
|
|
BeepAction.class,
|
|
ClipAction.class,
|
|
ScriptAction.class } )
|
|
|
|
@XmlRootElement( name = "alias_list" )
|
|
public class AliasList implements Comparable<AliasList>
|
|
{
|
|
private final static Logger mLog = LoggerFactory.getLogger( AliasList.class );
|
|
|
|
private String mName;
|
|
private ArrayList<Group> mGroups = new ArrayList<Group>();
|
|
|
|
private Map<String,Alias> mESN = new HashMap<>();
|
|
private Map<String,Alias> mFleetsync = new HashMap<>();
|
|
private Map<LoJackFunctionAndID,Alias> mLoJack = new HashMap<>();
|
|
private Map<String,Alias> mMDC1200 = new HashMap<>();
|
|
private Map<String,Alias> mMobileID = new HashMap<>();
|
|
private Map<String,Alias> mMPT1327 = new HashMap<>();
|
|
private Map<String, Alias> mSiteID = new HashMap<>();
|
|
private Map<Integer, Alias> mStatus = new HashMap<>();
|
|
private Map<String,Alias> mTalkgroup = new HashMap<>();
|
|
private Map<Integer,Alias> mUniqueID = new HashMap<>();
|
|
|
|
private boolean mESNWildcard = false;
|
|
private boolean mMobileIDWildcard = false;
|
|
private boolean mFleetsyncWildcard = false;
|
|
private boolean mMDC1200Wildcard = false;
|
|
private boolean mMPT1327Wildcard = false;
|
|
private boolean mSiteWildcard = false;
|
|
private boolean mTalkgroupWildcard = false;
|
|
|
|
public AliasList()
|
|
{
|
|
this( null );
|
|
}
|
|
|
|
public AliasList( String name )
|
|
{
|
|
mName = name;
|
|
update();
|
|
}
|
|
|
|
/**
|
|
* Load/Reload all lookup hashmaps
|
|
*/
|
|
public void update()
|
|
{
|
|
//Clear hashmaps
|
|
mESN.clear();
|
|
mFleetsync.clear();
|
|
mLoJack.clear();
|
|
mMDC1200.clear();
|
|
mMobileID.clear();
|
|
mMPT1327.clear();
|
|
mSiteID.clear();
|
|
mStatus.clear();
|
|
mTalkgroup.clear();
|
|
mUniqueID.clear();
|
|
|
|
for( Group group: mGroups )
|
|
{
|
|
for( Alias alias: group.getAlias() )
|
|
{
|
|
for( AliasID id: alias.getId() )
|
|
{
|
|
switch( id.getType() )
|
|
{
|
|
case ESN:
|
|
Esn esn = (Esn)id;
|
|
if( esn.getEsn().contains( "*" ) )
|
|
{
|
|
mESNWildcard = true;
|
|
|
|
mESN.put( fixWildcard( esn.getEsn() ), alias );
|
|
}
|
|
else
|
|
{
|
|
mESN.put( esn.getEsn(), alias );
|
|
}
|
|
break;
|
|
case Fleetsync:
|
|
FleetsyncID fs = (FleetsyncID)id;
|
|
|
|
if( fs.getIdent().contains( "*" ) )
|
|
{
|
|
mFleetsyncWildcard = true;
|
|
|
|
mFleetsync.put( fixWildcard( fs.getIdent() ), alias );
|
|
}
|
|
else
|
|
{
|
|
mFleetsync.put( fs.getIdent(), alias );
|
|
}
|
|
break;
|
|
case LoJack:
|
|
mLoJack.put( (LoJackFunctionAndID)id, alias );
|
|
break;
|
|
case MDC1200:
|
|
MDC1200ID mdc = (MDC1200ID)id;
|
|
|
|
if( mdc.getIdent().contains( "*" ) )
|
|
{
|
|
mMDC1200Wildcard = true;
|
|
|
|
//Replace (*) wildcard with regex wildcard (.)
|
|
mMDC1200.put( fixWildcard( mdc.getIdent() ), alias );
|
|
}
|
|
else
|
|
{
|
|
mMDC1200.put( mdc.getIdent(), alias );
|
|
}
|
|
break;
|
|
case MPT1327:
|
|
MPT1327ID mpt = (MPT1327ID)id;
|
|
|
|
String ident = mpt.getIdent();
|
|
|
|
if( ident != null )
|
|
{
|
|
if( ident.contains( "*" ) )
|
|
{
|
|
mMPT1327Wildcard = true;
|
|
|
|
//Replace (*) wildcard with regex wildcard (.)
|
|
mMPT1327.put( fixWildcard( ident ), alias );
|
|
}
|
|
else
|
|
{
|
|
mMPT1327.put( ident, alias );
|
|
}
|
|
}
|
|
break;
|
|
case MIN:
|
|
Min min = (Min)id;
|
|
|
|
if( min.getMin().contains( "*" ) )
|
|
{
|
|
mMobileIDWildcard = true;
|
|
mMobileID.put( fixWildcard( min.getMin() ), alias );
|
|
}
|
|
else
|
|
{
|
|
mMobileID.put( min.getMin(), alias );
|
|
}
|
|
break;
|
|
case LTRNetUID:
|
|
UniqueID uid = (UniqueID)id;
|
|
|
|
mUniqueID.put( uid.getUid(), alias );
|
|
break;
|
|
case Site:
|
|
SiteID siteID = (SiteID)id;
|
|
|
|
if( siteID.getSite().contains( "*" ) )
|
|
{
|
|
mSiteWildcard = true;
|
|
mSiteID.put( fixWildcard( siteID.getSite() ), alias );
|
|
}
|
|
else
|
|
{
|
|
mSiteID.put( siteID.getSite(), alias );
|
|
}
|
|
|
|
break;
|
|
case Status:
|
|
mStatus.put( ((StatusID)id).getStatus(), alias );
|
|
break;
|
|
case Talkgroup:
|
|
TalkgroupID tgid = (TalkgroupID)id;
|
|
|
|
if( tgid.getTalkgroup().contains( "*" ) )
|
|
{
|
|
mTalkgroupWildcard = true;
|
|
|
|
//Replace (*) wildcard with regex wildcard (.)
|
|
mTalkgroup.put( fixWildcard( tgid.getTalkgroup() ), alias );
|
|
}
|
|
else
|
|
{
|
|
mTalkgroup.put( tgid.getTalkgroup(), alias );
|
|
}
|
|
break;
|
|
case NonRecordable:
|
|
case Priority:
|
|
//We don't maintain lookups for these items
|
|
break;
|
|
default:
|
|
mLog.warn( "Unrecognized Alias ID Type:" + id.getType().name() );
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Converts user wildcard character (*) to regex single character wildcard (.)
|
|
* but ignores a regex multi-character wildcard (.*)
|
|
*/
|
|
private String fixWildcard( String value )
|
|
{
|
|
if( value.contains( "*" ) && !value.contains( ".*" ) )
|
|
{
|
|
return value.replace( "*", "." );
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
public Alias getSiteID( String siteID )
|
|
{
|
|
if( siteID != null )
|
|
{
|
|
if( mSiteWildcard )
|
|
{
|
|
for( String regex: mSiteID.keySet() )
|
|
{
|
|
if( siteID.matches( regex ) )
|
|
{
|
|
return mSiteID.get( regex );
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return mSiteID.get( siteID );
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public Alias getStatus( int status )
|
|
{
|
|
return mStatus.get( status );
|
|
}
|
|
|
|
public Alias getUniqueID( int uniqueID )
|
|
{
|
|
return mUniqueID.get( uniqueID );
|
|
}
|
|
|
|
public Alias getESNAlias( String esn )
|
|
{
|
|
if( esn != null )
|
|
{
|
|
if( mESNWildcard )
|
|
{
|
|
for( String regex: mESN.keySet() )
|
|
{
|
|
if( esn.matches( regex ) )
|
|
{
|
|
return mESN.get( regex );
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return mESN.get( esn );
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
|
|
public Alias getFleetsyncAlias( String ident )
|
|
{
|
|
if( ident != null )
|
|
{
|
|
if( mFleetsyncWildcard )
|
|
{
|
|
for( String regex: mFleetsync.keySet() )
|
|
{
|
|
if( ident.matches( regex ) )
|
|
{
|
|
return mFleetsync.get( regex );
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return mFleetsync.get( ident );
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public Alias getLoJackAlias( Function function, String id )
|
|
{
|
|
if( id != null )
|
|
{
|
|
for( LoJackFunctionAndID lojack: mLoJack.keySet() )
|
|
{
|
|
if( lojack.matches( function, id ) )
|
|
{
|
|
return mLoJack.get( lojack );
|
|
}
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public Alias getMDC1200Alias( String ident )
|
|
{
|
|
if( ident != null )
|
|
{
|
|
if( mMDC1200Wildcard )
|
|
{
|
|
for( String regex: mMDC1200.keySet() )
|
|
{
|
|
if( ident.matches( regex ) )
|
|
{
|
|
return mMDC1200.get( regex );
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return mMDC1200.get( ident );
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public Alias getMPT1327Alias( String ident )
|
|
{
|
|
if( ident != null )
|
|
{
|
|
if( mMPT1327Wildcard )
|
|
{
|
|
for( String regex: mMPT1327.keySet() )
|
|
{
|
|
if( ident.matches( regex ) )
|
|
{
|
|
return mMPT1327.get( regex );
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return mMPT1327.get( ident );
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public Group getGroup( Alias alias )
|
|
{
|
|
if( alias != null )
|
|
{
|
|
for( Group group: mGroups )
|
|
{
|
|
if( group.contains( alias ) )
|
|
{
|
|
return group;
|
|
}
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public Alias getMobileIDNumberAlias( String ident )
|
|
{
|
|
if( ident != null )
|
|
{
|
|
if( mMobileIDWildcard )
|
|
{
|
|
for( String regex: mMobileID.keySet() )
|
|
{
|
|
if( ident.matches( regex ) )
|
|
{
|
|
return mMobileID.get( regex );
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return mMobileID.get( ident );
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public Alias getTalkgroupAlias( String tgid )
|
|
{
|
|
if( tgid != null )
|
|
{
|
|
if( mTalkgroupWildcard )
|
|
{
|
|
for( String regex: mTalkgroup.keySet() )
|
|
{
|
|
if( tgid.matches( regex ) )
|
|
{
|
|
return mTalkgroup.get( regex );
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return mTalkgroup.get( tgid );
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public String toString()
|
|
{
|
|
return mName;
|
|
}
|
|
|
|
@XmlAttribute
|
|
public String getName()
|
|
{
|
|
return mName;
|
|
}
|
|
|
|
public void setName( String name )
|
|
{
|
|
mName = name;
|
|
}
|
|
|
|
public ArrayList<Group> getGroup()
|
|
{
|
|
return mGroups;
|
|
}
|
|
|
|
public void setGroup( ArrayList<Group> groups )
|
|
{
|
|
mGroups = groups;
|
|
}
|
|
|
|
public void addGroup( Group group )
|
|
{
|
|
mGroups.add( group );
|
|
}
|
|
|
|
public void removeGroup( Group group )
|
|
{
|
|
mGroups.remove( group );
|
|
}
|
|
|
|
@Override
|
|
public int compareTo( AliasList otherAliasList )
|
|
{
|
|
return getName().compareTo( otherAliasList.getName() );
|
|
}
|
|
|
|
public Alias getAlias( String value, MetadataType type )
|
|
{
|
|
switch( type )
|
|
{
|
|
case ESN:
|
|
return getESNAlias( value );
|
|
case FLEETSYNC:
|
|
return getFleetsyncAlias( value );
|
|
case MDC1200:
|
|
return getMDC1200Alias( value );
|
|
case MOBILE_ID:
|
|
return getMobileIDNumberAlias( value );
|
|
case MPT1327:
|
|
return getMPT1327Alias( value );
|
|
case SITE_ID:
|
|
return getSiteID( value );
|
|
case STATUS:
|
|
if( value != null )
|
|
{
|
|
try
|
|
{
|
|
return getStatus( Integer.valueOf( value ) );
|
|
}
|
|
catch( Exception e )
|
|
{
|
|
//do nothing, we couldn't parse the int value
|
|
}
|
|
}
|
|
break;
|
|
case FROM:
|
|
case TO:
|
|
return getTalkgroupAlias( value );
|
|
case UNIQUE_ID:
|
|
if( value != null )
|
|
{
|
|
try
|
|
{
|
|
return getUniqueID( Integer.valueOf( value ) );
|
|
}
|
|
catch( Exception e )
|
|
{
|
|
//do nothing, we couldn't parse the int value
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
}
|