SafeDispatch/MotoRepeaterCore/DataBaseSN.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Collections;
using SafeMobileLib;
using System.Threading;
using SafeMobileLib.MessageDecoders;

namespace MotoRepeater
{
    public class DataBaseSN : DataBaseInterface
    {
        private DBconnThread dbConnection;

        public static Thread DBThreadobjARS = null;
        public static Thread DBThreadobjGPS = null;
        public static Thread DBThreadobjAux = null;
        public static Thread DBThreadobjSMS = null;
        public static Thread DBThreadobjSMS_conf = null;
        public static Thread DBThreadobjAddr = null;
        public static Thread DBThreadobjPOLL = null;
        public static Thread DBThreadobjTallysman = null;

        private Thread checkUpdateInQueue = null;


        public static InterthreadMessageQueue<TallysmanEventArgs> tallysmanEventsQueue 
                    = new InterthreadMessageQueue<TallysmanEventArgs>();



        /// <summary>
        /// Default Constructor
        /// </summary>
        public DataBaseSN()
        {
            /*string MyConString = "SERVER=" + MotoRepeater_GW.cfg.DB_SERVER + "; " +
                   "DATABASE=" + MotoRepeater_GW.cfg.DB_DATABASE + "; " +
                   "UID=" + MotoRepeater_GW.cfg.DB_USERNAME + "; " +
                   "PASSWORD=" + MotoRepeater_GW.cfg.DB_PASSWORD + "; Pooling=true;max pool size = 100";*/

            dbConnection = new DBconnThread(MotoRepeater_GW.cfg.DB_SERVER, MotoRepeater_GW.cfg.DB_DATABASE,
               MotoRepeater_GW.cfg.DB_USERNAME, MotoRepeater_GW.cfg.DB_PASSWORD, MotoRepeater_GW.cfg.GWCODE + "");
            dbConnection.StartDB();

            // start the threads which will bring the list of smss, polls, etc
            StartDBService();

            checkUpdateInQueue = new Thread(delegate()
            {
                while (MotoRepeater_GW.isRunning)
                {
                    CheckForPollRequests();
                    Thread.Sleep(50);
                    CheckForSMSRequests();
                    Thread.Sleep(950);
                }
            });
            checkUpdateInQueue.Start();


            /*
            // add event listener for when a Poll request is received
            mBus.OnPollRequest += delegate(Int64 radioID)
            {
                PollRequestEventArgs e = new PollRequestEventArgs();
                e.RadioID = radioID;

                // raise the event
                OnPollRequestReceived(null, e);
            };

            // add event listener for when a radio needs to be enabled/disabled
            mBus.OnRadioEnableDisableRequest += delegate(Int64 radioID, bool enable, Wireline.SlotNumber slot)
            {
                RadioEnableDisableRequestEventArgs e = new RadioEnableDisableRequestEventArgs();
                e.Enabled = enable;
                e.RadioID = radioID;
                e.Slot = slot;

                // raise the event
                this.OnRadioEnableDisableRequest(null, e);
            };


            mBus.OnEmergencyAckRequest += delegate(Int64 radioID, Wireline.SlotNumber slot)
            {
                EmergencyAckEventArgs e = new EmergencyAckEventArgs();
                e.RadioID = radioID;
                e.Slot = slot;

                // raise the event
                this.OnEmergencyAckRequest(null, e);
            };


            mBus.OnChannelQueryRequest += delegate(Int64 radioGWID)
            {
                ChannelQueryEventArgs e = new ChannelQueryEventArgs();
                e.RadioGwID = radioGWID;
                
                // raise the event
                OnChannelQuery(null, e);
            };


            #region PRIVATECALL
            // intercept events for Private Call
            mBus.OnInitPrivateCallRequest += delegate(Int64 radioID, string broadcastAddress, Wireline.SlotNumber slot)
            {
                this.OnInitPrivateCallRequest(radioID, broadcastAddress, slot);
            };

            mBus.OnEndPrivateCallRequest += delegate(Int64 radioID, string broadcastAddress, Wireline.SlotNumber slot)
            {
                this.OnEndPrivateCallRequest(radioID, broadcastAddress, slot);
            };
            #endregion

            #region GROUPCALL
            // intercept events for Group Call
            mBus.OnInitGroupCallRequest += delegate(Int64 groupID, string broadcastAddress, Wireline.SlotNumber slot)
            {
                this.OnInitGroupCallRequest(groupID, broadcastAddress, slot);
            };

            mBus.OnEndGroupCallRequest += delegate(Int64 groupID, string broadcastAddress, Wireline.SlotNumber slot)
            {
                this.OnEndGroupCallRequest(groupID, broadcastAddress, slot);
            };
            #endregion

            #region ALLCALL
            // intercept events for All Call
            mBus.OnInitAllCallRequest += delegate(string broadcastAddress, Wireline.SlotNumber slot)
            {
                this.OnInitAllCallRequest(broadcastAddress, slot);
            };

            mBus.OnEndAllCallRequest += delegate(string broadcastAddress, Wireline.SlotNumber slot)
            {
                this.OnEndAllCallRequest(broadcastAddress, slot);
            };
            #endregion
            
            */
        }


        public void PollResponseReceived(long radioID, DateTime locationTime, int speed, double latitude, double longitude, Int64 seqID)
        {
            htCell_t cell = new htCell_t();
            cell.suid = radioID + "";
            cell.d_lat = latitude;
            cell.d_lng = longitude;
            cell.seqID = seqID;
            cell.lat = latitude + "";
            cell.lng = longitude + "";
            cell.spd = speed+"";
            cell.location_time = locationTime;

            lock (SN_Queues.ht_POLL_List.SyncRoot)
            {
                foreach (DictionaryEntry item in SN_Queues.ht_POLL_List)
                {
                    Utils.WriteLine("REQ " + ((POLLmsg)item.Value).requestID + "  |  seqID " + seqID , ConsoleColor.Red);

                    // check to see if this poll will ACK a poll request
                    if (((POLLmsg)item.Value).requestID == seqID)
                    {
                        ((POLLmsg)item.Value).response = cell.location_time;
                        ((POLLmsg)item.Value).lat = cell.lat;
                        ((POLLmsg)item.Value).lng = cell.lng;
                        ((POLLmsg)item.Value).speed = cell.spd;

                        // add position to the queue
                        SN_Queues.DBQueueLocation.PostItem(cell);

                        // add poll to the queue
                        SN_Queues.recvPOLLQueue.PostItem((POLLmsg)item.Value);

                        SN_Queues.ht_POLL_List.Remove(item);
                        break;
                    }
                }

                // remove poll from pending list
                lock (SafeMobileLib.SN_Queues.ht_pendingMsg.SyncRoot)
                {
                    try
                    {
                        Hashtable tmp = new Hashtable();
                        foreach (DictionaryEntry de in SafeMobileLib.SN_Queues.ht_pendingMsg)
                        {
                            MotoTRBOcmdMsg m = (MotoTRBOcmdMsg)de.Value;

                            // add message in the pending hash is the response is stil not received
                            if (m.m_seqID != seqID)
                                tmp.Add(m.m_seqID, m);
                        }
                        SafeMobileLib.SN_Queues.ht_pendingMsg = tmp;
                        lastHashVerify = DateTime.Now;
                    }
                    catch (Exception e)
                    {
                        //LOGS.LOG("Error: cannot reset pending messages HashTable" + e.ToString(), ConsoleColor.Red);
                    }
                }//release lock
            }
        }

        public void LocationResponseReceived(long radioID, DateTime locationTime, int speed, double latitude, double longitude)
        {
            htCell_t cell = new htCell_t();
            cell.suid = radioID + "";
            cell.d_lat = latitude;
            cell.d_lng = longitude;
            cell.lat = latitude + "";
            cell.lng = longitude + "";
            cell.spd = speed + "";
            cell.location_time = locationTime;

            // add location to the queue
            SN_Queues.DBQueueLocation.PostItem(cell);
        }


        public void LocationReceived(LocationEventArgs e)
        {
            htCell_t cell = new htCell_t();
            cell.suid = e.RadioID+"";
            cell.d_lat = e.Latitude;
            cell.d_lng = e.Longitude;
            cell.lat = e.Latitude + "";
            cell.lng = e.Longitude + "";
            cell.spd = e.Speed + "";
            cell.location_time =  (new DateTime(1970, 1, 1)).AddSeconds(e.GPSTime); //Utils.UnixTimeStampToDateTime(e.Time);

            // add level of confidence only if received
            if (e.LevelOfConfidence > -1)
                cell.level_confidence = (int)e.LevelOfConfidence;

            // add location to the queue
            SN_Queues.DBQueueLocation.PostItem(cell);
        }

        public void ARSStateReceived(long radioID, bool isON)
        {
            try
            {
                ArsMSG ars = new ArsMSG();
                ars.imei = radioID+"";
                ars.msg = isON ? "ON" : "OFF";
                SN_Queues.arsMsgQueue.PostItem(ars);
            }
            catch (Exception e)
            {
                Utils.WriteLine("ERROR ARS " + e.ToString());
            }
        }

        // radioID is equal with the suID
        public void SMSReceived(long radioID, byte[] received)
        {
            // NOT IN SAFENET
        }

        public void SMSReceived(long radioID, string message)
        {
            bool result = dbConnection.DB.insertSMSinDB("" + radioID, message);

            if(!result)
            {
                Utils.WriteLine("COULD NOT INSERT SMS", ConsoleColor.Red);
            }
            else
                Utils.WriteLine("SMS INSERTED", ConsoleColor.Gray);
        }

        public void SMSAckReceived(byte[] received, string seq_no)
        {

            Utils.WriteLine("»»» SMS ACK with sequence nr. " + seq_no);
            lock (SN_Queues.waitConfSMSList.SyncRoot)
            {
                int index = -1;
                int count = 0;
                foreach (SMSmsg msg in SN_Queues.waitConfSMSList)
                {
                    Int16 seqNo = 0;
                    Int16.TryParse(seq_no, out seqNo);
                    if (msg.seq_no == seqNo)
                    {
                        index = count;
                        SN_Queues.confSMSQueue.PostItem(msg);
                    }
                    count++;
                }
                if (index > -1) //we've found the message
                    SN_Queues.waitConfSMSList.RemoveAt(index);
            }
        }

        public void TelemetryReceived(long radioID, byte[] received)
        {
            // NOT IN SAFENET
        }


        public void TelemetryReceived(TelemetryReceivedEventArgs telemetryArgs)
        {
            // NOT IN SAFENET
        }


        public void RadioEnableDisableStatusReceived(long radioID, Wireline.SlotNumber slot, bool isEnabled)
        {
            //mBus.RadioEnableDisableStatusBroadcast(radioID, isEnabled);
        }

        public void EmergencyReceived(long radioID, Wireline.SlotNumber slot)
        {
            //mBus.SendEmergencyReceived(radioID);
        }

        public void CallStatusBroadcastReceived(long sourceID, long targertID, CallType callType, CallStatus callStatus, Wireline.SlotNumber slot)
        {
            //mBus.CallStatusBroadcast(sourceID, targertID, (int)callType, (int)callStatus, slot);
        }



        public void TallysmanEventReceived(TallysmanEventArgs tallysmanArgs)
        {
            
            // add received event to a queue
            tallysmanEventsQueue.PostItem(tallysmanArgs);
        }


        public void SendChannelBroadcastMessage(long radioGWID)
        {
            //mBus.sendChannelBroadcastMessage(radioGWID);
        }


        public void Stop()
        {
            StopDBService();
        }

        /// <summary>
        /// Start threads and database connections
        /// </summary>
        void StartDBService()
        {
            try
            {
                dbConnection.OnGPSInsertedBlocked += delegate ()
                {
                    OnGPSInsertedBlocked?.Invoke();
                    DBThreadobjGPS?.Abort();
                    DBThreadobjGPS = null;

                    DBThreadobjGPS = new Thread(new ThreadStart(dbConnection.HandleConnectionGPS));
                    DBThreadobjGPS.IsBackground = true;
                    DBThreadobjGPS.Start();

                };


                //Start GPS DB thread
                DBThreadobjGPS = new Thread(new ThreadStart(dbConnection.HandleConnectionGPS));
                DBThreadobjGPS.IsBackground = true;
                DBThreadobjGPS.Start();
                Thread.Sleep(200);

                //Start ARS DB thread
                DBThreadobjARS = new Thread(new ThreadStart(dbConnection.HandleConnectionARS));
                DBThreadobjARS.IsBackground = true;
                DBThreadobjARS.Start();
                Thread.Sleep(200);

                //Start Units DB thread
                DBThreadobjAux = new Thread(new ThreadStart(dbConnection.HandleConnectionAux));
                DBThreadobjAux.IsBackground = true;
                DBThreadobjAux.Start();
                Thread.Sleep(200);

                //Start SMS DB thread
                DBThreadobjSMS = new Thread(new ThreadStart(dbConnection.HandleConnectionSMS));
                DBThreadobjSMS.IsBackground = true;
                DBThreadobjSMS.Start();
                Thread.Sleep(200);

                //Start SMS DB thread
                DBThreadobjSMS_conf = new Thread(new ThreadStart(dbConnection.HandleConnectionSMS_conf));
                DBThreadobjSMS_conf.IsBackground = true;
                DBThreadobjSMS_conf.Start();
                Thread.Sleep(200);

                //Start Addres insert thread
                DBThreadobjAddr = new Thread(new ThreadStart(dbConnection.HandleConnectionAddr));
                DBThreadobjAddr.IsBackground = true;
                //DBThreadobjAddr.Start();
                Thread.Sleep(200);

                //Start POLL thread
                DBThreadobjPOLL = new Thread(new ThreadStart(dbConnection.HandleConnectionPOLL));
                DBThreadobjPOLL.IsBackground = true;
                DBThreadobjPOLL.Start();
                Thread.Sleep(200);


                //Start Tallysman thread
                DBThreadobjTallysman = new Thread(new ThreadStart(dbConnection.HandleTallysmanEvents));
                DBThreadobjTallysman.IsBackground = true;
                DBThreadobjTallysman.Start();
                Thread.Sleep(200);
            }
            catch (Exception e)
            {
                Utils.WriteLine("Could not intialize the connection with location server!\r\n" + e.Message + "\r\nPlease check your internet connection !!", ConsoleColor.Red);
                //System.Environment.Exit(1);
            }

        }

        /// <summary>
        /// Stop all threads and database connections
        /// </summary>
        private void StopDBService()
        {
            if (dbConnection != null)
            {
                dbConnection.StopDB();
            }

            if (DBThreadobjARS != null)
            {
                DBThreadobjARS.Abort();
            }

            if (DBThreadobjGPS != null)
            {
                DBThreadobjGPS.Abort();
            }

            if (DBThreadobjAux != null)
            {
                DBThreadobjAux.Abort();
            }

            if (DBThreadobjSMS != null)
            {
                DBThreadobjSMS.Abort();
            }

            if (DBThreadobjSMS_conf != null)
            {
                DBThreadobjSMS_conf.Abort();
            }

            if (DBThreadobjAddr != null)
            {
                DBThreadobjAddr.Abort();
            }

            if (DBThreadobjPOLL != null)
            {
                DBThreadobjPOLL.Abort();
            }

            if (DBThreadobjTallysman != null)
            {
                DBThreadobjTallysman.Abort();
            }
        }

        #region POLL REQUESTS MANAGEMENT
        private int reqID_send = 0;
        private DateTime lastHashVerify = DateTime.Now;
        private void CheckForPollRequests()
        {
            
            MotoTRBOcmdMsg msg = SN_Queues.locationQueue.GetItem(100);
            if (msg != null)
            {
                //Console.WriteLine("Processing command");
                //Console.WriteLine("SN_Queues.locationQueue.Count:" + SN_Queues.locationQueue.Count);
                ProcessPollCommand(msg); //this will update the m_seqID and m_time
                SafeMobileLib.SN_Queues.ht_pendingMsg.Add(msg.m_seqID, msg);
                msg = null;
                //Console.WriteLine("Processing end");
            }

            //is now answer within 30 secconds resend
            if (SafeMobileLib.SN_Queues.ht_pendingMsg.Count > 0)
            {
                if ((DateTime.Now.Ticks - lastHashVerify.Ticks) > 5 * 1000 * 10000)
                {
                    lock (SafeMobileLib.SN_Queues.ht_pendingMsg.SyncRoot)
                    {
                        try
                        {
                            Hashtable tmp = new Hashtable();
                            //Utils.WriteLine("GPS answers check at :" + DateTime.Now);
                            foreach (DictionaryEntry de in SafeMobileLib.SN_Queues.ht_pendingMsg)
                            {
                                MotoTRBOcmdMsg m = (MotoTRBOcmdMsg)de.Value;

                                // resend after 30 seconds if no response received
                                if (DateTime.Now.Ticks - m.m_created.Ticks > 180 * 1000 * 10000)
                                {
                                    //Utils.WriteLine("I CAN DELETE postItem", ConsoleColor.Cyan);
                                    // do not add the message again in the queue
                                }
                                else if (DateTime.Now.Ticks - m.m_created.Ticks > 30 * 1000 * 10000)
                                {
                                    if (DateTime.Now.Ticks - m.m_time.Ticks > 30 * 1000 * 10000)
                                    {
                                        //Utils.WriteLine("I HAVE TO RESEND MESSAGE", ConsoleColor.Magenta);
                                        m.m_cmd = (byte)MotoTRBOcmd.SEND_POLL;
                                        //LOGS.LOG("PUT back in ht_pendingMsg :" + m.m_suid);
                                        //Utils.WriteLine("PUT back in ht_pendingMsg :" + m.m_suid);
                                        SN_Queues.locationQueue.PostItem(m);
                                    }
                                    else
                                        tmp.Add(m.m_seqID, m);
                                }
                                else
                                    tmp.Add(m.m_seqID, m);

                            }
                            SafeMobileLib.SN_Queues.ht_pendingMsg = tmp;
                            lastHashVerify = DateTime.Now;
                        }
                        catch (Exception e)
                        {
                            //LOGS.LOG("Error: cannot reset pending messages HashTable" + e.ToString(), ConsoleColor.Red);
                        }
                    }//release lock
                    //LOGS.LOG("Debug: UN-LOCK1");
                }
            }
        }

        /// <summary>
        /// Process a poll request which needs to be send and then added to 
        /// the Poll Hashtable where all the pending requests are stored
        /// </summary>
        /// <param name="p_msg">A custom message containing the poll values</param>
        private void ProcessPollCommand(MotoTRBOcmdMsg p_msg)
        {
            try
            {
                reqID_send++;
                if (reqID_send == byte.MaxValue)
                    reqID_send = 1;

                p_msg.m_seqID = BitConverter.ToInt32(new byte[] { (byte)reqID_send, 0xAC, 0x68, 0x24 }, 0);
                p_msg.m_time = DateTime.Now;

                if (p_msg.m_cmd == (byte)MotoTRBOcmd.SEND_POLL)
                {
                    PollRequestEventArgs e = new PollRequestEventArgs();
                    e.RadioID = p_msg.m_suid;
                    e.SeqID = reqID_send;

                    OnPollRequestReceived(null, e);
                    
                    //SendPollRequest(p_msg.m_suid, reqID_send);
                    //Utils.ConsWrite(DebugMSG_Type.GPS, "Poll request sent for unit:" + p_msg.m_suid);

                    lock (SN_Queues.ht_POLL_List.SyncRoot)
                    {
                        foreach (DictionaryEntry item in SN_Queues.ht_POLL_List)
                        {
                            try
                            {
                                if (((POLLmsg)item.Value).suid == p_msg.m_suid && ((POLLmsg)item.Value).DBid.ToString() == p_msg.m_payload)
                                {
                                    ((POLLmsg)item.Value).sent = DateTime.Now.ToUniversalTime();
                                    ((POLLmsg)item.Value).requestID =  0x24*256*256*256 + 0x68*256*256 + 0xAC*256 + reqID_send;

                                    //Utils.WriteLine("ADDED POLL WITH REQID : " + ((POLLmsg)item.Value).requestID + " [0x24 0x68 0xAC 0x" + reqID_send + "]", ConsoleColor.Cyan);
                                    
                                    //Utils.ConsWrite(DebugMSG_Type.DB, "Poll request found in MotoTRBOGW.ht_POLL_List for unit:" + p_msg.m_suid);
                                    //Utils.ConsWrite(DebugMSG_Type.DB, "reqID_send:" + reqID_send);
                                    SN_Queues.sentPOLLQueue.PostItem((POLLmsg)item.Value);
                                    break;
                                }
                            }
                            catch (Exception ex)
                            {
                                Utils.WriteLine("ERROR in foreach (DictionaryEntry item in SN_Queues.ht_POLL_List):" + ex.ToString(), ConsoleColor.Red);
                            }
                        }
                    }

                }
            }
            catch (Exception e)
            {
                Utils.WriteLine("Could not send Location Request to unit: " + e.ToString(), ConsoleColor.Red);
            }
        }
        #endregion



        #region SMS REQUESTS MANAGEMENT
        private int reqID_sms = 2;

        //private DateTime lastHashVerify = DateTime.Now;
        private void CheckForSMSRequests()
        {
            try
            {
                //MotoTRBOcmdMsg msg = MotoTRBOGW.locationQueue.GetItem(100);
                SMSmsg msg = SN_Queues.sendSMSQueue.GetItem(100);//block until message is in queue
                // exit if not message
                if (msg == null)
                    return;
                // set the sequence number
                msg.seq_no = reqID_sms++;

                SMSRequestEventArgs e = new SMSRequestEventArgs();
                e.RadioID = msg.suid;
                e.seqID = msg.seq_no;
                e.isACKWanted = msg.req_conf;
                e.message = msg.msg;

                // trigger event
                OnSMSRequestReceived(null, e);

                if (msg.req_conf)
                {
                    //Utils.ConsWrite(DebugMSG_Type.SMS, "Requesting SMS Confirmation!!!!");
                    lock (SN_Queues.waitConfSMSList.SyncRoot)
                    {
                        msg.waitConfSMSList_time = DateTime.Now;

                        SN_Queues.waitConfSMSList.Add(msg);
                    }
                }

                Thread.Sleep(1200);//minimum interval between SMS as per MotoTRBO specs
            }
            catch (Exception ex)
            {
                Utils.WriteLine("MUST HANDLE THIS EXCEPTION : " + ex.ToString());
            }
        }
        #endregion
        /// <summary>
        /// Get the reporting interval from the Database for a particular unit 
        /// </summary>
        /// <param name="radioID">Radio Id of the unit for which </param>
        /// <returns></returns>
        public int GetReportingIntervalForUnit(string radioID)
        {
            int reportInterval = 60;
            if (SN_Queues.ht_SUInfo.ContainsKey(radioID))
                reportInterval = ((SUinfo)SN_Queues.ht_SUInfo[radioID]).repInterval;
            else
                reportInterval = -1;

            return reportInterval;
        }



        public bool UnitIsAssignedToGw(string radioID)
        {
            if (SN_Queues.ht_SUInfo.ContainsKey(radioID))
                return true;
            else
                return false;
        }

        #region EVENTS
        #region AUDIO EVENTS
        public delegate void InitPrivateCallRequest(Int64 radioID, String broadcastAddress, Wireline.SlotNumber slot);
        public event InitPrivateCallRequest OnInitPrivateCallRequest;
        public delegate void EndPrivateCallRequest(Int64 radioID, String broadcastAddress, Wireline.SlotNumber slot);
        public event EndPrivateCallRequest OnEndPrivateCallRequest;

        public delegate void InitGroupCallRequest(Int64 groupID, String broadcastAddress, Wireline.SlotNumber slot);
        public event InitGroupCallRequest OnInitGroupCallRequest;
        public delegate void EndGroupCallRequest(Int64 groupID, String broadcastAddress, Wireline.SlotNumber slot);
        public event EndGroupCallRequest OnEndGroupCallRequest;

        public delegate void InitAllCallRequest(String broadcastAddress, Wireline.SlotNumber slot);
        public event InitAllCallRequest OnInitAllCallRequest;
        public delegate void EndAllCallRequest(String broadcastAddress, Wireline.SlotNumber slot);
        public event EndAllCallRequest OnEndAllCallRequest;
        #endregion
        
        #region POLL EVENT
        /// <summary>
        /// Events for Poll Request Received
        /// </summary>
        private object _lockPoll = new object();
        public event EventHandler<PollRequestEventArgs> OnPollRequestReceived;
        event EventHandler<PollRequestEventArgs> DataBaseInterface.OnPollRequestReceived
        {
            add { lock (_lockPoll) { OnPollRequestReceived += value; } }
            remove { lock (_lockPoll) { OnPollRequestReceived -= value; } }
        }
        #endregion

        #region RADIO ENABLE DISABLE EVENT
        private object _lockRadioED = new object();
        public event EventHandler<RadioEnableDisableRequestEventArgs> OnRadioEnableDisableRequest;
        event EventHandler<RadioEnableDisableRequestEventArgs> DataBaseInterface.OnRadioEnableDisableRequest
        {
            add { lock (_lockRadioED) { OnRadioEnableDisableRequest += value; } }
            remove { lock (_lockRadioED) { OnRadioEnableDisableRequest -= value; } }
        }
        #endregion

        #region EMERGENCY ACK EVENT
        private object _lockEmergencyAck = new object();
        public event EventHandler<EmergencyAckEventArgs> OnEmergencyAckRequest;
        event EventHandler<EmergencyAckEventArgs> DataBaseInterface.OnEmergencyAckRequest
        {
            add { lock (_lockEmergencyAck) { OnEmergencyAckRequest += value; } }
            remove { lock (_lockEmergencyAck) { OnEmergencyAckRequest -= value; } }
        }
        #endregion

        #region CHANNEL QUERY EVENT
        private object _lockChannelQuery = new object();
        public event EventHandler<ChannelQueryEventArgs> OnChannelQuery;
        event EventHandler<ChannelQueryEventArgs> DataBaseInterface.OnChannelQuery
        {
            add { lock (_lockChannelQuery) { OnChannelQuery += value; } }
            remove { lock (_lockChannelQuery) { OnChannelQuery -= value; } }
        }
        #endregion

        #region SMS REQUEST EVENT
        private object _lockSMSRequest = new object();
        public event EventHandler<SMSRequestEventArgs> OnSMSRequestReceived;
        event EventHandler<SMSRequestEventArgs> DataBaseInterface.OnSMSRequestReceived
        {
            add { lock (_lockSMSRequest) { OnSMSRequestReceived += value; } }
            remove { lock (_lockSMSRequest) { OnSMSRequestReceived -= value; } }
        }
        #endregion

        #region GROUP SMS REQUEST EVENT
        private object _lockGroupSMSRequest = new object();
        public event EventHandler<SMSRequestEventArgs> OnGroupSMSRequestReceived;
        event EventHandler<SMSRequestEventArgs> DataBaseInterface.OnGroupSMSRequestReceived
        {
            add { lock (_lockGroupSMSRequest) { OnGroupSMSRequestReceived += value; } }
            remove { lock (_lockGroupSMSRequest) { OnGroupSMSRequestReceived -= value; } }
        }
        #endregion
        
        #region TELEMETRY REQUEST EVENT
        private object _lockTelemetryRequest = new object();
        public event EventHandler<TelemetryRequestEventArgs> OnTelemetryRequestReceived;
        event EventHandler<TelemetryRequestEventArgs> DataBaseInterface.OnTelemetryRequestReceived
        {
            add { lock (_lockTelemetryRequest) { OnTelemetryRequestReceived += value; } }
            remove { lock (_lockTelemetryRequest) { OnTelemetryRequestReceived -= value; } }
        }
        #endregion
        #endregion

        public delegate void GPSInsertedBlockedDel();
        public event GPSInsertedBlockedDel OnGPSInsertedBlocked;
    }
}