diff --git a/src/decode/p25/P25MessageProcessor.java b/src/decode/p25/P25MessageProcessor.java index a41f93b1..82bf3d01 100644 --- a/src/decode/p25/P25MessageProcessor.java +++ b/src/decode/p25/P25MessageProcessor.java @@ -10,8 +10,8 @@ import org.slf4j.LoggerFactory; import sample.Broadcaster; import sample.Listener; import alias.AliasList; +import decode.p25.message.IdentifierReceiver; import decode.p25.message.tsbk.osp.control.IdentifierUpdate; -import decode.p25.message.tsbk.osp.control.IdentifierProviderReceiver; public class P25MessageProcessor implements Listener { @@ -39,9 +39,9 @@ public class P25MessageProcessor implements Listener if( message.isValid() ) { /* Insert band identifier update messages into channel-type messages */ - if( message instanceof IdentifierProviderReceiver ) + if( message instanceof IdentifierReceiver ) { - IdentifierProviderReceiver receiver = (IdentifierProviderReceiver)message; + IdentifierReceiver receiver = (IdentifierReceiver)message; int[] identifiers = receiver.getIdentifiers(); diff --git a/src/decode/p25/message/tsbk/osp/control/IdentifierUpdateReceiver.java b/src/decode/p25/message/IdentifierReceiver.java similarity index 71% rename from src/decode/p25/message/tsbk/osp/control/IdentifierUpdateReceiver.java rename to src/decode/p25/message/IdentifierReceiver.java index 32c280af..aa203018 100644 --- a/src/decode/p25/message/tsbk/osp/control/IdentifierUpdateReceiver.java +++ b/src/decode/p25/message/IdentifierReceiver.java @@ -1,13 +1,12 @@ -package decode.p25.message.tsbk.osp.control; +package decode.p25.message; -import decode.p25.message.IdentifierProvider; /** * Interface to allow messages to be augmented with IdentiferUpdateXXX type * messages that provide the channel information necessary to calculate the * uplink and downlink frequency for the channel. */ -public interface IdentifierUpdateReceiver +public interface IdentifierReceiver { public void setIdentifierMessage( int identifier, IdentifierProvider message ); diff --git a/src/decode/p25/message/ldu/LDU1Message.java b/src/decode/p25/message/ldu/LDU1Message.java index b4952ea1..31d0b7e5 100644 --- a/src/decode/p25/message/ldu/LDU1Message.java +++ b/src/decode/p25/message/ldu/LDU1Message.java @@ -26,14 +26,17 @@ public class LDU1Message extends LDUMessage public static final int[] OPCODE = { 354,355,356,357,362,363 }; public static final int[] VENDOR = { 364,365,366,367,372,373,374,375 }; - public static final int[] OCTET_1 = { 364,365,366,367,372,373,374,375 }; - public static final int[] OCTET_2 = { 376,377,382,383,384,385,386,387 }; - public static final int[] OCTET_3 = { 536,537,538,539,540,541,546,547 }; - public static final int[] OCTET_4 = { 548,549,550,551,556,557,558,559 }; - public static final int[] OCTET_5 = { 560,561,566,567,568,569,570,571 }; - public static final int[] OCTET_6 = { 720,721,722,723,724,725,730,731 }; - public static final int[] OCTET_7 = { 732,733,734,735,740,741,742,743 }; - public static final int[] OCTET_8 = { 744,745,750,751,752,753,754,755 }; + public static final int[] LOW_SPEED_DATA = { 1456,1457,1458,1459,1460,1461, + 1462,1463,1472,1473,1474,1475,1476,1477,1478,1479 }; + +// public static final int[] OCTET_1 = { 364,365,366,367,372,373,374,375 }; +// public static final int[] OCTET_2 = { 376,377,382,383,384,385,386,387 }; +// public static final int[] OCTET_3 = { 536,537,538,539,540,541,546,547 }; +// public static final int[] OCTET_4 = { 548,549,550,551,556,557,558,559 }; +// public static final int[] OCTET_5 = { 560,561,566,567,568,569,570,571 }; +// public static final int[] OCTET_6 = { 720,721,722,723,724,725,730,731 }; +// public static final int[] OCTET_7 = { 732,733,734,735,740,741,742,743 }; +// public static final int[] OCTET_8 = { 744,745,750,751,752,753,754,755 }; public LDU1Message( BitSetBuffer message, DataUnitID duid, AliasList aliasList ) @@ -98,6 +101,8 @@ public class LDU1Message extends LDUMessage sb.append( getNAC() ); sb.append( " " ); sb.append( getDUID().getLabel() ); + sb.append( " LSD:" ); + sb.append( getLowSpeedData() ); sb.append( " " ); if( isEncrypted() ) @@ -150,6 +155,11 @@ public class LDU1Message extends LDUMessage return Vendor.fromValue( mMessage.getInt( VENDOR ) ); } + public String getLowSpeedData() + { + return mMessage.getHex( LOW_SPEED_DATA, 4 ); + } + /* Temporary override */ public boolean isValid() { diff --git a/src/decode/p25/message/ldu/lc/AdjacentSiteStatusBroadcast.java b/src/decode/p25/message/ldu/lc/AdjacentSiteStatusBroadcast.java index f9dd605e..ad5ff94a 100644 --- a/src/decode/p25/message/ldu/lc/AdjacentSiteStatusBroadcast.java +++ b/src/decode/p25/message/ldu/lc/AdjacentSiteStatusBroadcast.java @@ -4,13 +4,13 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; import decode.p25.message.IdentifierProvider; +import decode.p25.message.IdentifierReceiver; import decode.p25.message.ldu.LDU1Message; -import decode.p25.message.tsbk.osp.control.IdentifierProviderReceiver; import decode.p25.reference.LinkControlOpcode; import decode.p25.reference.Service; public class AdjacentSiteStatusBroadcast extends LDU1Message - implements IdentifierProviderReceiver + implements IdentifierReceiver { private final static Logger mLog = LoggerFactory.getLogger( AdjacentSiteStatusBroadcast.class ); diff --git a/src/decode/p25/message/ldu/lc/ChannelIdentifierUpdateExplicit.java b/src/decode/p25/message/ldu/lc/ChannelIdentifierUpdateExplicit.java new file mode 100644 index 00000000..53321bbb --- /dev/null +++ b/src/decode/p25/message/ldu/lc/ChannelIdentifierUpdateExplicit.java @@ -0,0 +1,89 @@ +package decode.p25.message.ldu.lc; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import decode.p25.message.IdentifierProvider; +import decode.p25.message.ldu.LDU1Message; +import decode.p25.reference.LinkControlOpcode; + +public class ChannelIdentifierUpdateExplicit extends LDU1Message + implements IdentifierProvider +{ + private final static Logger mLog = + LoggerFactory.getLogger( ChannelIdentifierUpdateExplicit.class ); + + public static final int[] IDENTIFIER = { 364,365,366,367 }; + public static final int[] BANDWIDTH = { 372,373,374,375 }; + public static final int[] TRANSMIT_OFFSET = { 376,377,382,383,384,385,386, + 387,536,537,538,539,540,541 }; + public static final int[] CHANNEL_SPACING = { 546,547,548,549,550,551,556, + 557,558,559 }; + public static final int[] BASE_FREQUENCY = { 560,561,566,567,568,569,570, + 571,720,721,722,723,724,725,730,731,732,733,734,735,740,741,742,743,744, + 745,750,751,752,753,754,755 }; + + public ChannelIdentifierUpdateExplicit( LDU1Message source ) + { + super( source ); + } + + @Override + public String getEventType() + { + return LinkControlOpcode.CHANNEL_IDENTIFIER_UPDATE_EXPLICIT.getDescription(); + } + + @Override + public String getMessage() + { + StringBuilder sb = new StringBuilder(); + + sb.append( getMessageStub() ); + + sb.append( " IDEN:" + getIdentifier() ); + + sb.append( " BASE:" + getBaseFrequency() ); + + sb.append( " BW:" + getBandwidth() ); + + sb.append( " SPACING:" + getChannelSpacing() ); + + sb.append( " OFFSET:" + getTransmitOffset() ); + + return sb.toString(); + } + + @Override + public int getIdentifier() + { + return mMessage.getInt( IDENTIFIER ); + } + + /** + * Channel bandwidth in hertz + */ + @Override + public int getBandwidth() + { + return mMessage.getInt( BANDWIDTH ) * 125; + } + + @Override + public long getChannelSpacing() + { + return mMessage.getLong( CHANNEL_SPACING ) * 125l; + } + + @Override + public long getBaseFrequency() + { + return mMessage.getLong( BASE_FREQUENCY ) * 5l; + } + + @Override + public long getTransmitOffset() + { + return -1 * mMessage.getLong( TRANSMIT_OFFSET ) * 250000l; + } +} diff --git a/src/decode/p25/message/ldu/lc/ExtendedFunctionCommand.java b/src/decode/p25/message/ldu/lc/ExtendedFunctionCommand.java new file mode 100644 index 00000000..cee555f0 --- /dev/null +++ b/src/decode/p25/message/ldu/lc/ExtendedFunctionCommand.java @@ -0,0 +1,87 @@ +package decode.p25.message.ldu.lc; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import decode.p25.message.ldu.LDU1Message; +import decode.p25.reference.ExtendedFunction; +import decode.p25.reference.LinkControlOpcode; + +public class ExtendedFunctionCommand extends LDU1Message +{ + private final static Logger mLog = + LoggerFactory.getLogger( ExtendedFunctionCommand.class ); + public static final int[] EXTENDED_FUNCTION = { 364,365,366,367,372,373,374, + 375,376,377,382,383,384,385,386,387 }; + public static final int[] ARGUMENT = { 536,537,538,539,540,541,546,547,548, + 549,550,551,556,557,558,559,560,561,566,567,568,569,570,571 }; + public static final int[] TARGET_ADDRESS = { 720,721,722,723,724,725,730, + 731,732,733,734,735,740,741,742,743,744,745,750,751,752,753,754,755 }; + + public ExtendedFunctionCommand( LDU1Message source ) + { + super( source ); + } + + @Override + public String getEventType() + { + return LinkControlOpcode.EXTENDED_FUNCTION_COMMAND.getDescription(); + } + + public String getMessage() + { + StringBuilder sb = new StringBuilder(); + + sb.append( getMessageStub() ); + + sb.append( " EXTENDED FUNCTION:" + getExtendedFunction().getLabel() ); + + sb.append( " ARGUMENT: " + getTargetAddress() ); + + sb.append( " TGT ADDR: " + getTargetAddress() ); + + return sb.toString(); + } + + public ExtendedFunction getExtendedFunction() + { + return ExtendedFunction.fromValue( mMessage.getInt( EXTENDED_FUNCTION ) ); + } + + public String getArgument() + { + return mMessage.getHex( ARGUMENT, 6 ); + } + + public String getSourceAddress() + { + switch( getExtendedFunction() ) + { + case RADIO_CHECK: + case RADIO_CHECK_ACK: + case RADIO_DETACH: + case RADIO_DETACH_ACK: + case RADIO_INHIBIT: + case RADIO_INHIBIT_ACK: + case RADIO_UNINHIBIT: + case RADIO_UNINHIBIT_ACK: + return getArgument(); + default: + break; + } + + return null; + } + + public String getTargetAddress() + { + return mMessage.getHex( TARGET_ADDRESS, 6 ); + } + + @Override + public String getToID() + { + return getTargetAddress(); + } +} diff --git a/src/decode/p25/message/ldu/lc/GroupAffiliationQuery.java b/src/decode/p25/message/ldu/lc/GroupAffiliationQuery.java new file mode 100644 index 00000000..22100c83 --- /dev/null +++ b/src/decode/p25/message/ldu/lc/GroupAffiliationQuery.java @@ -0,0 +1,52 @@ +package decode.p25.message.ldu.lc; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import decode.p25.message.ldu.LDU1Message; +import decode.p25.reference.LinkControlOpcode; + +public class GroupAffiliationQuery extends LDU1Message +{ + private final static Logger mLog = + LoggerFactory.getLogger( GroupAffiliationQuery.class ); + public static final int[] TARGET_ADDRESS = { 536,537,538,539,540,541,546, + 547,548,549,550,551,556,557,558,559,560,561,566,567,568,569,570,571 }; + public static final int[] SOURCE_ADDRESS = { 720,721,722,723,724,725,730, + 731,732,733,734,735,740,741,742,743,744,745,750,751,752,753,754,755 }; + + public GroupAffiliationQuery( LDU1Message message ) + { + super( message ); + } + + @Override + public String getEventType() + { + return LinkControlOpcode.GROUP_AFFILIATION_QUERY.getDescription(); + } + + @Override + public String getMessage() + { + StringBuilder sb = new StringBuilder(); + + sb.append( getMessageStub() ); + + sb.append( " FROM:" + getSourceAddress() ); + + sb.append( " TO:" + getTargetAddress() ); + + return sb.toString(); + } + + public String getTargetAddress() + { + return mMessage.getHex( TARGET_ADDRESS, 6 ); + } + + public String getSourceAddress() + { + return mMessage.getHex( SOURCE_ADDRESS, 6 ); + } +} diff --git a/src/decode/p25/message/ldu/lc/GroupVoiceChannelUpdate.java b/src/decode/p25/message/ldu/lc/GroupVoiceChannelUpdate.java new file mode 100644 index 00000000..89685506 --- /dev/null +++ b/src/decode/p25/message/ldu/lc/GroupVoiceChannelUpdate.java @@ -0,0 +1,160 @@ +package decode.p25.message.ldu.lc; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import decode.p25.message.IdentifierProvider; +import decode.p25.message.IdentifierReceiver; +import decode.p25.message.ldu.LDU1Message; +import decode.p25.reference.LinkControlOpcode; + +public class GroupVoiceChannelUpdate extends LDU1Message + implements IdentifierReceiver +{ + private final static Logger mLog = + LoggerFactory.getLogger( GroupVoiceChannelUpdate.class ); + + public static final int[] IDENTIFIER_A = { 364,365,366,367 }; + public static final int[] CHANNEL_A = { 372,373,374,375,376,377,382,383,384, + 385,386,387 }; + public static final int[] GROUP_ADDRESS_A = { 536,537,538,539,540,541,546, + 547,548,549,550,551,556,557,558,559 }; + public static final int[] IDENTIFIER_B = { 560,561,566,567 }; + public static final int[] CHANNEL_B = { 568,569,570,571,720,721,722,723,724, + 725,730,731 }; + public static final int[] GROUP_ADDRESS_B = { 732,733,734,735,740,741,742, + 743,744,745,750,751,752,753,754,755 }; + + private IdentifierProvider mIdentifierUpdateA; + private IdentifierProvider mIdentifierUpdateB; + + public GroupVoiceChannelUpdate( LDU1Message message ) + { + super( message ); + } + + @Override + public String getEventType() + { + return LinkControlOpcode.GROUP_VOICE_CHANNEL_UPDATE.getDescription(); + } + + @Override + public String getMessage() + { + StringBuilder sb = new StringBuilder(); + + sb.append( getMessageStub() ); + + sb.append( " CHAN A:" + getChannelA() ); + + sb.append( " GRP A:" + getGroupAddressA() ); + + if( hasChannelB() ) + { + sb.append( " CHAN B:" + getChannelA() ); + + sb.append( " GRP B:" + getGroupAddressA() ); + } + + return sb.toString(); + } + + public int getChannelIdentifierA() + { + return mMessage.getInt( IDENTIFIER_A ); + } + + public int getChannelNumberA() + { + return mMessage.getInt( CHANNEL_A ); + } + + public String getChannelA() + { + return getChannelIdentifierA() + "-" + getChannelNumberA(); + } + + public int getChannelIdentifierB() + { + return mMessage.getInt( IDENTIFIER_B ); + } + + public int getChannelNumberB() + { + return mMessage.getInt( CHANNEL_B ); + } + + public String getChannelB() + { + return getChannelIdentifierB() + "-" + getChannelNumberB(); + } + + public boolean hasChannelB() + { + return getChannelNumberB() != 0; + } + + public String getGroupAddressA() + { + return mMessage.getHex( GROUP_ADDRESS_A, 4 ); + } + + public String getGroupAddressB() + { + return mMessage.getHex( GROUP_ADDRESS_B, 4 ); + } + + @Override + public void setIdentifierMessage( int identifier, IdentifierProvider message ) + { + if( identifier == getChannelIdentifierA() ) + { + mIdentifierUpdateA = message; + } + if( identifier == getChannelIdentifierB() ) + { + mIdentifierUpdateB = message; + } + } + + @Override + public int[] getIdentifiers() + { + if( hasChannelB() ) + { + int[] identifiers = new int[ 2 ]; + identifiers[ 0 ] = getChannelIdentifierA(); + identifiers[ 1 ] = getChannelIdentifierB(); + + return identifiers; + } + else + { + int[] identifiers = new int[ 1 ]; + identifiers[ 0 ] = getChannelIdentifierA(); + + return identifiers; + } + } + + public long getDownlinkFrequencyA() + { + return calculateDownlink( mIdentifierUpdateA, getChannelNumberA() ); + } + + public long getUplinkFrequencyA() + { + return calculateUplink( mIdentifierUpdateA, getChannelNumberA() ); + } + + public long getDownlinkFrequencyB() + { + return calculateDownlink( mIdentifierUpdateB, getChannelNumberA() ); + } + + public long getUplinkFrequencyB() + { + return calculateUplink( mIdentifierUpdateB, getChannelNumberA() ); + } +} diff --git a/src/decode/p25/message/ldu/lc/GroupVoiceChannelUpdateExplicit.java b/src/decode/p25/message/ldu/lc/GroupVoiceChannelUpdateExplicit.java new file mode 100644 index 00000000..eb5470ba --- /dev/null +++ b/src/decode/p25/message/ldu/lc/GroupVoiceChannelUpdateExplicit.java @@ -0,0 +1,157 @@ +package decode.p25.message.ldu.lc; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import decode.p25.message.IdentifierProvider; +import decode.p25.message.IdentifierReceiver; +import decode.p25.message.P25Message.DuplexMode; +import decode.p25.message.P25Message.SessionMode; +import decode.p25.message.ldu.LDU1Message; +import decode.p25.reference.LinkControlOpcode; + +public class GroupVoiceChannelUpdateExplicit extends LDU1Message + implements IdentifierReceiver +{ + private final static Logger mLog = + LoggerFactory.getLogger( GroupVoiceChannelUpdateExplicit.class ); + + public static final int EMERGENCY_FLAG = 376; + public static final int ENCRYPTED_CHANNEL_FLAG = 377; + public static final int DUPLEX_MODE = 382; + public static final int SESSION_MODE = 383; + public static final int[] GROUP_ADDRESS = { 536,537,538,539,540,541,546,547, + 548,549,550,551,556,557,558,559 }; + public static final int[] TRANSMIT_IDENTIFIER = { 560,561,566,567 }; + public static final int[] TRANSMIT_CHANNEL = { 568,569,570,571,720,721,722, + 723,724,725,730,731 }; + public static final int[] RECEIVE_IDENTIFIER = { 732,733,734,735 }; + public static final int[] RECEIVE_CHANNEL = { 740,741,742,743,744,745,750, + 751,752,753,754,755 }; + + private IdentifierProvider mTransmitIdentifierUpdate; + private IdentifierProvider mReceiveIdentifierUpdate; + + public GroupVoiceChannelUpdateExplicit( LDU1Message message ) + { + super( message ); + } + + @Override + public String getEventType() + { + return LinkControlOpcode.GROUP_VOICE_CHANNEL_UPDATE_EXPLICIT.getDescription(); + } + + @Override + public String getMessage() + { + StringBuilder sb = new StringBuilder(); + + sb.append( getMessageStub() ); + + if( isEmergency() ) + { + sb.append( " EMERGENCY" ); + } + if( isEncryptedChannel() ) + { + sb.append( " ENCRYPTED CHANNEL" ); + } + + + return sb.toString(); + } + + public boolean isEmergency() + { + return mMessage.get( EMERGENCY_FLAG ); + } + + public boolean isEncryptedChannel() + { + return mMessage.get( ENCRYPTED_CHANNEL_FLAG ); + } + + public DuplexMode getDuplexMode() + { + return mMessage.get( DUPLEX_MODE ) ? DuplexMode.FULL : DuplexMode.HALF; + } + + public SessionMode getSessionMode() + { + return mMessage.get( SESSION_MODE ) ? + SessionMode.CIRCUIT : SessionMode.PACKET; + } + + public int getTransmitChannelIdentifier() + { + return mMessage.getInt( TRANSMIT_IDENTIFIER ); + } + + public int getTransmitChannelNumber() + { + return mMessage.getInt( TRANSMIT_CHANNEL ); + } + + public String getTransmitChannel() + { + return getTransmitChannelIdentifier() + "-" + getTransmitChannelNumber(); + } + + public int getReceiveChannelIdentifier() + { + return mMessage.getInt( RECEIVE_IDENTIFIER ); + } + + public int getReceiveChannelNumber() + { + return mMessage.getInt( RECEIVE_CHANNEL ); + } + + public String getReceiveChannel() + { + return getReceiveChannelIdentifier() + "-" + getReceiveChannelNumber(); + } + + public String getGroupAddress() + { + return mMessage.getHex( GROUP_ADDRESS, 4 ); + } + + @Override + public void setIdentifierMessage( int identifier, IdentifierProvider message ) + { + if( identifier == getTransmitChannelIdentifier() ) + { + mTransmitIdentifierUpdate = message; + } + if( identifier == getReceiveChannelIdentifier() ) + { + mReceiveIdentifierUpdate = message; + } + } + + @Override + public int[] getIdentifiers() + { + int[] identifiers = new int[ 2 ]; + + identifiers[ 0 ] = getTransmitChannelIdentifier(); + identifiers[ 1 ] = getReceiveChannelIdentifier(); + + return identifiers; + } + + public long getDownlinkFrequency() + { + return calculateDownlink( mTransmitIdentifierUpdate, + getTransmitChannelNumber() ); + } + + public long getUplinkFrequency() + { + return calculateUplink( mReceiveIdentifierUpdate, + getReceiveChannelNumber() ); + } +} diff --git a/src/decode/p25/message/ldu/lc/LDULCMessageFactory.java b/src/decode/p25/message/ldu/lc/LDULCMessageFactory.java index a9cd802d..e12871a8 100644 --- a/src/decode/p25/message/ldu/lc/LDULCMessageFactory.java +++ b/src/decode/p25/message/ldu/lc/LDULCMessageFactory.java @@ -32,8 +32,52 @@ public class LDULCMessageFactory return new CallTermination( message ); case CHANNEL_IDENTIFIER_UPDATE: return new ChannelIdentifierUpdate( message ); + case CHANNEL_IDENTIFIER_UPDATE_EXPLICIT: + return new ChannelIdentifierUpdateExplicit( message ); + case EXTENDED_FUNCTION_COMMAND: + return new ExtendedFunctionCommand( message ); + case GROUP_AFFILIATION_QUERY: + return new GroupAffiliationQuery( message ); + case GROUP_VOICE_CHANNEL_UPDATE: + return new GroupVoiceChannelUpdate( message ); + case GROUP_VOICE_CHANNEL_UPDATE_EXPLICIT: + return new GroupVoiceChannelUpdateExplicit( message ); case GROUP_VOICE_CHANNEL_USER: return new GroupVoiceChannelUser( message ); + case MESSAGE_UPDATE: + return new MessageUpdate( message ); + case NETWORK_STATUS_BROADCAST: + return new NetworkStatusBroadcast( message ); + case NETWORK_STATUS_BROADCAST_EXPLICIT: + return new NetworkStatusBroadcastExplicit( message ); + case PROTECTION_PARAMETER_BROADCAST: + return new ProtectionParameterBroadcast( message ); + case RFSS_STATUS_BROADCAST: + return new RFSSStatusBroadcast( message ); + case RFSS_STATUS_BROADCAST_EXPLICIT: + return new RFSSStatusBroadcastExplicit( message ); + case SECONDARY_CONTROL_CHANNEL_BROADCAST: + return new SecondaryControlChannelBroadcast( message ); + case SECONDARY_CONTROL_CHANNEL_BROADCAST_EXPLICIT: + return new SecondaryControlChannelBroadcastExplicit( message ); + case STATUS_QUERY: + return new StatusQuery( message ); + case STATUS_UPDATE: + return new StatusUpdate( message ); + case SYSTEM_SERVICE_BROADCAST: + return new SystemServiceBroadcast( message ); + case TELEPHONE_INTERCONNECT_ANSWER_REQUEST: + return new TelephoneInterconnectAnswerRequest( message ); + case TELEPHONE_INTERCONNECT_VOICE_CHANNEL_USER: + return new TelephoneInterconnectVoiceChannelUser( message ); + case UNIT_AUTHENTICATION_COMMAND: + return new UnitAuthenticationCommand( message ); + case UNIT_REGISTRATION_COMMAND: + return new UnitRegistrationCommand( message ); + case UNIT_TO_UNIT_ANSWER_REQUEST: + return new UnitToUnitAnswerRequest( message ); + case UNIT_TO_UNIT_VOICE_CHANNEL_USER: + return new UnitToUnitVoiceChannelUser( message ); default: break; } diff --git a/src/decode/p25/message/ldu/lc/MessageUpdate.java b/src/decode/p25/message/ldu/lc/MessageUpdate.java new file mode 100644 index 00000000..1af4bc29 --- /dev/null +++ b/src/decode/p25/message/ldu/lc/MessageUpdate.java @@ -0,0 +1,58 @@ +package decode.p25.message.ldu.lc; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import decode.p25.message.ldu.LDU1Message; +import decode.p25.reference.LinkControlOpcode; + +public class MessageUpdate extends LDU1Message +{ + private final static Logger mLog = + LoggerFactory.getLogger( MessageUpdate.class ); + public static final int[] SHORT_DATA_MESSAGE = { 364,365,366,367,372,373, + 374,375,376,377,382,383,384,385,386,387 }; + public static final int[] TARGET_ADDRESS = { 536,537,538,539,540,541,546, + 547,548,549,550,551,556,557,558,559,560,561,566,567,568,569,570,571 }; + public static final int[] SOURCE_ADDRESS = { 720,721,722,723,724,725,730, + 731,732,733,734,735,740,741,742,743,744,745,750,751,752,753,754,755 }; + + public MessageUpdate( LDU1Message message ) + { + super( message ); + } + + @Override + public String getEventType() + { + return LinkControlOpcode.MESSAGE_UPDATE.getDescription(); + } + + public String getMessage() + { + StringBuilder sb = new StringBuilder(); + + sb.append( getMessageStub() ); + + sb.append( " MSG:" + getShortDataMessage() ); + sb.append( " SRC ADDR: " + getSourceAddress() ); + sb.append( " TGT ADDR: " + getTargetAddress() ); + + return sb.toString(); + } + + public String getShortDataMessage() + { + return mMessage.getHex( SHORT_DATA_MESSAGE, 4 ); + } + + public String getTargetAddress() + { + return mMessage.getHex( TARGET_ADDRESS, 6 ); + } + + public String getSourceAddress() + { + return mMessage.getHex( SOURCE_ADDRESS, 6 ); + } +} diff --git a/src/decode/p25/message/ldu/lc/NetworkStatusBroadcast.java b/src/decode/p25/message/ldu/lc/NetworkStatusBroadcast.java new file mode 100644 index 00000000..7a6b77c6 --- /dev/null +++ b/src/decode/p25/message/ldu/lc/NetworkStatusBroadcast.java @@ -0,0 +1,110 @@ +package decode.p25.message.ldu.lc; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import decode.p25.message.IdentifierProvider; +import decode.p25.message.IdentifierReceiver; +import decode.p25.message.ldu.LDU1Message; +import decode.p25.reference.LinkControlOpcode; +import decode.p25.reference.Service; + +public class NetworkStatusBroadcast extends LDU1Message + implements IdentifierReceiver +{ + private final static Logger mLog = + LoggerFactory.getLogger( NetworkStatusBroadcast.class ); + public static final int[] NETWORK_ID = { 376,377,382,383,384,385,386,387, + 536,537,538,539,540,541,546,547,548,549,550,551 }; + public static final int[] SYSTEM_ID = { 556,557,558,559,560,561,566,567,568, + 569,570,571 }; + public static final int[] IDENTIFIER = { 720,721,722,723 }; + public static final int[] CHANNEL = { 724,725,730,731,732,733,734,735,740, + 741,742,743 }; + public static final int[] SYSTEM_SERVICE_CLASS = { 744,745,750,751,752,753, + 754,755 }; + + private IdentifierProvider mIdentifierUpdate; + + public NetworkStatusBroadcast( LDU1Message source ) + { + super( source ); + } + + @Override + public String getEventType() + { + return LinkControlOpcode.NETWORK_STATUS_BROADCAST.getDescription(); + } + + @Override + public String getMessage() + { + StringBuilder sb = new StringBuilder(); + + sb.append( getMessageStub() ); + + sb.append( " NETWORK:" + getNetworkID() ); + sb.append( " SYS:" + getSystemID() ); + sb.append( " CHAN:" + getChannel() ); + sb.append( " " + Service.getServices( getSystemServiceClass() ).toString() ); + + return sb.toString(); + } + + public String getNetworkID() + { + return mMessage.getHex( NETWORK_ID, 5 ); + } + + public String getSystemID() + { + return mMessage.getHex( SYSTEM_ID, 3 ); + } + + public int getIdentifier() + { + return mMessage.getInt( IDENTIFIER ); + } + + public int getChannelNumber() + { + return mMessage.getInt( CHANNEL ); + } + + public String getChannel() + { + return getIdentifier() + "-" + getChannelNumber(); + } + + public int getSystemServiceClass() + { + return mMessage.getInt( SYSTEM_SERVICE_CLASS ); + } + + @Override + public void setIdentifierMessage( int identifier, IdentifierProvider message ) + { + mIdentifierUpdate = message; + } + + @Override + public int[] getIdentifiers() + { + int[] identifiers = new int[ 1 ]; + + identifiers[ 0 ] = getIdentifier(); + + return identifiers; + } + + public long getDownlinkFrequency() + { + return calculateDownlink( mIdentifierUpdate, getChannelNumber() ); + } + + public long getUplinkFrequency() + { + return calculateUplink( mIdentifierUpdate, getChannelNumber() ); + } +} diff --git a/src/decode/p25/message/ldu/lc/NetworkStatusBroadcastExplicit.java b/src/decode/p25/message/ldu/lc/NetworkStatusBroadcastExplicit.java new file mode 100644 index 00000000..8012e815 --- /dev/null +++ b/src/decode/p25/message/ldu/lc/NetworkStatusBroadcastExplicit.java @@ -0,0 +1,131 @@ +package decode.p25.message.ldu.lc; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import decode.p25.message.IdentifierProvider; +import decode.p25.message.IdentifierReceiver; +import decode.p25.message.ldu.LDU1Message; +import decode.p25.reference.LinkControlOpcode; + +public class NetworkStatusBroadcastExplicit extends LDU1Message + implements IdentifierReceiver +{ + private final static Logger mLog = + LoggerFactory.getLogger( NetworkStatusBroadcastExplicit.class ); + public static final int[] NETWORK_ID = { 364,365,366,367,372,373,374,375, + 376,377,382,383,384,385,386,387,536,537,538,539 }; + public static final int[] SYSTEM_ID = { 540,541,546,547,548,549,550,551,556, + 557,558,559 }; + public static final int[] TRANSMIT_IDENTIFIER = { 560,561,566,567 }; + public static final int[] TRANSMIT_CHANNEL = { 568,569,570,571,720,721,722, + 723,724,725,730,731 }; + public static final int[] RECEIVE_IDENTIFIER = { 732,733,734,735 }; + public static final int[] RECEIVE_CHANNEL = { 740,741,742,743,744,745,750, + 751,752,753,754,755 }; + + private IdentifierProvider mTransmitIdentifierUpdate; + private IdentifierProvider mReceiveIdentifierUpdate; + + public NetworkStatusBroadcastExplicit( LDU1Message message ) + { + super( message ); + } + + @Override + public String getEventType() + { + return LinkControlOpcode.NETWORK_STATUS_BROADCAST_EXPLICIT.getDescription(); + } + + @Override + public String getMessage() + { + StringBuilder sb = new StringBuilder(); + + sb.append( getMessageStub() ); + + sb.append( " NETWORK:" + getNetworkID() ); + sb.append( " SYS:" + getSystemID() ); + sb.append( " TRANSMIT:" + getTransmitChannel() ); + sb.append( " RECEIVE:" + getReceiveChannel() ); + + return sb.toString(); + } + + public String getNetworkID() + { + return mMessage.getHex( NETWORK_ID, 5 ); + } + + public String getSystemID() + { + return mMessage.getHex( SYSTEM_ID, 3 ); + } + + public int getTransmitIdentifier() + { + return mMessage.getInt( TRANSMIT_IDENTIFIER ); + } + + public int getTransmitChannelNumber() + { + return mMessage.getInt( TRANSMIT_CHANNEL ); + } + + public String getTransmitChannel() + { + return getTransmitIdentifier() + "-" + getTransmitChannelNumber(); + } + + public int getReceiveIdentifier() + { + return mMessage.getInt( RECEIVE_IDENTIFIER ); + } + + public int getReceiveChannelNumber() + { + return mMessage.getInt( RECEIVE_CHANNEL ); + } + + public String getReceiveChannel() + { + return getReceiveIdentifier() + "-" + getReceiveChannelNumber(); + } + + @Override + public void setIdentifierMessage( int identifier, IdentifierProvider message ) + { + if( identifier == getTransmitIdentifier() ) + { + mTransmitIdentifierUpdate = message; + } + if( identifier == getReceiveIdentifier() ) + { + mReceiveIdentifierUpdate = message; + } + } + + @Override + public int[] getIdentifiers() + { + int[] identifiers = new int[ 2 ]; + + identifiers[ 0 ] = getTransmitIdentifier(); + identifiers[ 1 ] = getReceiveIdentifier(); + + return identifiers; + } + + public long getDownlinkFrequency() + { + return calculateDownlink( mTransmitIdentifierUpdate, + getTransmitChannelNumber() ); + } + + public long getUplinkFrequency() + { + return calculateUplink( mReceiveIdentifierUpdate, + getReceiveChannelNumber() ); + } +} diff --git a/src/decode/p25/message/ldu/lc/ProtectionParameterBroadcast.java b/src/decode/p25/message/ldu/lc/ProtectionParameterBroadcast.java new file mode 100644 index 00000000..fdae5e3a --- /dev/null +++ b/src/decode/p25/message/ldu/lc/ProtectionParameterBroadcast.java @@ -0,0 +1,59 @@ +package decode.p25.message.ldu.lc; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import decode.p25.message.ldu.LDU1Message; +import decode.p25.reference.Encryption; +import decode.p25.reference.LinkControlOpcode; + +public class ProtectionParameterBroadcast extends LDU1Message +{ + private final static Logger mLog = + LoggerFactory.getLogger( ProtectionParameterBroadcast.class ); + + public static final int[] ALGORITHM_ID = { 536,537,538,539,540,541,546,547 }; + public static final int[] KEY_ID = { 548,549,550,551,556,557,558,559,560, + 561,566,567,568,569,570,571 }; + public static final int[] TARGET_ADDRESS = { 720,721,722,723,724,725,730, + 731,732,733,734,735,740,741,742,743,744,745,750,751,752,753,754,755 }; + + public ProtectionParameterBroadcast( LDU1Message message ) + { + super( message ); + } + + @Override + public String getEventType() + { + return LinkControlOpcode.PROTECTION_PARAMETER_BROADCAST.getDescription(); + } + + public String getMessage() + { + StringBuilder sb = new StringBuilder(); + + sb.append( getMessageStub() ); + + sb.append( " ENCRYPTION:" + getEncryption().name() ); + sb.append( " KEY:" + getEncryptionKey() ); + sb.append( " ADDRESSS:" + getTargetAddress() ); + + return sb.toString(); + } + + public Encryption getEncryption() + { + return Encryption.fromValue( mMessage.getInt( ALGORITHM_ID ) ); + } + + public int getEncryptionKey() + { + return mMessage.getInt( KEY_ID ); + } + + public String getTargetAddress() + { + return mMessage.getHex( TARGET_ADDRESS, 6 ); + } +} diff --git a/src/decode/p25/message/ldu/lc/RFSSStatusBroadcast.java b/src/decode/p25/message/ldu/lc/RFSSStatusBroadcast.java new file mode 100644 index 00000000..0553f6a7 --- /dev/null +++ b/src/decode/p25/message/ldu/lc/RFSSStatusBroadcast.java @@ -0,0 +1,130 @@ +package decode.p25.message.ldu.lc; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import decode.p25.message.IdentifierProvider; +import decode.p25.message.IdentifierReceiver; +import decode.p25.message.ldu.LDU1Message; +import decode.p25.message.tsbk.osp.control.SystemService; +import decode.p25.reference.LinkControlOpcode; + +public class RFSSStatusBroadcast extends LDU1Message + implements IdentifierReceiver +{ + private final static Logger mLog = + LoggerFactory.getLogger( RFSSStatusBroadcast.class ); + + public static final int[] LRA = { 364,365,366,367,372,373,374,375 }; + public static final int[] SYSTEM_ID = { 384,385,386,387,536,537,538,539,540, + 541,546,547 }; + public static final int[] RFSS_ID = { 548,549,550,551,556,557,558,559 }; + public static final int[] SITE_ID = { 560,561,566,567,568,569,570,571 }; + public static final int[] IDENTIFIER = { 720,721,722,723 }; + public static final int[] CHANNEL = { 724,725,730,731,732,733,734,735,740, + 741,742,743 }; + public static final int[] SYSTEM_SERVICE_CLASS = { 744,745,750,751,752,753, + 754,755 }; + + private IdentifierProvider mIdentifierUpdate; + + public RFSSStatusBroadcast( LDU1Message message ) + { + super( message ); + } + + @Override + public String getEventType() + { + return LinkControlOpcode.RFSS_STATUS_BROADCAST.getDescription(); + } + + @Override + public String getMessage() + { + StringBuilder sb = new StringBuilder(); + + sb.append( getMessageStub() ); + + sb.append( " LRA:" + getLocationRegistrationArea() ); + + sb.append( " SYS:" + getSystem() ); + + sb.append( " SITE:" + getRFSubsystemID() + "-" + getSiteID() ); + + sb.append( " CHAN:" + getChannelNumber() ); + + sb.append( " " + SystemService.toString( getSystemServiceClass() ) ); + + sb.append( " " + mMessage.toString() ); + + return sb.toString(); + } + + public String getLocationRegistrationArea() + { + return mMessage.getHex( LRA, 2 ); + } + + public String getSystem() + { + return mMessage.getHex( SYSTEM_ID, 3 ); + } + + public String getRFSubsystemID() + { + return mMessage.getHex( RFSS_ID, 2 ); + } + + public String getSiteID() + { + return mMessage.getHex( SITE_ID, 2 ); + } + + public int getIdentifier() + { + return mMessage.getInt( IDENTIFIER ); + } + + public String getChannel() + { + return getIdentifier() + "-" + getChannelNumber(); + } + + public int getChannelNumber() + { + return mMessage.getInt( CHANNEL ); + } + + public int getSystemServiceClass() + { + return mMessage.getInt( SYSTEM_SERVICE_CLASS ); + } + + @Override + public void setIdentifierMessage( int identifier, IdentifierProvider message ) + { + mIdentifierUpdate = message; + } + + @Override + public int[] getIdentifiers() + { + int[] identifiers = new int[ 1 ]; + + identifiers[ 0 ] = getIdentifier(); + + return identifiers; + } + + public long getDownlinkFrequency() + { + return calculateDownlink( mIdentifierUpdate, getChannelNumber() ); + } + + public long getUplinkFrequency() + { + return calculateUplink( mIdentifierUpdate, getChannelNumber() ); + } + +} diff --git a/src/decode/p25/message/ldu/lc/RFSSStatusBroadcastExplicit.java b/src/decode/p25/message/ldu/lc/RFSSStatusBroadcastExplicit.java new file mode 100644 index 00000000..cb2fec68 --- /dev/null +++ b/src/decode/p25/message/ldu/lc/RFSSStatusBroadcastExplicit.java @@ -0,0 +1,150 @@ +package decode.p25.message.ldu.lc; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import decode.p25.message.IdentifierProvider; +import decode.p25.message.IdentifierReceiver; +import decode.p25.message.ldu.LDU1Message; +import decode.p25.message.tsbk.osp.control.SystemService; +import decode.p25.reference.LinkControlOpcode; + +public class RFSSStatusBroadcastExplicit extends LDU1Message + implements IdentifierReceiver +{ + private final static Logger mLog = + LoggerFactory.getLogger( RFSSStatusBroadcastExplicit.class ); + + public static final int[] LRA = { 364,365,366,367,372,373,374,375 }; + public static final int[] RECEIVE_IDENTIFIER = { 376,377,382,383 }; + public static final int[] RECEIVE_CHANNEL = { 384,385,386,387,536,537,538, + 539,540,541,546,547 }; + public static final int[] RFSS_ID = { 548,549,550,551,556,557,558,559 }; + public static final int[] SITE_ID = { 560,561,566,567,568,569,570,571 }; + public static final int[] TRANSMIT_IDENTIFIER = { 720,721,722,723 }; + public static final int[] TRANSMIT_CHANNEL = { 724,725,730,731,732,733,734, + 735,740,741,742,743 }; + public static final int[] SYSTEM_SERVICE_CLASS = { 744,745,750,751,752,753,754,755 }; + + private IdentifierProvider mTransmitIdentifierUpdate; + private IdentifierProvider mReceiveIdentifierUpdate; + + public RFSSStatusBroadcastExplicit( LDU1Message source ) + { + super( source ); + } + + @Override + public String getEventType() + { + return LinkControlOpcode.RFSS_STATUS_BROADCAST_EXPLICIT.getDescription(); + } + + @Override + public String getMessage() + { + StringBuilder sb = new StringBuilder(); + + sb.append( getMessageStub() ); + + sb.append( " LRA:" + getLocationRegistrationArea() ); + + sb.append( " SITE:" + getRFSubsystemID() + "-" + getSiteID() ); + + sb.append( " TRANSMIT:" + getTransmitChannelNumber() ); + + sb.append( " RECEIVE:" + getReceiveChannelNumber() ); + + sb.append( " " + SystemService.toString( getSystemServiceClass() ) ); + + sb.append( " " + mMessage.toString() ); + + return sb.toString(); + } + + public String getLocationRegistrationArea() + { + return mMessage.getHex( LRA, 2 ); + } + + public String getRFSubsystemID() + { + return mMessage.getHex( RFSS_ID, 2 ); + } + + public String getSiteID() + { + return mMessage.getHex( SITE_ID, 2 ); + } + + public int getTransmitIdentifier() + { + return mMessage.getInt( TRANSMIT_IDENTIFIER ); + } + + public String getTransmitChannel() + { + return getTransmitIdentifier() + "-" + getTransmitChannelNumber(); + } + + public int getTransmitChannelNumber() + { + return mMessage.getInt( TRANSMIT_CHANNEL ); + } + + public int getReceiveIdentifier() + { + return mMessage.getInt( RECEIVE_IDENTIFIER ); + } + + public String getReceiveChannel() + { + return getReceiveIdentifier() + "-" + getReceiveChannelNumber(); + } + + public int getReceiveChannelNumber() + { + return mMessage.getInt( RECEIVE_CHANNEL ); + } + + public int getSystemServiceClass() + { + return mMessage.getInt( SYSTEM_SERVICE_CLASS ); + } + + @Override + public void setIdentifierMessage( int identifier, IdentifierProvider message ) + { + if( identifier == getTransmitIdentifier() ) + { + mTransmitIdentifierUpdate = message; + } + + if( identifier == getReceiveIdentifier() ) + { + mReceiveIdentifierUpdate = message; + } + } + + @Override + public int[] getIdentifiers() + { + int[] identifiers = new int[ 2 ]; + + identifiers[ 0 ] = getTransmitIdentifier(); + identifiers[ 1 ] = getReceiveIdentifier(); + + return identifiers; + } + + public long getDownlinkFrequency() + { + return calculateDownlink( mTransmitIdentifierUpdate, getTransmitChannelNumber() ); + } + + public long getUplinkFrequency() + { + return calculateUplink( mReceiveIdentifierUpdate, getReceiveChannelNumber() ); + } + +} diff --git a/src/decode/p25/message/ldu/lc/SecondaryControlChannelBroadcast.java b/src/decode/p25/message/ldu/lc/SecondaryControlChannelBroadcast.java new file mode 100644 index 00000000..ad73d5a8 --- /dev/null +++ b/src/decode/p25/message/ldu/lc/SecondaryControlChannelBroadcast.java @@ -0,0 +1,156 @@ +package decode.p25.message.ldu.lc; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import decode.p25.message.IdentifierProvider; +import decode.p25.message.IdentifierReceiver; +import decode.p25.message.ldu.LDU1Message; +import decode.p25.message.tsbk.osp.control.SystemService; +import decode.p25.reference.LinkControlOpcode; + +public class SecondaryControlChannelBroadcast extends LDU1Message + implements IdentifierReceiver +{ + private final static Logger mLog = + LoggerFactory.getLogger( SecondaryControlChannelBroadcast.class ); + + public static final int[] RFSS_ID = { 364,365,366,367,372,373,374,375 }; + public static final int[] SITE_ID = { 376,377,382,383,384,385,386,387 }; + public static final int[] IDENTIFIER_A = { 536,537,538,539 }; + public static final int[] CHANNEL_A = { 540,541,546,547,548,549,550,551, + 556,557,558,559 }; + public static final int[] SYSTEM_SERVICE_CLASS_A = { 560,561,566,567,568,569,570,571 }; + public static final int[] IDENTIFIER_B = { 720,721,722,723 }; + public static final int[] CHANNEL_B = { 724,725,730,731,732,733,734,735,740, + 741,742,743 }; + public static final int[] SYSTEM_SERVICE_CLASS_B = { 744,745,750,751,752,753,754,755 }; + + private IdentifierProvider mIdentifierProviderA; + private IdentifierProvider mIdentifierProviderB; + + public SecondaryControlChannelBroadcast( LDU1Message message ) + { + super( message ); + } + + @Override + public String getEventType() + { + return LinkControlOpcode.SECONDARY_CONTROL_CHANNEL_BROADCAST.getDescription(); + } + + @Override + public String getMessage() + { + StringBuilder sb = new StringBuilder(); + + sb.append( getMessageStub() ); + + sb.append( " SITE:" + getRFSubsystemID() + "-" + getSiteID() ); + + sb.append( " CHAN A:" + getChannelA() ); + + sb.append( " " + SystemService.toString( getSystemServiceClassA() ) ); + + sb.append( " CHAN B:" + getChannelB() ); + + sb.append( " " + SystemService.toString( getSystemServiceClassB() ) ); + + return sb.toString(); + } + + public String getRFSubsystemID() + { + return mMessage.getHex( RFSS_ID, 2 ); + } + + public String getSiteID() + { + return mMessage.getHex( SITE_ID, 2 ); + } + + public int getIdentifierA() + { + return mMessage.getInt( IDENTIFIER_A ); + } + + public int getChannelA() + { + return mMessage.getInt( CHANNEL_A ); + } + + public String getChannelNumberA() + { + return getIdentifierA() + "-" + getChannelA(); + } + + public int getIdentifierB() + { + return mMessage.getInt( IDENTIFIER_B ); + } + + public int getChannelB() + { + return mMessage.getInt( CHANNEL_B ); + } + + public String getChannelNumberB() + { + return getIdentifierB() + "-" + getChannelB(); + } + + public int getSystemServiceClassA() + { + return mMessage.getInt( SYSTEM_SERVICE_CLASS_A ); + } + + public int getSystemServiceClassB() + { + return mMessage.getInt( SYSTEM_SERVICE_CLASS_B ); + } + + @Override + public void setIdentifierMessage( int identifier, IdentifierProvider message ) + { + if( identifier == getIdentifierA() ) + { + mIdentifierProviderA = message; + } + if( identifier == getIdentifierB() ) + { + mIdentifierProviderB = message; + } + } + + @Override + public int[] getIdentifiers() + { + int[] identifiers = new int[ 2 ]; + + identifiers[ 0 ] = getIdentifierA(); + identifiers[ 1 ] = getIdentifierB(); + + return identifiers; + } + + public long getDownlinkFrequencyA() + { + return calculateDownlink( mIdentifierProviderA, getChannelA() ); + } + + public long getUplinkFrequencyA() + { + return calculateUplink( mIdentifierProviderA, getChannelA() ); + } + + public long getDownlinkFrequencyB() + { + return calculateDownlink( mIdentifierProviderB, getChannelB() ); + } + + public long getUplinkFrequencyB() + { + return calculateUplink( mIdentifierProviderB, getChannelB() ); + } +} diff --git a/src/decode/p25/message/ldu/lc/SecondaryControlChannelBroadcastExplicit.java b/src/decode/p25/message/ldu/lc/SecondaryControlChannelBroadcastExplicit.java new file mode 100644 index 00000000..2f0caab2 --- /dev/null +++ b/src/decode/p25/message/ldu/lc/SecondaryControlChannelBroadcastExplicit.java @@ -0,0 +1,141 @@ +package decode.p25.message.ldu.lc; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import decode.p25.message.IdentifierProvider; +import decode.p25.message.IdentifierReceiver; +import decode.p25.message.ldu.LDU1Message; +import decode.p25.message.tsbk.osp.control.SystemService; +import decode.p25.reference.LinkControlOpcode; + +public class SecondaryControlChannelBroadcastExplicit + extends LDU1Message implements IdentifierReceiver +{ + private final static Logger mLog = + LoggerFactory.getLogger( SecondaryControlChannelBroadcastExplicit.class ); + + public static final int[] RFSS_ID = { 364,365,366,367,372,373,374,375 }; + public static final int[] SITE_ID = { 376,377,382,383,384,385,386,387 }; + public static final int[] TRANSMIT_IDENTIFIER = { 536,537,538,539 }; + public static final int[] TRANSMIT_CHANNEL = { 540,541,546,547,548,549,550, + 551,556,557,558,559 }; + public static final int[] RECEIVE_IDENTIFIER = { 560,561,566,567 }; + public static final int[] RECEIVE_CHANNEL = { 568,569,570,571,720,721,722, + 723,724,725,730,731 }; + public static final int[] SYSTEM_SERVICE_CLASS = { 732,733,734,735,740,741, + 742,743 }; + + private IdentifierProvider mTransmitIdentifierProvider; + private IdentifierProvider mReceiveIdentifierProvider; + + public SecondaryControlChannelBroadcastExplicit( LDU1Message message ) + { + super( message ); + } + + @Override + public String getEventType() + { + return LinkControlOpcode.SECONDARY_CONTROL_CHANNEL_BROADCAST_EXPLICIT.getDescription(); + } + + @Override + public String getMessage() + { + StringBuilder sb = new StringBuilder(); + + sb.append( getMessageStub() ); + + sb.append( " SITE:" + getRFSubsystemID() + "-" + getSiteID() ); + + sb.append( " TRANSMIT:" + getTransmitChannel() ); + + sb.append( " RECEIVE:" + getReceiveChannel() ); + + sb.append( " " + SystemService.toString( getSystemServiceClass() ) ); + + return sb.toString(); + } + + public String getRFSubsystemID() + { + return mMessage.getHex( RFSS_ID, 2 ); + } + + public String getSiteID() + { + return mMessage.getHex( SITE_ID, 2 ); + } + + public int getTransmitIdentifier() + { + return mMessage.getInt( TRANSMIT_IDENTIFIER ); + } + + public int getTransmitChannelNumber() + { + return mMessage.getInt( TRANSMIT_CHANNEL ); + } + + public String getTransmitChannel() + { + return getTransmitIdentifier() + "-" + getTransmitChannelNumber(); + } + + public int getReceiveIdentifier() + { + return mMessage.getInt( RECEIVE_IDENTIFIER ); + } + + public int getReceiveChannelNumber() + { + return mMessage.getInt( RECEIVE_CHANNEL ); + } + + public String getReceiveChannel() + { + return getReceiveIdentifier() + "-" + getReceiveChannelNumber(); + } + + public int getSystemServiceClass() + { + return mMessage.getInt( SYSTEM_SERVICE_CLASS ); + } + + @Override + public void setIdentifierMessage( int identifier, IdentifierProvider message ) + { + if( identifier == getTransmitIdentifier() ) + { + mTransmitIdentifierProvider = message; + } + if( identifier == getReceiveIdentifier() ) + { + mReceiveIdentifierProvider = message; + } + } + + @Override + public int[] getIdentifiers() + { + int[] identifiers = new int[ 2 ]; + + identifiers[ 0 ] = getTransmitIdentifier(); + identifiers[ 1 ] = getReceiveIdentifier(); + + return identifiers; + } + + public long getDownlinkFrequency() + { + return calculateDownlink( mTransmitIdentifierProvider, + getTransmitChannelNumber() ); + } + + public long getUplinkFrequency() + { + return calculateUplink( mReceiveIdentifierProvider, + getReceiveChannelNumber() ); + } +} diff --git a/src/decode/p25/message/ldu/lc/StatusQuery.java b/src/decode/p25/message/ldu/lc/StatusQuery.java new file mode 100644 index 00000000..41637685 --- /dev/null +++ b/src/decode/p25/message/ldu/lc/StatusQuery.java @@ -0,0 +1,52 @@ +package decode.p25.message.ldu.lc; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import decode.p25.message.ldu.LDU1Message; +import decode.p25.reference.LinkControlOpcode; + +public class StatusQuery extends LDU1Message +{ + private final static Logger mLog = + LoggerFactory.getLogger( StatusQuery.class ); + public static final int[] TARGET_ADDRESS = { 536,537,538,539,540,541,546, + 547,548,549,550,551,556,557,558,559,560,561,566,567,568,569,570,571 }; + public static final int[] SOURCE_ADDRESS = { 720,721,722,723,724,725,730, + 731,732,733,734,735,740,741,742,743,744,745,750,751,752,753,754,755 }; + + public StatusQuery( LDU1Message message ) + { + super( message ); + } + + @Override + public String getEventType() + { + return LinkControlOpcode.STATUS_QUERY.getDescription(); + } + + @Override + public String getMessage() + { + StringBuilder sb = new StringBuilder(); + + sb.append( getMessageStub() ); + + sb.append( " FROM:" + getSourceAddress() ); + + sb.append( " TO:" + getTargetAddress() ); + + return sb.toString(); + } + + public String getTargetAddress() + { + return mMessage.getHex( TARGET_ADDRESS, 6 ); + } + + public String getSourceAddress() + { + return mMessage.getHex( SOURCE_ADDRESS, 6 ); + } +} diff --git a/src/decode/p25/message/ldu/lc/StatusUpdate.java b/src/decode/p25/message/ldu/lc/StatusUpdate.java new file mode 100644 index 00000000..08c83342 --- /dev/null +++ b/src/decode/p25/message/ldu/lc/StatusUpdate.java @@ -0,0 +1,65 @@ +package decode.p25.message.ldu.lc; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import decode.p25.message.ldu.LDU1Message; +import decode.p25.reference.LinkControlOpcode; + +public class StatusUpdate extends LDU1Message +{ + private final static Logger mLog = + LoggerFactory.getLogger( StatusUpdate.class ); + public static final int[] USER_STATUS = { 364,365,366,367,372,373,374,375 }; + public static final int[] UNIT_STATUS = { 376,377,382,383,384,385,386,387 }; + public static final int[] TARGET_ADDRESS = { 536,537,538,539,540,541,546, + 547,548,549,550,551,556,557,558,559,560,561,566,567,568,569,570,571 }; + public static final int[] SOURCE_ADDRESS = { 720,721,722,723,724,725,730, + 731,732,733,734,735,740,741,742,743,744,745,750,751,752,753,754,755 }; + + public StatusUpdate( LDU1Message message ) + { + super( message ); + } + + @Override + public String getEventType() + { + return LinkControlOpcode.STATUS_UPDATE.getDescription(); + } + + @Override + public String getMessage() + { + StringBuilder sb = new StringBuilder(); + + sb.append( getMessageStub() ); + + sb.append( " STATUS USER:" + getUserStatus() ); + sb.append( " UNIT:" + getUnitStatus() ); + sb.append( " FROM:" + getSourceAddress() ); + sb.append( " TO:" + getTargetAddress() ); + + return sb.toString(); + } + + public String getUserStatus() + { + return mMessage.getHex( USER_STATUS, 2 ); + } + + public String getUnitStatus() + { + return mMessage.getHex( UNIT_STATUS, 2 ); + } + + public String getTargetAddress() + { + return mMessage.getHex( TARGET_ADDRESS, 6 ); + } + + public String getSourceAddress() + { + return mMessage.getHex( SOURCE_ADDRESS, 6 ); + } +} diff --git a/src/decode/p25/message/ldu/lc/SystemServiceBroadcast.java b/src/decode/p25/message/ldu/lc/SystemServiceBroadcast.java new file mode 100644 index 00000000..d7679ecb --- /dev/null +++ b/src/decode/p25/message/ldu/lc/SystemServiceBroadcast.java @@ -0,0 +1,64 @@ +package decode.p25.message.ldu.lc; + +import java.util.List; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import decode.p25.message.ldu.LDU1Message; +import decode.p25.reference.LinkControlOpcode; +import decode.p25.reference.Service; + +public class SystemServiceBroadcast extends LDU1Message +{ + private final static Logger mLog = + LoggerFactory.getLogger( SystemServiceBroadcast.class ); + public static final int[] REQUEST_PRIORITY_LEVEL = { 384,385,386,387 }; + public static final int[] AVAILABLE_SERVICES = { 536,537,538,539,540,541, + 546,547,548,549,550,551,556,557,558,559,560,561,566,567,568,569,570,571 }; + public static final int[] SUPPORTED_SERVICES = { 720,721,722,723,724,725, + 730,731,732,733,734,735,740,741,742,743,744,745,750,751,752,753,754,755 }; + + public SystemServiceBroadcast( LDU1Message message ) + { + super( message ); + } + + @Override + public String getEventType() + { + return LinkControlOpcode.SYSTEM_SERVICE_BROADCAST.getDescription(); + } + + @Override + public String getMessage() + { + StringBuilder sb = new StringBuilder(); + + sb.append( getMessageStub() ); + + sb.append( " SERVICES AVAILABLE " ); + + sb.append( getAvailableServices() ); + + sb.append( " SUPPORTED " ); + + sb.append( getSupportedServices() ); + + return sb.toString(); + } + + public List getAvailableServices() + { + long bitmap = mMessage.getLong( AVAILABLE_SERVICES ); + + return Service.getServices( bitmap ); + } + + public List getSupportedServices() + { + long bitmap = mMessage.getLong( SUPPORTED_SERVICES ); + + return Service.getServices( bitmap ); + } +} diff --git a/src/decode/p25/message/ldu/lc/TelephoneInterconnectAnswerRequest.java b/src/decode/p25/message/ldu/lc/TelephoneInterconnectAnswerRequest.java new file mode 100644 index 00000000..c70c7796 --- /dev/null +++ b/src/decode/p25/message/ldu/lc/TelephoneInterconnectAnswerRequest.java @@ -0,0 +1,81 @@ +package decode.p25.message.ldu.lc; + +import java.util.ArrayList; +import java.util.List; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import decode.p25.message.ldu.LDU1Message; +import decode.p25.reference.Digit; +import decode.p25.reference.LinkControlOpcode; + +public class TelephoneInterconnectAnswerRequest extends LDU1Message +{ + private final static Logger mLog = LoggerFactory.getLogger( + TelephoneInterconnectAnswerRequest.class ); + + public static final int[] DIGIT_1 = { 364,365,366,367 }; + public static final int[] DIGIT_2 = { 372,373,374,375 }; + public static final int[] DIGIT_3 = { 376,377,382,383 }; + public static final int[] DIGIT_4 = { 384,385,386,387 }; + public static final int[] DIGIT_5 = { 536,537,538,539 }; + public static final int[] DIGIT_6 = { 540,541,546,547 }; + public static final int[] DIGIT_7 = { 548,549,550,551 }; + public static final int[] DIGIT_8 = { 556,557,558,559 }; + public static final int[] DIGIT_9 = { 560,561,566,567 }; + public static final int[] DIGIT_10 = { 568,569,570,571 }; + public static final int[] TARGET_ADDRESS = { 720,721,722,723,724,725,730, + 731,732,733,734,735,740,741,742,743,744,745,750,751,752,753,754,755 }; + + public TelephoneInterconnectAnswerRequest( LDU1Message message ) + { + super( message ); + } + + @Override + public String getEventType() + { + return LinkControlOpcode.TELEPHONE_INTERCONNECT_ANSWER_REQUEST.getDescription(); + } + + @Override + public String getMessage() + { + StringBuilder sb = new StringBuilder(); + + sb.append( getMessageStub() ); + + sb.append( " TO:" ); + sb.append( getTargetAddress() ); + + sb.append( " TEL:" ); + sb.append( getTelephoneNumber() ); + + return sb.toString(); + } + + public String getTargetAddress() + { + return mMessage.getHex( TARGET_ADDRESS, 6 ); + } + + public String getTelephoneNumber() + { + List digits = new ArrayList(); + + digits.add( mMessage.getInt( DIGIT_1 ) ); + digits.add( mMessage.getInt( DIGIT_2 ) ); + digits.add( mMessage.getInt( DIGIT_3 ) ); + digits.add( mMessage.getInt( DIGIT_4 ) ); + digits.add( mMessage.getInt( DIGIT_5 ) ); + digits.add( mMessage.getInt( DIGIT_6 ) ); + digits.add( mMessage.getInt( DIGIT_7 ) ); + digits.add( mMessage.getInt( DIGIT_8 ) ); + digits.add( mMessage.getInt( DIGIT_9 ) ); + digits.add( mMessage.getInt( DIGIT_10 ) ); + + return Digit.decode( digits ); + } + +} diff --git a/src/decode/p25/message/ldu/lc/TelephoneInterconnectVoiceChannelUser.java b/src/decode/p25/message/ldu/lc/TelephoneInterconnectVoiceChannelUser.java new file mode 100644 index 00000000..00e6a04a --- /dev/null +++ b/src/decode/p25/message/ldu/lc/TelephoneInterconnectVoiceChannelUser.java @@ -0,0 +1,96 @@ +package decode.p25.message.ldu.lc; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import decode.p25.message.P25Message.DuplexMode; +import decode.p25.message.P25Message.SessionMode; +import decode.p25.message.ldu.LDU1Message; +import decode.p25.reference.LinkControlOpcode; + +public class TelephoneInterconnectVoiceChannelUser extends LDU1Message +{ + private final static Logger mLog = + LoggerFactory.getLogger( TelephoneInterconnectVoiceChannelUser.class ); + + /* Service Options */ + public static final int EMERGENCY_FLAG = 376; + public static final int ENCRYPTED_CHANNEL_FLAG = 377; + public static final int DUPLEX_MODE = 382; + public static final int SESSION_MODE = 383; + public static final int[] CALL_TIMER = { 548,549,550,551,556,557,558,559, + 560,561,566,567,568,569,570,571 }; + public static final int[] ADDRESS = { 720,721,722,723,724,725,730,731,732, + 733,734,735,740,741,742,743,744,745,750,751,752,753,754,755 }; + + public TelephoneInterconnectVoiceChannelUser( LDU1Message message ) + { + super( message ); + } + + @Override + public String getEventType() + { + return LinkControlOpcode.TELEPHONE_INTERCONNECT_VOICE_CHANNEL_USER.getDescription(); + } + + @Override + public String getMessage() + { + StringBuilder sb = new StringBuilder(); + + sb.append( getMessageStub() ); + + if( isEmergency() ) + { + sb.append( " EMERGENCY" ); + } + if( isEncryptedChannel() ) + { + sb.append( " ENCRYPTED CHANNEL" ); + } + + sb.append( " TIMER:" + getCallTimer() + " SECS" ); + + sb.append( " ADDR:" + getAddress() ); + + return sb.toString(); + } + + public boolean isEmergency() + { + return mMessage.get( EMERGENCY_FLAG ); + } + + public boolean isEncryptedChannel() + { + return mMessage.get( ENCRYPTED_CHANNEL_FLAG ); + } + + public DuplexMode getDuplexMode() + { + return mMessage.get( DUPLEX_MODE ) ? DuplexMode.FULL : DuplexMode.HALF; + } + + public SessionMode getSessionMode() + { + return mMessage.get( SESSION_MODE ) ? + SessionMode.CIRCUIT : SessionMode.PACKET; + } + + public String getAddress() + { + return mMessage.getHex( ADDRESS, 6 ); + } + + /** + * Call timer in seconds + */ + public int getCallTimer() + { + int units = mMessage.getInt( CALL_TIMER ); + + return (int)( units / 10 ); + } + +} diff --git a/src/decode/p25/message/ldu/lc/UnitAuthenticationCommand.java b/src/decode/p25/message/ldu/lc/UnitAuthenticationCommand.java new file mode 100644 index 00000000..1bdf3898 --- /dev/null +++ b/src/decode/p25/message/ldu/lc/UnitAuthenticationCommand.java @@ -0,0 +1,59 @@ +package decode.p25.message.ldu.lc; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import decode.p25.message.ldu.LDU1Message; +import decode.p25.reference.LinkControlOpcode; + +public class UnitAuthenticationCommand extends LDU1Message +{ + private final static Logger mLog = + LoggerFactory.getLogger( UnitAuthenticationCommand.class ); + public static final int[] NETWORK_ID = { 364,365,366,367,372,373,374,375, + 376,377,382,383,384,385,386,387,536,537,538,539 }; + public static final int[] SYSTEM_ID = { 540,541,546,547,548,549,550,551,556, + 557,558,559 }; + public static final int[] SOURCE_ID = { 560,561,566,567,568,569,570,571,720, + 721,722,723,724,725,730,731,732,733,734,735,740,741,742,743 }; + + public UnitAuthenticationCommand( LDU1Message message ) + { + super( message ); + } + + @Override + public String getEventType() + { + return LinkControlOpcode.UNIT_AUTHENTICATION_COMMAND.getDescription(); + } + + @Override + public String getMessage() + { + StringBuilder sb = new StringBuilder(); + + sb.append( getMessageStub() ); + + sb.append( " NETWORK:" + getNetworkID() ); + sb.append( " SYS:" + getSystemID() ); + sb.append( " ID:" + getSourceID() ); + + return sb.toString(); + } + + public String getNetworkID() + { + return mMessage.getHex( NETWORK_ID, 5 ); + } + + public String getSystemID() + { + return mMessage.getHex( SYSTEM_ID, 3 ); + } + + public String getSourceID() + { + return mMessage.getHex( SOURCE_ID, 6 ); + } +} diff --git a/src/decode/p25/message/ldu/lc/UnitRegistrationCommand.java b/src/decode/p25/message/ldu/lc/UnitRegistrationCommand.java new file mode 100644 index 00000000..4506430f --- /dev/null +++ b/src/decode/p25/message/ldu/lc/UnitRegistrationCommand.java @@ -0,0 +1,59 @@ +package decode.p25.message.ldu.lc; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import decode.p25.message.ldu.LDU1Message; +import decode.p25.reference.LinkControlOpcode; + +public class UnitRegistrationCommand extends LDU1Message +{ + private final static Logger mLog = + LoggerFactory.getLogger( UnitRegistrationCommand.class ); + public static final int[] NETWORK_ID = { 364,365,366,367,372,373,374,375, + 376,377,382,383,384,385,386,387,536,537,538,539 }; + public static final int[] SYSTEM_ID = { 540,541,546,547,548,549,550,551,556, + 557,558,559 }; + public static final int[] SOURCE_ID = { 560,561,566,567,568,569,570,571,720, + 721,722,723,724,725,730,731,732,733,734,735,740,741,742,743 }; + + public UnitRegistrationCommand( LDU1Message message ) + { + super( message ); + } + + @Override + public String getEventType() + { + return LinkControlOpcode.UNIT_REGISTRATION_COMMAND.getDescription(); + } + + @Override + public String getMessage() + { + StringBuilder sb = new StringBuilder(); + + sb.append( getMessageStub() ); + + sb.append( " NETWORK:" + getNetworkID() ); + sb.append( " SYS:" + getSystemID() ); + sb.append( " ID:" + getSourceID() ); + + return sb.toString(); + } + + public String getNetworkID() + { + return mMessage.getHex( NETWORK_ID, 5 ); + } + + public String getSystemID() + { + return mMessage.getHex( SYSTEM_ID, 3 ); + } + + public String getSourceID() + { + return mMessage.getHex( SOURCE_ID, 6 ); + } +} diff --git a/src/decode/p25/message/ldu/lc/UnitToUnitAnswerRequest.java b/src/decode/p25/message/ldu/lc/UnitToUnitAnswerRequest.java new file mode 100644 index 00000000..26a0fd70 --- /dev/null +++ b/src/decode/p25/message/ldu/lc/UnitToUnitAnswerRequest.java @@ -0,0 +1,89 @@ +package decode.p25.message.ldu.lc; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import decode.p25.message.P25Message.DuplexMode; +import decode.p25.message.P25Message.SessionMode; +import decode.p25.message.ldu.LDU1Message; +import decode.p25.reference.LinkControlOpcode; + +public class UnitToUnitAnswerRequest extends LDU1Message +{ + private final static Logger mLog = + LoggerFactory.getLogger( UnitToUnitAnswerRequest.class ); + /* Service Options */ + public static final int EMERGENCY_FLAG = 364; + public static final int ENCRYPTED_CHANNEL_FLAG = 365; + public static final int DUPLEX_MODE = 366; + public static final int SESSION_MODE = 367; + public static final int[] TARGET_ADDRESS = { 536,537,538,539,540,541,546, + 547,548,549,550,551,556,557,558,559,560,561,566,567,568,569,570,571 }; + public static final int[] SOURCE_ADDRESS = { 720,721,722,723,724,725,730, + 731,732,733,734,735,740,741,742,743,744,745,750,751,752,753,754,755 }; + + public UnitToUnitAnswerRequest( LDU1Message message ) + { + super( message ); + } + + @Override + public String getEventType() + { + return LinkControlOpcode.UNIT_TO_UNIT_ANSWER_REQUEST.getDescription(); + } + + @Override + public String getMessage() + { + StringBuilder sb = new StringBuilder(); + + sb.append( getMessageStub() ); + + if( isEmergency() ) + { + sb.append( " EMERGENCY" ); + } + if( isEncryptedChannel() ) + { + sb.append( " ENCRYPTED CHANNEL" ); + } + + sb.append( " FROM:" + getSourceAddress() ); + + sb.append( " TO:" + getTargetAddress() ); + + return sb.toString(); + } + + public boolean isEmergency() + { + return mMessage.get( EMERGENCY_FLAG ); + } + + public boolean isEncryptedChannel() + { + return mMessage.get( ENCRYPTED_CHANNEL_FLAG ); + } + + public DuplexMode getDuplexMode() + { + return mMessage.get( DUPLEX_MODE ) ? DuplexMode.FULL : DuplexMode.HALF; + } + + public SessionMode getSessionMode() + { + return mMessage.get( SESSION_MODE ) ? + SessionMode.CIRCUIT : SessionMode.PACKET; + } + + public String getTargetAddress() + { + return mMessage.getHex( TARGET_ADDRESS, 6 ); + } + + public String getSourceAddress() + { + return mMessage.getHex( SOURCE_ADDRESS, 6 ); + } +} diff --git a/src/decode/p25/message/ldu/lc/UnitToUnitVoiceChannelUser.java b/src/decode/p25/message/ldu/lc/UnitToUnitVoiceChannelUser.java new file mode 100644 index 00000000..37b582c4 --- /dev/null +++ b/src/decode/p25/message/ldu/lc/UnitToUnitVoiceChannelUser.java @@ -0,0 +1,89 @@ +package decode.p25.message.ldu.lc; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import decode.p25.message.P25Message.DuplexMode; +import decode.p25.message.P25Message.SessionMode; +import decode.p25.message.ldu.LDU1Message; +import decode.p25.reference.LinkControlOpcode; + +public class UnitToUnitVoiceChannelUser extends LDU1Message +{ + private final static Logger mLog = + LoggerFactory.getLogger( UnitToUnitVoiceChannelUser.class ); + /* Service Options */ + public static final int EMERGENCY_FLAG = 376; + public static final int ENCRYPTED_CHANNEL_FLAG = 377; + public static final int DUPLEX_MODE = 382; + public static final int SESSION_MODE = 383; + public static final int[] TARGET_ADDRESS = { 536,537,538,539,540,541,546, + 547,548,549,550,551,556,557,558,559,560,561,566,567,568,569,570,571 }; + public static final int[] SOURCE_ADDRESS = { 720,721,722,723,724,725,730, + 731,732,733,734,735,740,741,742,743,744,745,750,751,752,753,754,755 }; + + public UnitToUnitVoiceChannelUser( LDU1Message message ) + { + super( message ); + } + + @Override + public String getEventType() + { + return LinkControlOpcode.UNIT_TO_UNIT_VOICE_CHANNEL_USER.getDescription(); + } + + @Override + public String getMessage() + { + StringBuilder sb = new StringBuilder(); + + sb.append( getMessageStub() ); + + if( isEmergency() ) + { + sb.append( " EMERGENCY" ); + } + if( isEncryptedChannel() ) + { + sb.append( " ENCRYPTED CHANNEL" ); + } + + sb.append( " FROM:" + getSourceAddress() ); + + sb.append( " TO:" + getTargetAddress() ); + + return sb.toString(); + } + + public boolean isEmergency() + { + return mMessage.get( EMERGENCY_FLAG ); + } + + public boolean isEncryptedChannel() + { + return mMessage.get( ENCRYPTED_CHANNEL_FLAG ); + } + + public DuplexMode getDuplexMode() + { + return mMessage.get( DUPLEX_MODE ) ? DuplexMode.FULL : DuplexMode.HALF; + } + + public SessionMode getSessionMode() + { + return mMessage.get( SESSION_MODE ) ? + SessionMode.CIRCUIT : SessionMode.PACKET; + } + + public String getTargetAddress() + { + return mMessage.getHex( TARGET_ADDRESS, 6 ); + } + + public String getSourceAddress() + { + return mMessage.getHex( SOURCE_ADDRESS, 6 ); + } +} diff --git a/src/decode/p25/message/pdu/PDUConfirmedMessage.java b/src/decode/p25/message/pdu/PDUConfirmedMessage.java index 37495028..40c629ab 100644 --- a/src/decode/p25/message/pdu/PDUConfirmedMessage.java +++ b/src/decode/p25/message/pdu/PDUConfirmedMessage.java @@ -6,6 +6,7 @@ import org.slf4j.LoggerFactory; import alias.AliasList; import bits.BitSetBuffer; import decode.p25.reference.DataUnitID; +import decode.p25.reference.Vendor; public class PDUConfirmedMessage extends PDUMessage { @@ -25,6 +26,36 @@ public class PDUConfirmedMessage extends PDUMessage { return true; } + + @Override + public String getMessage() + { + StringBuilder sb = new StringBuilder(); + + sb.append( "NAC:" ); + sb.append( getNAC() ); + sb.append( " " ); + sb.append( getDUID().getLabel() ); + + sb.append( " LLID:" ); + sb.append( getLogicalLinkID() ); + + sb.append( " " ); + sb.append( getConfirmation() ); + sb.append( " " ); + sb.append( getDirection() ); + sb.append( " FMT:" ); + sb.append( getFormat().getLabel() ); + sb.append( " SAP:" ); + sb.append( getServiceAccessPoint().name() ); + sb.append( " VEND:" ); + sb.append( getVendor().getLabel() ); + sb.append( " BLKS TO FOLLOW:" ); + sb.append( getBlocksToFollowCount() ); + + return sb.toString(); + } + public String toString() { diff --git a/src/decode/p25/message/pdu/UnitToUnitChannelGrantExtended.java b/src/decode/p25/message/pdu/UnitToUnitChannelGrantExtended.java index c4d5ff37..b1ae4715 100644 --- a/src/decode/p25/message/pdu/UnitToUnitChannelGrantExtended.java +++ b/src/decode/p25/message/pdu/UnitToUnitChannelGrantExtended.java @@ -3,13 +3,13 @@ package decode.p25.message.pdu; import alias.AliasList; import bits.BitSetBuffer; import decode.p25.message.IdentifierProvider; -import decode.p25.message.tsbk.osp.control.IdentifierProviderReceiver; +import decode.p25.message.IdentifierReceiver; import decode.p25.reference.DataUnitID; import decode.p25.reference.Opcode; import edac.CRCP25; public abstract class UnitToUnitChannelGrantExtended extends PDUMessage - implements IdentifierProviderReceiver + implements IdentifierReceiver { /* Service Options */ public static final int EMERGENCY_FLAG = 128; diff --git a/src/decode/p25/message/pdu/osp/control/AdjacentStatusBroadcastExtended.java b/src/decode/p25/message/pdu/osp/control/AdjacentStatusBroadcastExtended.java index 3e0bb020..adcaaeee 100644 --- a/src/decode/p25/message/pdu/osp/control/AdjacentStatusBroadcastExtended.java +++ b/src/decode/p25/message/pdu/osp/control/AdjacentStatusBroadcastExtended.java @@ -3,15 +3,15 @@ package decode.p25.message.pdu.osp.control; import alias.AliasList; import bits.BitSetBuffer; import decode.p25.message.IdentifierProvider; +import decode.p25.message.IdentifierReceiver; import decode.p25.message.pdu.PDUMessage; -import decode.p25.message.tsbk.osp.control.IdentifierProviderReceiver; import decode.p25.message.tsbk.osp.control.SystemService; import decode.p25.reference.DataUnitID; import decode.p25.reference.Opcode; import edac.CRCP25; public class AdjacentStatusBroadcastExtended extends PDUMessage - implements IdentifierProviderReceiver + implements IdentifierReceiver { public static final int[] LRA = { 88,89,90,91,92,93,94,95 }; public static final int[] SYSTEM_ID = { 100,101,102,103,104,105,106,107,108, diff --git a/src/decode/p25/message/pdu/osp/control/NetworkStatusBroadcastExtended.java b/src/decode/p25/message/pdu/osp/control/NetworkStatusBroadcastExtended.java index 4e4c7b6c..3bfccd52 100644 --- a/src/decode/p25/message/pdu/osp/control/NetworkStatusBroadcastExtended.java +++ b/src/decode/p25/message/pdu/osp/control/NetworkStatusBroadcastExtended.java @@ -3,8 +3,8 @@ package decode.p25.message.pdu.osp.control; import alias.AliasList; import bits.BitSetBuffer; import decode.p25.message.IdentifierProvider; +import decode.p25.message.IdentifierReceiver; import decode.p25.message.pdu.PDUMessage; -import decode.p25.message.tsbk.osp.control.IdentifierProviderReceiver; import decode.p25.message.tsbk.osp.control.SystemService; import decode.p25.reference.DataUnitID; import decode.p25.reference.Opcode; @@ -12,7 +12,7 @@ import decode.p25.reference.P25NetworkCallsign; import edac.CRCP25; public class NetworkStatusBroadcastExtended extends PDUMessage - implements IdentifierProviderReceiver + implements IdentifierReceiver { public static final int[] LRA = { 88,89,90,91,92,93,94,95 }; public static final int[] SYSTEM_ID = { 100,101,102,103,104,105,106,107,108, diff --git a/src/decode/p25/message/pdu/osp/control/RFSSStatusBroadcastExtended.java b/src/decode/p25/message/pdu/osp/control/RFSSStatusBroadcastExtended.java index 5793e043..e7397a74 100644 --- a/src/decode/p25/message/pdu/osp/control/RFSSStatusBroadcastExtended.java +++ b/src/decode/p25/message/pdu/osp/control/RFSSStatusBroadcastExtended.java @@ -3,15 +3,15 @@ package decode.p25.message.pdu.osp.control; import alias.AliasList; import bits.BitSetBuffer; import decode.p25.message.IdentifierProvider; +import decode.p25.message.IdentifierReceiver; import decode.p25.message.pdu.PDUMessage; -import decode.p25.message.tsbk.osp.control.IdentifierProviderReceiver; import decode.p25.message.tsbk.osp.control.SystemService; import decode.p25.reference.DataUnitID; import decode.p25.reference.Opcode; import edac.CRCP25; public class RFSSStatusBroadcastExtended extends PDUMessage - implements IdentifierProviderReceiver + implements IdentifierReceiver { public static final int[] LRA = { 88,89,90,91,92,93,94,95 }; public static final int ACTIVE_NETWORK_CONNECTION_INDICATOR = 99; diff --git a/src/decode/p25/message/pdu/osp/data/GroupDataChannelGrantExtended.java b/src/decode/p25/message/pdu/osp/data/GroupDataChannelGrantExtended.java index 11816a1e..3921f05a 100644 --- a/src/decode/p25/message/pdu/osp/data/GroupDataChannelGrantExtended.java +++ b/src/decode/p25/message/pdu/osp/data/GroupDataChannelGrantExtended.java @@ -5,14 +5,14 @@ import java.util.Date; import alias.AliasList; import bits.BitSetBuffer; import decode.p25.message.IdentifierProvider; +import decode.p25.message.IdentifierReceiver; import decode.p25.message.pdu.PDUMessage; -import decode.p25.message.tsbk.osp.control.IdentifierProviderReceiver; import decode.p25.reference.DataUnitID; import decode.p25.reference.Opcode; import edac.CRCP25; public class GroupDataChannelGrantExtended extends PDUMessage - implements IdentifierProviderReceiver + implements IdentifierReceiver { /* Service Options */ public static final int EMERGENCY_FLAG = 128; diff --git a/src/decode/p25/message/pdu/osp/data/IndividualDataChannelGrantExtended.java b/src/decode/p25/message/pdu/osp/data/IndividualDataChannelGrantExtended.java index 7c757264..45ab5a82 100644 --- a/src/decode/p25/message/pdu/osp/data/IndividualDataChannelGrantExtended.java +++ b/src/decode/p25/message/pdu/osp/data/IndividualDataChannelGrantExtended.java @@ -2,14 +2,14 @@ package decode.p25.message.pdu.osp.data; import alias.AliasList; import bits.BitSetBuffer; +import decode.p25.message.IdentifierReceiver; import decode.p25.message.pdu.UnitToUnitChannelGrantExtended; -import decode.p25.message.tsbk.osp.control.IdentifierProviderReceiver; import decode.p25.reference.DataUnitID; import decode.p25.reference.Opcode; public class IndividualDataChannelGrantExtended extends UnitToUnitChannelGrantExtended - implements IdentifierProviderReceiver + implements IdentifierReceiver { public IndividualDataChannelGrantExtended( BitSetBuffer message, DataUnitID duid, AliasList aliasList ) diff --git a/src/decode/p25/message/pdu/osp/voice/GroupVoiceChannelGrantExplicit.java b/src/decode/p25/message/pdu/osp/voice/GroupVoiceChannelGrantExplicit.java index 1e4454f5..40f927f4 100644 --- a/src/decode/p25/message/pdu/osp/voice/GroupVoiceChannelGrantExplicit.java +++ b/src/decode/p25/message/pdu/osp/voice/GroupVoiceChannelGrantExplicit.java @@ -3,14 +3,14 @@ package decode.p25.message.pdu.osp.voice; import alias.AliasList; import bits.BitSetBuffer; import decode.p25.message.IdentifierProvider; +import decode.p25.message.IdentifierReceiver; import decode.p25.message.pdu.PDUMessage; -import decode.p25.message.tsbk.osp.control.IdentifierProviderReceiver; import decode.p25.reference.DataUnitID; import decode.p25.reference.Opcode; import edac.CRCP25; public class GroupVoiceChannelGrantExplicit extends PDUMessage - implements IdentifierProviderReceiver + implements IdentifierReceiver { /* Service Options */ public static final int EMERGENCY_FLAG = 128; diff --git a/src/decode/p25/message/pdu/osp/voice/TelephoneInterconnectChannelGrantExplicit.java b/src/decode/p25/message/pdu/osp/voice/TelephoneInterconnectChannelGrantExplicit.java index 08d46678..e405cda7 100644 --- a/src/decode/p25/message/pdu/osp/voice/TelephoneInterconnectChannelGrantExplicit.java +++ b/src/decode/p25/message/pdu/osp/voice/TelephoneInterconnectChannelGrantExplicit.java @@ -5,14 +5,14 @@ import java.util.Date; import alias.AliasList; import bits.BitSetBuffer; import decode.p25.message.IdentifierProvider; +import decode.p25.message.IdentifierReceiver; import decode.p25.message.pdu.PDUMessage; -import decode.p25.message.tsbk.osp.control.IdentifierProviderReceiver; import decode.p25.reference.DataUnitID; import decode.p25.reference.Opcode; import edac.CRCP25; public class TelephoneInterconnectChannelGrantExplicit extends PDUMessage - implements IdentifierProviderReceiver + implements IdentifierReceiver { /* Service Options */ public static final int EMERGENCY_FLAG = 128; diff --git a/src/decode/p25/message/pdu/osp/voice/UnitToUnitVoiceChannelGrantExtended.java b/src/decode/p25/message/pdu/osp/voice/UnitToUnitVoiceChannelGrantExtended.java index 2c615109..f856b191 100644 --- a/src/decode/p25/message/pdu/osp/voice/UnitToUnitVoiceChannelGrantExtended.java +++ b/src/decode/p25/message/pdu/osp/voice/UnitToUnitVoiceChannelGrantExtended.java @@ -2,14 +2,14 @@ package decode.p25.message.pdu.osp.voice; import alias.AliasList; import bits.BitSetBuffer; +import decode.p25.message.IdentifierReceiver; import decode.p25.message.pdu.UnitToUnitChannelGrantExtended; -import decode.p25.message.tsbk.osp.control.IdentifierProviderReceiver; import decode.p25.reference.DataUnitID; import decode.p25.reference.Opcode; public class UnitToUnitVoiceChannelGrantExtended extends UnitToUnitChannelGrantExtended - implements IdentifierProviderReceiver + implements IdentifierReceiver { public UnitToUnitVoiceChannelGrantExtended( BitSetBuffer message, DataUnitID duid, AliasList aliasList ) diff --git a/src/decode/p25/message/pdu/osp/voice/UnitToUnitVoiceChannelGrantUpdateExtended.java b/src/decode/p25/message/pdu/osp/voice/UnitToUnitVoiceChannelGrantUpdateExtended.java index 65d6de8a..ab2121d5 100644 --- a/src/decode/p25/message/pdu/osp/voice/UnitToUnitVoiceChannelGrantUpdateExtended.java +++ b/src/decode/p25/message/pdu/osp/voice/UnitToUnitVoiceChannelGrantUpdateExtended.java @@ -3,14 +3,14 @@ package decode.p25.message.pdu.osp.voice; import alias.AliasList; import bits.BitSetBuffer; import decode.p25.message.IdentifierProvider; +import decode.p25.message.IdentifierReceiver; import decode.p25.message.pdu.PDUMessage; -import decode.p25.message.tsbk.osp.control.IdentifierProviderReceiver; import decode.p25.reference.DataUnitID; import decode.p25.reference.Opcode; import edac.CRCP25; public class UnitToUnitVoiceChannelGrantUpdateExtended extends PDUMessage - implements IdentifierProviderReceiver + implements IdentifierReceiver { /* Service Options */ public static final int EMERGENCY_FLAG = 128; diff --git a/src/decode/p25/message/tdu/lc/AdjacentSiteStatusBroadcast.java b/src/decode/p25/message/tdu/lc/AdjacentSiteStatusBroadcast.java index b0bac516..8d9eaf04 100644 --- a/src/decode/p25/message/tdu/lc/AdjacentSiteStatusBroadcast.java +++ b/src/decode/p25/message/tdu/lc/AdjacentSiteStatusBroadcast.java @@ -4,13 +4,13 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; import decode.p25.message.IdentifierProvider; -import decode.p25.message.tsbk.osp.control.IdentifierProviderReceiver; +import decode.p25.message.IdentifierReceiver; import decode.p25.message.tsbk.osp.control.SystemService; import decode.p25.reference.LinkControlOpcode; import decode.p25.reference.Service; public class AdjacentSiteStatusBroadcast extends TDULinkControlMessage - implements IdentifierProviderReceiver + implements IdentifierReceiver { private final static Logger mLog = LoggerFactory.getLogger( AdjacentSiteStatusBroadcast.class ); diff --git a/src/decode/p25/message/tdu/lc/GroupVoiceChannelUpdate.java b/src/decode/p25/message/tdu/lc/GroupVoiceChannelUpdate.java index f70dbfad..57d1b55f 100644 --- a/src/decode/p25/message/tdu/lc/GroupVoiceChannelUpdate.java +++ b/src/decode/p25/message/tdu/lc/GroupVoiceChannelUpdate.java @@ -4,11 +4,11 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; import decode.p25.message.IdentifierProvider; -import decode.p25.message.tsbk.osp.control.IdentifierProviderReceiver; +import decode.p25.message.IdentifierReceiver; import decode.p25.reference.LinkControlOpcode; public class GroupVoiceChannelUpdate extends TDULinkControlMessage - implements IdentifierProviderReceiver + implements IdentifierReceiver { private final static Logger mLog = LoggerFactory.getLogger( GroupVoiceChannelUpdate.class ); diff --git a/src/decode/p25/message/tdu/lc/GroupVoiceChannelUpdateExplicit.java b/src/decode/p25/message/tdu/lc/GroupVoiceChannelUpdateExplicit.java index 194647e0..ba857730 100644 --- a/src/decode/p25/message/tdu/lc/GroupVoiceChannelUpdateExplicit.java +++ b/src/decode/p25/message/tdu/lc/GroupVoiceChannelUpdateExplicit.java @@ -4,13 +4,13 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; import decode.p25.message.IdentifierProvider; +import decode.p25.message.IdentifierReceiver; import decode.p25.message.P25Message.DuplexMode; import decode.p25.message.P25Message.SessionMode; -import decode.p25.message.tsbk.osp.control.IdentifierProviderReceiver; import decode.p25.reference.LinkControlOpcode; public class GroupVoiceChannelUpdateExplicit extends TDULinkControlMessage - implements IdentifierProviderReceiver + implements IdentifierReceiver { private final static Logger mLog = LoggerFactory.getLogger( GroupVoiceChannelUpdateExplicit.class ); diff --git a/src/decode/p25/message/tdu/lc/NetworkStatusBroadcast.java b/src/decode/p25/message/tdu/lc/NetworkStatusBroadcast.java index afdeb88d..317c7d12 100644 --- a/src/decode/p25/message/tdu/lc/NetworkStatusBroadcast.java +++ b/src/decode/p25/message/tdu/lc/NetworkStatusBroadcast.java @@ -4,12 +4,12 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; import decode.p25.message.IdentifierProvider; -import decode.p25.message.tsbk.osp.control.IdentifierProviderReceiver; +import decode.p25.message.IdentifierReceiver; import decode.p25.reference.LinkControlOpcode; import decode.p25.reference.Service; public class NetworkStatusBroadcast extends TDULinkControlMessage - implements IdentifierProviderReceiver + implements IdentifierReceiver { private final static Logger mLog = LoggerFactory.getLogger( NetworkStatusBroadcast.class ); diff --git a/src/decode/p25/message/tdu/lc/NetworkStatusBroadcastExplicit.java b/src/decode/p25/message/tdu/lc/NetworkStatusBroadcastExplicit.java index b4604c72..17d466d1 100644 --- a/src/decode/p25/message/tdu/lc/NetworkStatusBroadcastExplicit.java +++ b/src/decode/p25/message/tdu/lc/NetworkStatusBroadcastExplicit.java @@ -4,12 +4,12 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; import decode.p25.message.IdentifierProvider; -import decode.p25.message.tsbk.osp.control.IdentifierProviderReceiver; +import decode.p25.message.IdentifierReceiver; import decode.p25.reference.LinkControlOpcode; import decode.p25.reference.Service; public class NetworkStatusBroadcastExplicit extends TDULinkControlMessage - implements IdentifierProviderReceiver + implements IdentifierReceiver { private final static Logger mLog = LoggerFactory.getLogger( NetworkStatusBroadcastExplicit.class ); diff --git a/src/decode/p25/message/tdu/lc/RFSSStatusBroadcast.java b/src/decode/p25/message/tdu/lc/RFSSStatusBroadcast.java index d973655b..3364a62b 100644 --- a/src/decode/p25/message/tdu/lc/RFSSStatusBroadcast.java +++ b/src/decode/p25/message/tdu/lc/RFSSStatusBroadcast.java @@ -4,12 +4,12 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; import decode.p25.message.IdentifierProvider; -import decode.p25.message.tsbk.osp.control.IdentifierProviderReceiver; +import decode.p25.message.IdentifierReceiver; import decode.p25.message.tsbk.osp.control.SystemService; import decode.p25.reference.LinkControlOpcode; public class RFSSStatusBroadcast extends TDULinkControlMessage - implements IdentifierProviderReceiver + implements IdentifierReceiver { private final static Logger mLog = LoggerFactory.getLogger( RFSSStatusBroadcast.class ); diff --git a/src/decode/p25/message/tdu/lc/RFSSStatusBroadcastExplicit.java b/src/decode/p25/message/tdu/lc/RFSSStatusBroadcastExplicit.java index bce824ac..c4cfe45d 100644 --- a/src/decode/p25/message/tdu/lc/RFSSStatusBroadcastExplicit.java +++ b/src/decode/p25/message/tdu/lc/RFSSStatusBroadcastExplicit.java @@ -4,12 +4,12 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; import decode.p25.message.IdentifierProvider; -import decode.p25.message.tsbk.osp.control.IdentifierProviderReceiver; +import decode.p25.message.IdentifierReceiver; import decode.p25.message.tsbk.osp.control.SystemService; import decode.p25.reference.LinkControlOpcode; public class RFSSStatusBroadcastExplicit extends TDULinkControlMessage - implements IdentifierProviderReceiver + implements IdentifierReceiver { private final static Logger mLog = LoggerFactory.getLogger( RFSSStatusBroadcastExplicit.class ); diff --git a/src/decode/p25/message/tdu/lc/SecondaryControlChannelBroadcast.java b/src/decode/p25/message/tdu/lc/SecondaryControlChannelBroadcast.java index 906ad67d..3170a3c0 100644 --- a/src/decode/p25/message/tdu/lc/SecondaryControlChannelBroadcast.java +++ b/src/decode/p25/message/tdu/lc/SecondaryControlChannelBroadcast.java @@ -4,12 +4,12 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; import decode.p25.message.IdentifierProvider; -import decode.p25.message.tsbk.osp.control.IdentifierProviderReceiver; +import decode.p25.message.IdentifierReceiver; import decode.p25.message.tsbk.osp.control.SystemService; import decode.p25.reference.LinkControlOpcode; public class SecondaryControlChannelBroadcast extends TDULinkControlMessage - implements IdentifierProviderReceiver + implements IdentifierReceiver { private final static Logger mLog = LoggerFactory.getLogger( SecondaryControlChannelBroadcast.class ); diff --git a/src/decode/p25/message/tdu/lc/SecondaryControlChannelBroadcastExplicit.java b/src/decode/p25/message/tdu/lc/SecondaryControlChannelBroadcastExplicit.java index 1fa58744..efa6657b 100644 --- a/src/decode/p25/message/tdu/lc/SecondaryControlChannelBroadcastExplicit.java +++ b/src/decode/p25/message/tdu/lc/SecondaryControlChannelBroadcastExplicit.java @@ -4,12 +4,12 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; import decode.p25.message.IdentifierProvider; -import decode.p25.message.tsbk.osp.control.IdentifierProviderReceiver; +import decode.p25.message.IdentifierReceiver; import decode.p25.message.tsbk.osp.control.SystemService; import decode.p25.reference.LinkControlOpcode; public class SecondaryControlChannelBroadcastExplicit - extends TDULinkControlMessage implements IdentifierProviderReceiver + extends TDULinkControlMessage implements IdentifierReceiver { private final static Logger mLog = LoggerFactory.getLogger( SecondaryControlChannelBroadcastExplicit.class ); diff --git a/src/decode/p25/message/tsbk/ChannelGrant.java b/src/decode/p25/message/tsbk/ChannelGrant.java index 4e26914f..ae1475e0 100644 --- a/src/decode/p25/message/tsbk/ChannelGrant.java +++ b/src/decode/p25/message/tsbk/ChannelGrant.java @@ -3,11 +3,11 @@ package decode.p25.message.tsbk; import alias.AliasList; import bits.BitSetBuffer; import decode.p25.message.IdentifierProvider; -import decode.p25.message.tsbk.osp.control.IdentifierProviderReceiver; +import decode.p25.message.IdentifierReceiver; import decode.p25.reference.DataUnitID; public abstract class ChannelGrant extends ServiceMessage - implements IdentifierProviderReceiver + implements IdentifierReceiver { public static final int[] PRIORITY = { 85,86,87 }; public static final int[] CHANNEL_IDENTIFIER = { 88,89,90,91 }; diff --git a/src/decode/p25/message/tsbk/GroupMultiChannelGrant.java b/src/decode/p25/message/tsbk/GroupMultiChannelGrant.java index e07427e5..5561d3fb 100644 --- a/src/decode/p25/message/tsbk/GroupMultiChannelGrant.java +++ b/src/decode/p25/message/tsbk/GroupMultiChannelGrant.java @@ -3,11 +3,11 @@ package decode.p25.message.tsbk; import alias.AliasList; import bits.BitSetBuffer; import decode.p25.message.IdentifierProvider; -import decode.p25.message.tsbk.osp.control.IdentifierProviderReceiver; +import decode.p25.message.IdentifierReceiver; import decode.p25.reference.DataUnitID; public abstract class GroupMultiChannelGrant extends ChannelGrant - implements IdentifierProviderReceiver + implements IdentifierReceiver { public static final int[] CHANNEL_IDENTIFIER_1 = { 80,81,82,83 }; public static final int[] CHANNEL_NUMBER_1 = { 84,85,86,87, diff --git a/src/decode/p25/message/tsbk/motorola/ChannelCWIDUpdate.java b/src/decode/p25/message/tsbk/motorola/ChannelCWIDUpdate.java index 5d126d03..640c8c5a 100644 --- a/src/decode/p25/message/tsbk/motorola/ChannelCWIDUpdate.java +++ b/src/decode/p25/message/tsbk/motorola/ChannelCWIDUpdate.java @@ -3,11 +3,11 @@ package decode.p25.message.tsbk.motorola; import alias.AliasList; import bits.BitSetBuffer; import decode.p25.message.IdentifierProvider; -import decode.p25.message.tsbk.osp.control.IdentifierProviderReceiver; +import decode.p25.message.IdentifierReceiver; import decode.p25.reference.DataUnitID; public class ChannelCWIDUpdate extends MotorolaTSBKMessage - implements IdentifierProviderReceiver + implements IdentifierReceiver { public static final int[] CHARACTER_1 = { 80,81,82,83,84,85 }; public static final int[] CHARACTER_2 = { 86,87,88,89,90,91 }; diff --git a/src/decode/p25/message/tsbk/osp/control/AdjacentStatusBroadcast.java b/src/decode/p25/message/tsbk/osp/control/AdjacentStatusBroadcast.java index ae688465..9a50acba 100644 --- a/src/decode/p25/message/tsbk/osp/control/AdjacentStatusBroadcast.java +++ b/src/decode/p25/message/tsbk/osp/control/AdjacentStatusBroadcast.java @@ -3,11 +3,12 @@ package decode.p25.message.tsbk.osp.control; import alias.AliasList; import bits.BitSetBuffer; import decode.p25.message.IdentifierProvider; +import decode.p25.message.IdentifierReceiver; import decode.p25.message.tsbk.TSBKMessage; import decode.p25.reference.DataUnitID; import decode.p25.reference.Opcode; -public class AdjacentStatusBroadcast extends TSBKMessage implements IdentifierProviderReceiver +public class AdjacentStatusBroadcast extends TSBKMessage implements IdentifierReceiver { public static final int[] LOCATION_REGISTRATION_AREA = { 80,81,82,83,84,85, 86,87 }; diff --git a/src/decode/p25/message/tsbk/osp/control/IdentifierProviderReceiver.java b/src/decode/p25/message/tsbk/osp/control/IdentifierProviderReceiver.java deleted file mode 100644 index e93db470..00000000 --- a/src/decode/p25/message/tsbk/osp/control/IdentifierProviderReceiver.java +++ /dev/null @@ -1,15 +0,0 @@ -package decode.p25.message.tsbk.osp.control; - -import decode.p25.message.IdentifierProvider; - -/** - * Interface to allow messages to be augmented with IdentiferUpdateXXX type - * messages that provide the channel information necessary to calculate the - * uplink and downlink frequency for the channel. - */ -public interface IdentifierProviderReceiver -{ - public void setIdentifierMessage( int identifier, IdentifierProvider message ); - - public int[] getIdentifiers(); -} diff --git a/src/decode/p25/message/tsbk/osp/control/NetworkStatusBroadcast.java b/src/decode/p25/message/tsbk/osp/control/NetworkStatusBroadcast.java index cd21e449..0fe58369 100644 --- a/src/decode/p25/message/tsbk/osp/control/NetworkStatusBroadcast.java +++ b/src/decode/p25/message/tsbk/osp/control/NetworkStatusBroadcast.java @@ -3,12 +3,13 @@ package decode.p25.message.tsbk.osp.control; import alias.AliasList; import bits.BitSetBuffer; import decode.p25.message.IdentifierProvider; +import decode.p25.message.IdentifierReceiver; import decode.p25.message.tsbk.TSBKMessage; import decode.p25.reference.DataUnitID; import decode.p25.reference.Opcode; import decode.p25.reference.P25NetworkCallsign; -public class NetworkStatusBroadcast extends TSBKMessage implements IdentifierProviderReceiver +public class NetworkStatusBroadcast extends TSBKMessage implements IdentifierReceiver { public static final int[] LOCATION_REGISTRATION_AREA = { 80,81,82,83,84,85, 86,87 }; diff --git a/src/decode/p25/message/tsbk/osp/control/RFSSStatusBroadcast.java b/src/decode/p25/message/tsbk/osp/control/RFSSStatusBroadcast.java index e9c960e1..db4edefa 100644 --- a/src/decode/p25/message/tsbk/osp/control/RFSSStatusBroadcast.java +++ b/src/decode/p25/message/tsbk/osp/control/RFSSStatusBroadcast.java @@ -3,11 +3,12 @@ package decode.p25.message.tsbk.osp.control; import alias.AliasList; import bits.BitSetBuffer; import decode.p25.message.IdentifierProvider; +import decode.p25.message.IdentifierReceiver; import decode.p25.message.tsbk.TSBKMessage; import decode.p25.reference.DataUnitID; import decode.p25.reference.Opcode; -public class RFSSStatusBroadcast extends TSBKMessage implements IdentifierProviderReceiver +public class RFSSStatusBroadcast extends TSBKMessage implements IdentifierReceiver { public static final int[] LOCATION_REGISTRATION_AREA = { 80,81,82,83,84,85, 86,87 }; diff --git a/src/decode/p25/message/tsbk/osp/control/SecondaryControlChannelBroadcast.java b/src/decode/p25/message/tsbk/osp/control/SecondaryControlChannelBroadcast.java index 1d58d1be..e8c8511d 100644 --- a/src/decode/p25/message/tsbk/osp/control/SecondaryControlChannelBroadcast.java +++ b/src/decode/p25/message/tsbk/osp/control/SecondaryControlChannelBroadcast.java @@ -6,12 +6,13 @@ import org.slf4j.LoggerFactory; import alias.AliasList; import bits.BitSetBuffer; import decode.p25.message.IdentifierProvider; +import decode.p25.message.IdentifierReceiver; import decode.p25.message.tsbk.TSBKMessage; import decode.p25.reference.DataUnitID; import decode.p25.reference.Opcode; public class SecondaryControlChannelBroadcast extends TSBKMessage - implements IdentifierProviderReceiver, Comparable + implements IdentifierReceiver, Comparable { private final static Logger mLog = LoggerFactory.getLogger( SecondaryControlChannelBroadcast.class ); diff --git a/src/decode/p25/message/tsbk/osp/data/SNDCPDataChannelAnnouncementExplicit.java b/src/decode/p25/message/tsbk/osp/data/SNDCPDataChannelAnnouncementExplicit.java index 4929cead..8d11c1ba 100644 --- a/src/decode/p25/message/tsbk/osp/data/SNDCPDataChannelAnnouncementExplicit.java +++ b/src/decode/p25/message/tsbk/osp/data/SNDCPDataChannelAnnouncementExplicit.java @@ -3,11 +3,11 @@ package decode.p25.message.tsbk.osp.data; import alias.AliasList; import bits.BitSetBuffer; import decode.p25.message.IdentifierProvider; -import decode.p25.message.tsbk.osp.control.IdentifierProviderReceiver; +import decode.p25.message.IdentifierReceiver; import decode.p25.reference.DataUnitID; public class SNDCPDataChannelAnnouncementExplicit extends SNDCPData - implements IdentifierProviderReceiver + implements IdentifierReceiver { public static final int AUTONOMOUS_ACCESS_AVAILABLE_INDICATOR = 88; public static final int REQUESTED_ACCESS_AVAILABLE_INDICATOR = 89; diff --git a/src/decode/p25/message/tsbk/osp/data/SNDCPDataChannelGrant.java b/src/decode/p25/message/tsbk/osp/data/SNDCPDataChannelGrant.java index ce2abe4d..2affb5f1 100644 --- a/src/decode/p25/message/tsbk/osp/data/SNDCPDataChannelGrant.java +++ b/src/decode/p25/message/tsbk/osp/data/SNDCPDataChannelGrant.java @@ -3,10 +3,10 @@ package decode.p25.message.tsbk.osp.data; import alias.AliasList; import bits.BitSetBuffer; import decode.p25.message.IdentifierProvider; -import decode.p25.message.tsbk.osp.control.IdentifierProviderReceiver; +import decode.p25.message.IdentifierReceiver; import decode.p25.reference.DataUnitID; -public class SNDCPDataChannelGrant extends SNDCPData implements IdentifierProviderReceiver +public class SNDCPDataChannelGrant extends SNDCPData implements IdentifierReceiver { public static final int[] TRANSMIT_IDENTIFIER = { 88,89,90,91 }; public static final int[] TRANSMIT_NUMBER = { 92,93,94,95,96,97,98,99,100,