laurentiu.constantin/SafeDispatch
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
refactor_code3
SafeDispatch/MotoRepeaterCore/Wireline.cs

2685 lines
129 KiB
C#
Raw Permalink Normal View History

first version
2024-02-22 16:43:59 +00:00
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Net.Sockets;
using System.Net;
using System.Runtime.Caching;
using SafeMobileLib;
namespace MotoRepeater
{
public class Wireline
{
// all available operations
public enum Operations
{
WL_REGISTRATION_REQUEST = 0x01,
WL_REGISTRATION_STATUS = 0x02,
WL_REGISTRATION_GENERAL_OPS = 0x03,
WL_PROTOCOL_VERSION_QUERY = 0x04,
WL_PROTOCOL_VERSION_QUERY_RESPONSE = 0x05,
WL_CHNL_STATUS = 0x11,
WL_CHNL_STATUS_QUERY = 0x12,
WL_VC_CHNL_CTRL_REQUEST = 0x13,
WL_VC_CHNL_CTRL_STATUS = 0x16,
WL_VC_CSBK_CALL = 0x17,
WL_VC_VOICE_START = 0x18,
WL_VC_VOICE_END_BURST = 0X19,
WL_VC_CALL_SESSION_STATUS = 0x20,
WL_VC_VOICE_BURST = 0x21,
WL_VC_PRIVACY_BURST = 0X22
};
private static byte[] AuthenticationID = new byte[] { 0x01, 0x02, 0x00, 0x6E };
private static byte[] VendorKey = new byte[] { 0x85, 0x8a, 0x5e, 0xa6, 0x8c, 0xf9, 0xa9, 0x7f, 0x49, 0xc7,
0x10, 0x87, 0xe7, 0xf2, 0xb4, 0x64, 0xd5, 0x9c, 0x52, 0x5d };
private static byte[] AuthenticationKey = new byte[] { 0x00 }; // set by the user in the repeater
private static byte[] AuthenticationSignatureKey = new byte[40];
/* System variables */
private Thread wirelineHandlerThread;
public int majorWirelineProtocolVersion = 3;
public byte wirelineProtocolVersion = 0x00;
private bool isWirelineRegistered = false;
private SlotNumber currentSlot = SlotNumber.BothSlots;
private LinkEstablishment le;
/* CRT CALL VARIABLES */
private CSBKCall crtCSBKCallStausSlot1 = new CSBKCall();
private CSBKCall crtCSBKCallStausSlot2 = new CSBKCall();
// store the previous burst type in order to add the missing frames
private int previousBrustTypeSlot1 = 0x06;
private int previousBrustTypeSlot2 = 0x06;
private byte currentWirelineProtocolVersion = 0x00;
private byte oldestWirelineProtocolVersion = 0x00;
private MemoryCache mem = new MemoryCache("MotoTRBOCache");
public Wireline(LinkEstablishment linkEstablishment)
{
this.le = linkEstablishment;
le.OnRegistrationResponseReceived += new LinkEstablishment.RegistrationResponseDEl(le_OnRegistrationResponseReceived);
le.OnWirelineMessageReceived += new LinkEstablishment.WirelineMessageReceivedDEl(le_OnWirelineMessageReceived);
this.OnRadioStatusChanged += new RadioStatusChangedDEl(Wireline_OnRadioStatusChanged);
this.OnCSBKCallReceived += new CSBKCallReceivedDEl(Wireline_OnCSBKCallReceived);
this.OnChannelControlStatusReceived += new ChannelControlStatusReceivedDel(Wireline_OnChannelControlStatusReceived);
this.OnCallSesionStatusReceived += new CallSessionStatusReceivedDEl(Wireline_OnCallSesionStatusReceived);
SetCurrentAndOldestWirelineProtocolVersion();
GenerateAuthenticationSignatureKey();
/* TEST WITH THE VALUES FROM MOTOROLA
AuthenticationID = new byte[] { 0x01, 0x01, 0x00, 0x2A };
VendorKey = new byte[] { 0xcf, 0xd0, 0x25, 0xcb, 0x75, 0x60, 0xdb, 0x13, 0x5d, 0x70,
0x2a, 0x20, 0x1e, 0x65, 0xd0, 0x30, 0x9f, 0xd2, 0xb3, 0xb2 };
//AuthenticationKey = new byte[] { 0xAB, 0xCD }; // set by the user
//AuthenticationSignatureKey = new byte[40];
GenerateAuthenticationSignatureKey();
byte[] pdu;
byte[] restp = AddWirelineSignatureKey(
pdu = new byte[] { 0xb2, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x94, 0xb8, 0xcf, 0x00, 0x00, 0x01, 0x00, 0x01,
0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x80, 0x04, 0x04}
);
//*/
}
/* When a new Wireline Message is received by the Link Establishment */
void le_OnWirelineMessageReceived(byte[] received, string peerIP, Int32 peerPort)
{
try
{
decode(received, peerIP, peerPort);
}
catch (Exception ex)
{
Console.Write("\n\n " + ex.ToString());
}
}
void le_OnRegistrationResponseReceived(bool isValid)
{
if (isValid)
{
Utils.WriteLine("LE Registered. Starting Wireline registration...");
List<RegEntry> regEntries = new List<RegEntry>();
regEntries.Add(new RegEntry(AddressType.AllIndividualCall, 1, 16777215));
regEntries.Add(new RegEntry(AddressType.AllTalkgroupCall, 1, 16777215));
regEntries.Add(new RegEntry(AddressType.AllLocalTalkgroupsCall, 1, 16777215));
regEntries.Add(new RegEntry(AddressType.AllWideTakgroupsCall, 1, 16777215));
//reg.regEntriesList.Add(new RegEntry(AddressType.GroupCall, 1, 1024));
Register(le.GetRegisteredSlots(), regEntries);
//le.SendLEMessage(createWirelineMessage(Operations.WL_REGISTRATION_REQUEST, reg));
}
}
// set the current and oldest wireline Protocol Version
private void SetCurrentAndOldestWirelineProtocolVersion()
{
// clear previous values
currentWirelineProtocolVersion = 0x00;
oldestWirelineProtocolVersion = 0x00;
// create two 'bit' arrays for System ID and Protocol Version
bool[] systemID = new bool[6];
bool[] protocolVers = new bool[10];
bool[] oldestProtocolVers = new bool[10];
switch (le.systemType)
{
case MotoRepeater.LinkEstablishment.SystemType.IP_SITE_CONNECT:
{
systemID = new bool[] { false, false, false, false, false, true };
break;
}
case MotoRepeater.LinkEstablishment.SystemType.CAPACITY_PLUS:
{
systemID = new bool[] { false, false, false, false, true, false };
break;
}
case MotoRepeater.LinkEstablishment.SystemType.LINKED_CAPACITY_PLUS:
{
systemID = new bool[] { false, false, false, true, false, false };
break;
}
}
switch (le.releaseNumber)
{
case MotoRepeater.LinkEstablishment.SystemReleaseNumber.R23A:
{
majorWirelineProtocolVersion = 3;
wirelineProtocolVersion = 0x0C; // 0b00000100
break;
}
case MotoRepeater.LinkEstablishment.SystemReleaseNumber.R23:
case MotoRepeater.LinkEstablishment.SystemReleaseNumber.R22:
{
majorWirelineProtocolVersion = 1;
wirelineProtocolVersion = 0x04; // 0b00001100
break;
}
}
currentWirelineProtocolVersion = wirelineProtocolVersion;
oldestWirelineProtocolVersion = 0x04;
}
// function which will generate the authentication Signature KEY which is used as HMAC-SHA1 key for
// generating the Authentication Signature bytes which are added to each Call Control Wireline Messages
private void GenerateAuthenticationSignatureKey()
{
List<byte> authSign = new List<byte>();
authSign.AddRange(VendorKey);
// padd with zeros
for (int i = 0; i < 20 - AuthenticationKey.Length; i++)
{
authSign.Add(0x00);
}
foreach (byte by in AuthenticationKey)
authSign.Add(by);
// save the authentication signature key which is compute from the Vendor Key and Authentication Key
AuthenticationSignatureKey = authSign.ToArray();
}
/// <summary>
/// Returns the byte array which needs to be send, already containing the wireline authentication signature
/// </summary>
/// <param name="wirelineMessage">the byte array which will be used used for genereting the Wireline Signature Key</param>
/// <returns>A byte array containing the original byte array followed by the Authentication ID [Motorola Provided] and
/// the Authentication Signature Key [Generated using HMACSha1 algoritm]</returns>
private byte[] AddWirelineSignatureKey(byte[] wirelineMessage)
{
// encrypts the wireline messages using Authentication Signature as the key
System.Security.Cryptography.HMACSHA1 hmacSha1 = new System.Security.Cryptography.HMACSHA1(AuthenticationSignatureKey);
hmacSha1.ComputeHash(wirelineMessage);
// trim the authentication signature to only 10 bytes
byte[] truncatedAuthenticationSignature = new byte[10];
for (int i = 0; i < 10; i++)
truncatedAuthenticationSignature[i] = hmacSha1.Hash[i];
// add Authentication Key and Authentication Signature to the end of the wireline message
List<byte> resp = new List<byte>(wirelineMessage);
resp.AddRange(AuthenticationID);
resp.AddRange(truncatedAuthenticationSignature);
// return the complete wireline message
return resp.ToArray();
}
#region WIRELINE MESSAGES
/// <summary>
/// Wireline registration procedure. This procedure creats the wireline message which will be sent to the
/// repeater in order to create the wireline registration
/// </summary>
/// <param name="slot">The slot on which the wireline registration is required</param>
/// <param name="regEntriesList">The list of entries for which the call messages will be received and parsed</param>
public void Register(SlotNumber slot, List<RegEntry> regEntriesList)
{
// create a wireline registration object and populate it with the required values
WirelineRegistration reg = new WirelineRegistration();
reg.slotNumber = slot;
reg.wirelineChannelStatus = Wireline.WirelineChannelStatus.NotRegisteredWLStatus;
// copy all registry
foreach (RegEntry regEntry in regEntriesList)
reg.regEntriesList.Add(regEntry);
// add Authentication Signature to the wireline message
byte[] toSend = AddWirelineSignatureKey(createWirelineMessage(Operations.WL_REGISTRATION_REQUEST, reg));
// send wireline message to the repeater
SendWirelineMessage(toSend);
}
/// <summary>
/// Deregister a prior registration on a desired slot
/// </summary>
/// <param name="slot">The slot on which the wireline registration was done</param>
public void DeRegister(SlotNumber slot)
{
WirelineQueryRegistration queryReg = new WirelineQueryRegistration();
queryReg.regOpCode = RegistrationOperationCode.DeRegister;
queryReg.slotNumber = slot;
// add Authentication Signature to the wireline message
byte[] toSend = AddWirelineSignatureKey(createWirelineMessage(Operations.WL_REGISTRATION_GENERAL_OPS, queryReg));
// send wireline message to the repeater
SendWirelineMessage(toSend);
}
// query a prior registration to find out the Identifier of the registration
public void QueryRegistration(SlotNumber slot)
{
WirelineQueryRegistration queryReg = new WirelineQueryRegistration();
queryReg.regOpCode = RegistrationOperationCode.QueryRegStatus;
queryReg.slotNumber = slot;
// add Authentication Signature to the wireline message
byte[] toSend = AddWirelineSignatureKey(createWirelineMessage(Operations.WL_REGISTRATION_GENERAL_OPS, queryReg));
SendWirelineMessage(toSend);
}
// check what protocol version is supported by the repeater
public void ProtocolVersionQuery()
{
// add Authentication Signature to the wireline message
byte[] toSend = AddWirelineSignatureKey(createWirelineMessage(Operations.WL_PROTOCOL_VERSION_QUERY, null));
SendWirelineMessage(toSend);
}
// request status from the repeater about the rest channel or conventional channel
// depending on the system type
public void ChannelStatusReq(SlotNumber slot)
{
CSBKCall call = new CSBKCall();
call.slotNumber = slot;
// add Authentication Signature to the wireline message
byte[] toSend = AddWirelineSignatureKey(createWirelineMessage(Operations.WL_CHNL_STATUS_QUERY, call));
SendWirelineMessage(toSend);
}
#region ENABLE/DISABLE
/// <summary>
/// Enable a radio on a specific slot
/// </summary>
/// <param name="radioID">The radio ID of the unit which needs to be enabled</param>
/// <param name="slot">Slot number on which the request will be sent</param>
public void EnableRadioOnSlot(Int64 radioID, SlotNumber slot)
{
CSBKCall call = new CSBKCall();
call.slotNumber = slot;
call.callType = CallType.RadioUninhibitRequest;
call.sourceID = le.myselfPeer.peerID;
call.targetID = radioID;
// add Authentication Signature to the wireline message
byte[] toSend = AddWirelineSignatureKey(createWirelineMessage(Operations.WL_VC_CHNL_CTRL_REQUEST, call));
SendWirelineMessage(toSend);
}
/// <summary>
/// Enable a radio on the current slot
/// </summary>
/// <param name="radioID">The radio ID of the unit which needs to be enabled</param>
public void EnableRadio(Int64 radioID)
{
EnableRadioOnSlot(radioID, GetCurrentSlot());
}
/// <summary>
/// Disable a radio on a specific slot
/// </summary>
/// <param name="radioID">The radio ID of the unit which needs to be disabled</param>
/// <param name="slot">Slot number on which the request will be sent</param>
public void DisableRadioOnSlot(Int64 radioID, SlotNumber slot)
{
CSBKCall call = new CSBKCall();
call.slotNumber = slot;
call.callType = CallType.RadioInhibitRequest;
call.sourceID = le.myselfPeer.peerID;
call.targetID = radioID;
// add Authentication Signature to the wireline message
byte[] toSend = AddWirelineSignatureKey(createWirelineMessage(Operations.WL_VC_CHNL_CTRL_REQUEST, call));
// if thread allready exists I should send the commnad only once
if (mem.Contains(String.Format("{0}.{1}", radioID, slot)))
{
// get the thread and reset the counter to 0
//Thread running = (Thread)mem.Get(String.Format("{0}.{1}", radioID, slot));
return;
}
// create a thread which will resend the message after 3 seconds
Thread p = new Thread(() =>
{
// save the message which needs to be sent
byte[] toSendd = (byte[])toSend.Clone();
Int64 radioIDD = radioID;
SlotNumber slott = slot;
int count = 0;
// run this procedure for three times or while the answer is received from the repeater
while (mem.Contains(String.Format("{0}.{1}", radioID, slot)))
{
Thread.CurrentThread.IsBackground = true;
// send wireline message each 3 seconds
if (count++ % 30 == 0)
{
//Utils.WriteLine(String.Format("Thread {0}.{1} is alive", radioID, slot));
SendWirelineMessage(toSendd);
}
Thread.Sleep(100); // sleep 100 ms
}
//Utils.WriteLine(String.Format("Thread {0}.{1} ended", radioID, slot));
});
p.Name = String.Format("{0}.{1}", radioID, slot);
p.Start();
// add thread to the memory cache and set live duration to 10 seconds
mem.Add(p.Name, p, new CacheItemPolicy() { AbsoluteExpiration = DateTime.UtcNow.AddSeconds(10) });
}
/// <summary>
/// Disable a radio on the current slot
/// </summary>
/// <param name="radioID">The radio ID of the unit which needs to be disabled</param>
public void DisableRadio(Int64 radioID)
{
DisableRadioOnSlot(radioID, GetCurrentSlot());
}
/// <summary>
/// Event Callback for when a radio changes its status to Enable or Disable.
/// This callback will have to remove the thread that sends the Inhibit [disable] request from memCache
/// </summary>
/// <param name="radioID">The radio which changed its status</param>
/// <param name="slot">The slot on which the radio had reported</param>
/// <param name="isEnabled">The radio state. Will be true if the radio is Enabled or false otherwise</param>
void Wireline_OnRadioStatusChanged(long radioID, Wireline.SlotNumber slot, bool isEnabled)
{
// close the thread which sends the Inhibit [disble] command, if exists
if (!isEnabled && mem.Contains(String.Format("{0}.{1}", radioID, slot)))
{
mem.Remove(String.Format("{0}.{1}", radioID, slot));
}
}
/// <summary>
/// Acknowledge an emergency received from a field radio on the current selected slot
/// </summary>
/// <param name="radioID">The field radio which had sent the emergency</param>
public void EmergencyAck(Int64 radioID)
{
EmergencyACKOnSlot(radioID, GetCurrentSlot());
}
/// <summary>
/// Acknowledge an emergency received from a field radio
/// </summary>
/// <param name="radioID">The field radio which had sent the emergency</param>
/// <param name="slot">The slot on which the request will be sent</param>
public void EmergencyACKOnSlot(Int64 radioID, SlotNumber slot)
{
// response to Emergency with Emerg ACK
CSBKCall csbkCall = new CSBKCall();
csbkCall.slotNumber = slot;
csbkCall.sourceID = le.myselfPeer.peerID;
csbkCall.targetID = radioID;
csbkCall.callType = CallType.EmergencyCSBKAlertResponse;
this.SendWirelineMessage(AddWirelineSignatureKey(createWirelineMessage(Operations.WL_VC_CHNL_CTRL_REQUEST, csbkCall)));
}
#endregion
#region CALL
/// <summary>
/// Initiate a private call on the specified slot
/// </summary>
/// <param name="radioID">The radio ID of the field station which needs to be called</param>
/// <param name="slot">Slot number on which the request will be sent</param>
public void InitiatePrivateCallOnSlot(Int64 radioID, SlotNumber slot)
{
CSBKCall call = new CSBKCall();
call.callType = CallType.PrivateCallRequest;
call.preambleDuration = PreambleDuration.BurstDurationMS;
call.preambleValue = 0x03;
call.slotNumber = slot;
call.sourceID = (slot == SlotNumber.Slot1 ? le.myselfPeer.slot1ID : le.myselfPeer.slot2ID);
call.targetID = radioID;
if ((slot == SlotNumber.Slot1 && crtCSBKCallStausSlot1 != null) ||
(slot == SlotNumber.Slot2 && crtCSBKCallStausSlot2 != null))
{
// save current call parameters
crtCSBKCallStausSlot1 = call;
// add Authentication Signature to the wireline message
byte[] toSend = AddWirelineSignatureKey(createWirelineMessage(Operations.WL_VC_CHNL_CTRL_REQUEST, call));
SendWirelineMessage(toSend);
}
}
public void InitiatePrivateCallOnSlotAfterPreamble(Int64 radioID, SlotNumber slot)
{
CSBKCall call = new CSBKCall();
call.callType = CallType.PrivateCallResponse;
call.preambleDuration = PreambleDuration.BurstDurationMS;
call.preambleValue = 0x03;
call.slotNumber = slot;
call.sourceID = (slot == SlotNumber.Slot1 ? le.myselfPeer.slot1ID : le.myselfPeer.slot2ID);
call.targetID = radioID;
call.callAttributes = CallAttributes.SmartAfterPreamble;
if ((slot == SlotNumber.Slot1 && crtCSBKCallStausSlot1 != null) ||
(slot == SlotNumber.Slot2 && crtCSBKCallStausSlot2 != null))
{
// save current call parameters
crtCSBKCallStausSlot1 = call;
// add Authentication Signature to the wireline message
byte[] toSend = AddWirelineSignatureKey(createWirelineMessage(Operations.WL_VC_CHNL_CTRL_REQUEST, call));
SendWirelineMessage(toSend);
}
}
/// <summary>
/// Terminate a private call on the specified slot
/// </summary>
/// <param name="radioID">The radio ID of the field station which needs to end the call</param>
/// <param name="slot">Slot number on which the request will be sent</param>
public void EndPrivateCallOnSlot(Int64 radioID, SlotNumber slot)
{
CSBKCall call = new CSBKCall();
call.callType = CallType.PrivateCallRequest;
call.preambleDuration = PreambleDuration.BurstDurationMS;
call.preambleValue = 0x03;
call.slotNumber = slot;
call.sourceID = slot == SlotNumber.Slot1 ? le.myselfPeer.slot1ID : le.myselfPeer.slot2ID;
call.targetID = radioID;
// add Authentication Signature to the wireline message
byte[] toSend = AddWirelineSignatureKey(createWirelineMessage(Operations.WL_VC_CHNL_CTRL_REQUEST, call));
SendWirelineMessage(toSend);
}
/// <summary>
/// Initiate a group call on the specified slot
/// </summary>
/// <param name="groupID">The group ID of the field stations which needs to be called</param>
/// <param name="slot">Slot number on which the request will be sent</param>
public void InitiateGroupCallOnSlot(Int64 groupID, SlotNumber slot)
{
CSBKCall call = new CSBKCall();
call.callType = CallType.GroupVoiceCall;
call.preambleDuration = PreambleDuration.BurstDurationMS;
call.preambleValue = 0x03;
call.slotNumber = slot;
call.sourceID = slot == SlotNumber.Slot1 ? le.myselfPeer.slot1ID : le.myselfPeer.slot2ID;
call.targetID = groupID;
// save current call parameters
crtCSBKCallStausSlot1 = call;
// add Authentication Signature to the wireline message
byte[] toSend = AddWirelineSignatureKey(createWirelineMessage(Operations.WL_VC_CHNL_CTRL_REQUEST, call));
SendWirelineMessage(toSend);
}
/// <summary>
/// Terminate a group call on the specified slot
/// </summary>
/// <param name="groupID">The group ID of the field stations which needs to end the call</param>
/// <param name="slot">Slot number on which the request will be sent</param>
public void EndGroupCallOnSlot(Int64 groupID, SlotNumber slot)
{
CSBKCall call = new CSBKCall();
call.callType = CallType.GroupVoiceCall;
call.preambleDuration = PreambleDuration.BurstDurationMS;
call.preambleValue = 0x03;
call.slotNumber = slot;
call.sourceID = slot == SlotNumber.Slot1 ? le.myselfPeer.slot1ID : le.myselfPeer.slot2ID;
call.targetID = groupID;
// add Authentication Signature to the wireline message
byte[] toSend = AddWirelineSignatureKey(createWirelineMessage(Operations.WL_VC_CHNL_CTRL_REQUEST, call));
SendWirelineMessage(toSend);
}
/// <summary>
/// Initiate an all call on the specified slot
/// </summary>
/// <param name="slot">Slot number on which the request will be sent</param>
public void InitiateAllCallOnSlot(SlotNumber slot)
{
CSBKCall call = new CSBKCall();
call.callType = CallType.AllCall;
call.preambleDuration = PreambleDuration.BurstDurationMS;
call.preambleValue = 0x03;
call.slotNumber = slot;
call.sourceID = slot == SlotNumber.Slot1 ? le.myselfPeer.slot1ID : le.myselfPeer.slot2ID;
call.targetID = 16777215;
// save current call parameters
crtCSBKCallStausSlot1 = call;
// add Authentication Signature to the wireline message
byte[] toSend = AddWirelineSignatureKey(createWirelineMessage(Operations.WL_VC_CHNL_CTRL_REQUEST, call));
SendWirelineMessage(toSend);
}
/// <summary>
/// Terminate an all call on the specified slot
/// </summary>
/// <param name="slot">Slot number on which the request will be sent</param>
public void EndAllCallOnSlot(SlotNumber slot)
{
CSBKCall call = new CSBKCall();
call.callType = CallType.AllCall;
call.preambleDuration = PreambleDuration.BurstDurationMS;
call.preambleValue = 0x03;
call.slotNumber = slot;
call.sourceID = slot == SlotNumber.Slot1 ? le.myselfPeer.slot1ID : le.myselfPeer.slot2ID;
call.targetID = 16777215;
// add Authentication Signature to the wireline message
byte[] toSend = AddWirelineSignatureKey(createWirelineMessage(Operations.WL_VC_CHNL_CTRL_REQUEST, call));
SendWirelineMessage(toSend);
}
/// <summary>
/// Event Callback for a channel control status received. The event is triggered each time a call changes
/// it's status, this is equal to channel status had changed
/// </summary>
/// <param name="sourceID">The radio ID of the field radio which had initiated the call</param>
/// <param name="targetID">The radio ID of the field radio which had been called</param>
/// <param name="callType">The type of call which is in progress/was made</param>
/// <param name="chnCtrlStatus">The status of the channel </param>
/// <param name="slot">The slot on which the call was made</param>
void Wireline_OnChannelControlStatusReceived(Int64 callID, CallType callType, ChannelControlStatus chnCtrlStatus, SlotNumber slot)
{
// call has been accepted and I can send voice as from the docs/Smart Wireshark
if (chnCtrlStatus == ChannelControlStatus.SmartInProgress)
{
Thread p = new Thread(new ThreadStart(CSBKVoiceCall));
p.Start();
}
}
/// <summary>
/// Event Callback for a call session status received. The event is triggered each time a call is transmited,
/// declined etc.
/// </summary>
/// <param name="sourceID">The radio ID of the field radio which had initiated the call</param>
/// <param name="targetID">The radio ID of the field radio which had been called</param>
/// <param name="callType">The type of call which is in progress/was made</param>
/// <param name="callSessionStatus">The status of the call on Transportation Layer</param>
/// <param name="slot">The slot on which the call was made</param>
void Wireline_OnCallSesionStatusReceived(Int64 sourceID, Int64 targertID, CallType callType, CallSessionStatus callSessionStatus, SlotNumber slot)
{
// get csbkCall for current slot number
CSBKCall crtCSBKCall = (slot == SlotNumber.Slot1 ? crtCSBKCallStausSlot1 : crtCSBKCallStausSlot2);
// I should resend the call request because the call is hanged as a result of a CSBK Preamble recieved
if (callSessionStatus == CallSessionStatus.CallHang && crtCSBKCall.isCSBKPreambleReceived)
{
switch (crtCSBKCall.callType)
{
// initiate the all call on selected slot
case CallType.AllCall:
InitiateAllCallOnSlot(slot);
break;
// initiate the group call on selected slot
case CallType.GroupVoiceCall:
InitiateGroupCallOnSlot(crtCSBKCall.targetID, slot);
break;
// initiate the private call on selected slot
case CallType.PrivateCallRequest:
InitiatePrivateCallOnSlotAfterPreamble(crtCSBKCall.targetID, slot);
break;
}
crtCSBKCall.isCSBKPreambleReceived = false;
}
}
/// <summary>
///
/// </summary>
/// <param name="callID"></param>
/// <param name="isAccepted"></param>
private void Wireline_OnCSBKCallReceived(Int64 sourceID, Int64 targetID, CallType callType, SlotNumber slot)
{
// get csbkCall for current slot number
CSBKCall crtCSBKCall = (slot == SlotNumber.Slot1 ? crtCSBKCallStausSlot1 : crtCSBKCallStausSlot2);
// flag that the Preamble CSBK was received and I can now resend the cmd when the hang status is received
crtCSBKCall.isCSBKPreambleReceived = true;
}
private void CSBKVoiceCall()
{
for(int i=0; i<30; i++)
{
CSBKCall csbkCall = new CSBKCall();
csbkCall.slotNumber = SlotNumber.Slot1;
// add Authentication Signature to the wireline message
byte[] toSend = AddWirelineSignatureKey(createWirelineMessage(Operations.WL_VC_VOICE_BURST, csbkCall));
Thread.Sleep(100);
SendWirelineMessage(toSend);
}
}
#endregion
// return the current slot number
public SlotNumber GetCurrentSlot()
{
return currentSlot;
}
public SlotNumber GetSlotNumber(int slotNumber)
{
switch (slotNumber)
{
case 1: return SlotNumber.Slot1;
case 2: return SlotNumber.Slot2;
case 3: return SlotNumber.BothSlots;
case 0:
{
if (le.systemType == LinkEstablishment.SystemType.IP_SITE_CONNECT)
return SlotNumber.SiteIPAddress;
else if (le.systemType == LinkEstablishment.SystemType.CAPACITY_PLUS)
return SlotNumber.RestChannel;
else
return SlotNumber.BothSlots;
}
default: return SlotNumber.BothSlots;
}
}
#endregion
private Int32 csbkCallParam1 = 0x7bee;
private Int32 csbkCallParam2 = 0x3178;
private Int32 csbkCallParam3 = 0x94;
private Int32 csbkCallParam4 = 0x2A;
private static int val = 0x01;
private byte[] createWirelineMessage(Operations operation, Object parameters)
{
List<byte> responseList = new List<byte>();
// opCode
responseList.Add(0xB2);
// ID of the sending peer = me
responseList.Add(BitConverter.GetBytes(le.myselfPeer.peerID)[3]);
responseList.Add(BitConverter.GetBytes(le.myselfPeer.peerID)[2]);
responseList.Add(BitConverter.GetBytes(le.myselfPeer.peerID)[1]);
responseList.Add(BitConverter.GetBytes(le.myselfPeer.peerID)[0]);
// increment registration PDU number
if (operation == Operations.WL_REGISTRATION_REQUEST ||
operation == Operations.WL_REGISTRATION_GENERAL_OPS)
WirelineRegistration.registrationPduID++;
byte[] response = { };
switch (operation)
{
#region WL_REGISTRATION_REQUEST
case Operations.WL_REGISTRATION_REQUEST:
{
WirelineRegistration wireReg = null;
try
{
// get the paramerets in the correct form
wireReg = (WirelineRegistration)parameters;
}
catch (Exception)
{
// THROW AN EXCEPTION
return new byte[0];
}
/* Wireline Operation Code*/
responseList.Add((byte)Operations.WL_REGISTRATION_REQUEST);
/* registrationSlotNumber - Only for de-register operation in SS/IPSC mode */
if (le.systemType == LinkEstablishment.SystemType.LINKED_CAPACITY_PLUS)
responseList.Add((byte)0x00);
else
responseList.Add((byte)wireReg.slotNumber);
/* registrationPduID - The identifier of the registration PDU [Uint32] */
responseList.Add(BitConverter.GetBytes(WirelineRegistration.registrationPduID)[3]);
responseList.Add(BitConverter.GetBytes(WirelineRegistration.registrationPduID)[2]);
responseList.Add(BitConverter.GetBytes(WirelineRegistration.registrationPduID)[1]);
responseList.Add(BitConverter.GetBytes(WirelineRegistration.registrationPduID)[0]);
/* registrationID - The identifier associated with the registration profile in this PDU. [Uint16] */
responseList.Add(BitConverter.GetBytes(wireReg.registrationID)[1]);
responseList.Add(BitConverter.GetBytes(wireReg.registrationID)[0]);
/* wirelineStatusRegistration - Registration flag for Wireline Channel Status [Uint8] */
responseList.Add((byte)wireReg.wirelineChannelStatus);
/* numberOfRegistrationEntries - Number of registration entries in this registration message [Uint8] */
responseList.Add((byte)wireReg.regEntriesList.Count);
foreach (RegEntry entity in wireReg.regEntriesList)
{
/* AddressType - Address type of the call being registered in this entry */
responseList.Add((byte)entity.addressType);
/* addressRangeStart - Start of radio/group addresses (CAI ID) range in this entry [Uint32] */
responseList.Add(BitConverter.GetBytes(entity.addressRangeStart)[3]);
responseList.Add(BitConverter.GetBytes(entity.addressRangeStart)[2]);
responseList.Add(BitConverter.GetBytes(entity.addressRangeStart)[1]);
responseList.Add(BitConverter.GetBytes(entity.addressRangeStart)[0]);
/* addressRangeEnd - Start of radio/group addresses (CAI ID) range in this entry [Uint32] */
responseList.Add(BitConverter.GetBytes(entity.addressRangeEnd)[3]);
responseList.Add(BitConverter.GetBytes(entity.addressRangeEnd)[2]);
responseList.Add(BitConverter.GetBytes(entity.addressRangeEnd)[1]);
responseList.Add(BitConverter.GetBytes(entity.addressRangeEnd)[0]);
/* Reserved field */
responseList.Add((byte)0x80);
/* CSBK Attributes - Attributes of CSBK Registration in this entry */
responseList.Add((byte)entity.csbkAttributes);
/* Reserved field */
responseList.Add((byte)0x00);
}
/* Current or Accepted Wireline Protocol Version */
responseList.Add(currentWirelineProtocolVersion);
responseList.Add(oldestWirelineProtocolVersion);
// convert the list of bytes to a byte array
response = new byte[responseList.Count];
for (int i = 0; i < responseList.Count; i++)
response[i] = responseList[i];
break;
}
#endregion
#region WL_REGISTRATION_GENERAL_OPS
case Operations.WL_REGISTRATION_GENERAL_OPS:
{
WirelineQueryRegistration queryReg = null;
try
{
// get the paramerets in the correct form
queryReg = (WirelineQueryRegistration)parameters;
}
catch (Exception)
{
// THROW AN EXCEPTION
return new byte[0];
}
/* Wireline Operation Code*/
responseList.Add((byte)Operations.WL_REGISTRATION_GENERAL_OPS);
/* registrationSlotNumber - Only for de-register operation in SS/IPSC mode */
if(le.systemType == LinkEstablishment.SystemType.IP_SITE_CONNECT && queryReg.regOpCode == RegistrationOperationCode.DeRegister)
responseList.Add((byte)queryReg.slotNumber);
else
responseList.Add((byte)0x00);
/* registrationPduID - The identifier of the registration PDU [Uint32] */
responseList.Add(BitConverter.GetBytes(queryReg.registrationPduID)[3]);
responseList.Add(BitConverter.GetBytes(queryReg.registrationPduID)[2]);
responseList.Add(BitConverter.GetBytes(queryReg.registrationPduID)[1]);
responseList.Add(BitConverter.GetBytes(queryReg.registrationPduID)[0]);
/* registrationOperationOpcode - The registration Operation Code [Uint8] */
responseList.Add((byte)queryReg.regOpCode);
/* Current or Accepted Wireline Protocol Version */
responseList.Add(currentWirelineProtocolVersion);
responseList.Add(oldestWirelineProtocolVersion);
// convert the list of bytes to a byte array
response = new byte[responseList.Count];
for (int i = 0; i < responseList.Count; i++)
response[i] = responseList[i];
break;
}
#endregion
#region WL_PROTOCOL_VERSION_QUERY
case Operations.WL_PROTOCOL_VERSION_QUERY:
{
/* Wireline Operation Code*/
responseList.Add((byte)Operations.WL_PROTOCOL_VERSION_QUERY);
/* Reserved field */
responseList.Add((byte)0x00);
/* query ID - ID of the protocol version query PDU. Response from the repeater
* pertaining to this message has the same Query ID value */
responseList.Add(BitConverter.GetBytes(queryID)[3]);
responseList.Add(BitConverter.GetBytes(queryID)[2]);
responseList.Add(BitConverter.GetBytes(queryID)[1]);
responseList.Add(BitConverter.GetBytes(queryID)[0]);
//increment query id
queryID++;
/* Current or Accepted Wireline Protocol Version */
responseList.Add(currentWirelineProtocolVersion);
responseList.Add(oldestWirelineProtocolVersion);
// convert the list of bytes to a byte array
response = new byte[responseList.Count];
for (int i = 0; i < responseList.Count; i++)
response[i] = responseList[i];
break;
}
#endregion
#region WL_CHNL_STATUS_QUERY
case Operations.WL_CHNL_STATUS_QUERY:
{
CSBKCall call = null;
try
{
// get the paramerets in the correct form
call = (CSBKCall)parameters;
}
catch (Exception)
{
// THROW AN EXCEPTION
return new byte[0];
}
/* Wireline Operation Code*/
responseList.Add((byte)Operations.WL_CHNL_STATUS_QUERY);
/* slot number - Specifies the channel/slot reporting the channel status.*/
responseList.Add((byte)call.slotNumber);
/* Current or Accepted Wireline Protocol Version */
responseList.Add(currentWirelineProtocolVersion);
responseList.Add(oldestWirelineProtocolVersion);
// convert the list of bytes to a byte array
response = new byte[responseList.Count];
for (int i = 0; i < responseList.Count; i++)
response[i] = responseList[i];
break;
}
#endregion
#region WL_VC_CHNL_CTRL_REQUEST
/*
* This message is sent from the third party applications to the repeater peer to initial the
* CSBK call or send CSBK call response
*/
case Operations.WL_VC_CHNL_CTRL_REQUEST:
{
CSBKCall call = null;
try
{
// get the paramerets in the correct form
call = (CSBKCall)parameters;
}
catch (Exception )
{
// THROW AN EXCEPTION
return new byte[0];
}
/* Wireline Operation Code*/
responseList.Add((byte)Operations.WL_VC_CHNL_CTRL_REQUEST);
/* slot number - Specifies the channel/slot reporting the channel status */
responseList.Add((byte)call.slotNumber);
/* call ID */
responseList.Add(BitConverter.GetBytes(call.callID)[3]);
responseList.Add(BitConverter.GetBytes(call.callID)[2]);
responseList.Add(BitConverter.GetBytes(call.callID)[1]);
responseList.Add(BitConverter.GetBytes(call.callID)[0]);
/* callType - The type of call */
responseList.Add((byte)call.callType);
/* source ID - The ID of the subscriber that initiated the call */
responseList.Add(BitConverter.GetBytes(call.sourceID)[3]);
responseList.Add(BitConverter.GetBytes(call.sourceID)[2]);
responseList.Add(BitConverter.GetBytes(call.sourceID)[1]);
responseList.Add(BitConverter.GetBytes(call.sourceID)[0]);
/* target ID - The ID of the subscriber that initiated the call */
responseList.Add(BitConverter.GetBytes(call.targetID)[3]);
responseList.Add(BitConverter.GetBytes(call.targetID)[2]);
responseList.Add(BitConverter.GetBytes(call.targetID)[1]);
responseList.Add(BitConverter.GetBytes(call.targetID)[0]);
/* accessCriteria - The priority type to access the channel */
responseList.Add((byte)call.accessCriteria);
/* callAttributes - General Call Attributes */
responseList.Add((byte)call.callAttributes);
/* Reserved field */
responseList.Add((byte)0x00);
/* preambleDuration - Only available for CSBK Call.
* The numbers of Preamble bursts send before transmission. */
if (call.preambleDuration.ToString().Contains("BurstDurationMS"))
responseList.Add((byte)call.preambleValue);
else
responseList.Add((byte)0x00);
/* Reserved field */
responseList.Add((byte)0x00);
responseList.Add((byte)0x00);
/* CSBK Arguments - Only available for CSBK call
* The arguments encoded in the DMR CSBK burst [Uint64] */
responseList.Add((byte)0x00);
responseList.Add((byte)0x00); // reserved
responseList.Add((byte)0x00);
responseList.Add((byte)0x00);
responseList.Add((byte)0x00);
responseList.Add((byte)0x00);
responseList.Add((byte)0x00);
responseList.Add((byte)0x00);
/*
responseList.Add(BitConverter.GetBytes(call.targetID)[2]);
responseList.Add(BitConverter.GetBytes(call.targetID)[1]);
responseList.Add(BitConverter.GetBytes(call.targetID)[0]);
responseList.Add(BitConverter.GetBytes(call.sourceID)[2]);
responseList.Add(BitConverter.GetBytes(call.sourceID)[1]);
responseList.Add(BitConverter.GetBytes(call.sourceID)[0]);
*/
/* Current or Accepted Wireline Protocol Version */
responseList.Add(currentWirelineProtocolVersion);
responseList.Add(oldestWirelineProtocolVersion);
// convert the list of bytes to a byte array
response = new byte[responseList.Count];
for (int i = 0; i < responseList.Count; i++)
response[i] = responseList[i];
break;
}
#endregion
#region WL_VC_VOICE_BURST
/*
* This message is sent from the third party applications to the repeater peer containing
* all the voice data [I hope: pray]
*/
case Operations.WL_VC_VOICE_BURST:
{
CSBKCall crtCSBKCall = null;
try
{
// get the paramerets in the correct form
crtCSBKCall = (CSBKCall)parameters;
// set current csbk call values depending on the slot
crtCSBKCall = (crtCSBKCall.slotNumber == SlotNumber.Slot1 ? crtCSBKCallStausSlot1 : crtCSBKCallStausSlot2);
}
catch (Exception)
{
// THROW AN EXCEPTION
return new byte[0];
}
/* Wireline Operation Code*/
responseList.Add((byte)Operations.WL_VC_VOICE_BURST);
/* slot number - Specifies the channel/slot reporting the channel status */
responseList.Add((byte)crtCSBKCall.slotNumber);
/* call ID */
responseList.Add(BitConverter.GetBytes(crtCSBKCall.crtCallID)[3]);
responseList.Add(BitConverter.GetBytes(crtCSBKCall.crtCallID)[2]);
responseList.Add(BitConverter.GetBytes(crtCSBKCall.crtCallID)[1]);
responseList.Add(BitConverter.GetBytes(crtCSBKCall.crtCallID)[0]);
/* callType - The type of call */
responseList.Add((byte)crtCSBKCall.callType);
/* source ID - The ID of the subscriber that initiated the call */
responseList.Add(BitConverter.GetBytes(crtCSBKCall.sourceID)[3]);
responseList.Add(BitConverter.GetBytes(crtCSBKCall.sourceID)[2]);
responseList.Add(BitConverter.GetBytes(crtCSBKCall.sourceID)[1]);
responseList.Add(BitConverter.GetBytes(crtCSBKCall.sourceID)[0]);
/* target ID - The ID of the subscriber that initiated the call */
responseList.Add(BitConverter.GetBytes(crtCSBKCall.targetID)[3]);
responseList.Add(BitConverter.GetBytes(crtCSBKCall.targetID)[2]);
responseList.Add(BitConverter.GetBytes(crtCSBKCall.targetID)[1]);
responseList.Add(BitConverter.GetBytes(crtCSBKCall.targetID)[0]);
/* RESERVED ? ? ? */
responseList.Add(0xA0);
/* RESERVED */
responseList.Add(0x00);
/* callAttributes or Preamble Duration */
responseList.Add((byte)crtCSBKCall.callAttributes);
/* Reserved field */
responseList.Add((byte)0x5D);
/* CSBK Field Param 1 */
responseList.Add(BitConverter.GetBytes(csbkCallParam1)[1]);
responseList.Add(BitConverter.GetBytes(csbkCallParam1)[0]);
csbkCallParam1++;
/* CSBK Field Param 2 */
responseList.Add(BitConverter.GetBytes(csbkCallParam2)[1]);
responseList.Add(BitConverter.GetBytes(csbkCallParam2)[0]);
/* CSBK Field Param 3 */
responseList.Add(BitConverter.GetBytes(csbkCallParam3)[0]);
csbkCallParam3 = csbkCallParam3 + 0x02;
/* CSBK Field Param 4 */
responseList.Add(BitConverter.GetBytes(csbkCallParam4)[0]);
csbkCallParam4 = csbkCallParam4 - 0x20;
/* CSBK Arguments - Only available for CSBK call
* The arguments encoded in the DMR CSBK burst [Uint64] */
responseList.Add((byte)0x00);
responseList.Add((byte)0x00); // reserved
responseList.Add((byte)0x00);
responseList.Add((byte)0x00);
/* Seqeuence number */
responseList.Add((byte)(val++ % 6));
/* 10 RESERVED Fields */
responseList.Add((byte)0x00);
responseList.Add((byte)0x00);
responseList.Add((byte)0x00);
responseList.Add((byte)0x00);
responseList.Add((byte)0x00);
responseList.Add((byte)0x00);
responseList.Add((byte)0x00);
responseList.Add((byte)0x00);
responseList.Add((byte)0x00);
responseList.Add((byte)0x00);
/* add 19 bytes for voice ??? */
responseList.AddRange(new byte[] { 0xb8, 0x34, 0xb3, 0x87, 0xa2, 0xa2, 0xb6, 0x0e, 0x29, 0x8b, 0x99, 0x80, 0xcd, 0x83, 0xb0, 0x39, 0x94, 0x59, 0xc0 });
/* RESERVED */
responseList.Add(0x00);
responseList.Add(0x00);
/* Current or Accepted Wireline Protocol Version */
responseList.Add(currentWirelineProtocolVersion);
responseList.Add(oldestWirelineProtocolVersion);
// convert the list of bytes to a byte array
response = new byte[responseList.Count];
for (int i = 0; i < responseList.Count; i++)
response[i] = responseList[i];
break;
}
#endregion
}
return response;
}
public void decode(byte[] toDecode, string peerIP, Int32 peerPort)
{
int crtPosition = 0;
byte opCode = toDecode[crtPosition++];
// first opCode is for a CSBK Call message
//if (opCode != 0xB2)
// return;
/* get peerID */
byte[] remotePeerID = new byte[4];
remotePeerID[3] = toDecode[crtPosition++];
remotePeerID[2] = toDecode[crtPosition++];
remotePeerID[1] = toDecode[crtPosition++];
remotePeerID[0] = toDecode[crtPosition++];
Int64 peerID = BitConverter.ToUInt32(remotePeerID, 0);
byte wirelineOpCode = toDecode[crtPosition++];
Utils.WriteLine("");
Utils.WriteLine(String.Format("»»» {0}", GetMessageType(wirelineOpCode)), ConsoleColor.Yellow);
//Utils.WriteLine(Utils.printBytesArray(toDecode));
switch (wirelineOpCode)
{
#region WL_REGISTRATION_STATUS
case (byte)Operations.WL_REGISTRATION_STATUS:
{
if (wirelineProtocolVersion >= 1)
{
// identifier of the registration PDU [Uint32]
byte[] registrationPduID = new byte[4];
registrationPduID[3] = toDecode[crtPosition++];
registrationPduID[2] = toDecode[crtPosition++];
registrationPduID[1] = toDecode[crtPosition++];
registrationPduID[0] = toDecode[crtPosition++];
Int64 registrPduID = BitConverter.ToUInt32(registrationPduID, 0);
// identifier associated with the registration profile in this PDU [Uint16]
byte[] registrationIDSlot1 = new byte[2];
registrationIDSlot1[1] = toDecode[crtPosition++];
registrationIDSlot1[0] = toDecode[crtPosition++];
// identifier associated with the registration profile in this PDU [Uint16]
byte[] registrationIDSlot2 = new byte[2];
registrationIDSlot2[1] = toDecode[crtPosition++];
registrationIDSlot2[0] = toDecode[crtPosition++];
// registration status [Uint8]
byte registrationStatus = toDecode[crtPosition++];
// registration status code [Uint8]
byte registrationStatusCode = toDecode[crtPosition++];
// Current or Accepted Wireline Protocol Version [Uint8]
byte currentWirelineProtocolVersion = toDecode[crtPosition++];
// Oldest Wireline Protocol Version [Uint8]
byte oldestWirelineProtocolVersion = toDecode[crtPosition++];
Utils.WriteLine(String.Format("\tRegistration Status: {0}", GetRegistrationStatus(registrationStatus)), ConsoleType.WIRELINE);
Utils.WriteLine(String.Format("\tRegistration Status Code: {0}", GetRegistrationStatusCode(registrationStatusCode)), ConsoleType.WIRELINE);
// do not display and trigger nothing if the registered PDU is empty
if (!(registrPduID > 0))
break;
if (BitConverter.ToInt16(registrationIDSlot1, 0) != 0)
{
Utils.WriteLine(String.Format("\tSlot 1 Registered"), ConsoleType.WIRELINE);
OnRegistrationReceived(true, SlotNumber.Slot1);
}
if (BitConverter.ToInt16(registrationIDSlot2, 0) != 0)
{
Utils.WriteLine(String.Format("\tSlot 2 Registered"), ConsoleType.WIRELINE);
OnRegistrationReceived(true, SlotNumber.Slot2);
}
}
break;
}
#endregion
#region WL_REGISTRATION_GENERAL_OPS
case (byte)Operations.WL_REGISTRATION_GENERAL_OPS:
{
if (wirelineProtocolVersion >= 1)
{
// identifier associated with the registration profile in this PDU [Uint16]
int registrationSlot = toDecode[crtPosition++];
// identifier of the registration PDU [Uint32]
byte[] registrationPduID = new byte[4];
registrationPduID[3] = toDecode[crtPosition++];
registrationPduID[2] = toDecode[crtPosition++];
registrationPduID[1] = toDecode[crtPosition++];
registrationPduID[0] = toDecode[crtPosition++];
Int64 registrPduID = BitConverter.ToUInt32(registrationPduID, 0);
// registration operation code [Uint8]
byte registrationOperationCode = toDecode[crtPosition++];
// Current or Accepted Wireline Protocol Version [Uint8]
byte currentWirelineProtocolVersion = toDecode[crtPosition++];
// Oldest Wireline Protocol Version [Uint8]
byte oldestWirelineProtocolVersion = toDecode[crtPosition++];
Utils.WriteLine("RegSlot " + registrationSlot + " | OpCode " + registrationOperationCode + " [" + registrPduID + "]", ConsoleType.WIRELINE);
}
break;
}
#endregion
#region WL_PROTOCOL_VERSION_QUERY_RESPONSE
/*
* This message is sent from the repeater peer to the third party application as a response
* to the WL_PROTOCOL_VERSION_QUERY. The repeater always responds with its
* current and oldest version irrespective of the version numbers in the Wireline Protocol
* Version Query.
*/
case (byte)Operations.WL_PROTOCOL_VERSION_QUERY_RESPONSE:
{
if (wirelineProtocolVersion >= 3)
{
// reserved field
Int64 reserved = toDecode[crtPosition++];
// queryID - ID of the protocol version query PDU.
// Response from the repeater pertaining to this message
// has the same Query ID value [Uint32]
byte[] queryID = new byte[4];
queryID[3] = toDecode[crtPosition++];
queryID[2] = toDecode[crtPosition++];
queryID[1] = toDecode[crtPosition++];
queryID[0] = toDecode[crtPosition++];
Int64 querryID = BitConverter.ToUInt32(queryID, 0);
// Current Wireline Protocol Version [Uint8]
byte currentWirelineProtocolVersion = toDecode[crtPosition++];
// Oldest Wireline Protocol Version [Uint8]
byte oldestWirelineProtocolVersion = toDecode[crtPosition++];
}
break;
}
#endregion
#region WL_CHNL_STATUS
/*
* This message is sent from the repeater peer to the third party applications to report the
* conventional channel status of SS/IPSC system or rest channel status of CPP/LCP
* system. This message is only sent out by the first repeater peer, which receives the call
* over the air from the radio or receives the call over the network from the third party
* application.
* Only the third party application who has subscribed the wireline channel status during
* wireline registration can receive this message.
* A repeater peer sends out a Wireline Channel Status in one of the following situations:
* 1) Upon receiving a Wireline Channel Status Query from the third party application.
* 2) The register channel status of SS/IPSC system or rest channel status of
* CPC/LCP system is updated.
* In MOTOTRBO 2.2, the data revert repeaters in CPP/LCP system didn’t send Wireline
* Channel Status PDU.
*/
case (byte)Operations.WL_CHNL_STATUS:
{
if (wirelineProtocolVersion >= 1)
{
// Slot number - Specifies the channel/slot reporting the channel status.[Uint8]
byte slotNumber = toDecode[crtPosition++];
// statusPduID - The ID of the status PDU
// uniquely identifies the
// channel status PDU. [Uint32]
byte[] statusPduID = new byte[4];
statusPduID[3] = toDecode[crtPosition++];
statusPduID[2] = toDecode[crtPosition++];
statusPduID[1] = toDecode[crtPosition++];
statusPduID[0] = toDecode[crtPosition++];
Int64 statusPDUID = BitConverter.ToUInt32(statusPduID, 0);
// Only available in IPSC modes. The channel status information. [Uint8]
byte conventionalChannelStatus = toDecode[crtPosition++];
// Only available in CPP/LCP modes. The rest channel status information. [Uint8]
byte restChannelStatus = toDecode[crtPosition++];
// Call type [Uint8]
byte typeOfCall = toDecode[crtPosition++];
// Current Wireline Protocol Version [Uint8]
byte currentWirelineProtocolVersion = toDecode[crtPosition++];
// Oldest Wireline Protocol Version [Uint8]
byte oldestWirelineProtocolVersion = toDecode[crtPosition++];
Utils.WriteLine(String.Format("\t{0}", GetSlotNumberName(slotNumber, le.systemType)), ConsoleType.WIRELINE);
Utils.WriteLine(String.Format("\tConventional Channel Status: {0}", GetChannelStatus(conventionalChannelStatus)), ConsoleType.WIRELINE);
Utils.WriteLine(String.Format("\tRest Channel Status: {0}", GetChannelStatus(restChannelStatus)), ConsoleType.WIRELINE);
Utils.WriteLine(String.Format("\tCall Type: {0}", GetCallType(typeOfCall)), ConsoleType.WIRELINE);
}
break;
}
#endregion
#region WL_VC_CHNL_CTRL_STATUS
/*
* This message is sent from the repeater peer to the third party applications to response
* the Wireline Call Channel Control Request.
*/
case (byte)Operations.WL_VC_CHNL_CTRL_STATUS:
{
if (wirelineProtocolVersion >= 1)
{
// Slot number - Specifies the channel/slot reporting the channel status.[Uint8]
byte slotNumber = toDecode[crtPosition++];
// call ID - The ID of the call
byte[] callID = new byte[4];
callID[3] = toDecode[crtPosition++];
callID[2] = toDecode[crtPosition++];
callID[1] = toDecode[crtPosition++];
callID[0] = toDecode[crtPosition++];
Int64 calllID = BitConverter.ToUInt32(callID, 0);
// The type of the call [Uint8]
byte callType = toDecode[crtPosition++];
// chnCtrlstatus - Channel control Status [Uint8]
byte chnCtrlstatus = toDecode[crtPosition++];
// DeclineReasonCode - The reason for decline the call control request [Uint8]
byte declineReasonCode = toDecode[crtPosition++];
// Current Wireline Protocol Version [Uint8]
byte currentWirelineProtocolVersion = toDecode[crtPosition++];
// Oldest Wireline Protocol Version [Uint8]
byte oldestWirelineProtocolVersion = toDecode[crtPosition++];
Utils.WriteLine(String.Format("\tSlot {0}",GetSlotNumber(slotNumber)), ConsoleType.WIRELINE);
Utils.WriteLine(String.Format("\tCall Type: {0}", GetCallType(callType)), ConsoleType.WIRELINE);
Utils.WriteLine(String.Format("\tChannel Ctrl Status: {0}", GetChannelControlStatus(chnCtrlstatus)), ConsoleType.WIRELINE);
if ((SlotNumber)slotNumber == SlotNumber.Slot1)
crtCSBKCallStausSlot1.chnCtrlstatus = (ChannelControlStatus)chnCtrlstatus;
else
crtCSBKCallStausSlot2.chnCtrlstatus = (ChannelControlStatus)chnCtrlstatus;
OnChannelControlStatusReceived(calllID, (CallType)callType, (ChannelControlStatus)chnCtrlstatus, (SlotNumber) slotNumber);
}
break;
}
#endregion
#region WL_VC_CSBK_CALL
/*
* This message is sent from the repeater peer to the third party application to send the
* CSBK request or response message
*/
case (byte)Operations.WL_VC_CSBK_CALL:
{
if (wirelineProtocolVersion >= 1)
{
// Slot number - Specifies the channel/slot reporting the channel status.[Uint8]
byte slotNumber = toDecode[crtPosition++];
// call ID - The ID of the call
byte[] callID = new byte[4];
callID[3] = toDecode[crtPosition++];
callID[2] = toDecode[crtPosition++];
callID[1] = toDecode[crtPosition++];
callID[0] = toDecode[crtPosition++];
Int64 calllID = BitConverter.ToUInt32(callID, 0);
// The type of the call [Uint8]
byte callType = toDecode[crtPosition++];
// source ID - The ID of the subscriber that initiated the call
byte[] sourceID = new byte[4];
sourceID[3] = toDecode[crtPosition++];
sourceID[2] = toDecode[crtPosition++];
sourceID[1] = toDecode[crtPosition++];
sourceID[0] = toDecode[crtPosition++];
Int64 sourceeID = BitConverter.ToUInt32(sourceID, 0);
// target ID - The ID of the subscriber ot talk-group to which the call is targeted
byte[] targetID = new byte[4];
targetID[3] = toDecode[crtPosition++];
targetID[2] = toDecode[crtPosition++];
targetID[1] = toDecode[crtPosition++];
targetID[0] = toDecode[crtPosition++];
Int64 targettID = BitConverter.ToUInt32(targetID, 0);
// reserved [Uint8]
byte reserved = toDecode[crtPosition++];
// MFID - The DMR Feature Set ID / Manufacturer’s ID [Uint8]
byte mfid = toDecode[crtPosition++];
// CSBK Arguments - The reason for decline the call control request [Uint8]
byte[] csbkArguments = new byte[8];
csbkArguments[7] = toDecode[crtPosition++];
csbkArguments[6] = toDecode[crtPosition++];
csbkArguments[5] = toDecode[crtPosition++];
csbkArguments[4] = toDecode[crtPosition++];
csbkArguments[3] = toDecode[crtPosition++];
csbkArguments[2] = toDecode[crtPosition++];
csbkArguments[1] = toDecode[crtPosition++];
csbkArguments[0] = toDecode[crtPosition++];
// rawRssiValue - The raw RSSI value for each burst
byte[] rawRssiValue = new byte[2];
rawRssiValue[1] = toDecode[crtPosition++];
rawRssiValue[0] = toDecode[crtPosition++];
// Current Wireline Protocol Version [Uint8]
byte currentWirelineProtocolVersion = toDecode[crtPosition++];
// Oldest Wireline Protocol Version [Uint8]
byte oldestWirelineProtocolVersion = toDecode[crtPosition++];
Utils.WriteLine(String.Format("\t{0}", GetSlotNumberName(slotNumber, le.systemType)), ConsoleType.WIRELINE);
Utils.WriteLine(String.Format("\tCall Type: {0}", GetCallType(callType)), ConsoleType.WIRELINE);
Utils.WriteLine(String.Format("\tSource ID: {0}", sourceeID), ConsoleType.WIRELINE);
Utils.WriteLine(String.Format("\tTarget ID: {0}", targettID), ConsoleType.WIRELINE);
switch (callType)
{
case (byte)CallType.RadioInhibitResponse:
{
// eg.
// 0xB2 0x0 0x0 0x0 0x2 0x17 0x1 0x0 0x0 0x0 0x65 0x4A 0x0 0x0 0x0 0x6F 0x0 0x0
// 0x0 0x1 0x0 0x0 0x10 0x0 0xFF 0x0 0x0 0x1 0x0 0x0 0x6F 0x3B 0x60 0xC 0x4
OnRadioStatusChanged(sourceeID, GetSlotNumber(slotNumber), false);
break;
}
case (byte)CallType.RadioUninhibitResponse:
{
// eg.
// 0xB2 0x0 0x0 0x0 0x2 0x17 0x1 0x0 0x0 0x0 0x4C 0x4C 0x0 0x0 0x0 0x65 0x0 0x0
// 0x0 0x1 0x0 0x0 0x10 0x0 0xFE 0x0 0x0 0x1 0x0 0x0 0x65 0x3B 0x69 0xC 0x4
OnRadioStatusChanged(sourceeID, GetSlotNumber(slotNumber), true);
break;
}
case (byte)CallType.EmergencyCSBKAlertRequest:
{
OnEmergencyChanged(sourceeID, GetSlotNumber(slotNumber));
break;
}
case (byte)CallType.AllCall:
case (byte)CallType.GroupVoiceCall:
case (byte)CallType.PrivateCallRequest:
{
OnCSBKCallReceived(sourceeID, targettID, (CallType)callType, (SlotNumber)slotNumber);
break;
}
}
}
break;
}
#endregion
#region WL_VC_VOICE_START
/*
* This message is sent by the repeater peer to indicate the beginning of a voice stream.
*/
case (byte)Operations.WL_VC_VOICE_START:
{
if (wirelineProtocolVersion >= 1)
{
// Slot number - Specifies the channel/slot reporting the channel status.[Uint8]
byte slotNumber = toDecode[crtPosition++];
// call ID - The ID of the call
byte[] callID = new byte[4];
callID[3] = toDecode[crtPosition++];
callID[2] = toDecode[crtPosition++];
callID[1] = toDecode[crtPosition++];
callID[0] = toDecode[crtPosition++];
Int64 calllID = BitConverter.ToUInt32(callID, 0);
// The type of the call [Uint8]
byte callType = toDecode[crtPosition++];
CallType callTypee = GetCallType(callType);
// source ID - The ID of the subscriber that initiated the call
byte[] sourceID = new byte[4];
sourceID[3] = toDecode[crtPosition++];
sourceID[2] = toDecode[crtPosition++];
sourceID[1] = toDecode[crtPosition++];
sourceID[0] = toDecode[crtPosition++];
Int64 sourceeID = BitConverter.ToUInt32(sourceID, 0);
// target ID - The ID of the subscriber ot talk-group to which the call is targeted
byte[] targetID = new byte[4];
targetID[3] = toDecode[crtPosition++];
targetID[2] = toDecode[crtPosition++];
targetID[1] = toDecode[crtPosition++];
targetID[0] = toDecode[crtPosition++];
Int64 targettID = BitConverter.ToUInt32(targetID, 0);
// callAttributes [Uint8] - Call General attributes
byte callAttributes = toDecode[crtPosition++];
// reserved [Uint8]
byte reserved = toDecode[crtPosition++];
// MFID [Uint8] - The DMR Feature Set ID / Manufacturer’s ID
byte mfid = toDecode[crtPosition++];
// service option [Uint8] - DMR LC Service Option
byte serviceOption = toDecode[crtPosition++];
// Current Wireline Protocol Version [Uint8]
byte currentWirelineProtocolVersion = toDecode[crtPosition++];
// Oldest Wireline Protocol Version [Uint8]
byte oldestWirelineProtocolVersion = toDecode[crtPosition++];
Utils.WriteLine(String.Format("\t{0}", GetSlotNumberName(slotNumber, le.systemType)), ConsoleType.WIRELINE);
Utils.WriteLine(String.Format("\tCall Type: {0}", GetCallType(callType)), ConsoleType.WIRELINE);
Utils.WriteLine(String.Format("\tSource ID: {0}", sourceeID), ConsoleType.WIRELINE);
Utils.WriteLine(String.Format("\tTarget ID: {0}", targettID), ConsoleType.WIRELINE);
if (callTypee == CallType.AllCall || callTypee == CallType.GroupVoiceCall
|| callTypee == CallType.PrivateVoiceCall || callTypee == CallType.EmergencyVoiceCall)
OnCallStatusReceived(sourceeID, targettID, ConvertCallType4MessageBus(callTypee),
ConvertCallSessionStatus4MessageBus(CallSessionStatus.CallInProgress), GetSlotNumber(slotNumber));
}
break;
}
#endregion
#region WL_VC_VOICE_END_BURST
/*
* This message is sent by the repeater peer to indicate the beginning of a voice stream.
*/
case (byte)Operations.WL_VC_VOICE_END_BURST:
{
if (wirelineProtocolVersion >= 1)
{
// Slot number - Specifies the channel/slot reporting the channel status.[Uint8]
byte slotNumber = toDecode[crtPosition++];
// call ID - The ID of the call
byte[] callID = new byte[4];
callID[3] = toDecode[crtPosition++];
callID[2] = toDecode[crtPosition++];
callID[1] = toDecode[crtPosition++];
callID[0] = toDecode[crtPosition++];
Int64 calllID = BitConverter.ToUInt32(callID, 0);
// The type of the call [Uint8]
byte callType = toDecode[crtPosition++];
CallType callTypee = GetCallType(callType);
// source ID - The ID of the subscriber that initiated the call
byte[] sourceID = new byte[4];
sourceID[3] = toDecode[crtPosition++];
sourceID[2] = toDecode[crtPosition++];
sourceID[1] = toDecode[crtPosition++];
sourceID[0] = toDecode[crtPosition++];
Int64 sourceeID = BitConverter.ToUInt32(sourceID, 0);
// target ID - The ID of the subscriber ot talk-group to which the call is targeted
byte[] targetID = new byte[4];
targetID[3] = toDecode[crtPosition++];
targetID[2] = toDecode[crtPosition++];
targetID[1] = toDecode[crtPosition++];
targetID[0] = toDecode[crtPosition++];
Int64 targettID = BitConverter.ToUInt32(targetID, 0);
// callAttributes [Uint8] - Call General attributes
byte[] rtpInformationField = new byte[12];
rtpInformationField[11] = toDecode[crtPosition++];
rtpInformationField[10] = toDecode[crtPosition++];
rtpInformationField[9] = toDecode[crtPosition++];
rtpInformationField[8] = toDecode[crtPosition++];
rtpInformationField[7] = toDecode[crtPosition++];
rtpInformationField[6] = toDecode[crtPosition++];
rtpInformationField[5] = toDecode[crtPosition++];
rtpInformationField[4] = toDecode[crtPosition++];
rtpInformationField[3] = toDecode[crtPosition++];
rtpInformationField[2] = toDecode[crtPosition++];
rtpInformationField[1] = toDecode[crtPosition++];
rtpInformationField[0] = toDecode[crtPosition++];
// burst type [Uint8] - DMR voice burst type Must be Voice Terminator
byte burstType = toDecode[crtPosition++];
// reserved [Uint8]
byte reserved = toDecode[crtPosition++];
// MFID [Uint8] - The DMR Feature Set ID / Manufacturer’s ID
byte mfid = toDecode[crtPosition++];
// service option [Uint8] - DMR LC Service Option
byte serviceOption = toDecode[crtPosition++];
// Current Wireline Protocol Version [Uint8]
byte currentWirelineProtocolVersion = toDecode[crtPosition++];
// Oldest Wireline Protocol Version [Uint8]
byte oldestWirelineProtocolVersion = toDecode[crtPosition++];
//Utils.WriteLine(ConsoleType.WIRELINE, String.Format("\t{0}", GetSlotNumberName(slotNumber, le.systemType)));
//Utils.WriteLine(ConsoleType.WIRELINE, String.Format("\tCall Type: {0}", GetCallType(callType)));
//Utils.WriteLine(ConsoleType.WIRELINE, String.Format("\tSource ID: {0}", sourceeID));
//Utils.WriteLine(ConsoleType.WIRELINE, String.Format("\tTarget ID: {0}", targettID));
Utils.WriteLine(String.Format("\tBurst Type: {0}", GetBurstType(burstType)), ConsoleType.WIRELINE);
/*
if (callTypee == CallType.AllCall || callTypee == CallType.GroupVoiceCall || callTypee == CallType.PrivateCallRequest)
OnCallStatusReceived(sourceeID, targettID, ConvertCallType4MessageBus(callTypee),
ConvertCallSessionStatus4MessageBus(CallSessionStatus.CallInProgress), GetSlotNumber(slotNumber));
*/
}
break;
}
#endregion
#region WL_VC_CALL_SESSION_STATUS
/*
* This message is sent from repeater peer to the third party application to inform the call
* session status. Only the repeater peer, which receives the call over the air from the
* radio or receives the call from the third party application over the network interface,
* sends out the WL_VC_CALL_SESSION_STATUS message
*/
case (byte)Operations.WL_VC_CALL_SESSION_STATUS:
{
if (wirelineProtocolVersion >= 1)
{
// Slot number - Specifies the channel/slot reporting the channel status.[Uint8]
byte slotNumber = toDecode[crtPosition++];
// call ID - The ID of the call
byte[] callID = new byte[4];
callID[3] = toDecode[crtPosition++];
callID[2] = toDecode[crtPosition++];
callID[1] = toDecode[crtPosition++];
callID[0] = toDecode[crtPosition++];
Int64 calllID = BitConverter.ToUInt32(callID, 0);
// The type of the call [Uint8]
byte callType = toDecode[crtPosition++];
// source ID - The ID of the subscriber that initiated the call
byte[] sourceID = new byte[4];
sourceID[3] = toDecode[crtPosition++];
sourceID[2] = toDecode[crtPosition++];
sourceID[1] = toDecode[crtPosition++];
sourceID[0] = toDecode[crtPosition++];
Int64 sourceeID = BitConverter.ToUInt32(sourceID, 0);
// target ID - The ID of the subscriber ot talk-group to which the call is targeted
byte[] targetID = new byte[4];
targetID[3] = toDecode[crtPosition++];
targetID[2] = toDecode[crtPosition++];
targetID[1] = toDecode[crtPosition++];
targetID[0] = toDecode[crtPosition++];
Int64 targettID = BitConverter.ToUInt32(targetID, 0);
// reserved [Uint32]
byte reserved = toDecode[crtPosition++];
reserved = toDecode[crtPosition++];
reserved = toDecode[crtPosition++];
reserved = toDecode[crtPosition++];
// MFIcallSessionStatusD - Call Session Stats [Uint8]
byte callSessionStatus = toDecode[crtPosition++];
// Current Wireline Protocol Version [Uint8]
byte currentWirelineProtocolVersion = toDecode[crtPosition++];
// Oldest Wireline Protocol Version [Uint8]
byte oldestWirelineProtocolVersion = toDecode[crtPosition++];
Utils.WriteLine(String.Format("\t{0}", GetSlotNumberName(slotNumber, le.systemType)));
Utils.WriteLine(String.Format("\tCall Type: {0}", GetCallType(callType)));
Utils.WriteLine(String.Format("\tSource ID: {0}", sourceeID));
Utils.WriteLine(String.Format("\tTarget ID: {0}", targettID));
Utils.WriteLine(String.Format("\tCall Session Status: {0}", GetCallSessionStatus(callSessionStatus)));
CallSessionStatus callStatus = (callSessionStatus == (byte)CallSessionStatus.CallEnd ? CallSessionStatus.CallEnd : CallSessionStatus.CallHang);
// broadcast the call status only if in hangtime or ended
if(callStatus == CallSessionStatus.CallEnd || callStatus == CallSessionStatus.CallHang)
{
if (callType == (byte)CallType.AllCall || callType == (byte)CallType.GroupVoiceCall
|| callType == (byte)CallType.PrivateVoiceCall || callType == (byte)CallType.EmergencyVoiceCall)
OnCallStatusReceived(sourceeID, targettID, ConvertCallType4MessageBus((CallType)callType),
ConvertCallSessionStatus4MessageBus(callStatus), GetSlotNumber(slotNumber, le.systemType));
/*
if (callType == (byte)CallType.GroupVoiceCall)
OnCallStatusReceived(sourceeID, targettID, ConvertCallType4MessageBus(CallType.GroupVoiceCall),
ConvertCallSessionStatus4MessageBus(callStatus), GetSlotNumber(slotNumber, le.systemType));
else if (callType == (byte)CallType.PrivateVoiceCall)
OnCallStatusReceived(sourceeID, targettID, ConvertCallType4MessageBus(CallType.PrivateVoiceCall),
ConvertCallSessionStatus4MessageBus(callStatus), GetSlotNumber(slotNumber, le.systemType));
else if (callType == (byte)CallType.AllCall)
OnCallStatusReceived(sourceeID, targettID, ConvertCallType4MessageBus(CallType.AllCall),
ConvertCallSessionStatus4MessageBus(callStatus), GetSlotNumber(slotNumber, le.systemType));
else if (callType == (byte)CallType.EmergencyVoiceCall)
OnCallStatusReceived(sourceeID, targettID, ConvertCallType4MessageBus(CallType.EmergencyVoiceCall),
ConvertCallSessionStatus4MessageBus(callStatus), GetSlotNumber(slotNumber, le.systemType));
*/
}
// fire event for call session status received
OnCallSesionStatusReceived(sourceeID, targettID, (CallType)callType, (CallSessionStatus)callSessionStatus, (SlotNumber) slotNumber);
}
break;
}
#endregion
#region WL_VC_VOICE_BURST
/*
* This message is used by the Repeater Peer to send Voice Burst to the third party
* application.
*/
case (byte)Operations.WL_VC_VOICE_BURST:
{
if (wirelineProtocolVersion >= 1)
{
// Slot number - Specifies the channel/slot reporting the channel status.[Uint8]
byte slotNumber = toDecode[crtPosition++];
// call ID - The ID of the call
byte[] callID = new byte[4];
callID[3] = toDecode[crtPosition++];
callID[2] = toDecode[crtPosition++];
callID[1] = toDecode[crtPosition++];
callID[0] = toDecode[crtPosition++];
Int64 calllID = BitConverter.ToUInt32(callID, 0);
// The type of the call [Uint8]
byte callType = toDecode[crtPosition++];
CallType callTypee = GetCallType(callType);
// source ID - The ID of the subscriber that initiated the call
byte[] sourceID = new byte[4];
sourceID[3] = toDecode[crtPosition++];
sourceID[2] = toDecode[crtPosition++];
sourceID[1] = toDecode[crtPosition++];
sourceID[0] = toDecode[crtPosition++];
Int64 sourceeID = BitConverter.ToUInt32(sourceID, 0);
// target ID - The ID of the subscriber ot talk-group to which the call is targeted
byte[] targetID = new byte[4];
targetID[3] = toDecode[crtPosition++];
targetID[2] = toDecode[crtPosition++];
targetID[1] = toDecode[crtPosition++];
targetID[0] = toDecode[crtPosition++];
Int64 targettID = BitConverter.ToUInt32(targetID, 0);
// callAttributes [Uint8] - Call General attributes
byte callAttributes = toDecode[crtPosition++];
// reserved [Uint8]
byte reserved = toDecode[crtPosition++];
// rptInformationField [Uint8 * 12] - RPT Header Information
byte[] rtpInformationField = new byte[12];
rtpInformationField[11] = toDecode[crtPosition++];
rtpInformationField[10] = toDecode[crtPosition++];
rtpInformationField[9] = toDecode[crtPosition++];
rtpInformationField[8] = toDecode[crtPosition++];
rtpInformationField[7] = toDecode[crtPosition++];
rtpInformationField[6] = toDecode[crtPosition++];
rtpInformationField[5] = toDecode[crtPosition++];
rtpInformationField[4] = toDecode[crtPosition++];
rtpInformationField[3] = toDecode[crtPosition++];
rtpInformationField[2] = toDecode[crtPosition++];
rtpInformationField[1] = toDecode[crtPosition++];
rtpInformationField[0] = toDecode[crtPosition++];
// burst type [Uint8] - DMR voice burst type Must be Voice Terminator
byte burstType = toDecode[crtPosition++];
// reserved [Uint8]
byte reserved3 = toDecode[crtPosition++];
// MFID [Uint8] - The DMR Feature Set ID / Manufacturer’s ID
byte mfid = toDecode[crtPosition++];
// service option [Uint8] - DMR LC Service Option
byte serviceOption = toDecode[crtPosition++];
// algorithmID [Uint8] - Algorithm ID
byte algorithmID = toDecode[crtPosition++];
// keyID [Uint8] - ID of the Privacy Key
byte keyID = toDecode[crtPosition++];
// iv [Uint8] - Initialization Vector
byte[] iv = new byte[4];
iv[3] = toDecode[crtPosition++];
iv[2] = toDecode[crtPosition++];
iv[1] = toDecode[crtPosition++];
iv[0] = toDecode[crtPosition++];
// ambe [Uint8 * 20] - The AMBE voice encoded frames
byte[] ambe = new byte[20];
ambe[0] = toDecode[crtPosition++];
ambe[1] = toDecode[crtPosition++];
ambe[2] = toDecode[crtPosition++];
ambe[3] = toDecode[crtPosition++];
ambe[4] = toDecode[crtPosition++];
ambe[5] = toDecode[crtPosition++];
ambe[6] = toDecode[crtPosition++];
ambe[7] = toDecode[crtPosition++];
ambe[8] = toDecode[crtPosition++];
ambe[9] = toDecode[crtPosition++];
ambe[10] = toDecode[crtPosition++];
ambe[11] = toDecode[crtPosition++];
ambe[12] = toDecode[crtPosition++];
ambe[13] = toDecode[crtPosition++];
ambe[14] = toDecode[crtPosition++];
ambe[15] = toDecode[crtPosition++];
ambe[16] = toDecode[crtPosition++];
ambe[17] = toDecode[crtPosition++];
ambe[18] = toDecode[crtPosition++];
ambe[19] = toDecode[crtPosition++];
// add ambe burst to file
//DecodeAMBE2(ambe, GetBurstType(burstType), (SlotNumber)slotNumber);
// rawRssiValue [Uint16] - Only for WL outbound: The raw RSSI value for each voice burst
byte[] rawRssiValue = new byte[2];
rawRssiValue[1] = toDecode[crtPosition++];
rawRssiValue[0] = toDecode[crtPosition++];
// Current Wireline Protocol Version [Uint8]
byte currentWirelineProtocolVersion = toDecode[crtPosition++];
// Oldest Wireline Protocol Version [Uint8]
byte oldestWirelineProtocolVersion = toDecode[crtPosition++];
Utils.WriteLine(String.Format("\t{0}", GetSlotNumberName(slotNumber, le.systemType)), ConsoleType.WIRELINE);
//Utils.WriteLine(ConsoleType.WIRELINE, String.Format("\tCall Type: {0}", GetCallType(callType)));
//Utils.WriteLine(ConsoleType.WIRELINE, String.Format("\tSource ID: {0}", sourceeID));
//Utils.WriteLine(ConsoleType.WIRELINE, String.Format("\tTarget ID: {0}", targettID));
//Utils.WriteLine(ConsoleType.WIRELINE, String.Format("\tCurrent Version: {0}", currentWirelineProtocolVersion));
//Utils.WriteLine(ConsoleType.WIRELINE, String.Format("\tOldest Version: {0}", oldestWirelineProtocolVersion));
Utils.WriteLine(String.Format("\tBurst Type: {0}", GetBurstType(burstType)), ConsoleType.WIRELINE);
// verify if a voice burst was skyped and send an empty one if yes
int skipped = 0;
// set the previous bursty type for this slot number
int prevWorkingBurstType = (slotNumber == (byte)SlotNumber.Slot1 ? previousBrustTypeSlot1 : previousBrustTypeSlot2);
if (burstType < prevWorkingBurstType)
skipped = Math.Abs(burstType + 6 - prevWorkingBurstType) % 6 - 1;
else
skipped = Math.Abs(burstType - prevWorkingBurstType % 6) - 1;
if (skipped > 0)
{
for (int i = 0; i < skipped; i++)
{
// frame 1
OnAudioFrameReceived(new byte[7], (Wireline.SlotNumber)slotNumber);
// frame 2
OnAudioFrameReceived(new byte[7], (Wireline.SlotNumber)slotNumber);
// frame 3
OnAudioFrameReceived(new byte[7], (Wireline.SlotNumber)slotNumber);
}
}
// trigger event for voice frame received
List<byte[]> voiceFrames = AMBE.Rate34PrepareForEncoding(ambe);
foreach (byte[] by in voiceFrames)
OnAudioFrameReceived(by, (Wireline.SlotNumber)slotNumber);
// save previous burst type for specified slot
if (slotNumber == (byte)SlotNumber.Slot1)
previousBrustTypeSlot1 = burstType;
else
previousBrustTypeSlot2 = burstType;
}
break;
}
#endregion
#region WL_VC_PRIVACY_BURST
/*
* This message is use by the Repeater Peer to send Privacy Voice Burst to the third party
* application.
*/
case (byte)Operations.WL_VC_PRIVACY_BURST:
{
if (wirelineProtocolVersion >= 1)
{
// Slot number - Specifies the channel/slot reporting the channel status.[Uint8]
byte slotNumber = toDecode[crtPosition++];
// call ID - The ID of the call
byte[] callID = new byte[4];
callID[3] = toDecode[crtPosition++];
callID[2] = toDecode[crtPosition++];
callID[1] = toDecode[crtPosition++];
callID[0] = toDecode[crtPosition++];
Int64 calllID = BitConverter.ToUInt32(callID, 0);
// The type of the call [Uint8]
byte callType = toDecode[crtPosition++];
CallType callTypee = GetCallType(callType);
// source ID - The ID of the subscriber that initiated the call
byte[] sourceID = new byte[4];
sourceID[3] = toDecode[crtPosition++];
sourceID[2] = toDecode[crtPosition++];
sourceID[1] = toDecode[crtPosition++];
sourceID[0] = toDecode[crtPosition++];
Int64 sourceeID = BitConverter.ToUInt32(sourceID, 0);
// target ID - The ID of the subscriber ot talk-group to which the call is targeted
byte[] targetID = new byte[4];
targetID[3] = toDecode[crtPosition++];
targetID[2] = toDecode[crtPosition++];
targetID[1] = toDecode[crtPosition++];
targetID[0] = toDecode[crtPosition++];
Int64 targettID = BitConverter.ToUInt32(targetID, 0);
// rptInformationField [Uint8 * 12] - RPT Header Information
byte[] rtpInformationField = new byte[12];
rtpInformationField[11] = toDecode[crtPosition++];
rtpInformationField[10] = toDecode[crtPosition++];
rtpInformationField[9] = toDecode[crtPosition++];
rtpInformationField[8] = toDecode[crtPosition++];
rtpInformationField[7] = toDecode[crtPosition++];
rtpInformationField[6] = toDecode[crtPosition++];
rtpInformationField[5] = toDecode[crtPosition++];
rtpInformationField[4] = toDecode[crtPosition++];
rtpInformationField[3] = toDecode[crtPosition++];
rtpInformationField[2] = toDecode[crtPosition++];
rtpInformationField[1] = toDecode[crtPosition++];
rtpInformationField[0] = toDecode[crtPosition++];
// burst type [Uint8] - DMR Voice burst Type Must be Privacy Header
byte burstType = toDecode[crtPosition++];
// reserved [Uint8]
byte reserved = toDecode[crtPosition++];
// MFID [Uint8] - The DMR Feature Set ID / Manufacturer’s ID
byte mfid = toDecode[crtPosition++];
// service option [Uint8] - DMR LC Service Option
byte serviceOption = toDecode[crtPosition++];
// algorithmID [Uint8] - Algorithm ID
byte algorithmID = toDecode[crtPosition++];
// keyID [Uint8] - ID of the Privacy Key
byte keyID = toDecode[crtPosition++];
// iv [Uint8] - Initialization Vector
byte iv = toDecode[crtPosition++];
// Current Wireline Protocol Version [Uint8]
byte currentWirelineProtocolVersion = toDecode[crtPosition++];
// Oldest Wireline Protocol Version [Uint8]
byte oldestWirelineProtocolVersion = toDecode[crtPosition++];
Utils.WriteLine(String.Format("\t{0}", GetSlotNumberName(slotNumber, le.systemType)), ConsoleType.WIRELINE);
Utils.WriteLine(String.Format("\tCall Type: {0}", GetCallType(callType)), ConsoleType.WIRELINE);
Utils.WriteLine(String.Format("\tSource ID: {0}", sourceeID), ConsoleType.WIRELINE);
Utils.WriteLine(String.Format("\tTarget ID: {0}", targettID), ConsoleType.WIRELINE);
Utils.WriteLine(String.Format("\tBurst Type: {0}", GetBurstType(burstType)), ConsoleType.WIRELINE);
if (callTypee == CallType.AllCall || callTypee == CallType.GroupVoiceCall
|| callTypee == CallType.PrivateVoiceCall || callTypee == CallType.EmergencyVoiceCall)
OnCallStatusReceived(sourceeID, targettID, ConvertCallType4MessageBus(callTypee),
ConvertCallSessionStatus4MessageBus(CallSessionStatus.CallInProgress), GetSlotNumber(slotNumber));
}
break;
}
#endregion
default:
{
Utils.WriteLine(String.Format("Unknown Wireline Message: 0x{0:X} [{1}:{2}]", wirelineOpCode, peerIP, peerPort), ConsoleType.WIRELINE);
Utils.WriteLine(Utils.PrintBytesArray(toDecode), ConsoleType.WIRELINE);
break;
}
}
}
#region WIRELINE SENDING
/* Send a Wireline message to the desired peer */
public void SendWirelineMessage(byte[] message, String peerIP, Int32 peerUDPPort)
{
if (message.Length < 1)
return;
try
{
le.udpClient.Client.SendTo(message, new IPEndPoint(IPAddress.Parse(peerIP), peerUDPPort));
Utils.WriteLine(String.Format("««« {0,-34} [{1}]", GetMessageType(message[5]), peerIP), ConsoleType.WIRELINE); // + ":" + peerUDPPort);
//Utils.WriteLine(ConsoleType.WIRELINE, Utils.printBytesArray(message));
}
catch (Exception ex)
{
Utils.WriteLine("Wireline Thread Send exception: " + ex.ToString(), ConsoleType.WIRELINE);
}
}
/* Send a Wireline message to the current Master Peer */
public void SendWirelineMessage(byte[] message)
{
SendWirelineMessage(message, le.masterPeer.ipAddress, le.masterPeer.port);
}
/* Get a string that represents the Message Type based on the opCode */
private string GetMessageType(byte wirelineOpCode)
{
switch (wirelineOpCode)
{
case (byte)Operations.WL_REGISTRATION_REQUEST: return Operations.WL_REGISTRATION_REQUEST.ToString();
case (byte)Operations.WL_REGISTRATION_STATUS: return Operations.WL_REGISTRATION_STATUS.ToString();
case (byte)Operations.WL_REGISTRATION_GENERAL_OPS: return Operations.WL_REGISTRATION_GENERAL_OPS.ToString();
case (byte)Operations.WL_PROTOCOL_VERSION_QUERY: return Operations.WL_PROTOCOL_VERSION_QUERY.ToString();
case (byte)Operations.WL_PROTOCOL_VERSION_QUERY_RESPONSE: return Operations.WL_PROTOCOL_VERSION_QUERY_RESPONSE.ToString();
case (byte)Operations.WL_CHNL_STATUS: return Operations.WL_CHNL_STATUS.ToString();
case (byte)Operations.WL_CHNL_STATUS_QUERY: return Operations.WL_CHNL_STATUS_QUERY.ToString();
case (byte)Operations.WL_VC_CHNL_CTRL_REQUEST: return Operations.WL_VC_CHNL_CTRL_REQUEST.ToString();
case (byte)Operations.WL_VC_CHNL_CTRL_STATUS: return Operations.WL_VC_CHNL_CTRL_STATUS.ToString();
case (byte)Operations.WL_VC_CSBK_CALL: return Operations.WL_VC_CSBK_CALL.ToString();
case (byte)Operations.WL_VC_VOICE_START: return Operations.WL_VC_VOICE_START.ToString();
case (byte)Operations.WL_VC_VOICE_END_BURST: return Operations.WL_VC_VOICE_END_BURST.ToString();
case (byte)Operations.WL_VC_CALL_SESSION_STATUS: return Operations.WL_VC_CALL_SESSION_STATUS.ToString();
case (byte)Operations.WL_VC_VOICE_BURST: return Operations.WL_VC_VOICE_BURST.ToString();
case (byte)Operations.WL_VC_PRIVACY_BURST: return Operations.WL_VC_PRIVACY_BURST.ToString();
default: return "Unknown Wireline Message";
}
}
#endregion
#region WIRELINE CALL ENUMS
public enum AccessCriteria
{
PoliteAccess = 0x01
};
public enum CallAttributes
{
ForwardCSBK = 0x20,
DoNotForwardCSBK = 0x00,
SmartPTT = 0x80,
SmartAfterPreamble = 0xA0
};
public enum PreambleDuration
{
MinDuration = 0x00,
MaxDuration = 0x80,
BurstDurationMS = 0x3C
};
public enum CallSessionStatus
{
CallHang = 0x0A,
CallEnd = 0x0B,
CallInProgress = 0x09,
RESERVED = 0x00
};
public enum CallType
{
PreamblePrivateCSBKCall = 0x32,
PreambleGroupCSBKCall = 0x33,
PreambleEmergencyCall = 0x34,
EmergencyCSBKAlertRequest = 0x40,
EmergencyCSBKAlertResponse = 0x41,
EmergencyVoiceCall = 0x42,
PrivateCallRequest = 0x43,
PrivateCallResponse = 0x44,
CallAlertRequest = 0x45,
CallAlertResponse = 0x46,
RadioCheckRequest = 0x47,
RadioCheckResponse = 0x48,
RadioInhibitRequest = 0x49,
RadioInhibitResponse = 0x4A,
RadioUninhibitRequest = 0x4B,
RadioUninhibitResponse = 0x4C,
RadioRemoteMonitorRequest = 0x4D,
RadioRemoteMonitorResponse = 0x4E,
GroupVoiceCall = 0x4F,
PrivateVoiceCall = 0x50,
AllCall = 0x53,
Reserved = 0x54,
Other = 0x55,
IPConsoleRadioUninhibitRequest = 0x56,
IPConsoleRadioInhibitRequest = 0x57,
IPConsoleRadioUninhibitResponse = 0x58,
IPConsoleRadioInhibitResponse = 0x59,
GroupPhoneCall = 0x5A,
PrivatePhoneCall = 0x5B,
PhoneAllCall = 0x5C,
CallAlertNackResponse = 0x83,
RadioMonitorNackResponse = 0x84,
RadioInhibitUninhibitNackResponse = 0x85
};
public enum ChannelStatus
{
Active = 0x01,
Idle = 0x02,
SlotBlocked = 0x0A,
SlotUnblocked = 0x0B,
BusyRestChannel = 0x10,
RestChannelIdleAvailable = 0x11, // works for idle and available
LocalGroupCallsNotAllowed = 0x12,
LocalGroupCallsAllowed = 0x13,
RestChannelBlocked = 0x14
};
public enum ChannelControlStatus
{
Received = 0x01,
Transmiting = 0x02,
TransmissionSuccessful = 0x03,
SmartInProgress = 0x04,
Declined = 0x05
};
public enum SlotNumber
{
Slot1 = 0x01,
Slot2 = 0x02,
BothSlots = 0x03,
RestChannel = 0x00, // only in CPC
SiteIPAddress = 0x00, // only in IPSC
Reserved = 0xFF
};
public enum RegistrationStatusCode
{
CFSNotEnabled = 0x01,
RegistrationEntriesExceded = 0x02,
IncompatibleVersion = 0x03
};
public enum RegistrationStatus
{
Successful = 0x00,
Unsuccessful = 0x01
};
public enum RegistrationOperationCode
{
QueryRegStatus = 0x01,
DeRegister = 0x02
};
public enum WirelineChannelStatus
{
RegisteredWLStatus = 0x80,
NotRegisteredWLStatus = 0x00
};
public enum AddressType
{
IndividualCall = 0x01,
GroupCall = 0x02,
AllIndividualCall = 0x03,
AllTalkgroupCall = 0x04,
AllWideTakgroupsCall = 0x05,
AllLocalTalkgroupsCall = 0x06
};
public enum CSBKAttributes
{
// bit 0
VoiceCallNotInterruptible = 0x00,
VoiceCallInterruptible = 0x01,
// bit 1
ClearCall = 0x00,
PrivacyCall = 0x02,
// bit 2-3
ClearCall23 = 0x00,
BasicPrivacy = 0x01,
EnhancedPrivacy = 0x02,
// bit 6
CSBKService = 0x00,
CSBKMonitorOnly = 0x40,
// bit 7
CSBKNotRegisteredService = 0x00,
CSBKRegisteredService = 0x80
}
public enum VoiceAttributes
{
NormalService = 0x00,
VoiceMonitorOnly = 0x01,
NotRegisteredVoiceService = 0x00,
RegisterVoiceService = 0x01
};
public enum BurstType
{
VoiceBurstA = 0x01,
VoiceBurstB = 0x02,
VoiceBurstC = 0x03,
VoiceBurstD = 0x04,
VoiceBurstE = 0x05,
VoiceBurstF = 0x06,
VoiceTerminator = 0x07,
PrivacyHeader = 0x08,
Unknown = 0x00
}
public enum ServiceOption
{
// bit 3 - Only for group call
NonBroadcastService = 0x00,
BroadcastService = 0x04,
// bit 7
NonEmergencyService = 0x00,
BroadcastService7 = 0x80
}
public enum PrivacyType
{
Clear = 0x00,
Basic = 0x01,
Enhanced = 0x02
};
public enum ManufacturerID
{
StandardFeature = 0x00,
MotorolaSolutionProprietaryFeature = 0x10,
}
private string GetRegistrationStatus(int registrationStatus)
{
switch(registrationStatus)
{
case (int)RegistrationStatus.Successful: return "Successful";
case (int)RegistrationStatus.Unsuccessful: return "Unsuccessful";
default: return "RESERVED";
}
}
private string GetRegistrationStatusCode(int registrationStatusCode)
{
switch(registrationStatusCode)
{
case (int)RegistrationStatusCode.CFSNotEnabled: return "CFS Not Enabled";
case (int)RegistrationStatusCode.IncompatibleVersion: return "Incompatible Version";
case (int)RegistrationStatusCode.RegistrationEntriesExceded: return "Registration Entries Exceded";
case (int)0x00: return "Registered";
default: return "RESERVED";
}
}
private int ConvertCallType4MessageBus(CallType type)
{
switch (type)
{
case CallType.GroupVoiceCall: return (int)SafeMobileLib.CallType.GROUPCALL;
case CallType.PrivateVoiceCall: return (int)SafeMobileLib.CallType.PRIVATECALL;
case CallType.AllCall: return (int)SafeMobileLib.CallType.ALLCALL;
case CallType.EmergencyVoiceCall: return (int)SafeMobileLib.CallType.EMERGENCYCALL;
default: return 0;
}
}
private string GetCallType(int type)
{
switch (type)
{
case (int)CallType.CallAlertNackResponse: return "CallAlertNackResponse";
case (int)CallType.CallAlertRequest: return "CallAlertRequest";
case (int)CallType.CallAlertResponse: return "CallAlertResponse";
case (int)CallType.EmergencyCSBKAlertRequest: return "EmergencyCSBKAlertRequest";
case (int)CallType.EmergencyCSBKAlertResponse: return "EmergencyCSBKAlertResponse";
case (int)CallType.EmergencyVoiceCall: return "EmergencyVoiceCall";
case (int)CallType.GroupVoiceCall: return "GroupVoiceCall";
case (int)CallType.PrivateVoiceCall: return "PrivateVoiceCall";
case (int)CallType.IPConsoleRadioInhibitRequest: return "IPConsoleRadioInhibitRequest";
case (int)CallType.IPConsoleRadioInhibitResponse: return "IPConsoleRadioInhibitResponse";
case (int)CallType.IPConsoleRadioUninhibitRequest: return "IPConsoleRadioUninhibitRequest";
case (int)CallType.IPConsoleRadioUninhibitResponse: return "IPConsoleRadioUninhibitResponse";
case (int)CallType.AllCall: return "AllCall";
case (int)CallType.Other: return "Other";
case (int)CallType.GroupPhoneCall: return "GroupPhoneCall";
case (int)CallType.PrivatePhoneCall: return "PrivatePhoneCall";
case (int)CallType.PreambleEmergencyCall: return "PreambleEmergencyCall";
case (int)CallType.PreambleGroupCSBKCall: return "PreambleGroupCSBKCall";
case (int)CallType.PreamblePrivateCSBKCall: return "PreamblePrivateCSBKCall";
case (int)CallType.RadioCheckRequest: return "RadioCheckRequest";
case (int)CallType.RadioCheckResponse: return "RadioCheckResponse";
case (int)CallType.RadioInhibitRequest: return "RadioInhibitRequest";
case (int)CallType.RadioInhibitResponse: return "RadioInhibitResponse";
case (int)CallType.RadioInhibitUninhibitNackResponse: return "RadioInhibitUninhibitNackResponse";
case (int)CallType.RadioMonitorNackResponse: return "RadioMonitorNackResponse";
case (int)CallType.RadioRemoteMonitorRequest: return "RadioRemoteMonitorRequest";
case (int)CallType.RadioRemoteMonitorResponse: return "RadioRemoteMonitorResponse";
case (int)CallType.RadioUninhibitRequest: return "RadioUninhibitRequest";
case (int)CallType.RadioUninhibitResponse: return "RadioUninhibitResponse";
default:
{
if ((type >= 0x00 && type <= 0x31) || (type >= 0x35 && type <= 0x3F) || (type >= 0x4F && type <= 0x54)
|| (type >= 0x5A && type <= 0x5C) || (type >= 0x86 && type <= 0xFF))
return "RESERVED";
else
return "Unknown call type";
}
}
}
private CallType GetCallType(byte type)
{
switch (type)
{
case (byte)CallType.AllCall: return CallType.AllCall;
case (byte)CallType.GroupVoiceCall: return CallType.GroupVoiceCall;
case (byte)CallType.PrivateVoiceCall: return CallType.PrivateVoiceCall;
case (byte)CallType.PrivateCallRequest: return CallType.PrivateCallRequest;
case (byte)CallType.PrivateCallResponse: return CallType.PrivateCallResponse;
case (byte)CallType.GroupPhoneCall: return CallType.GroupPhoneCall;
case (byte)CallType.PrivatePhoneCall: return CallType.PrivatePhoneCall;
case (byte)CallType.PhoneAllCall: return CallType.PhoneAllCall;
case (byte)CallType.CallAlertNackResponse: return CallType.CallAlertNackResponse;
case (byte)CallType.CallAlertRequest: return CallType.CallAlertRequest;
case (byte)CallType.CallAlertResponse: return CallType.CallAlertResponse;
case (byte)CallType.EmergencyCSBKAlertRequest: return CallType.EmergencyCSBKAlertRequest;
case (byte)CallType.EmergencyCSBKAlertResponse: return CallType.EmergencyCSBKAlertResponse;
case (byte)CallType.IPConsoleRadioInhibitRequest: return CallType.IPConsoleRadioInhibitRequest;
case (byte)CallType.IPConsoleRadioInhibitResponse: return CallType.IPConsoleRadioInhibitResponse;
case (byte)CallType.IPConsoleRadioUninhibitRequest: return CallType.IPConsoleRadioUninhibitRequest;
case (byte)CallType.IPConsoleRadioUninhibitResponse: return CallType.IPConsoleRadioUninhibitResponse;
case (byte)CallType.Other: return CallType.Other;
case (byte)CallType.PreambleEmergencyCall: return CallType.PreambleEmergencyCall;
case (byte)CallType.PreambleGroupCSBKCall: return CallType.PreambleGroupCSBKCall;
case (byte)CallType.PreamblePrivateCSBKCall: return CallType.PreamblePrivateCSBKCall;
case (byte)CallType.RadioCheckRequest: return CallType.RadioCheckRequest;
case (byte)CallType.RadioCheckResponse: return CallType.RadioCheckResponse;
case (byte)CallType.RadioInhibitRequest: return CallType.RadioInhibitRequest;
case (byte)CallType.RadioInhibitResponse: return CallType.RadioInhibitResponse;
case (byte)CallType.RadioInhibitUninhibitNackResponse: return CallType.RadioInhibitUninhibitNackResponse;
case (byte)CallType.RadioMonitorNackResponse: return CallType.RadioMonitorNackResponse;
case (byte)CallType.RadioRemoteMonitorRequest: return CallType.RadioRemoteMonitorRequest;
case (byte)CallType.RadioRemoteMonitorResponse: return CallType.RadioRemoteMonitorResponse;
case (byte)CallType.RadioUninhibitRequest: return CallType.RadioUninhibitRequest;
case (byte)CallType.RadioUninhibitResponse: return CallType.RadioUninhibitResponse;
case (byte)CallType.EmergencyVoiceCall: return CallType.EmergencyVoiceCall;
default:
{
if ((type >= 0x00 && type <= 0x31) || (type >= 0x35 && type <= 0x3F) || (type >= 0x4F && type <= 0x54)
|| (type >= 0x5A && type <= 0x5C) || (type >= 0x86 && type <= 0xFF))
return CallType.Reserved;
else
return CallType.Reserved;
}
}
}
private BurstType GetBurstType(byte type)
{
switch (type)
{
case (byte)BurstType.PrivacyHeader: return BurstType.PrivacyHeader;
case (byte)BurstType.VoiceBurstA: return BurstType.VoiceBurstA;
case (byte)BurstType.VoiceBurstB: return BurstType.VoiceBurstB;
case (byte)BurstType.VoiceBurstC: return BurstType.VoiceBurstC;
case (byte)BurstType.VoiceBurstD: return BurstType.VoiceBurstD;
case (byte)BurstType.VoiceBurstE: return BurstType.VoiceBurstE;
case (byte)BurstType.VoiceBurstF: return BurstType.VoiceBurstF;
case (byte)BurstType.VoiceTerminator: return BurstType.VoiceTerminator;
default: return BurstType.Unknown;
}
}
private string GetChannelStatus(int channelStatus)
{
switch (channelStatus)
{
case (int)ChannelStatus.Active: return "Active";
case (int)ChannelStatus.Idle: return "Idle";
case (int)ChannelStatus.SlotBlocked: return "SlotBlocked";
case (int)ChannelStatus.SlotUnblocked: return "SlotUnblocked";
case (int)ChannelStatus.BusyRestChannel: return "BusyRestChannel";
case (int)ChannelStatus.RestChannelIdleAvailable: return "RestChannelIdleAvailable";
case (int)ChannelStatus.LocalGroupCallsNotAllowed: return "LocalGroupCallsBotAllowed";
case (int)ChannelStatus.LocalGroupCallsAllowed: return "LocalGroupCallsAllowed";
case (int)ChannelStatus.RestChannelBlocked: return "RestChannelBlocked";
default:
{
if (channelStatus == 0x00 || (channelStatus >= 0x03 && channelStatus <= 0x09) ||
(channelStatus >= 0x0C && channelStatus <= 0x0F) || (channelStatus >= 0x15 && channelStatus <= 0xFF))
return "RESERVED";
else
return "Unknown Channel Control Status";
}
}
}
private string GetSlotNumberName(int slotNumber, MotoRepeater.LinkEstablishment.SystemType systemType)
{
switch (slotNumber)
{
case (int)SlotNumber.Slot1: return "Slot1";
case (int)SlotNumber.Slot2: return "Slot2";
case 0x00:
{
switch (systemType)
{
case MotoRepeater.LinkEstablishment.SystemType.IP_SITE_CONNECT: return "RESERVED";
case MotoRepeater.LinkEstablishment.SystemType.CAPACITY_PLUS: return "RestChannel";
case MotoRepeater.LinkEstablishment.SystemType.LINKED_CAPACITY_PLUS: return "SiteIPAddress";
default: return "RESERVED";
}
}
default: return "RESERVED";
}
}
private SlotNumber GetSlotNumber(int slotNumber, MotoRepeater.LinkEstablishment.SystemType systemType)
{
switch (slotNumber)
{
case (int)SlotNumber.Slot1: return SlotNumber.Slot1;
case (int)SlotNumber.Slot2: return SlotNumber.Slot2;
case 0x00:
{
switch (systemType)
{
case MotoRepeater.LinkEstablishment.SystemType.IP_SITE_CONNECT: return SlotNumber.Reserved;
case MotoRepeater.LinkEstablishment.SystemType.CAPACITY_PLUS: return SlotNumber.RestChannel;
case MotoRepeater.LinkEstablishment.SystemType.LINKED_CAPACITY_PLUS: return SlotNumber.SiteIPAddress;
default: return SlotNumber.Reserved;
}
}
default: return SlotNumber.Reserved;
}
}
private int ConvertCallSessionStatus4MessageBus(CallSessionStatus status)
{
switch (status)
{
case CallSessionStatus.CallInProgress: return (int)CallStatus.INPROGRESS;
case CallSessionStatus.CallHang: return (int)CallStatus.HANGTIME;
case CallSessionStatus.CallEnd: return (int)CallStatus.ENDED;
default: return 0;
}
}
private CallSessionStatus GetCallSessionStatus(int callSessionStatus)
{
switch (callSessionStatus)
{
case (int)CallSessionStatus.CallInProgress: return CallSessionStatus.CallInProgress;
case (int)CallSessionStatus.CallHang: return CallSessionStatus.CallHang;
case (int)CallSessionStatus.CallEnd: return CallSessionStatus.CallEnd;
default: return CallSessionStatus.RESERVED;
}
}
private string GetChannelControlStatus(int chCtrlStatus)
{
switch (chCtrlStatus)
{
case (int)ChannelControlStatus.Received: return "Received";
case (int)ChannelControlStatus.Transmiting: return "Transmiting";
case (int)ChannelControlStatus.TransmissionSuccessful: return "TransmissionSuccessful";
case (int)ChannelControlStatus.Declined: return "Declined";
default: return "RESERVED";
}
}
#endregion
#region WIRELINE CLASSES
private static Int64 queryID = 0x01;
public class CSBKCall
{
public SlotNumber slotNumber = SlotNumber.Slot1;
public Int64 callID
{
get { return _callID; }
}
private static Int64 _callID = 0x131313;
public CallType callType = CallType.PreamblePrivateCSBKCall;
public Int64 sourceID = 0;
public Int64 targetID = 0;
public AccessCriteria accessCriteria = AccessCriteria.PoliteAccess;
public CallAttributes callAttributes = CallAttributes.SmartPTT;
public PreambleDuration preambleDuration = PreambleDuration.MinDuration;
public Int16 preambleValue = 0x03;
// added for current CSBK Call Status
public ChannelControlStatus chnCtrlstatus = ChannelControlStatus.Declined;
public Int64 crtCallID = 0;
public Boolean isCSBKPreambleReceived = false;
public CSBKCall() { _callID++; }
}
public class WirelineRegistration
{
public SlotNumber slotNumber = SlotNumber.Slot1;
public static Int64 registrationPduID = BitConverter.ToInt32(new byte[] { 0x61, 0x01, 0x15, 0x43 }, 0);
public readonly Int64 registrationID = 0x1;
public RegistrationOperationCode regOpCode = RegistrationOperationCode.QueryRegStatus;
public WirelineChannelStatus wirelineChannelStatus = WirelineChannelStatus.NotRegisteredWLStatus;
public int numberOfRegistrationEntries = 0;
public List<RegEntry> regEntriesList = new List<RegEntry>();
public WirelineRegistration() { }
// add a new entry for which the status will be broadcasted
public void AddRegEntry(RegEntry entry)
{
this.numberOfRegistrationEntries++;
regEntriesList.Add(entry);
}
}
public class RegEntry
{
public AddressType addressType = AddressType.AllIndividualCall;
public Int64 addressRangeStart = 0;
public Int64 addressRangeEnd = 0;
public CSBKAttributes csbkAttributes = CSBKAttributes.CSBKRegisteredService;
public RegEntry(AddressType addressType, Int64 startID, Int64 endID)
{
this.addressType = addressType;
this.addressRangeStart = startID;
this.addressRangeEnd = endID;
}
}
public class WirelineQueryRegistration
{
public SlotNumber slotNumber = SlotNumber.Slot1;
public Int64 registrationPduID = 0;
public RegistrationOperationCode regOpCode = RegistrationOperationCode.QueryRegStatus;
public WirelineQueryRegistration() { }
}
#endregion
#region EVENT DELEGATES
public delegate void RadioStatusChangedDEl(Int64 radioID, SlotNumber slot, Boolean isEnabled);
public event RadioStatusChangedDEl OnRadioStatusChanged;
public delegate void EmergencyReceivedDEl(Int64 radioID, SlotNumber slot);
public event EmergencyReceivedDEl OnEmergencyChanged;
public delegate void RegistrationReceivedDEl(Boolean isValid, SlotNumber slot);
public event RegistrationReceivedDEl OnRegistrationReceived;
public delegate void CallStatusReceivedDEl(Int64 sourceID, Int64 targertID, int callType, int callStatus, SlotNumber slot);
public event CallStatusReceivedDEl OnCallStatusReceived;
private delegate void ChannelControlStatusReceivedDel(Int64 callID, CallType callType, ChannelControlStatus chnCtrlStatus, SlotNumber slot);
private event ChannelControlStatusReceivedDel OnChannelControlStatusReceived;
public delegate void CallSessionStatusReceivedDEl(Int64 sourceID, Int64 targertID, CallType callType, CallSessionStatus callSessionStatus, SlotNumber slot);
public event CallSessionStatusReceivedDEl OnCallSesionStatusReceived;
public delegate void CSBKCallReceivedDEl(Int64 sourceID, Int64 targetID, CallType callType, SlotNumber slot);
public event CSBKCallReceivedDEl OnCSBKCallReceived;
public delegate void AudioFrameReceivedDEl(byte[] audioFrame, SlotNumber slot);
public event AudioFrameReceivedDEl OnAudioFrameReceived;
#endregion
}
}
Reference in New Issue Copy Permalink