SafeDispatch/MotoTrbo_GW/radio.cs

964 lines
38 KiB
C#
Raw Normal View History

2024-02-22 16:43:59 +00:00
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Windows.Forms;
using Telerik.WinControls.UI;
using System.Collections;
using Nini.Config;
using Telerik.WinControls;
using SafeMobileLib;
using MotoTRBO_XNL_Cmd;
using System.Threading;
using System.Diagnostics;
namespace MotoTrbo_GW
{
public partial class radioForm : ShapeNew
{
private bool radioON=false;
System.Threading.Timer _gatewayStatusTimer = null;
private bool onOFFpreStatus = false;
private int radioID;
private int radioIMEI;
private int radioNetworkID;
private IConfigSource source = null;
public string DBServer, DBSchema, DBUser, DBPass, DBPort;
DBgatewaysManager db4gateway;
List<RadioZones> zonesList;
List<RadioChannels> channelList;
private Boolean Collapse = false;
ArrayList radioIPlist;
//voice device
private int selectedOUTDevice;
private string selectedOUTDeviceName;
private int selectedINDevice;
private string selectedINDeviceName;
public ArrayList soundOUTDevices;
public ArrayList soundINDevices;
//IP's
private string radioIP;
private string messageBusIP;
private int messageBusPort = 17233;
public RadioComHandler rcHandler =null;
private PingThread ping;
RadioConnection radioC;
private object _locker = new object();
#region LINX
/// <summary>
/// Returns the Radio gateway ID
/// </summary>
public int RadioID
{
get {
return radioID;
}
}
/// <summary>
/// Returns the Radio gateway IP
/// </summary>
public string RadioIP
{
get {
return radioIP;
}
}
#endregion
#region constructor
public radioForm(int RadioID, string radioIP, int radioImei)
{
selectedZoneNr = 0; selectedChannelNr = 0;
radioID = RadioID;
this.radioIP = radioIP;
this.radioIMEI = radioImei;
//constructor stuff
constructorHelper();
//load config
LoadConfig();
//DB manager for zones and channels
db4gateway = new DBgatewaysManager(DBServer, DBSchema, DBUser, DBPass, DBPort);
//add zones
LoadZones();
//add channels
LoadChannels();
iniVoiceComponents();
SafeMobileLib.Utils.WriteLine("Constructor done for radio with ID:" + radioID);
// add default to texboxes
string voiceMulticastIP = "224.10." + Main.GWID.ToString() + "." + radioID.ToString();
tbVoiceIP.Text = voiceMulticastIP;
tbVoicePort.Text = "17234";
tbRadioIMEI.Text = radioIMEI.ToString();
tbMulticastIp.Text = Main.messageBusIP;
tbMulticastPort.Text = Main.messageBusPort;
_gatewayStatusTimer = new System.Threading.Timer(_gatewayStatusTimer_Elapsed, null, 3000, 10000);
Thread PingThreadObj = new Thread(new ThreadStart(watchForPing));
PingThreadObj.IsBackground = true;
PingThreadObj.Start();
}
void _gatewayStatusTimer_Elapsed(object obj)
{
if (radioON)
{
//send Gateway On command to MSG bus
string test = "#500#" + Main.GWID + "#" + radioID + "#ON#";
MessageBusHandler.SendOnMsgBuss("0.0", test);
}
}
#region ping events
private bool Connect_in_progress = false;
void watchForPing()
{
bool status = false;
while (true)
{
if(Main.RadioComArr.ContainsKey(radioIP))
status = true;
else
status =false;
if (!status)
{
if (radioON)
{
SafeMobileLib.Utils.WriteLine("Ping failed and gw still ON -> shuting GW down to sync");
onOFFpreStatus = true;
PingCallbackTurnOff d = new PingCallbackTurnOff(PingFallowUPTurnOff);
this.Invoke(d, new object[] { });
}
else
{
//SafeMobileLib.Utils.WriteLine("Ping failed and gw OFF -> already sync");
}
}
else
{
if (!radioON)
{
if (onOFFpreStatus)
{
if (!Connect_in_progress)
{
PingCallback d = new PingCallback(PingFallowUP);
this.Invoke(d, new object[] { });
}
}
}
else
{
//SafeMobileLib.Utils.WriteLine("Ping success and gw ON -> already sync");
}
}
Thread.Sleep(5000);
}
}
void ping_OnNewPingComplete(bool status, string interfaceIP)
{
if (!status)
{
if (radioON)
{
SafeMobileLib.Utils.WriteLine("Ping failed and gw still ON -> shuting GW down to sync");
onOFFpreStatus = true;
PingCallbackTurnOff d = new PingCallbackTurnOff(PingFallowUPTurnOff);
this.Invoke(d, new object[] { });
}
else
{
//SafeMobileLib.Utils.WriteLine("Ping failed and gw OFF -> already sync");
}
}
else
{
if (!radioON)
{
if (onOFFpreStatus)
{
if (!Connect_in_progress)
{
PingCallback d = new PingCallback(PingFallowUP);
this.Invoke(d, new object[] { });
}
}
}
else
{
//SafeMobileLib.Utils.WriteLine("Ping success and gw ON -> already sync");
}
}
}
delegate void PingCallback();
public void PingFallowUP()
{
System.Threading.Thread.Sleep(500);
btONOFF.PerformClick();
}
delegate void PingCallbackTurnOff();
public void PingFallowUPTurnOff()
{
TurnOff(true);
}
#endregion
private void constructorHelper()
{
soundOUTDevices = new ArrayList();
soundINDevices = new ArrayList();
// load default configuration
selectedOUTDevice = 0;
selectedOUTDeviceName = "";
selectedINDevice = 0;
selectedINDeviceName = "";
InitializeComponent();
((Telerik.WinControls.Primitives.BorderPrimitive)(this.btCollapse.GetChildAt(2))).ForeColor = System.Drawing.Color.Transparent;
((Telerik.WinControls.Primitives.BorderPrimitive)(this.ImgRad.GetChildAt(2))).ForeColor = System.Drawing.Color.Transparent;
((Telerik.WinControls.Primitives.BorderPrimitive)(this.ImgStat.GetChildAt(2))).ForeColor = System.Drawing.Color.Transparent;
btONOFF.Text = "ON";
cbChan.Enabled = false;
cbZone.Enabled = false;
//this before loadSetup
radioIPlist = new ArrayList();
radioIPlist.Add(this.radioIP);
//radioIPlist = RadioStuff.getAllRadiosIPs();
cbRadioIP.DataSource = radioIPlist;
lbStatusScreen.Text = "";
}
#endregion
private void EnableAudioSettingsPanels(bool value)
{
listPlayBDevices.Enabled = value;
listRecBDevices.Enabled = value;
btnSaveRadioSettings.Enabled = value;
}
#region events
public void AuthDone()
{
btONOFF.Text = "OFF";
ImgRad.Image = global::MotoTrbo_GW.Properties.Resources.radioGREEN;
ImgStat.Image = global::MotoTrbo_GW.Properties.Resources.green_status;
EnableAudioSettingsPanels(false);
cbChan.Enabled = true;
cbZone.Enabled = true;
radioON = true;
btONOFF.Enabled = true;
rcHandler.SendZoneChannelChange(0,0);
Connect_in_progress = false;
//send on message to MSG bus
string test = "#100#" + Main.GWID + "." + radioID + "#1#";
MessageBusHandler.SendOnMsgBuss("0.0", test);
try
{
SafeMobileLib.Utils.WriteEventLog("Safemobile", "Station with IP:" + radioIP + " is ON", EventLogEntryType.Information, 31021);
}
catch (Exception ex)
{
SafeMobileLib.Utils.WriteLine("Unable to write log Event ex:" + ex.ToString());
}
}
delegate void ChannelEventCallback(int zoneNr, int channelNr);
void rcHandler_OnChannelEvent(int zoneNr,int channelNr)
{
ChannelEventCallback d = new ChannelEventCallback(ChannelEvent);
this.Invoke(d, new object[] {zoneNr, channelNr });
}
public void ChannelEvent(int zoneNr, int channelNr)
{
try
{
selectedChannelNr = channelNr;
selectedZoneNr = zoneNr;
int cnt = -1;
SafeMobileLib.Utils.WriteLine("GW== received zone nr " + zoneNr);
SafeMobileLib.Utils.WriteLine("GW== received channel nr " + channelNr);
// zone stuff
if (cbZone.Items.Count > 0 && cbZone.Items.Count >=zoneNr)
{
cbZone.Text = cbZone.Items[zoneNr - 1].Text;
lbZone.Text = cbZone.Items[zoneNr - 1].Text;
cnt = -1;
foreach (RadMenuItem obj in cbZone.Items)
{
cnt++;
if (obj.Name == cbZone.Items[zoneNr - 1].Name) { obj.IsChecked = true; }
else obj.IsChecked = false;
}
}
//channel stuff
LoadChannels();
if (cbChan.Items.Count > 0 && cbChan.Items.Count >= channelNr)
{
cbChan.Text = cbChan.Items[channelNr - 1].Text;
lbChannel.Text = cbChan.Items[channelNr - 1].Text;
cnt = -1;
foreach (RadMenuItem obj in cbChan.Items)
{
cnt++;
if (obj.Name == cbChan.Items[channelNr - 1].Name) { obj.IsChecked = true; }
else obj.IsChecked = false;
}
}
}
catch (Exception ex)
{
SafeMobileLib.Utils.WriteLine(ex.ToString());
RadMessageBox.Show("Invalid channel....switching to channel 1 zone 1");
rcHandler.SendZoneChannelChange(1, 1);
}
}
delegate void PropertyChangedCallback(RADIO_STATUS rStatus);
void rcHandler_PropertyChanged(object sender, PropertyChangedEventArgs e)
{
SafeMobileLib.Utils.WriteLine("New value for radio status:" + ((RadioComHandler)sender).RadioStatusProp);
PropertyChangedCallback d = new PropertyChangedCallback(RadioStatusChanged);
this.Invoke(d, new object[] { ((RadioComHandler)sender).RadioStatusProp });
}
private void RadioStatusChanged(RADIO_STATUS rStatus)
{
lbRadio_Status.Text = rStatus.ToString();
}
#endregion
#region configs
private void LoadConfig()
{
try
{
source = new IniConfigSource(Main.CFG_FILE);
DBServer = Main.DBServer;//source.Configs["Database"].Get("IP");
DBSchema = Main.DBSchema;//source.Configs["Database"].Get("Schema");
DBUser = Main.DBUser;//source.Configs["Database"].Get("User");
DBPort = Main.DBPort;//source.Configs["Database"].Get("Port");
DBPass = Main.DBPass;//source.Configs["Database"].Get("Passwd");
//messageBusIP = source.Configs["MessageBus"].Get("ip");
//messageBusPort = Convert.ToInt32(source.Configs["MessageBus"].Get("port"));
//tbMulticastIp.Text = messageBusIP;
if (source.Configs["Voice"].Contains("SelectedOutDevice" + radioID.ToString()))
{
selectedOUTDeviceName = source.Configs["Voice"].Get("SelectedOutDevice" + radioID.ToString());
selectedINDeviceName = source.Configs["Voice"].Get("SelectedInDevice" + radioID.ToString());
onOFFpreStatus = Convert.ToBoolean(source.Configs["Voice"].Get("onOFF" + radioID.ToString()));
SafeMobileLib.Utils.WriteLine("settings loaded for radio :" + radioID);
}
else
{
SafeMobileLib.Utils.WriteLine("No settings found for radio :" + radioID);
}
}
catch (Exception e)
{
SafeMobileLib.Utils.WriteLine(e.Message + " " + e.StackTrace + " " + e.Source);
}
}
public void SaveConfig()
{
//SafeMobileLib.Utils.WriteLine("saving settings for " + radioIMEI.ToString() + " IP:" + cbRadioIP.SelectedValue);
source = new IniConfigSource(Main.CFG_FILE);
if (source.Configs["Voice"].Contains("SelectedOutDevice" + radioID.ToString()))
{
SafeMobileLib.Utils.WriteLine("Saving settings for radio ID:" + radioID);
source.Configs["Voice"].Set("SelectedOutDevice" + radioID.ToString(), selectedOUTDeviceName);
source.Configs["Voice"].Set("SelectedInDevice" + radioID.ToString(), selectedINDeviceName);
source.Configs["Voice"].Set("RadioIP" + radioID.ToString(), cbRadioIP.SelectedValue);
source.Configs["Voice"].Set("onOFF" + radioID.ToString(), radioON);
}
else
{
SafeMobileLib.Utils.WriteLine("Adding new entry in config file for radio ID:" + radioIMEI);
source.Configs["Voice"].Set("SelectedOutDevice" + radioID.ToString(), selectedOUTDeviceName);
source.Configs["Voice"].Set("SelectedInDevice" + radioID.ToString(), selectedINDeviceName);
source.Configs["Voice"].Set("RadioIP" + radioID.ToString(), cbRadioIP.SelectedValue);
source.Configs["Voice"].Set("onOFF" + radioID.ToString(), radioON);
}
source.Save();
}
public void DeleteConfig()
{
source = new IniConfigSource(Main.CFG_FILE);
if (source.Configs["Voice"].Contains("SelectedOutDevice" + radioID.ToString()))
{
source.Configs["Voice"].Remove("SelectedOutDevice" + radioID.ToString());
source.Configs["Voice"].Remove("SelectedInDevice" + radioID.ToString());
source.Configs["Voice"].Remove("RadioIP" + radioID.ToString());
source.Configs["Voice"].Remove("MulticastIP" + radioID.ToString());
}
source.Save();
}
#endregion
#region bigu
private void btCollapse_Click(object sender, EventArgs e)
{
ChangeState();
}
public Boolean ChangeState()
{
if (Collapse)
{
this.Size = new Size(this.Size.Width, 230);
btCollapse.Image = global::MotoTrbo_GW.Properties.Resources.minus;
}
else
{
this.Size = new Size(this.Size.Width, 27);
btCollapse.Image = global::MotoTrbo_GW.Properties.Resources.plus;
}
Collapse = !Collapse;
return Collapse;
}
private void btONOFF_Click(object sender, EventArgs e)
{
SafeMobileLib.Utils.WriteLine("******************************\n" + radioIP + "\n***** CALL to btONOFF_Click(start) ******\n******************************");
if (!radioON)
{
Connect_in_progress = true;
btONOFF.Enabled = false;
//start
if (soundOUTDevices.Count > 0 && soundINDevices.Count > 0)
{
int rNetworkID = -1;
// Lock here because the hash is populated on another thread and the containsKey method can return false info
lock (_locker)
{
if (RouteManager.NetworkIDs_Hash.ContainsKey(radioIP))
rNetworkID = (int)RouteManager.NetworkIDs_Hash[radioIP];
}
if (rNetworkID == -1)
{
SafeMobileLib.Utils.WriteLine("++++++++++++++++++++++++++++++++++++++++++++");
SafeMobileLib.Utils.WriteLine($"Network ID missing for {radioIP} Gateway radio could not Start!!!" );
SafeMobileLib.Utils.WriteLine("++++++++++++++++++++++++++++++++++++++++++++");
RadMessageBox.Show("Gateway radio not found!!" + radioIP, "MotoTRBO gateway", MessageBoxButtons.OK, RadMessageIcon.Exclamation);
btONOFF.Enabled = true;
Connect_in_progress = false;
}
else
{
try
{
SafeMobileLib.Utils.WriteLine($"******************************\n {radioIP} \n***** CALL to btONOFF_Click (network ID found)******\n******************************");
if (Main.RadioComArr.ContainsKey(radioIP))
{
SafeMobileLib.Utils.WriteLine($"******************************\n {radioIP} \n***** CALL to btONOFF_Click (connection found)******\n******************************");
radioC = Main.RadioComArr[radioIP];
SafeMobileLib.Utils.WriteLine("(((((((((((( devIN:" + selectedINDevice + " devOUT:" + selectedOUTDevice + ")))))))");
rcHandler = new RadioComHandler(radioC, radioID, radioIP, rNetworkID, radioIMEI, selectedINDevice, selectedOUTDevice);
rcHandler.OnChannelEvent += new RadioComHandler.ChannelEvent(rcHandler_OnChannelEvent);
rcHandler.PropertyChanged += new PropertyChangedEventHandler(rcHandler_PropertyChanged);
// Fire event for LINX
StartedRadioComHandler?.Invoke(this, rcHandler);
while (!radioC.AuthDone)
{
SafeMobileLib.Utils.WriteLine("VOice thread Spleeping.. AUTH not completed");
SafeMobileLib.Utils.WriteLine($"******************************\n {radioIP} \n***** CALL to btONOFF_Click (Connection not complited)******\n******************************");
System.Threading.Thread.Sleep(500);
}
if (rcHandler.Start() == false)
{
SafeMobileLib.Utils.WriteLine($"******************************\n {radioIP} \n***** CALL to btONOFF_Click 3******\n******************************");
RadMessageBox.Show("Gateway radio not found!!" + radioIP, "MotoTRBO gateway", MessageBoxButtons.OK, RadMessageIcon.Exclamation);
btONOFF.Enabled = true;
Connect_in_progress = false;
}
else
{
SafeMobileLib.Utils.WriteLine($"******************************\n {radioIP} \n***** CALL to btONOFF_Click (END)******\n******************************");
AuthDone();
}
}
else
{
SafeMobileLib.Utils.WriteLine("++++++++++++++++++++++++++++++++++++++++++++");
SafeMobileLib.Utils.WriteLine($"Main.RadioComArr ip {radioIP} missing Gateway radio could not Start!! Waiting for antother ping" );
SafeMobileLib.Utils.WriteLine("++++++++++++++++++++++++++++++++++++++++++++");
//RadMessageBox.Show("Gateway radio not found!!" + radioIP, "MotoTRBO gateway", MessageBoxButtons.OK, RadMessageIcon.Exclamation);
btONOFF.Enabled = true;
Connect_in_progress = false;
}
}
catch (Exception ex)
{
SafeMobileLib.Utils.WriteLine("Error on ON/OFF button click:"+ex.ToString());
}
}
}
else
{
RadMessageBox.Show("No sound device found!!!");
TurnOff(false);
btONOFF.Enabled = true;
Connect_in_progress = false;
}
}
else
{
TurnOff(false);
}
}
#endregion
#region zones and channels
//channels
private List<String> ChanelList = null;
private int selectedChannelNr = 0;
private void LoadChannels()
{
if (selectedZoneNr > 0)
{
cbChan.Items.Clear();
channelList = db4gateway.gelAllradioChannels(zonesList[selectedZoneNr - 1].Id);
ChanelList = new List<string>();
foreach (RadioChannels rc in channelList)
ChanelList.Add(rc.Name);
int cnt = -1;
foreach (String obj in ChanelList)
{
cnt++;
RadMenuItem tmp = new RadMenuItem(obj);
tmp.Name = "chmenu" + cnt.ToString();
cbChan.Items.Add(tmp);
tmp.Click += new System.EventHandler(ChannelChangeEvent);
}
if (cbChan.Items.Count > 0)
{
((RadMenuItem)cbChan.Items[0]).IsChecked = true;
cbChan.Text = ((RadMenuItem)cbChan.Items[0]).Text;
}
}
}
private void ChannelChangeEvent(object sender, EventArgs e)
{
selectedChannelNr = 0;
foreach (RadMenuItem obj in cbChan.Items)
{
selectedChannelNr++;
if (obj.Name == ((RadMenuItem)sender).Name) { break; }
}
SafeMobileLib.Utils.WriteLine("Sending channel change nr=" + selectedChannelNr);
rcHandler.SendZoneChannelChange(selectedZoneNr, selectedChannelNr);
}
//zones
private List<String> ZoneList = null;
private int selectedZoneNr = 0;
private void LoadZones()
{
zonesList = db4gateway.gelAllradioZones(radioID);
ZoneList = new List<string>();
foreach (RadioZones rz in zonesList)
ZoneList.Add("zone "+rz.Nr);
int cnt = -1;
foreach (String obj in ZoneList)
{
cnt++;
RadMenuItem tmp = new RadMenuItem(obj);
tmp.Name = "chmenu" + cnt.ToString();
cbZone.Items.Add(tmp);
tmp.Click += new System.EventHandler(ZoneChangeEvent);
}
if (cbZone.Items.Count > 0)
{
selectedZoneNr = 1;
((RadMenuItem)cbZone.Items[0]).IsChecked = true;
cbZone.Text = ((RadMenuItem)cbZone.Items[0]).Text;
}
}
private void ZoneChangeEvent(object sender, EventArgs e)
{
selectedZoneNr = 0;
foreach (RadMenuItem obj in cbZone.Items)
{
selectedZoneNr++;
if (obj.Name == ((RadMenuItem)sender).Name) { break; }
}
SafeMobileLib.Utils.WriteLine("Sending zone change nr=" + selectedZoneNr);
rcHandler.SendZoneChannelChange(selectedZoneNr, selectedChannelNr);
}
#endregion
#region VOICE Components
private void iniVoiceComponents()
{
// load default configuration
selectedOUTDevice = -1;
selectedINDevice = -1;
for (int i = 0; i < cbRadioIP.Items.Count; i++)
{
if (cbRadioIP.Items[i].Text == radioIP)
{
cbRadioIP.SelectedIndex = i;
break;
}
}
try
{
sDevice soundDevice;
List<sDevice> listOfInputDevices, listOfOutputDevices;
if (Main.AudioDriver == AudioDriverType.Asio)
{
listOfInputDevices = Main.GetAsioInputDevices();
listOfOutputDevices = Main.GetAsioOutputDevices();
}
else
{
listOfInputDevices = AudioManager.GetWaveInputDevices();
listOfOutputDevices = AudioManager.GetWaveOutputDevices();
}
int nrOfInDevices = listOfInputDevices.Count;
for (int i = 0; i < nrOfInDevices; i++)
{
soundDevice = listOfInputDevices[i];
soundINDevices.Add(soundDevice);
RadListDataItem ci = new RadListDataItem(soundDevice.name);
listRecBDevices.Items.Add(ci);
}
int nrOfOUTDevices = listOfOutputDevices.Count;
for (int i = 0; i < nrOfOUTDevices; i++)
{
soundDevice = listOfOutputDevices[i];
soundOUTDevices.Add(soundDevice);
RadListDataItem ci = new RadListDataItem(soundDevice.name);
listPlayBDevices.Items.Add(ci);
}
if (listPlayBDevices.Items.Count > 0)
{
if (selectedOUTDevice < listPlayBDevices.Items.Count)
{
bool found = false;
foreach (sDevice dev in soundOUTDevices)
{
if (dev.name.Equals(selectedOUTDeviceName))
{
found = true;
SafeMobileLib.Utils.WriteLine("Sound Device OUT found on config file dev name: " + dev.name + " with index: " + dev.index);
listPlayBDevices.SelectedIndex = dev.index;
selectedOUTDevice = dev.index;
break;
}
}
if (!found)
{
listPlayBDevices.SelectedIndex = 0;
selectedOUTDevice = 0;
}
}
else
{
listPlayBDevices.SelectedIndex = 0;
selectedOUTDevice = 0;
}
}
if (listRecBDevices.Items.Count > 0)
{
if (selectedINDevice < listRecBDevices.Items.Count)
{
bool found = false;
foreach (sDevice dev in soundINDevices)
{
if (dev.name == selectedINDeviceName)
{
found = true;
SafeMobileLib.Utils.WriteLine("Sound Device IN found on config file dev name: " + dev.name + " with index: " + dev.index);
listRecBDevices.SelectedIndex = dev.index;
selectedINDevice = dev.index;
break;
}
}
if (!found)
{
listRecBDevices.SelectedIndex = 0;
selectedINDevice = 0;
}
}
else
{
listRecBDevices.SelectedIndex = 0;
selectedINDevice = 0;
}
}
}
catch (Exception ex)
{
SafeMobileLib.Utils.WriteLine("ERROR in voice ini : " + ex.ToString());
}
}
private void Filler(IntPtr data, int size)
{
//this is dummy function
}
private void Voice_Out(IntPtr data, int size)
{ //this is dummy function
}
public struct sDevice
{
public int index;
public string name;
}
#endregion
private void btnSaveRadioSettings_Click(object sender, EventArgs e)
{
SaveConfig();
RestarRadio();
}
private void radioForm_FormClosing(object sender, FormClosingEventArgs e)
{
//send off to SD
string test = "#100#" + Main.GWID + "." + radioID + "#0#";
MessageBusHandler.SendOnMsgBuss("0.0", test);
SaveConfig();
}
public void SendClose()
{
if (radioON)
{
//send off to SD
string test = "#100#" + Main.GWID + "." + radioID + "#0#";
MessageBusHandler.SendOnMsgBuss("0.0", test);
}
}
private void RestarRadio()
{
SafeMobileLib.Utils.WriteLine("Resarting radio " + radioIP.ToString());
if (radioON)
{
btONOFF.Text = "ON";
ImgRad.Image = global::MotoTrbo_GW.Properties.Resources.radioblack1;
ImgStat.Image = global::MotoTrbo_GW.Properties.Resources.red_status;
EnableAudioSettingsPanels(true);
cbChan.Enabled = false;
cbZone.Enabled = false;
radioON = false;
//stop
// Fire Event for LINX
StoppingRadioComHandler?.Invoke(this, rcHandler);
rcHandler.Stop();
Connect_in_progress = true;
SafeMobileLib.Utils.WriteLine("Restarting rcHandler for" + radioIP.ToString());
if (Main.RadioComArr.ContainsKey(radioIP))
{
RadioConnection radioC = Main.RadioComArr[radioIP];
rcHandler = new RadioComHandler(radioC, radioID, radioIP, radioNetworkID, radioIMEI, selectedINDevice, selectedOUTDevice);
//rcHandler.OnAuthDone += new RadioComHandler.AuthDoneDEl(rcHandler_OnAuthDone);
rcHandler.OnChannelEvent += new RadioComHandler.ChannelEvent(rcHandler_OnChannelEvent);
rcHandler.PropertyChanged += new PropertyChangedEventHandler(rcHandler_PropertyChanged);
// Fire Event for LINX
StartedRadioComHandler?.Invoke(this, rcHandler);
btONOFF.Enabled = false;
//start
while (!radioC.AuthDone)
{
SafeMobileLib.Utils.WriteLine("VOice thread Spleeping.. AUTH not completed");
System.Threading.Thread.Sleep(500);
}
if (rcHandler.Start() == false)
{
RadMessageBox.Show("Gateway radio not found!!" + radioIP, "MotoTRBO gateway", MessageBoxButtons.OK, RadMessageIcon.Exclamation);
btONOFF.Enabled = true;
}
else
{
AuthDone();
}
}
else
{
RadMessageBox.Show("Gateway radio not found!!" + radioIP, "MotoTRBO gateway", MessageBoxButtons.OK, RadMessageIcon.Exclamation);
btONOFF.Enabled = true;
}
}
}
private void TurnOff(bool restartWhenPowerOn)
{
btONOFF.Text = "ON";
ImgRad.Image = global::MotoTrbo_GW.Properties.Resources.radioblack1;
ImgStat.Image = global::MotoTrbo_GW.Properties.Resources.red_status;
EnableAudioSettingsPanels(true);
cbChan.Enabled = false;
cbZone.Enabled = false;
radioON = false;
onOFFpreStatus = restartWhenPowerOn;
//stop
// Fire event for LINX
StoppingRadioComHandler?.Invoke(this, rcHandler);
try
{
if (rcHandler != null)
rcHandler.Stop();
}
catch (Exception ex)
{
SafeMobileLib.Utils.WriteLine(ex.ToString());
}
rcHandler = null;
lbRadio_Status.Text = "Off";
try
{
SafeMobileLib.Utils.WriteEventLog("Safemobile", "Station with IP:"+radioIP+" is OFF", EventLogEntryType.Information, 31020);
}
catch (Exception ex)
{
SafeMobileLib.Utils.WriteLine("Unable to write log Event ex:" + ex.ToString());
}
}
private void listPlayBDevices_SelectedIndexChanged(object sender, Telerik.WinControls.UI.Data.PositionChangedEventArgs e)
{
try
{
foreach (sDevice dev in soundOUTDevices)
{
if (dev.name == ((RadListDataItem)listPlayBDevices.SelectedItem).Text)
{
selectedOUTDevice = dev.index;
selectedOUTDeviceName = dev.name;
break;
}
}
}
catch (Exception ex)
{
SafeMobileLib.Utils.WriteLine("Error in selecting device");
SafeMobileLib.Utils.WriteLine(ex.ToString());
}
}
private void listPlayBDevices_EnabledChanged(object sender, EventArgs e)
{
foreach(RadListDataItem item in ((RadListControl)sender).Items)
{
if (item == null || item.VisualItem == null)
continue;
if(((RadListControl)sender).Enabled)
{
item.VisualItem.ResetValue(LightVisualElement.NumberOfColorsProperty, ValueResetFlags.Local);
item.VisualItem.ResetValue(LightVisualElement.BackColorProperty, ValueResetFlags.Local);
item.VisualItem.ResetValue(LightVisualElement.ForeColorProperty, ValueResetFlags.Local);
item.VisualItem.ResetValue(LightVisualElement.BorderColorProperty, ValueResetFlags.Local);
item.VisualItem.ResetValue(LightVisualElement.FontProperty, ValueResetFlags.Local);
}
else
{
item.VisualItem.NumberOfColors = 1;
item.VisualItem.BackColor = item.Selected ? Color.Wheat : Color.Transparent;
}
}
}
bool firstTime = true;
private void radTabStrip1_SelectedPageChanged(object sender, EventArgs e)
{
if(radTabStrip1.SelectedPage == radPageViewPage2 && firstTime)
{
listPlayBDevices_EnabledChanged(listPlayBDevices, null);
listPlayBDevices_EnabledChanged(listRecBDevices, null);
firstTime = false;
}
}
private void listRecBDevices_SelectedIndexChanged(object sender, Telerik.WinControls.UI.Data.PositionChangedEventArgs e)
{
try
{
foreach (sDevice dev in soundINDevices)
{
if (dev.name == ((RadListDataItem)listRecBDevices.SelectedItem).Text)
{
selectedINDevice = dev.index;
selectedINDeviceName = dev.name;
break;
}
}
}
catch (Exception ex)
{
SafeMobileLib.Utils.WriteLine("Error in selecting device");
SafeMobileLib.Utils.WriteLine(ex.ToString());
}
}
public delegate void RadioComHandlerDelegate(object sender, RadioComHandler rcHandler);
public event RadioComHandlerDelegate StartedRadioComHandler;
public event RadioComHandlerDelegate StoppingRadioComHandler;
}
}